From 876847f4d7efe36e553e13c9fe214b0ab34a5561 Mon Sep 17 00:00:00 2001 From: toblii Date: Fri, 30 May 2025 09:49:37 +0300 Subject: [PATCH 1/2] Homwork-3:tobias holm --- CMakeCache.txt | 758 + .../4.0.2-dirty/CMakeCUDACompiler.cmake | 89 + CMakeFiles/4.0.2-dirty/CMakeCXXCompiler.cmake | 100 + .../CMakeDetermineCompilerABI_CUDA.bin | Bin 0 -> 999680 bytes CMakeFiles/4.0.2-dirty/CMakeSystem.cmake | 15 + .../CompilerIdCUDA/CMakeCUDACompilerId.cu | 935 + CMakeFiles/4.0.2-dirty/CompilerIdCUDA/a.out | Bin 0 -> 1000048 bytes .../tmp/CMakeCUDACompilerId.cpp1.ii | 36265 +++++++++++++++ .../tmp/CMakeCUDACompilerId.cpp4.ii | 34363 +++++++++++++++ .../tmp/CMakeCUDACompilerId.cudafe1.c | 51 + .../tmp/CMakeCUDACompilerId.cudafe1.cpp | 36281 ++++++++++++++++ .../tmp/CMakeCUDACompilerId.cudafe1.gpu | 467 + .../tmp/CMakeCUDACompilerId.cudafe1.stub.c | 15 + .../tmp/CMakeCUDACompilerId.fatbin | Bin 0 -> 1096 bytes .../tmp/CMakeCUDACompilerId.fatbin.c | 60 + .../tmp/CMakeCUDACompilerId.module_id | 1 + .../CompilerIdCUDA/tmp/CMakeCUDACompilerId.o | Bin 0 -> 6912 bytes .../tmp/CMakeCUDACompilerId.ptx | 14 + .../tmp/CMakeCUDACompilerId.sm_52.cubin | Bin 0 -> 872 bytes .../CompilerIdCUDA/tmp/a_dlink.fatbin | Bin 0 -> 952 bytes .../CompilerIdCUDA/tmp/a_dlink.fatbin.c | 55 + .../4.0.2-dirty/CompilerIdCUDA/tmp/a_dlink.o | Bin 0 -> 2904 bytes .../CompilerIdCUDA/tmp/a_dlink.reg.c | 1 + .../CompilerIdCUDA/tmp/a_dlink.sm_52.cubin | Bin 0 -> 872 bytes .../CompilerIdCXX/CMakeCXXCompilerId.cpp | 920 + CMakeFiles/4.0.2-dirty/CompilerIdCXX/a.out | Bin 0 -> 15552 bytes CMakeFiles/CMakeConfigureLog.yaml | 634 + CMakeFiles/CMakeDirectoryInformation.cmake | 16 + CMakeFiles/InstallScripts.json | 7 + CMakeFiles/Makefile.cmake | 57 + CMakeFiles/Makefile2 | 122 + CMakeFiles/TargetDirectories.txt | 3 + CMakeFiles/app.dir/DependInfo.cmake | 23 + CMakeFiles/app.dir/build.make | 140 + CMakeFiles/app.dir/cmake_clean.cmake | 12 + CMakeFiles/app.dir/cmake_device_link.o | Bin 0 -> 12552 bytes CMakeFiles/app.dir/compiler_depend.internal | 322 + CMakeFiles/app.dir/compiler_depend.make | 955 + CMakeFiles/app.dir/compiler_depend.ts | 2 + CMakeFiles/app.dir/depend.make | 2 + CMakeFiles/app.dir/deviceLinkLibs.rsp | 1 + CMakeFiles/app.dir/deviceObjects1.rsp | 1 + CMakeFiles/app.dir/dlink.txt | 1 + CMakeFiles/app.dir/flags.make | 10 + CMakeFiles/app.dir/includes_CUDA.rsp | 1 + CMakeFiles/app.dir/link.d | 139 + CMakeFiles/app.dir/link.txt | 1 + CMakeFiles/app.dir/linkLibs.rsp | 1 + CMakeFiles/app.dir/main.cu.o | Bin 0 -> 89144 bytes CMakeFiles/app.dir/main.cu.o.d | 317 + CMakeFiles/app.dir/objects1.rsp | 1 + CMakeFiles/app.dir/progress.make | 4 + CMakeFiles/cmake.check_cache | 1 + CMakeFiles/progress.marks | 1 + Makefile | 181 + app | Bin 0 -> 80328 bytes .../api/v1/query/client-vscode/query.json | 1 + .../reply/cache-v2-b7625ea7196d4b1733bc.json | 2475 ++ .../cmakeFiles-v1-68e0bf6dc779deff2066.json | 236 + .../codemodel-v2-fb5930f2db7e4c68716a.json | 60 + ...irectory-.-Debug-f5ebdc15457944623624.json | 14 + .../reply/index-2025-05-27T14-02-45-0782.json | 132 + ...target-app-Debug-4072aed3cbe4f32d8d52.json | 169 + .../toolchains-v1-858f352aa1e21a1deb68.json | 114 + build/CMakeCache.txt | 761 + .../4.0.2-dirty/CMakeCUDACompiler.cmake | 89 + .../4.0.2-dirty/CMakeCXXCompiler.cmake | 108 + .../CMakeDetermineCompilerABI_CUDA.bin | Bin 0 -> 999680 bytes .../CMakeDetermineCompilerABI_CXX.bin | Bin 0 -> 15456 bytes .../CMakeFiles/4.0.2-dirty/CMakeSystem.cmake | 15 + .../CompilerIdCUDA/CMakeCUDACompilerId.cu | 935 + .../4.0.2-dirty/CompilerIdCUDA/a.out | Bin 0 -> 1000048 bytes .../tmp/CMakeCUDACompilerId.cpp1.ii | 36265 +++++++++++++++ .../tmp/CMakeCUDACompilerId.cpp4.ii | 34363 +++++++++++++++ .../tmp/CMakeCUDACompilerId.cudafe1.c | 51 + .../tmp/CMakeCUDACompilerId.cudafe1.cpp | 36281 ++++++++++++++++ .../tmp/CMakeCUDACompilerId.cudafe1.gpu | 467 + .../tmp/CMakeCUDACompilerId.cudafe1.stub.c | 15 + .../tmp/CMakeCUDACompilerId.fatbin | Bin 0 -> 1096 bytes .../tmp/CMakeCUDACompilerId.fatbin.c | 60 + .../tmp/CMakeCUDACompilerId.module_id | 1 + .../CompilerIdCUDA/tmp/CMakeCUDACompilerId.o | Bin 0 -> 6912 bytes .../tmp/CMakeCUDACompilerId.ptx | 14 + .../tmp/CMakeCUDACompilerId.sm_52.cubin | Bin 0 -> 872 bytes .../CompilerIdCUDA/tmp/a_dlink.fatbin | Bin 0 -> 952 bytes .../CompilerIdCUDA/tmp/a_dlink.fatbin.c | 55 + .../4.0.2-dirty/CompilerIdCUDA/tmp/a_dlink.o | Bin 0 -> 2904 bytes .../CompilerIdCUDA/tmp/a_dlink.reg.c | 1 + .../CompilerIdCUDA/tmp/a_dlink.sm_52.cubin | Bin 0 -> 872 bytes .../CompilerIdCXX/CMakeCXXCompilerId.cpp | 920 + .../4.0.2-dirty/CompilerIdCXX/a.out | Bin 0 -> 15568 bytes build/CMakeFiles/CMakeConfigureLog.yaml | 801 + build/CMakeFiles/InstallScripts.json | 7 + build/CMakeFiles/TargetDirectories.txt | 3 + build/CMakeFiles/cmake.check_cache | 1 + build/CMakeFiles/rules.ninja | 73 + build/build.ninja | 160 + build/cmake_install.cmake | 66 + build/compile_commands.json | 8 + cmake_install.cmake | 66 + data/0/run_cuda.log | 1 + data/1/run_cuda.log | 1 + data/2/run_cuda.log | 1 + data/3/run_cuda.log | 1 + data/4/run_cuda.log | 1 + data/5/run_cuda.log | 1 + data/6/run_cuda.log | 1 + data/7/run_cuda.log | 1 + data/8/run_cuda.log | 1 + data/9/run_cuda.log | 1 + main.cu | 183 +- test.sh | 32 + 112 files changed, 228344 insertions(+), 13 deletions(-) create mode 100644 CMakeCache.txt create mode 100644 CMakeFiles/4.0.2-dirty/CMakeCUDACompiler.cmake create mode 100644 CMakeFiles/4.0.2-dirty/CMakeCXXCompiler.cmake create mode 100755 CMakeFiles/4.0.2-dirty/CMakeDetermineCompilerABI_CUDA.bin create mode 100644 CMakeFiles/4.0.2-dirty/CMakeSystem.cmake create mode 100644 CMakeFiles/4.0.2-dirty/CompilerIdCUDA/CMakeCUDACompilerId.cu create mode 100755 CMakeFiles/4.0.2-dirty/CompilerIdCUDA/a.out create mode 100644 CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp1.ii create mode 100644 CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp4.ii create mode 100644 CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.c create mode 100644 CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.cpp create mode 100644 CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.gpu create mode 100644 CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.stub.c create mode 100644 CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.fatbin create mode 100644 CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.fatbin.c create mode 100644 CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.module_id create mode 100644 CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.o create mode 100644 CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.ptx create mode 100644 CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.sm_52.cubin create mode 100644 CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/a_dlink.fatbin create mode 100644 CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/a_dlink.fatbin.c create mode 100644 CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/a_dlink.o create mode 100644 CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/a_dlink.reg.c create mode 100644 CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/a_dlink.sm_52.cubin create mode 100644 CMakeFiles/4.0.2-dirty/CompilerIdCXX/CMakeCXXCompilerId.cpp create mode 100755 CMakeFiles/4.0.2-dirty/CompilerIdCXX/a.out create mode 100644 CMakeFiles/CMakeConfigureLog.yaml create mode 100644 CMakeFiles/CMakeDirectoryInformation.cmake create mode 100644 CMakeFiles/InstallScripts.json create mode 100644 CMakeFiles/Makefile.cmake create mode 100644 CMakeFiles/Makefile2 create mode 100644 CMakeFiles/TargetDirectories.txt create mode 100644 CMakeFiles/app.dir/DependInfo.cmake create mode 100644 CMakeFiles/app.dir/build.make create mode 100644 CMakeFiles/app.dir/cmake_clean.cmake create mode 100644 CMakeFiles/app.dir/cmake_device_link.o create mode 100644 CMakeFiles/app.dir/compiler_depend.internal create mode 100644 CMakeFiles/app.dir/compiler_depend.make create mode 100644 CMakeFiles/app.dir/compiler_depend.ts create mode 100644 CMakeFiles/app.dir/depend.make create mode 100644 CMakeFiles/app.dir/deviceLinkLibs.rsp create mode 100644 CMakeFiles/app.dir/deviceObjects1.rsp create mode 100644 CMakeFiles/app.dir/dlink.txt create mode 100644 CMakeFiles/app.dir/flags.make create mode 100644 CMakeFiles/app.dir/includes_CUDA.rsp create mode 100644 CMakeFiles/app.dir/link.d create mode 100644 CMakeFiles/app.dir/link.txt create mode 100644 CMakeFiles/app.dir/linkLibs.rsp create mode 100644 CMakeFiles/app.dir/main.cu.o create mode 100644 CMakeFiles/app.dir/main.cu.o.d create mode 100644 CMakeFiles/app.dir/objects1.rsp create mode 100644 CMakeFiles/app.dir/progress.make create mode 100644 CMakeFiles/cmake.check_cache create mode 100644 CMakeFiles/progress.marks create mode 100644 Makefile create mode 100755 app create mode 100644 build/.cmake/api/v1/query/client-vscode/query.json create mode 100644 build/.cmake/api/v1/reply/cache-v2-b7625ea7196d4b1733bc.json create mode 100644 build/.cmake/api/v1/reply/cmakeFiles-v1-68e0bf6dc779deff2066.json create mode 100644 build/.cmake/api/v1/reply/codemodel-v2-fb5930f2db7e4c68716a.json create mode 100644 build/.cmake/api/v1/reply/directory-.-Debug-f5ebdc15457944623624.json create mode 100644 build/.cmake/api/v1/reply/index-2025-05-27T14-02-45-0782.json create mode 100644 build/.cmake/api/v1/reply/target-app-Debug-4072aed3cbe4f32d8d52.json create mode 100644 build/.cmake/api/v1/reply/toolchains-v1-858f352aa1e21a1deb68.json create mode 100644 build/CMakeCache.txt create mode 100644 build/CMakeFiles/4.0.2-dirty/CMakeCUDACompiler.cmake create mode 100644 build/CMakeFiles/4.0.2-dirty/CMakeCXXCompiler.cmake create mode 100755 build/CMakeFiles/4.0.2-dirty/CMakeDetermineCompilerABI_CUDA.bin create mode 100755 build/CMakeFiles/4.0.2-dirty/CMakeDetermineCompilerABI_CXX.bin create mode 100644 build/CMakeFiles/4.0.2-dirty/CMakeSystem.cmake create mode 100644 build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/CMakeCUDACompilerId.cu create mode 100755 build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/a.out create mode 100644 build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp1.ii create mode 100644 build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp4.ii create mode 100644 build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.c create mode 100644 build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.cpp create mode 100644 build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.gpu create mode 100644 build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.stub.c create mode 100644 build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.fatbin create mode 100644 build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.fatbin.c create mode 100644 build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.module_id create mode 100644 build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.o create mode 100644 build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.ptx create mode 100644 build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.sm_52.cubin create mode 100644 build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/a_dlink.fatbin create mode 100644 build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/a_dlink.fatbin.c create mode 100644 build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/a_dlink.o create mode 100644 build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/a_dlink.reg.c create mode 100644 build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/a_dlink.sm_52.cubin create mode 100644 build/CMakeFiles/4.0.2-dirty/CompilerIdCXX/CMakeCXXCompilerId.cpp create mode 100755 build/CMakeFiles/4.0.2-dirty/CompilerIdCXX/a.out create mode 100644 build/CMakeFiles/CMakeConfigureLog.yaml create mode 100644 build/CMakeFiles/InstallScripts.json create mode 100644 build/CMakeFiles/TargetDirectories.txt create mode 100644 build/CMakeFiles/cmake.check_cache create mode 100644 build/CMakeFiles/rules.ninja create mode 100644 build/build.ninja create mode 100644 build/cmake_install.cmake create mode 100644 build/compile_commands.json create mode 100644 cmake_install.cmake create mode 100644 data/0/run_cuda.log create mode 100644 data/1/run_cuda.log create mode 100644 data/2/run_cuda.log create mode 100644 data/3/run_cuda.log create mode 100644 data/4/run_cuda.log create mode 100644 data/5/run_cuda.log create mode 100644 data/6/run_cuda.log create mode 100644 data/7/run_cuda.log create mode 100644 data/8/run_cuda.log create mode 100644 data/9/run_cuda.log create mode 100755 test.sh diff --git a/CMakeCache.txt b/CMakeCache.txt new file mode 100644 index 0000000..c6b5a52 --- /dev/null +++ b/CMakeCache.txt @@ -0,0 +1,758 @@ +# This is the CMakeCache file. +# For build in directory: /home/tobli/abo/pprog/Homework-3 +# It was generated by CMake: /usr/bin/cmake +# You can edit this file to change values found and used by cmake. +# If you do not want to change any of the values, simply exit the editor. +# If you do want to change a value, simply edit, save, and exit the editor. +# The syntax for the file is as follows: +# KEY:TYPE=VALUE +# KEY is the name of a variable in the cache. +# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!. +# VALUE is the current value for the KEY. + +######################## +# EXTERNAL cache entries +######################## + +//Path to a program. +CMAKE_ADDR2LINE:FILEPATH=/usr/bin/addr2line + +//Path to a program. +CMAKE_AR:FILEPATH=/usr/bin/ar + +//Choose the type of build, options are: None Debug Release RelWithDebInfo +// MinSizeRel ... +CMAKE_BUILD_TYPE:STRING= + +//Enable/Disable color output during build. +CMAKE_COLOR_MAKEFILE:BOOL=ON + +//CUDA architectures +CMAKE_CUDA_ARCHITECTURES:STRING=52 + +//No help, variable specified on the command line. +CMAKE_CUDA_COMPILER:UNINITIALIZED=/opt/cuda/bin/nvcc + +//Flags used by the CUDA compiler during all build types. +CMAKE_CUDA_FLAGS:STRING= + +//Flags used by the CUDA compiler during DEBUG builds. +CMAKE_CUDA_FLAGS_DEBUG:STRING=-g + +//Flags used by the CUDA compiler during MINSIZEREL builds. +CMAKE_CUDA_FLAGS_MINSIZEREL:STRING=-O1 -DNDEBUG + +//Flags used by the CUDA compiler during RELEASE builds. +CMAKE_CUDA_FLAGS_RELEASE:STRING=-O3 -DNDEBUG + +//Flags used by the CUDA compiler during RELWITHDEBINFO builds. +CMAKE_CUDA_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG + +//CXX compiler +CMAKE_CXX_COMPILER:FILEPATH=/usr/bin/c++ + +//A wrapper around 'ar' adding the appropriate '--plugin' option +// for the GCC compiler +CMAKE_CXX_COMPILER_AR:FILEPATH=/usr/bin/gcc-ar + +//A wrapper around 'ranlib' adding the appropriate '--plugin' option +// for the GCC compiler +CMAKE_CXX_COMPILER_RANLIB:FILEPATH=/usr/bin/gcc-ranlib + +//Flags used by the CXX compiler during all build types. +CMAKE_CXX_FLAGS:STRING= + +//Flags used by the CXX compiler during DEBUG builds. +CMAKE_CXX_FLAGS_DEBUG:STRING=-g + +//Flags used by the CXX compiler during MINSIZEREL builds. +CMAKE_CXX_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG + +//Flags used by the CXX compiler during RELEASE builds. +CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG + +//Flags used by the CXX compiler during RELWITHDEBINFO builds. +CMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG + +//Path to a program. +CMAKE_DLLTOOL:FILEPATH=CMAKE_DLLTOOL-NOTFOUND + +//Flags used by the linker during all build types. +CMAKE_EXE_LINKER_FLAGS:STRING= + +//Flags used by the linker during DEBUG builds. +CMAKE_EXE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during MINSIZEREL builds. +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during RELEASE builds. +CMAKE_EXE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during RELWITHDEBINFO builds. +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Enable/Disable output of compile commands during generation. +CMAKE_EXPORT_COMPILE_COMMANDS:BOOL= + +//Value Computed by CMake. +CMAKE_FIND_PACKAGE_REDIRECTS_DIR:STATIC=/home/tobli/abo/pprog/Homework-3/CMakeFiles/pkgRedirects + +//Install path prefix, prepended onto install directories. +CMAKE_INSTALL_PREFIX:PATH=/usr/local + +//Path to a program. +CMAKE_LINKER:FILEPATH=/usr/bin/ld + +//Path to a program. +CMAKE_MAKE_PROGRAM:FILEPATH=/usr/bin/make + +//Flags used by the linker during the creation of modules during +// all build types. +CMAKE_MODULE_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of modules during +// DEBUG builds. +CMAKE_MODULE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of modules during +// MINSIZEREL builds. +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of modules during +// RELEASE builds. +CMAKE_MODULE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of modules during +// RELWITHDEBINFO builds. +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_NM:FILEPATH=/usr/bin/nm + +//Path to a program. +CMAKE_OBJCOPY:FILEPATH=/usr/bin/objcopy + +//Path to a program. +CMAKE_OBJDUMP:FILEPATH=/usr/bin/objdump + +//Value Computed by CMake +CMAKE_PROJECT_DESCRIPTION:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_HOMEPAGE_URL:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_NAME:STATIC=app + +//Path to a program. +CMAKE_RANLIB:FILEPATH=/usr/bin/ranlib + +//Path to a program. +CMAKE_READELF:FILEPATH=/usr/bin/readelf + +//Flags used by the linker during the creation of shared libraries +// during all build types. +CMAKE_SHARED_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of shared libraries +// during DEBUG builds. +CMAKE_SHARED_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of shared libraries +// during MINSIZEREL builds. +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of shared libraries +// during RELEASE builds. +CMAKE_SHARED_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of shared libraries +// during RELWITHDEBINFO builds. +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//If set, runtime paths are not added when installing shared libraries, +// but are added when building. +CMAKE_SKIP_INSTALL_RPATH:BOOL=NO + +//If set, runtime paths are not added when using shared libraries. +CMAKE_SKIP_RPATH:BOOL=NO + +//Flags used by the linker during the creation of static libraries +// during all build types. +CMAKE_STATIC_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of static libraries +// during DEBUG builds. +CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of static libraries +// during MINSIZEREL builds. +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of static libraries +// during RELEASE builds. +CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of static libraries +// during RELWITHDEBINFO builds. +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_STRIP:FILEPATH=/usr/bin/strip + +//Path to a program. +CMAKE_TAPI:FILEPATH=CMAKE_TAPI-NOTFOUND + +//If this value is on, makefiles will be generated without the +// .SILENT directive, and all commands will be echoed to the console +// during the make. This is useful for debugging only. With Visual +// Studio IDE projects all commands are done without /nologo. +CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE + +//Path to a file. +CUDAToolkit_CUPTI_INCLUDE_DIR:PATH=/opt/cuda/targets/x86_64-linux/include/../../../extras/CUPTI/include + +//Path to a library. +CUDAToolkit_rt_LIBRARY:FILEPATH=/usr/lib/librt.a + +//Path to a library. +CUDA_CUDART:FILEPATH=/opt/cuda/lib/libcudart.so + +//Path to a library. +CUDA_OpenCL_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libOpenCL.so + +//Path to a library. +CUDA_cuFile_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcufile.so + +//Path to a library. +CUDA_cuFile_rdma_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcufile_rdma.so + +//Path to a library. +CUDA_cuFile_rdma_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcufile_rdma_static.a + +//Path to a library. +CUDA_cuFile_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcufile_static.a + +//Path to a library. +CUDA_cublasLt_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcublasLt.so + +//Path to a library. +CUDA_cublasLt_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcublasLt_static.a + +//Path to a library. +CUDA_cublas_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcublas.so + +//Path to a library. +CUDA_cublas_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcublas_static.a + +//Path to a library. +CUDA_cuda_driver_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/stubs/libcuda.so + +//Path to a library. +CUDA_cudart_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcudart.so + +//Path to a library. +CUDA_cudart_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcudart_static.a + +//Path to a library. +CUDA_cudla_LIBRARY:FILEPATH=CUDA_cudla_LIBRARY-NOTFOUND + +//Path to a library. +CUDA_cufft_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcufft.so + +//Path to a library. +CUDA_cufft_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcufft_static.a + +//Path to a library. +CUDA_cufft_static_nocallback_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcufft_static_nocallback.a + +//Path to a library. +CUDA_cufftw_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcufftw.so + +//Path to a library. +CUDA_cufftw_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcufftw_static.a + +//Path to a library. +CUDA_culibos_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libculibos.a + +//Path to a library. +CUDA_cupti_LIBRARY:FILEPATH=/opt/cuda/extras/CUPTI/lib64/libcupti.so + +//Path to a library. +CUDA_cupti_static_LIBRARY:FILEPATH=/opt/cuda/extras/CUPTI/lib64/libcupti_static.a + +//Path to a library. +CUDA_curand_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcurand.so + +//Path to a library. +CUDA_curand_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcurand_static.a + +//Path to a library. +CUDA_cusolver_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcusolver.so + +//Path to a library. +CUDA_cusolver_lapack_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcusolver_lapack_static.a + +//Path to a library. +CUDA_cusolver_metis_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcusolver_metis_static.a + +//Path to a library. +CUDA_cusolver_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcusolver_static.a + +//Path to a library. +CUDA_cusparse_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcusparse.so + +//Path to a library. +CUDA_cusparse_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libcusparse_static.a + +//Path to a library. +CUDA_nppc_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnppc.so + +//Path to a library. +CUDA_nppc_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnppc_static.a + +//Path to a library. +CUDA_nppial_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnppial.so + +//Path to a library. +CUDA_nppial_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnppial_static.a + +//Path to a library. +CUDA_nppicc_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnppicc.so + +//Path to a library. +CUDA_nppicc_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnppicc_static.a + +//Path to a library. +CUDA_nppicom_LIBRARY:FILEPATH=CUDA_nppicom_LIBRARY-NOTFOUND + +//Path to a library. +CUDA_nppicom_static_LIBRARY:FILEPATH=CUDA_nppicom_static_LIBRARY-NOTFOUND + +//Path to a library. +CUDA_nppidei_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnppidei.so + +//Path to a library. +CUDA_nppidei_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnppidei_static.a + +//Path to a library. +CUDA_nppif_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnppif.so + +//Path to a library. +CUDA_nppif_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnppif_static.a + +//Path to a library. +CUDA_nppig_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnppig.so + +//Path to a library. +CUDA_nppig_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnppig_static.a + +//Path to a library. +CUDA_nppim_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnppim.so + +//Path to a library. +CUDA_nppim_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnppim_static.a + +//Path to a library. +CUDA_nppist_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnppist.so + +//Path to a library. +CUDA_nppist_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnppist_static.a + +//Path to a library. +CUDA_nppisu_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnppisu.so + +//Path to a library. +CUDA_nppisu_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnppisu_static.a + +//Path to a library. +CUDA_nppitc_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnppitc.so + +//Path to a library. +CUDA_nppitc_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnppitc_static.a + +//Path to a library. +CUDA_npps_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnpps.so + +//Path to a library. +CUDA_npps_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnpps_static.a + +//Path to a library. +CUDA_nvJitLink_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnvJitLink.so + +//Path to a library. +CUDA_nvJitLink_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnvJitLink_static.a + +//Path to a library. +CUDA_nvToolsExt_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnvToolsExt.so + +//Path to a library. +CUDA_nvfatbin_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnvfatbin.so + +//Path to a library. +CUDA_nvfatbin_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnvfatbin_static.a + +//Path to a library. +CUDA_nvgraph_LIBRARY:FILEPATH=CUDA_nvgraph_LIBRARY-NOTFOUND + +//Path to a library. +CUDA_nvgraph_static_LIBRARY:FILEPATH=CUDA_nvgraph_static_LIBRARY-NOTFOUND + +//Path to a library. +CUDA_nvjpeg_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnvjpeg.so + +//Path to a library. +CUDA_nvjpeg_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnvjpeg_static.a + +//Path to a library. +CUDA_nvml_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/stubs/libnvidia-ml.so + +//Path to a library. +CUDA_nvml_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/stubs/libnvidia-ml.a + +//Path to a library. +CUDA_nvperf_host_LIBRARY:FILEPATH=/opt/cuda/extras/CUPTI/lib64/libnvperf_host.so + +//Path to a library. +CUDA_nvperf_host_static_LIBRARY:FILEPATH=/opt/cuda/extras/CUPTI/lib64/libnvperf_host_static.a + +//Path to a library. +CUDA_nvperf_target_LIBRARY:FILEPATH=/opt/cuda/extras/CUPTI/lib64/libnvperf_target.so + +//Path to a library. +CUDA_nvptxcompiler_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnvptxcompiler_static.a + +//Path to a library. +CUDA_nvrtc_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnvrtc.so + +//Path to a library. +CUDA_nvrtc_builtins_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnvrtc-builtins.so + +//Path to a library. +CUDA_nvrtc_builtins_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnvrtc-builtins_static.a + +//Path to a library. +CUDA_nvrtc_static_LIBRARY:FILEPATH=/opt/cuda/targets/x86_64-linux/lib/libnvrtc_static.a + +//Path to a library. +CUDA_pcsamplingutil_LIBRARY:FILEPATH=/opt/cuda/extras/CUPTI/lib64/libpcsamplingutil.so + +//Value Computed by CMake +app_BINARY_DIR:STATIC=/home/tobli/abo/pprog/Homework-3 + +//Value Computed by CMake +app_IS_TOP_LEVEL:STATIC=ON + +//Value Computed by CMake +app_SOURCE_DIR:STATIC=/home/tobli/abo/pprog/Homework-3 + + +######################## +# INTERNAL cache entries +######################## + +//ADVANCED property for variable: CMAKE_ADDR2LINE +CMAKE_ADDR2LINE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_AR +CMAKE_AR-ADVANCED:INTERNAL=1 +//This is the directory where this CMakeCache.txt was created +CMAKE_CACHEFILE_DIR:INTERNAL=/home/tobli/abo/pprog/Homework-3 +//Major version of cmake used to create the current loaded cache +CMAKE_CACHE_MAJOR_VERSION:INTERNAL=4 +//Minor version of cmake used to create the current loaded cache +CMAKE_CACHE_MINOR_VERSION:INTERNAL=0 +//Patch version of cmake used to create the current loaded cache +CMAKE_CACHE_PATCH_VERSION:INTERNAL=2 +//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE +CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1 +//Path to CMake executable. +CMAKE_COMMAND:INTERNAL=/usr/bin/cmake +//Path to cpack program executable. +CMAKE_CPACK_COMMAND:INTERNAL=/usr/bin/cpack +//Path to ctest program executable. +CMAKE_CTEST_COMMAND:INTERNAL=/usr/bin/ctest +//ADVANCED property for variable: CMAKE_CUDA_COMPILER +CMAKE_CUDA_COMPILER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CUDA_FLAGS +CMAKE_CUDA_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CUDA_FLAGS_DEBUG +CMAKE_CUDA_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CUDA_FLAGS_MINSIZEREL +CMAKE_CUDA_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CUDA_FLAGS_RELEASE +CMAKE_CUDA_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CUDA_FLAGS_RELWITHDEBINFO +CMAKE_CUDA_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_COMPILER +CMAKE_CXX_COMPILER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_COMPILER_AR +CMAKE_CXX_COMPILER_AR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_COMPILER_RANLIB +CMAKE_CXX_COMPILER_RANLIB-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS +CMAKE_CXX_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_DEBUG +CMAKE_CXX_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_MINSIZEREL +CMAKE_CXX_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELEASE +CMAKE_CXX_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELWITHDEBINFO +CMAKE_CXX_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_DLLTOOL +CMAKE_DLLTOOL-ADVANCED:INTERNAL=1 +//Path to cache edit program executable. +CMAKE_EDIT_COMMAND:INTERNAL=/usr/bin/ccmake +//Executable file format +CMAKE_EXECUTABLE_FORMAT:INTERNAL=ELF +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS +CMAKE_EXE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_DEBUG +CMAKE_EXE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_MINSIZEREL +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELEASE +CMAKE_EXE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXPORT_COMPILE_COMMANDS +CMAKE_EXPORT_COMPILE_COMMANDS-ADVANCED:INTERNAL=1 +//Name of external makefile project generator. +CMAKE_EXTRA_GENERATOR:INTERNAL= +//Name of generator. +CMAKE_GENERATOR:INTERNAL=Unix Makefiles +//Generator instance identifier. +CMAKE_GENERATOR_INSTANCE:INTERNAL= +//Name of generator platform. +CMAKE_GENERATOR_PLATFORM:INTERNAL= +//Name of generator toolset. +CMAKE_GENERATOR_TOOLSET:INTERNAL= +//Test CMAKE_HAVE_LIBC_PTHREAD +CMAKE_HAVE_LIBC_PTHREAD:INTERNAL=1 +//Source directory with the top level CMakeLists.txt file for this +// project +CMAKE_HOME_DIRECTORY:INTERNAL=/home/tobli/abo/pprog/Homework-3 +//Install .so files without execute permission. +CMAKE_INSTALL_SO_NO_EXE:INTERNAL=0 +//ADVANCED property for variable: CMAKE_LINKER +CMAKE_LINKER-ADVANCED:INTERNAL=1 +//Name of CMakeLists files to read +CMAKE_LIST_FILE_NAME:INTERNAL=CMakeLists.txt +//ADVANCED property for variable: CMAKE_MAKE_PROGRAM +CMAKE_MAKE_PROGRAM-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS +CMAKE_MODULE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_DEBUG +CMAKE_MODULE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELEASE +CMAKE_MODULE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_NM +CMAKE_NM-ADVANCED:INTERNAL=1 +//number of local generators +CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJCOPY +CMAKE_OBJCOPY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJDUMP +CMAKE_OBJDUMP-ADVANCED:INTERNAL=1 +//Platform information initialized +CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_RANLIB +CMAKE_RANLIB-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_READELF +CMAKE_READELF-ADVANCED:INTERNAL=1 +//Path to CMake installation. +CMAKE_ROOT:INTERNAL=/usr/share/cmake +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS +CMAKE_SHARED_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_DEBUG +CMAKE_SHARED_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELEASE +CMAKE_SHARED_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SKIP_INSTALL_RPATH +CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SKIP_RPATH +CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS +CMAKE_STATIC_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_DEBUG +CMAKE_STATIC_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELEASE +CMAKE_STATIC_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STRIP +CMAKE_STRIP-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_TAPI +CMAKE_TAPI-ADVANCED:INTERNAL=1 +//uname command +CMAKE_UNAME:INTERNAL=/usr/bin/uname +//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE +CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDAToolkit_CUPTI_INCLUDE_DIR +CUDAToolkit_CUPTI_INCLUDE_DIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDAToolkit_rt_LIBRARY +CUDAToolkit_rt_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_CUDART +CUDA_CUDART-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_OpenCL_LIBRARY +CUDA_OpenCL_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cuFile_LIBRARY +CUDA_cuFile_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cuFile_rdma_LIBRARY +CUDA_cuFile_rdma_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cuFile_rdma_static_LIBRARY +CUDA_cuFile_rdma_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cuFile_static_LIBRARY +CUDA_cuFile_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cublasLt_LIBRARY +CUDA_cublasLt_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cublasLt_static_LIBRARY +CUDA_cublasLt_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cublas_LIBRARY +CUDA_cublas_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cublas_static_LIBRARY +CUDA_cublas_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cuda_driver_LIBRARY +CUDA_cuda_driver_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cudart_LIBRARY +CUDA_cudart_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cudart_static_LIBRARY +CUDA_cudart_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cudla_LIBRARY +CUDA_cudla_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cufft_LIBRARY +CUDA_cufft_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cufft_static_LIBRARY +CUDA_cufft_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cufft_static_nocallback_LIBRARY +CUDA_cufft_static_nocallback_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cufftw_LIBRARY +CUDA_cufftw_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cufftw_static_LIBRARY +CUDA_cufftw_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_culibos_LIBRARY +CUDA_culibos_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cupti_LIBRARY +CUDA_cupti_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cupti_static_LIBRARY +CUDA_cupti_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_curand_LIBRARY +CUDA_curand_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_curand_static_LIBRARY +CUDA_curand_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cusolver_LIBRARY +CUDA_cusolver_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cusolver_lapack_static_LIBRARY +CUDA_cusolver_lapack_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cusolver_metis_static_LIBRARY +CUDA_cusolver_metis_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cusolver_static_LIBRARY +CUDA_cusolver_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cusparse_LIBRARY +CUDA_cusparse_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_cusparse_static_LIBRARY +CUDA_cusparse_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppc_LIBRARY +CUDA_nppc_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppc_static_LIBRARY +CUDA_nppc_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppial_LIBRARY +CUDA_nppial_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppial_static_LIBRARY +CUDA_nppial_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppicc_LIBRARY +CUDA_nppicc_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppicc_static_LIBRARY +CUDA_nppicc_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppicom_LIBRARY +CUDA_nppicom_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppicom_static_LIBRARY +CUDA_nppicom_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppidei_LIBRARY +CUDA_nppidei_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppidei_static_LIBRARY +CUDA_nppidei_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppif_LIBRARY +CUDA_nppif_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppif_static_LIBRARY +CUDA_nppif_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppig_LIBRARY +CUDA_nppig_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppig_static_LIBRARY +CUDA_nppig_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppim_LIBRARY +CUDA_nppim_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppim_static_LIBRARY +CUDA_nppim_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppist_LIBRARY +CUDA_nppist_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppist_static_LIBRARY +CUDA_nppist_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppisu_LIBRARY +CUDA_nppisu_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppisu_static_LIBRARY +CUDA_nppisu_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppitc_LIBRARY +CUDA_nppitc_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nppitc_static_LIBRARY +CUDA_nppitc_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_npps_LIBRARY +CUDA_npps_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_npps_static_LIBRARY +CUDA_npps_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nvJitLink_LIBRARY +CUDA_nvJitLink_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nvJitLink_static_LIBRARY +CUDA_nvJitLink_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nvToolsExt_LIBRARY +CUDA_nvToolsExt_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nvfatbin_LIBRARY +CUDA_nvfatbin_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nvfatbin_static_LIBRARY +CUDA_nvfatbin_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nvgraph_LIBRARY +CUDA_nvgraph_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nvgraph_static_LIBRARY +CUDA_nvgraph_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nvjpeg_LIBRARY +CUDA_nvjpeg_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nvjpeg_static_LIBRARY +CUDA_nvjpeg_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nvml_LIBRARY +CUDA_nvml_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nvml_static_LIBRARY +CUDA_nvml_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nvperf_host_LIBRARY +CUDA_nvperf_host_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nvperf_host_static_LIBRARY +CUDA_nvperf_host_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nvperf_target_LIBRARY +CUDA_nvperf_target_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nvptxcompiler_static_LIBRARY +CUDA_nvptxcompiler_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nvrtc_LIBRARY +CUDA_nvrtc_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nvrtc_builtins_LIBRARY +CUDA_nvrtc_builtins_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nvrtc_builtins_static_LIBRARY +CUDA_nvrtc_builtins_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_nvrtc_static_LIBRARY +CUDA_nvrtc_static_LIBRARY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CUDA_pcsamplingutil_LIBRARY +CUDA_pcsamplingutil_LIBRARY-ADVANCED:INTERNAL=1 +//Details about finding CUDAToolkit +FIND_PACKAGE_MESSAGE_DETAILS_CUDAToolkit:INTERNAL=[/opt/cuda/targets/x86_64-linux/include][/opt/cuda/lib/libcudart.so][/opt/cuda/bin][v12.8.93()] +//Details about finding Threads +FIND_PACKAGE_MESSAGE_DETAILS_Threads:INTERNAL=[TRUE][v()] + diff --git a/CMakeFiles/4.0.2-dirty/CMakeCUDACompiler.cmake b/CMakeFiles/4.0.2-dirty/CMakeCUDACompiler.cmake new file mode 100644 index 0000000..b284154 --- /dev/null +++ b/CMakeFiles/4.0.2-dirty/CMakeCUDACompiler.cmake @@ -0,0 +1,89 @@ +set(CMAKE_CUDA_COMPILER "/opt/cuda/bin/nvcc") +set(CMAKE_CUDA_HOST_COMPILER "") +set(CMAKE_CUDA_HOST_LINK_LAUNCHER "/usr/bin/g++-14") +set(CMAKE_CUDA_COMPILER_ID "NVIDIA") +set(CMAKE_CUDA_COMPILER_VERSION "12.8.93") +set(CMAKE_CUDA_HOST_COMPILER_ID "GNU") +set(CMAKE_CUDA_HOST_COMPILER_VERSION "14.2.1") +set(CMAKE_CUDA_DEVICE_LINKER "/opt/cuda/bin/nvlink") +set(CMAKE_CUDA_FATBINARY "/opt/cuda/bin/fatbinary") +set(CMAKE_CUDA_STANDARD_COMPUTED_DEFAULT "17") +set(CMAKE_CUDA_EXTENSIONS_COMPUTED_DEFAULT "ON") +set(CMAKE_CUDA_STANDARD_LATEST "20") +set(CMAKE_CUDA_COMPILE_FEATURES "cuda_std_03;cuda_std_11;cuda_std_14;cuda_std_17;cuda_std_20") +set(CMAKE_CUDA03_COMPILE_FEATURES "cuda_std_03") +set(CMAKE_CUDA11_COMPILE_FEATURES "cuda_std_11") +set(CMAKE_CUDA14_COMPILE_FEATURES "cuda_std_14") +set(CMAKE_CUDA17_COMPILE_FEATURES "cuda_std_17") +set(CMAKE_CUDA20_COMPILE_FEATURES "cuda_std_20") +set(CMAKE_CUDA23_COMPILE_FEATURES "") +set(CMAKE_CUDA26_COMPILE_FEATURES "") + +set(CMAKE_CUDA_PLATFORM_ID "Linux") +set(CMAKE_CUDA_SIMULATE_ID "GNU") +set(CMAKE_CUDA_COMPILER_FRONTEND_VARIANT "") +set(CMAKE_CUDA_SIMULATE_VERSION "14.2") + + + +set(CMAKE_CUDA_COMPILER_ENV_VAR "CUDACXX") +set(CMAKE_CUDA_HOST_COMPILER_ENV_VAR "CUDAHOSTCXX") + +set(CMAKE_CUDA_COMPILER_LOADED 1) +set(CMAKE_CUDA_COMPILER_ID_RUN 1) +set(CMAKE_CUDA_SOURCE_FILE_EXTENSIONS cu) +set(CMAKE_CUDA_LINKER_PREFERENCE 15) +set(CMAKE_CUDA_LINKER_PREFERENCE_PROPAGATES 1) +set(CMAKE_CUDA_LINKER_DEPFILE_SUPPORTED TRUE) +set(CMAKE_LINKER_PUSHPOP_STATE_SUPPORTED TRUE) +set(CMAKE_CUDA_LINKER_PUSHPOP_STATE_SUPPORTED TRUE) + +set(CMAKE_CUDA_SIZEOF_DATA_PTR "8") +set(CMAKE_CUDA_COMPILER_ABI "ELF") +set(CMAKE_CUDA_BYTE_ORDER "LITTLE_ENDIAN") +set(CMAKE_CUDA_LIBRARY_ARCHITECTURE "") + +if(CMAKE_CUDA_SIZEOF_DATA_PTR) + set(CMAKE_SIZEOF_VOID_P "${CMAKE_CUDA_SIZEOF_DATA_PTR}") +endif() + +if(CMAKE_CUDA_COMPILER_ABI) + set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CUDA_COMPILER_ABI}") +endif() + +if(CMAKE_CUDA_LIBRARY_ARCHITECTURE) + set(CMAKE_LIBRARY_ARCHITECTURE "") +endif() + +set(CMAKE_CUDA_COMPILER_TOOLKIT_ROOT "/opt/cuda") +set(CMAKE_CUDA_COMPILER_TOOLKIT_LIBRARY_ROOT "/opt/cuda") +set(CMAKE_CUDA_COMPILER_TOOLKIT_VERSION "12.8.93") +set(CMAKE_CUDA_COMPILER_LIBRARY_ROOT "/opt/cuda") + +set(CMAKE_CUDA_ARCHITECTURES_ALL "50-real;52-real;53-real;60-real;61-real;62-real;70-real;72-real;75-real;80-real;86-real;87-real;89-real;90-real;100-real;101-real;120") +set(CMAKE_CUDA_ARCHITECTURES_ALL_MAJOR "50-real;60-real;70-real;80-real;90-real;100-real;120") +set(CMAKE_CUDA_ARCHITECTURES_NATIVE "75-real") + +set(CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES "/opt/cuda/targets/x86_64-linux/include") + +set(CMAKE_CUDA_HOST_IMPLICIT_LINK_LIBRARIES "") +set(CMAKE_CUDA_HOST_IMPLICIT_LINK_DIRECTORIES "/opt/cuda/targets/x86_64-linux/lib/stubs;/opt/cuda/targets/x86_64-linux/lib") +set(CMAKE_CUDA_HOST_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "") + +set(CMAKE_CUDA_IMPLICIT_INCLUDE_DIRECTORIES "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include;/usr/local/include;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed;/usr/include") +set(CMAKE_CUDA_IMPLICIT_LINK_LIBRARIES "stdc++;m;gcc_s;gcc;c;gcc_s;gcc") +set(CMAKE_CUDA_IMPLICIT_LINK_DIRECTORIES "/opt/cuda/targets/x86_64-linux/lib/stubs;/opt/cuda/targets/x86_64-linux/lib;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1;/usr/lib;/lib") +set(CMAKE_CUDA_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "") + +set(CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT "STATIC") + +set(CMAKE_LINKER "/usr/bin/ld") +set(CMAKE_LINKER_LINK "") +set(CMAKE_LINKER_LLD "") +set(CMAKE_CUDA_COMPILER_LINKER "/usr/bin/ld") +set(CMAKE_CUDA_COMPILER_LINKER_ID "GNU") +set(CMAKE_CUDA_COMPILER_LINKER_VERSION 2.44.0) +set(CMAKE_CUDA_COMPILER_LINKER_FRONTEND_VARIANT GNU) +set(CMAKE_AR "/usr/bin/ar") +set(CMAKE_RANLIB "/usr/bin/ranlib") +set(CMAKE_MT "") diff --git a/CMakeFiles/4.0.2-dirty/CMakeCXXCompiler.cmake b/CMakeFiles/4.0.2-dirty/CMakeCXXCompiler.cmake new file mode 100644 index 0000000..a4dcfda --- /dev/null +++ b/CMakeFiles/4.0.2-dirty/CMakeCXXCompiler.cmake @@ -0,0 +1,100 @@ +set(CMAKE_CXX_COMPILER "/usr/bin/c++") +set(CMAKE_CXX_COMPILER_ARG1 "") +set(CMAKE_CXX_COMPILER_ID "GNU") +set(CMAKE_CXX_COMPILER_VERSION "15.1.1") +set(CMAKE_CXX_COMPILER_VERSION_INTERNAL "") +set(CMAKE_CXX_COMPILER_WRAPPER "") +set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "17") +set(CMAKE_CXX_EXTENSIONS_COMPUTED_DEFAULT "ON") +set(CMAKE_CXX_STANDARD_LATEST "") +set(CMAKE_CXX_COMPILE_FEATURES "") +set(CMAKE_CXX98_COMPILE_FEATURES "") +set(CMAKE_CXX11_COMPILE_FEATURES "") +set(CMAKE_CXX14_COMPILE_FEATURES "") +set(CMAKE_CXX17_COMPILE_FEATURES "") +set(CMAKE_CXX20_COMPILE_FEATURES "") +set(CMAKE_CXX23_COMPILE_FEATURES "") +set(CMAKE_CXX26_COMPILE_FEATURES "") + +set(CMAKE_CXX_PLATFORM_ID "Linux") +set(CMAKE_CXX_SIMULATE_ID "") +set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "GNU") +set(CMAKE_CXX_COMPILER_APPLE_SYSROOT "") +set(CMAKE_CXX_SIMULATE_VERSION "") + + + + +set(CMAKE_AR "/usr/bin/ar") +set(CMAKE_CXX_COMPILER_AR "/usr/bin/gcc-ar") +set(CMAKE_RANLIB "/usr/bin/ranlib") +set(CMAKE_CXX_COMPILER_RANLIB "/usr/bin/gcc-ranlib") +set(CMAKE_LINKER "/usr/bin/ld") +set(CMAKE_LINKER_LINK "") +set(CMAKE_LINKER_LLD "") +set(CMAKE_CXX_COMPILER_LINKER "") +set(CMAKE_CXX_COMPILER_LINKER_ID "") +set(CMAKE_CXX_COMPILER_LINKER_VERSION ) +set(CMAKE_CXX_COMPILER_LINKER_FRONTEND_VARIANT ) +set(CMAKE_MT "") +set(CMAKE_TAPI "CMAKE_TAPI-NOTFOUND") +set(CMAKE_COMPILER_IS_GNUCXX 1) +set(CMAKE_CXX_COMPILER_LOADED 1) +set(CMAKE_CXX_COMPILER_WORKS ) +set(CMAKE_CXX_ABI_COMPILED ) + +set(CMAKE_CXX_COMPILER_ENV_VAR "CXX") + +set(CMAKE_CXX_COMPILER_ID_RUN 1) +set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;mpp;CPP;ixx;cppm;ccm;cxxm;c++m) +set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC) + +foreach (lang IN ITEMS C OBJC OBJCXX) + if (CMAKE_${lang}_COMPILER_ID_RUN) + foreach(extension IN LISTS CMAKE_${lang}_SOURCE_FILE_EXTENSIONS) + list(REMOVE_ITEM CMAKE_CXX_SOURCE_FILE_EXTENSIONS ${extension}) + endforeach() + endif() +endforeach() + +set(CMAKE_CXX_LINKER_PREFERENCE 30) +set(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1) +set(CMAKE_CXX_LINKER_DEPFILE_SUPPORTED ) +set(CMAKE_LINKER_PUSHPOP_STATE_SUPPORTED ) +set(CMAKE_CXX_LINKER_PUSHPOP_STATE_SUPPORTED ) + +# Save compiler ABI information. +set(CMAKE_CXX_SIZEOF_DATA_PTR "") +set(CMAKE_CXX_COMPILER_ABI "") +set(CMAKE_CXX_BYTE_ORDER "") +set(CMAKE_CXX_LIBRARY_ARCHITECTURE "") + +if(CMAKE_CXX_SIZEOF_DATA_PTR) + set(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}") +endif() + +if(CMAKE_CXX_COMPILER_ABI) + set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}") +endif() + +if(CMAKE_CXX_LIBRARY_ARCHITECTURE) + set(CMAKE_LIBRARY_ARCHITECTURE "") +endif() + +set(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX "") +if(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX) + set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_CXX_CL_SHOWINCLUDES_PREFIX}") +endif() + + + + + +set(CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES "") +set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "") +set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "") +set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "") +set(CMAKE_CXX_COMPILER_CLANG_RESOURCE_DIR "") + +set(CMAKE_CXX_COMPILER_IMPORT_STD "") + diff --git a/CMakeFiles/4.0.2-dirty/CMakeDetermineCompilerABI_CUDA.bin b/CMakeFiles/4.0.2-dirty/CMakeDetermineCompilerABI_CUDA.bin new file mode 100755 index 0000000000000000000000000000000000000000..ca93fd3f56bc2a2761d938a9e03d2a91a96461a7 GIT binary patch literal 999680 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�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
|}g9CyMdlhHn;E-^>`; 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
RC(+BCc5U3Bi+`|?Tznu5c#|J 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%0DmX8{{F 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℞G3%9Smi_G{5cxZXl(_#(Y(HjwhdfJo#U|$o986JP`&&tD7FhVZ$9{&= z%kay=D}M`#ZNjYM+s_t%ZP*FIlD{Ehx2)y$p~2o)zTU9?ge8CXv;{kh+0bEoEiN-` zdtu4ndBlzdi}AbFvKJWk5Durx-!fu*F&kK`&jbnYU~4@dmIzD!77*K>S+7R3?C&cA zk-r;AiSsY9C)Q9K{ND6gbHe-7hHndA`CCKmG-jQU zW#2OF0US=jlD}h!9mT9$YscAm!!8n*{LLdapV<(vXEM&7Fzh&C$zPY)HeliJYCVs! zvm3S-Smkg1FTfu9H?e`?EzJ0h8n%tFuX#AUiq6rY!0(dz>djp4ckLl@^^bC*p|$? zg?1lWW7yWhlD{*F-S-K#AvE2tzcUS+#NiZeAb(4VT>=*V_HAxF8*kXTV3ofSVka^i zD6rS!NyCm6mi!G6JA_%UOwVH;zdZ#afA1wF&cAKIc4yWfL@e&tn4GNz*Zxi?HXSVd zU2Q!Ze82X07Y?V&-(q5SttQr)ZP}J4_Z(r#U!T|o%(`Yg;CI6scC@hMZ&PB&GaK?Q zHl8(HrrQt|mi+zvO0WaKlD~SKCA^)6Z2?yKTTN_dW&=~~*jZ=Toj9C=C4Yw#o5rkH zo1xmk{=O#=`8$V{IR6s6Z56e_UqN#-;nkR&qXpOgI>gQa3x8+Yc|6(hIpCGQbyt9` zVAfe{*S@%6(}g8}rx4qRSvOUmckp*H`)JR$;c$w)KMInKqPwRsNFdWqP+O#pK0qh9AZ&l`#Xr(9$?{bQ#&T_GW;~~%HJ@tZJBjWwl_Z9Y1k3MlD{Wg zgFW^!<#ns==X&?H(*AZAmi%2!>>6f6gX~%P4#TDiOa4wGb}Cr-`+Cr{;ReHQ#6ed1 zTSROLvjN|>;TMLTDlGZik=Q7+UZ!T*-;n~5zp13e{ol*Mwr18}aTWXfyZcPP1lRtq zAojot_P4KHCkGq833%mi6|u{ib*4~W*@u2>*mXF_f+c_Z6Z;yoZpQ!0J6Txrw*#@m zm<>&`*SN5yZu1af$=}15fz1XBe^=W!+-%s+V3ohM#I|5Iu;0$ND-4?=Ecu%tHo2Vg zdUcv*e>dO+i-hFw!AsfSzQitK)?X1|f4`$w7@sV-_O~6e6Ts5?K&*K7{JokV2wwTy z&z5m;8+p+l<*zZ+q^$$K+ilEcx4; z*qzJR-=?;`4;pqNSmkdfv2&RX47c}{?>FoKVaeb9Ey0ds)~mZ(wU-U+BoO(#`V#i{ zePa7D>mMdI;jN)p7(ao7De7x~D~Zhl3x9_;Gd|2P{BrQh-$G)WFzXap_GQCP5SIK6 z5xZq6uMfp-Ox~vr+fP{Xch99@XE7UcY~BYA+g@1mcOJ20!D9UGxzOZ|8ukzlr^??l zVtX+g*lzEU-elM%!jiuQ#I|SFtJZnhuvY{ke_N0e=U-w^)KVM#N@DT1^Gwcuf@^v)}KUsY{DC8axM~F`!#Yg*BG|7u;lMdV)uPSZ3qpr>?MXx;&6&KkiVtG zE&&UFXWDsjvV|TGbHOTqBg9T*HW0FTzccJuVaeYBu|t^kOnceio&xduKuVl{n}hAn ztnX19@E21}&eno!f2R|h4wlvjySL0Y{4N|$mA}Qr?)s2eXG)s67H=AMj^7r$L!43cmf4AB*ZD-Sl7GRaX)x>sY zHc(*O(8jPkaX1A_{thQLjajcs=VgE26Nvmhmy|gF61#0NwZShXHsO8W!}LpV?XN@Z z9I)_rtNone8^h;-SN_&zfURKG*=~LK&ammilD|`k?Zd2FYgyZlZ8)4FFZnx^*lU>$ z4YF;pd1nYq{(8iwfTi`po)K-{60pkORAM(SA~w*`vOk*kW(!OHu1yC!gIO;_&kOdq zxj^La0aD`pOYCT7{lj$K65ih~*8Xn8Ar|$uzk`VF0T%wgZs&Z$@YBF6f5XJKW!Bkl zzbo;KVMho{{+5tjTt8~~dQ7XI$B{yuNm&R~_lwZyhyHgNJ>b1jA& zHbq$SH$iOjeah=)>T$;YZoml^3CZ8PNQwKu#4cji&!sltZ@8PBlLgoQwj*`|Sd8D* zc5YsBm-crcc;#D#Gvo%aL|r^rkG#)xgk zY{;=b>@(~tVaea##O_?c{`R$P_`l8+L%O03asQXte$4tSTCu-VOwJQHn4-S+x02W_u(ZFq#)oplF9)yuEhM%Hv(93B zAAF=?CkRXahKSwrFJ2$2?U?Ls*nYy2zk4nKJB!&+rDeMtw!N_A?>u71g2nh9YS}9c zdkBY93Wy_h|He{&4GL|F2-fY|oTdWCw8Vt-!|i2U6VWPe)`dtyGd!S{&8ond-~ z@qU79e|I+pyACY;?W*(Q{;%QNf>-|55Ic=oCuG^b8TJ4Ur(nt7F~p8y_Vmx^|7h4n z!jivv#O5;_a_k%`H|#iJ$zPY)HelgzhZHj&KE6};uNPS5Z+#lrL-U9YgzUY{J51g- z!jiwUiCx94SE$>-h8@JI6bZ@SHl)P)m)Ob7`rKap%Po_0k>J|jTw+Ing};0Bx`X?O zhOYpx{LLUXhgoNgZUffpi*(<52uuEMKObyMX5C`DPJUt7*20p%Gl|_dm)a0=S{u(k zF>DftQ?!BnEhTmdSopj3)G2*le<@G5VJ=wZZ-m&1%m!xbdye>vYbNhlVaeYBu|t^k zs&roVx2HhlZ~?eBDA)4{^uJe@b;-ER0@IGiefi;3O! z9$@NdzaeayR!bC zit6h-T5#>JL+l)|@b|brm*8K@7(NHQ^0%%D*a~Ky5apHkdOsRAU0CvW3bB2dbyF?- zyOadxq^UEcv^d*fq?C zDlPklVbg>qeP zjNgFCy$%Oiu;g!lVqas{&9He7U!e0&7MA?&K0 zadVA7G;C+E%HLXITQD1#V%L(l4Vxk?`I{g%`47tLg*D6mZoml^3CZ7`x$JLWViz&% zd(?)6_YJ+m_+-JgzwL;f02br7m2K}1!w&?n{B3AFALn1n8*_3g4gF2LeG^~^<`-Vu zbL9g1r9c(<6MQKty+6cXBgEC-9qAqE6J0t^8QqV8v`iE0>fOm-7qf1Si&xi!VWJT$~z` zpP0Q9{K6D;9UVT9a~}SH;`hk~_c{=j|M>jCn~lwS+)LTBO14NbMVUSl<<*-_*=Y4|3fl{ONI2+ zAEx4uFAk2qw}e!$1g{*6pD7=gFQFgd)qDD)BZDU(PoB#2GUe%wQIn*b<_X`yS(`58 zeUW?VV)n!}JO*j96|B#Xcl-_>MB=$aQ0g-DgkIuqL>`PhL|u{bKn+Ts3-mS|!z$O_B2d1S943!Q02p4dG3E zVZg75WP zPWX6k?3!S$Bl2N^PCC{KR4k4G#XWBtJ1|Y`8Hm zaYy>#*q9{+u~WE$Ng%-vxnuGFIfM0hL9QF~W8dO(q?RAKF*`W_NHTWhRAYYEd4!kl z#3jzVl85JDI(8?1OJmV}5RX?@_Cm26Z~=4UFVY&36HD|!B)MmxlM<`!Ll0lV5JZOa zB|}@NVwL^qg1-afgi#7ozU`V`LeX+ro*T3bmZ~mT6yqOa=ASCIr)J+IFWo;9-K_hln1AhQ{_Qp z@>M*@>$;t{P9LLY0=iSmu#zf7-$L+&M?8AQcVPUlE zCj5O?`UAM}bD)hxTUzN{ zURMw11b;ua2bLRL%A8<_O0p{c+Ei2s&Zl3J(HNUTMq*gdll=IE*YHw);y0~v-Ba^p zlko3j8uMkDNUl3bqd*Ocrpa1xN^X#&#rM z!VxIhq2Uzfs9LYFCS1z%Z)Iwv{KtNnjz1>TP%yviVxE9s<;A|j&`;MqfSVMb-1+0F z#)7U#OZQUhPDq^}pH9p4;Nb5kkz3LDVtRTo68wF?wrwy-Hv~IyHvoJxI5=`^+Th^c zIz0IrPqsC|lZ|-t9iD7I2Twl7lOOS9M=G9d3U-*3f}B_d6ZA8;Vs+`r*?j|bbqiPcE#7T6c($b6(M;a;5a{|Eu$Kt zy{{|3lieuMBa|qH_=MhO$IOeJjP%Nj9qJh^-4^hem!SNAld#WIy3|;>#_Mq z;-xJsj|3}s;c;$!Oja(YU1cYXzYjCOe}q#E&VNr~vd5P3Zg(MG%8ln{<;BNj=TaB< zfQWq1aNxiJ9=|zQTI0=*;`b8=D{Apl{K@qEcxvoeQ$w^(`VRL?> z+0O;>aDFVD7i)^&CmO7XQL6Ze^t^al?0^Vjn`^&qlKNAJP5Fry2MgjC6vWaBV&@=x z$wN8uVoIH3&`q`9G)et2(qYq`iS7sU;}}L6(O3|fOFHGoqm(r#wo12SQv`Gl;dOT= zI{!Nwza=l$B|ml^HN5f;x}d6)k@A(Pxm{NVpTj%IMvUkz@+G8Y2F0(!o|zRsl{55X3ShV&$qlcI3|&Rf3Sv9+YLi`Z z!mEeY(ev<+Lx19*>vO^@bA}$J$L!D10$i?wMEA`F@hkBwKTBKg*>yfm)9jRj*jEMd z%MlA!)FD*R_2IPAy}9wy6e!YjF)}LXZ-=AZ%YyT<(QJurMI&)iIY6DO-P1BxS`wVU zE-$tPjX|f5=MLRUmC>VBk?@9S?2E|IgA~Y%eF-nJ(DnAw+Pz)Smu2BkgY!QLug@8} zi51~bBB}=~rS;)Y)k~2uvMePia`Z@EqV?uzyc=$V?= z^=KscYHg(a=Szc=Y9kdG(4RqumpA7nZaW7r2VY$pDgWuxNO01}ITb$!D`?Y?#yhVp zNIZNlzr3vc7`?hAr(#*K;*TQ!7P*_4+$U7-k|$JN=fConV87v<=bfFi<8sy7)-qSmo+<0&7 z#xyL}2P-B~Al#T6`}xjzv#)4IJ{gashu25rU5_3tNHp145XVuaX0juBrS+tR1nL8 zu=Hi!Aep0^gU|hr=4h;cO0pfAUJx6U9$vz~`IX+@$om2ex;2=i1+lMlW8cOwxxP!s zd_}L?do-dkX1|E=4E;K1=n@)kGJ)FwY##|P3C_oq{aOur4CXGm;jN^}mHC<*K2;F= zHdp3qUhNM!{w`54sFeh3@Z*S3;dSBlQt9ZC{CKm?1?bo%dy09-%)x|=V{OFH8-PGT z*P^u2@5>sfp;#kwu+GT5&xzGzl}HcHUx6y8YQJlVl_huR7u0-o6ish~Zhw*+{yBH( zG6~Z9(;hJ1GOSY#l*J?q`>MJ0FddpSrXlaWB@sNws-hv3tL|B)6hASg{%j@cL$&gL#R&&cQ^(%b1iE>w*=t z@M2!P^JnG9@!B)zo~=#D%Z=rYc=_HYczG#nmqaR-mW+gOGm;i0Zg))0+MJ5jC4EtE zWdyStInO&&bPGh3t{`#O`8r!|#U~|KL-JV!%>YjAL-Uv7(3F;oR#xK9J{=8kog=X$ zn20Td72DA=nuz7tko81-WF$?*l{^vYgqs^LXh}mhmqx~4C=mWq`JEH{0{ib~npdOs ze8h@bkZ86!FCLEaW=j+DK0P7%#U|JoFb^)p9!ScY|378u|528X*G-GyIGWq_-@)e| zLl<*nr7e?xe4M7_nDzygyMh(HarN`!quci2mHJh5AwT{^kL2%&q25;_QV@TpM}F*R zvM&c4OG*lW=0?)`jYeiCSA*n65&(HNHF7Qo8%utV0thrF|0-0;gPQoGA__E7rikvE7@>$? zY2qP8T&9V;5IDV&gD2qZo9u$KPVAPt;Y$@g@aJ+gv zKQRhB;Smh#Wf=Q3BXTP?1S|f5m$3oi3juCheZPfGc+uz&yxAO>{4STBtFgC)s z0p?<7ko#LXvD*B2>(BT=H5RW#@a{Ccz98P*OhRmJ-3nr@3M$u^+#kW)M0)iyKGe_( zdQo2Ng8bMe(3f=of3;Wqf7;S=iyy@ zKIY+*P5XN`w)MRmReyMy2{-QPdV+>mHl6)b_}u>%1SAfBnG5*~EXO*A`H%MySe6zX z=GT!72iC?tWhftsk7-G#teHty+xEE5LX!yK*)y`SM5xOfw@5@!<( zyOnp)yAt}DPCr-PK|`FLwoyOZ)6bQ6(2Y9^cTqpH>F3HjqUvc6^|KHEO!!NW;5KtX z0Zo*r2P6;O<)nm{th{X)y-IhGR+iK84!vj`94lXfhrx{7Mg%j;$MVDS3G!nqeyqH0 z2>z>o<^2EXkG-Rb!)p0H+=%#ybSWhlN8>Ndz=L>?G#s%iAHNt=H$I$h)&?sp@gy4m zU@Tsy^}BWQk6)QU@(;MN99_w6!RsmU3!@lz`H9Y}qOni%yB-KuY^1$6-iFrR%5yHk z<3u)2XGilp;N8g&=i)v}u;QN(=Epw9E9nLC0mm3^k7WTjOj3gtRaBR5sXT%Io?G%D z{@bJ^7yoriuEl@PD`{R3Zv%NA<`ql#LvU8;i~kO-{O=ImO+QOmjgZc*n?^f0Vg+44 z4pv<5(&80OD~K0SyGyZC3_$ljElBi8r{@Fl9NXKbf<&K|^t>0Ix6F_2C`b$;OGrO%}b2J;<&4{1$vo{*s*Br6rKnFkG*#R zkE%KszX=3L6`kNUwq9bJ*3fH4X-y2;Y?*->nE@f) zT6?pe*0#2%r?nR?R;vjC5>Np_0i_BE>K>z9ya0ld@AtlI?U_kH|Mq+S-}n8W?>RgV z*|XPeugm+s>s{|{Wo82wiR^V{SAkErRF(NR91XYTRaHshHe-(T+Y{%oK3WqsZs?DPIB`yQ9+m9-B(bO#v%Ji0<{+LxR9 z)NSIO$w4RwBuQr{nS=@wWcoQ@n}kXd3`l;(Bvg~2{6XudO+pO`vI3#j<4EA8Ryx!= zlj-)36&RP3$fI;G8h*p@QBilt1>T5Vx?|s^{r;+7@lDyVAw0K|ko1rj_4uWlwnz5s z&&dA$c9WFZo|>BUMpVhBx=j;$Qe%^Hc;!1L~G?dJ9&MER*M0 zkhyb!{7P7qe!d8$&ww~2vXhXFyqO&KJPiK;N8!rg^owMH)6)ev&_)1>abV4?E5E>L z{({r|1*iE7PV-lB`ct5Z92~W(!RcN}2B&)^8JzBwWN^AylEG=ycF;A0(=R6LUJPZ< zLCzA-jsc?cI6a+N0te>?I6b{w@GmFEZi=LR@EU2r;?9TVU* z5^JFm69Sy>0H>$#6FR{>6>wVD&EWMtNBlpG*Qc=P#dv)b@5OlieyI2R8-3ni==1(m zpZ9;*_e1ddJ~9-7JXUF=uJ-r()V+;&CJ4M9Y4CcMNdT{P2|}$?O#*m5(%|)2lK@_i zGDb_rzQtD9kLZJuqfJtCXu10&IxdOhbHVv4YN4?qQ3W}PO=qN@gCsx&4Sa5Jkwo4 z=t$jbp@pIY$|Lm8DejGl#k|>*z~ctGE%>bb2%Gb&&XF~e6nDEsbCUTz=$-IBqjP`N z(Xt$4%^tnF*B+g8pCSi*R=hCy%ntk!_vq899&c$c#^+v12A_K+8GP=QWbnCHlHhaD zcF;A!XVQ{&t3sK}j^cOrLN<;og$~IceFgOD*<|*T0H3cYPr5H8vo{6!d;i&zTP)P zrJ5^34?P=qS35?ig2V<%t%_0+gLFFX3I`FVgHX#|Y2_(w+lV+Zx#)754yc3#>5s^5 zBjMGNrVWx3dT3uXj6_I9v2k}LMMnNQ3GwV8hs;35T5Bj1bl*=b&``!vLBqzDl3w-1%-n$eLNy77LS17LYDh2?>QYI_Hr2|kwtfrrj(8&#r4^3a z=_3cA{CPX-z6}4dL-~)p$rCztH~P)K{6|L9l>hjma1SYce?$0>d92$`f4Zq8{KuDs z|CnG4z<;E*!1=a?fd4qtR)GJ|3ZLYihLWvsgjx&yN6>k(If&LR4J{a>1Z$6QAbb5C z(>VTkbLT*%%(19*)64}3%@so3!bel1zYLnTkD}{f0 zt3l2!=}M>h){1_qk2&5~dyfCEKbS7P>hC2_o`2M5kAEYdrGc_!_8Sl;ZDb~m?DYR| zm_{zpMt1st*2+8mZ`wxA)JEXGd$n-wVOl7&EzGhlRNEGIO_grkQU&Z3_2ILJX<_-R zGLW7A7i|l#d{qY2xXHfpKW1=ZK2Y(;9qX$0r)R!;gg4H;jvfDJbcEs@Zx!99)2w? zWUs9PY2FF7Zb3a9^X7H=-z6E)nxn8Jr|d5}a@;<5G#&AOLETu(Blk*X>hy%?37Lv| z7Y;$)Ac}H5Vu$xUE=+LG_-bzgNH}Iv(E-5n3Ekk|a|)$KtayfBA-$0;!0`WueIKBS zds5fgt^O@+xn#V^>-2!IP2cwj{^oxX2R75IN!Ai%#r+XnLdKkosrP{2Ri?fd~C zq3E|l&~LRrlPccqnuIr|K}1l!`5%9bH=`-?28aCC?v zcgDOC`*b{uNEJFc%YH2w&oq56jAy*Q7mequwn8wTFWCZle(qG;Lcq@*Z7T%)+`-9x z#}jl{1{9SO+Js_;ZWZOdV-xn^nIDbFz1(irXQPhiPCK4^DJ>usjAxO)7sk`9??vO8 zX)6TdnQ9B<$1~Qp5RB(MTOkvv_SatJbd0Ob@MHOtN$XW_ajwkU z10gy;@og0z39l|(*Nn2<%$<3ADt%wr&CH09_ zZ_Hhu`!x0C8K+*{eJA(woB8&zzdd&&mLMv2N9OKNez{bbm$PHuDRVZHj$#6_%Vz(q zoV2moe*|OVSm(e={1X17hB|a&IuUL+yz=vhbEnUXj0XoNkb*6PuJe(;6_@!4n>(mej@v|vUt$%Et2Wo40fOeyR=-$ZR?XJ z4FUIaiR}3mnkM=@%0b@Ssb8sS_nEXxQ@2{v7MZkaQx~fW+PlT1AsmyswVF0V(pr`@ z$OKYf(lQevrMYorh+Zh>4c0{%p#|H^;<7qd^O9gS+$Ungx?(Lp$55YRXj_S{%YP}j z$Qp>@SFD9KNbz?-YBGOIQ|I${AeNIYtU)BFwt$P2IRn4(*mgD$H#<(--l6O ztp3dOknXb#KGmHm5cxI9O~09IC0o;>Ce3sbphk*Gms^vpPDe+$t)rtDgBJY{{`?RA z9_pfjuR%JGS=BpCK%Y+P;MT_$%E7i z`>eFjYWu8_=kkVHDbrxnV)i-SJ}1euvtgP%mN$Hz4-bHYm{PQ#N>}iZiDPG#J@?>- z!Tp>@wsdiqk==XBmj-f%K2NQB!%*WQtKMVic3{VkBn;o((=?%r$A?}97>gekc?-FS|;%*FDf5vIwPU|l@!`5NcyD8y?Fe${S zm*!Jnj(8WFrq=|;*E#LmDE_=NZ0*==)jAF&RWTRC-r-fWA5sqlJ4&$_bg+(GfL}9K zy@S-KcUMx(JT5P{6PEcdEDbhtFT-ml-Pbs=BFQa}xZAL^!$i>7_ljUQVg$Ddw;Quo zq{D4!d96{M7|x1x7-PAF``;IA};=TZY=zQ(K9C9&Ol^bM`E&WhT8ScuQ(hi3})Z~ zD11yo;Rfu>=2y!i`T`4o&)auL-FLC~TrKmNY3l_KFDX0(OCa!23OvB67#mQUx?Rf8 zmo*dk`M~m+z_2l{NL^NdwGS+7+fLPd^maq)c;a|wh*l`#ql)ltt( zSSEulqI28ZVtE;HyAl0y-bX8g$>nONy&FA6F50wR)&-BD&UkwcCaW9J*bP9yTkWJM ztNmo?p(mnE&qy&0G^M1|v{v3C;pdZXcf{B?W0{F&U{|zhiz)bIp-Q2+G42en4Zxr} znXSTxue1vDQvrn&bF*1>k;@j~;EFsPINs$mlG&?fv>br>`XtH1r9(a*UpKhOhb}k% za|8Ps`?2L0;MEpbO}~rkJa0iZqs*ODjuBbhLs^x*uq5eTi~ttK_y#?n2$+aYdxkmn%^?bPQZGMENg<@8Oa>Lpu*U0V?3rGG`3@rOuP8&h>7)FY{%qd z(wEQ=I-JaNsnhrnzEG5>|6;+`E}Ld%Wk@1=i2ow?(_aZ?e!=lhuw@|Uk-%!~Pw|4) z*aGsS-XI~csx~mz(`&C<6m{1H_R}{8R+nn(%xdOwrzdq$V05|ntvHsp3GdW|dm6M& z@TB%b>Ye<-_0o%Mha9X>qIF9`3&iZvaZmOA7{_9FetGUmEVBZ>(tE6#MG^PW6|5b6 zc!r3g6d#3~PpKSj`sE0((PQA{E?NlS<){@i4g)VqZ)_#%K!KM^g_k2~g1LT9padO% ziCW9bw2L*b@b@gyyQ~2E`~E;tr&%d1|2mBc9(7lUnJqvufVDH(OCys3n*1iHSH(=&_lLeUVj4S|{=FtK$#@_xC1(;Dvh81GOm?ausTLdpR z>$)e5z5NjE=IhjM9((bg)Wwc2eB8s}9)Ni!;SEZvucHKJuBy)6t1!c%3P?wI zf#-AMi- z^PPgflwp}FB3>i^=T%1B#wUf%m`{U`3tN_Smx_AXT_16iUH)IAd;(#9#7lOC(QYKm zy)=#mH31ixaA$BJpH>mMJyscWW7Q3}&#H;sJ|}#YI|tW?@wEZZhj1$f!A>#D4GlP= z$NC6~I!9j%Nx^JUJ?Z*nLf@&<(A`;(7yYls6UzJ>%^iMBTOwvmj6@xtWo$CCJh7hz zMf%r<)esD8`N*%A9Mb!U4D2I}@3F%8WJ%^W>VmY4npPs*FTC$6VS1l+E@F)o08X$Y zDOwOFT={ZFP_ewB5*}+>b!UU{;51TL4|GZ~A*yG@Tu0Z#3hbtI7U{)+`@YTk-+z71mD&q+EQ&n~1LK=!7?Jl1iz&=rpd= zYP#@*Ben$H8Us-4=JB5HFALI?JEN5W~Qq;%62OZ;=Agrd?V#d{9gv z3QjBGHP|~?_ZOHLabUyG1xGb4E>7gu8BKgw9OJy=?0qxo9rrY(JbhgEXAA3<^o|ir z=Zbj!1!d_s4{^s?6nFP>ba`CX!Jl?M^bdOD-3rJxRFb6RP>vk}vUAXpiS2qr^_7z2 zjT30B1i32Ec*Cj1l(ik%`;_x}+6-9RqsfAT#h^D#q!?4sj`Ohawk&Q&zJi=Q@Mkjo zZN$3}aXMaf95S}T;ktpB;aUzP>k{5+oOg_uq1k7m-gsy>o`xS(KItNqLskZV`_bD@ z)qM1J4SySqGw;4=`P-QCw}a5Ta?+V(XDvO{(A23aO=^~TVBKHf+#`n;w>xlUTm~eR zN1C1xsKJv_IN$uCr(F*{YCFSe21t`b5B9D*?7@Y^H5_UPEU-D!)F~~%03VFvy&w28 z`iN{f^E_>R8TUs5CO1l0gQiVVC17_anNtrt){1m__esj{~9kZiiDpDu$7ka3vtdt8~v@ZoB|rLoXjVAB`|vNdbdon4*)(>nj9i`uIOosQ-iT z8ddlp4X=WqNV+Fu8@)Dl2~G@}{c*$d#=Tmc0+TKl7{>oWGnEw?0@FJ*=^hKdiT>_1 z$8$7OnV6vAaMB$@!<)qa!Qi>kllh^A;{V{dm&g1g7!Ta-q;OkqreQ87iNnJ-I1Y$) zC^N|>Do4`&WFLC2^jY`~q0G}_Zu0K8Li3a5{AsL2Ur`ft8yE2sT@*SY335aq2%XSa z4acxJbVBs*(6D41(I)N<4QqtNMz`qqWIujfPf~}8K1x!a!p`o8Q>hm-bmuZll zHkO^|s|y3{e9U8)>x}xQBi}B=-lqeFk=N+EBdbO2b8P3x&kGtVA0Q!G*#8kw7tgTa z=ZN;Aj_c|kQRdyq?l(>q&JWQ$DAQ70ACvA@Y^^wI2V3786~<99^pFHOLEQ3^*y>S? zGS%Tu z4v`Ye)S+|#Ar75OlrF0L$T*aXLuYq*eIyVfy(07$D!bkZw>wSm3IUCTcLu`>uj%c{ z+RLAFcOv`wXJsK11Fo5buMX@qzSb;US-4GEoq!+0y3+V}re0EC>z(*o<9OT8`G>5u z|Fd(1r5rOJ%DY5#^Vv&?k1!efiobaYCqA4bUvpaC=Uf&&tbZr;Lj2C+*?ES*;@*i< zrHOk)o)F(;HY)C&oX*6zk~7$op^RvRX__Ou)J<~a%e#iA($o{0PMdPzE2@{e)HWH< zHV!gXgxW_k=w--Rt1h8QygRKMDyPe>>fgCi4xXk$1O94a(b$mL7iv8fnq$v9j{A1~ zY$)u*Y_URR-lm7ax$pKmp|H!)|AaC>BH!qQ=NcZxP*~hM1ODWB`2zhQw|lEIbH)q5`Kj2c=ncOG441K>S`H~b3e2)6!t?Zr@s^Q(s+7q z3@yBZ(MH_qG5`Kr*<-Jnl;ggoVEi2Jde}S`VO@6p@Fz#>MOi3R6|1?kkJ(lBh=IA4j2jxKWw8E zh!rp1+$b#N+|m6-bAB*F*;Hk`ZW8=(oVXMq)D#?`?RmiMnyhiSU~JwFujqbBl^7?2 zOTETCh=fKc8hT>T+YDL_jmzag)Ce7T-f^EI09yMS@HQ(a7#fH8n$v)gYsWM*Jfs195NY%va$LRPcBRqUN)>7Xu6&0hEw)EhHcWlxDJ!7%({g(O! z_@HSWh5akxT~kTSp?7{q1f%S{7+a?zxZ_h#yA{{}n0Svb3T&6rG`W&2uX-0ZNC>f?TZa zq?a)19qV+`w~*owK2c|UBfq_d8Oujjlz3;kdwY%_OoE2bOUFp0KVQz8TECN8PoE&Q zj{1evx^PC!`(86WYreU>UnnC1wlGu`#O;@xT)f`&`$sL>@7zez7scHD;kJiwqgn^^!joIHQksAbg%#+ev*drWLQ!GY|9ZE&8<;oewhhqOez zyI855SkHEU_9$7}^3STFl*EAIuS93LQ}&U+_v0hN;_bZjeWc94uad7Py-ZalPa!~i zDWsI>i_%{9h90(D3^;BqlWKcgUL6q1RHExjVt9ar(OV?eBVzn`4}$v7a$u}mH*ZL1 ztMq|}`nl^IJxw|4G;Ul^whj`o#62`T#*3^j!ynpPEZI)o`%dT{_O(WuiPUw>JIb^} z7AAuo$*fZ{&bzF$EX>Z)9`!u)<)<1#_aN3SXa4IB%qw%V@@e+~UY8}g8~GCFy~Oli zNg`i+wT$S0GEr6pBhmi~^X+6uslj9GZ0U^-`x5D^+bV*}`_X?0&f{=j7R+Kid&7AD zSC`04en+~)1b)9Qydqk+3~IkIbWgie@&qqLKEib=Qnx7>l1xp+-DGAZCwsHtHA60s zc-i}903AexlTIhIvr7{7KT}C*hFF9>3{ub<3l5FVLNmE_r7D<47i}W8TLi?t?m8%ru=R`AKoLAei~JZC%w2+!|0UbJrvA6Z0-uD?j0t72_0&WmbCL` zCnc1rXKM-fB_Z-nDOUKlvT<~0up+Ef7VC?S@6Oi{gatV$q(9)IHG~ zQ=Tv(U{unKw<$pJ3!3Ct|J3Td(voP&$_S+L2n$CMcU>$yt|V56$}%a-=H0TojBuFl zs)+YpGb|x=I9M-)5Hn$k`h~Vr(3ssaVTGoiNC1_5Zj5)!UZjhABHqt?&CGq;#HKTfyw-VkVc(~ zu}sAW*7%$KL{W`IcGQ3|UZPV*9&wjPydM>&pOK#l&C8YZ2P!AnA94R%J|(1XH82_X zrsm0TEIWI=ADtjEav=@NTON^ydSKaEgBDqXx@EOa~Zx=v{1QWt!^vlW^a%Q`E8zVsZgf zAOd}f71Gx7u&I#gW*KCsy<@zPA2mM+cn&dKIG#$emIM7$pBv{THp96%`I-}m;|9P4 z^GHGXKwM2nmOxqHHrnWP(67u^Cf#Au^YgY$8I6aiR7@&UN8!I&|Gi+dlbHrSf~k&Y zCjq=f+L%uKn7EhH{#R|KImagi zb9d!SdRnqqqY2dCOown((V|Ax95nZZ0)RpYieU6)X6S>q;~$TQN6>9ephbZexr$xX z%znDiYfp`oY>=t3d>(Vi%)f6)eeOZt^7>!HM<6)?kR$b;o!8}%hV^WR7*QD#9lEQn zWQ{BjGpC%5BR;>E1J@4kxjBzu78+e;u$0Z&Fz)>x$ZNnz6+>la8z-Ld zo&p20ykwO?d>$CyA=)TVQ-n9ReYzuTgQCw3@&VcT%@nckS~Mb-rhq)*Kzf|)=5xbp|^-+db#D+)RcVgMmCDaw5ahK<7zsAxQYQuazw6Z+Pzawj0v`r3SZ>WFBP!ok$`@7 z=8llXEnbz!L}^DW!NM%b{a#YsWrm*SB$5{!yFtm^J#ZSs7P_Gr(>0C&^T6``UAWO$aZFXGd zxGlG+>|;S9ad$og(>x z+@q3MTxuY_HIo|@+MnA^q243-5sgRc7g?Ya9ev5JTt>fGbZ$SIi43;|VAYm8h{ss( zH7`}zj2O}*sFr(ER=1d#{gg`ZTmetNB#cSA19S(732?c&OB6I zroO=6fvJ=EI|%bHs-WhsD<`g2{%5N2v#Id&^1@HdM1yKEoXofwCW zhg!vdpk>~6IF7UV6~)+CSMKAy#JxyWS*(6iStxUW@1cpR($yQ29j>bv%G^P6+$)is ziWs_&P)77NEK^A;#ozv^EBHGgHI~1nse1krfrP&rs-Md-+RIF(pP6O~3AWuJA$2Ps z$-i7*{PK2G1y7gzvtNVt%n{^k#thDC_ARJ!4Kz^6>f|x~^V&6U< z7E0m9_=(76DxzLTJkj!cwSUg5_;d@XG|Z{52z~cR3X693Q#>_j!hRafjv>6=ysnn5 z1F&T9%cwylEh;%4iW+au9RJH~I$q;q0h85~H`-q@FTe9R`irHMoHvMno&J{>NV4u5x?90%NcWU;d&5eGlEh+i#R2FN%6 z%eGTAxf|IW`M%7{^)zE9ms$cLI>!;2V-&*L%)2G2OIzOUpZbD7E#Fiy$9|Tkq@B-d zJB*b9Ja#V+|Exm`PqT&JCtoHz-qKm-A9-lGT3b#G27+?BFd}mGpWohhrTxLS!hKR9 zJCV3AvN%lQA1Ld^X3*Wg%529x7VLSpB6MbR!9SUTUyEmNt)Sol zqSY++FFQ=Z+fBh?vL1}7QrF}n)&xXrSz2AJM^IIWAaQZ3@Y8z!>bPo=e_)#k^#34J z4?-loX>*h^y5Eu2g+R{#o#MT}j&fMTQ3fTlpiF<$i(e8bnU0h>bqWu+uE#Fv2Kr+8 zQ~xJgPmnEGM44iLDLW|(nfVLwmAj1c#rDkHmt=gvydO$0TJ|@jPITNx4nuZqLX0xx zF#Ya9zm`wXzEA+K+;Q)cI<0HxKb6e>T80(g)cuJf{#~=R(@V<`TK~p>_azzGD}|9& zYu{4Obbrsq+Aul|BXVNBDP!0&0Flf&A_W{+DfcePwv78-i0{J63r zH1w)+`Ss1}(9r8DlisDZ3HS1vmYH)(f_7y7?d+HNQ@6;r`Xb<>SA501#qv!Bt0}qu z{5J5(T$TH0Nm*hK^eOCbB4`jn2m*Y;45J#W3#?CSh5OOqqljJ+T48Q|cy}%K)=c z#x%ivOe}ZDRrHCgOm2 za#xHmP`6U*x}$5clH3;>I*#QXU51zIRf`%b&+csxK^yKwxYFbnun9)B5qybmr`zth zA+Sr>HqoFvv64m=D1-j0&uoL3(NN*mN?p9oe3Zp&)OE8KLk51<>4I*;o<)p_@|Hn} zG&-;y%3Bo4k@Nor6QcCc?lUaD*mbOk=k14BJuxB5+Yezmv>VGIACTqz;CAsoI4oP6 zdmj6h#g9YmsjBl3{eQYW75)Wh7U9R}6n^6D$psw75G;%pnHGt=yRdMt zruIhsd2L~9E+&W_-WV|j)!SDq7i>(Oy}OB*h238d_z&yv9WY)9Dq& zFU1a;CGUjIQ-T+qN&5A*mx^TvKKDbhTY5rFd3(e%3ZLoCvFs@;zc0p5X}{-K(#qpF z`AJ*df3|SN{g2b$@9F+!vGuN=PjBnIUB2nQ+&Nl)@GA|vH(GS>94*^B2bs~ry+TFq zl?Si)%Tv&w-w(*|&e4nI!E2j+cFD7I^cwrR(LT4xvvag>Uw7H(K6!?QE}R2%G$ohX zS*rFJy6omYNpE69`)aBxdC zZM(#eHu2>CVhTz8I4$r?TY&g+rog}30_WNS3v2=6$C(1(wgpbM1+L&7C7Z^rOe;qS zK6?`yh^96^A1}$okFx=!zeEkp+9qMTG+su}GbYc3H)clX$OieD-?SL3>K%ygd z>v&~FWW4^-hmQ9dO)DC2hbfdF?_X?z{CIz13k2i+cUvGo-rH<}V7%Yv{gCm>aHRXj zj(?enSD6psbsklSh&79W&XCdZoF>nN_mgHGHj1S>O+CW9uJ2C9dqBtg6D@hRzwf9+ z$GctAipIOn6v~gc!xqSo_s_OKFy3F-0{QWN&lU*AdmHbE8SjKyw)bYp#Ke+|62&0` z81ts%b^zduxbJLVkSP^nJU;KQ!RE))olH zx5O66kMB>mKrp`lT7;?5_w5qD z%yjuQTi{Y#AY=;=@5>Z8c%&J0oh`6K-?vNrXH(z>TL2d`#plj-gzg{J_K(JoBk0^{SPj7Hpv(z_Bn)!TH7V zOQ#pk0ilPS@tL;tAdUd+FR_-J%KC+VFsLKum43RMA%>1D-r@89IpY3Q4c7$ejq1M4 za}C8Iy?RzQ&fTyd@Yl>&!Akv!z!n|0x(ki;wsyZlE(yfpRE_9`k&1?2io3+UcuhDf z7$xovejSVaWlqxzl0vQ5BjVPoK7q!Fy+++yyKM|@>%kguX2jDdw#?t1^oFbv*TEBV zoiaihcW}>|SbfCn;u>H3lJe%ck;IY=gQ*}8#jq-aVN@$91Bu9&Vmb^8~M~=tc^cq5l z?TNXw%WzRC6=QfKfXaWDlk`x`4vR7h3s$6IG3zDr7j-ccUulFeL3E&3Rjh*9TRN`{xRadmX9~oL56oz#Yc`ebi0(FPkD_m^MUb+PK~=~irj+u zG9R^Vi7)d}+YRE&6W)g@w_^?v6d~%+PGZu7RT^Q2ypx;+gTty`hx&AVwyWJ*w%`0)^A??51r9h&zjzGMuq#-@9=R z5g%~Ly?T!7A|7Lc2=wuEJbOMtW!@HlFMG{bM>Ip6zE#whNFUr}MpT)%<+`un22Kn= zA0U_7yW`oL2WT!vR|h2|&9X?Q+g@=b_k?B7C#;M%j(Zu|(st?w+b&^cdbgXp%(h8b z8FGr-l>4ByJ>tsrZSOPEUaz*|E!;;x=e%(i4sWQ81X+HM{4Vet8$Y1nHP-#sDk>_RUo&1jE_B|b?n`;UvD-*Txg`cm+_`D}!fa$M*`M*s9i?t#dgroyH0cCtVm<@pw=FTTu^90Q!H17F;P< z;ZB|9f4e{IfvXU92=F+FI%_fTB#;-AAo^cyf&}iO?q1?9?^AwWJZUA4bhR`@5R}<* zanJAZD|i>(=k$bJExOq+v-uNj{yx!xl0VYs`@Bp2vuyrGoBt`B-(~ZUwfT!BpEEOl z$IXR~I$XElaIeRLOO#`>A#LxVtivr7m7+4O5v7f2uL|e+sQVi6%hwc*=WKtHes51| zwhdJtv)||bLk(44Yx5ZoVS)Dg)w~yvr^1#G##3hV8P8cVAN%^rc=yN^UV4*}&pY$R z6v%jjz8W(2lo^k(ObFpR{YSOztNvek%Blr2AE+a5pPnB^kH{mTp zt#{~tI46h;JSA6;DIxoy1niNKXULcOaZe{8;r&nsAM+*=M`}~*CvZIyaLj%2wl^g< zncM;!G51MJhfUv+J-3T1qx$OUbUY)Od6&I*b#&BR6Sd(PX3OR>hg(FR6%B8VyZ^Kk zL?V}(yk3j1P1H3s)L_gF5rD_%sUcrkGo0c<1D<-k^R2nPsTb9 z;9Q;8beZpS0wXTjrqB;cQj56jG>JBhU<2N*g^6F1e4lt;me<37AlffCoz4d509-iq z5@F%MgirSByW0bJMXw$(RTbXl<@Bv0ya{Zma5whVUnR1S3!4HPh7AW6ltP~tzfcNI z7=`RD#SnV@jl6fanSRHz$<^FY8{-gzDQm6&PxO6m2m9{&xOZ`^dERPzay_?r-cX(T zdLsMjDH-89FDAI`{4%HKxT6yNa~h zOb9$-(fZ|PvlhT1DE`~T`+PDdbej8)Zm#g}HVGG!V9x`pZDc@bUev!daHZtR+_8AD zrkcVlV39ZakD*ZKE9`yn$WWXslm}pJ{$H7Daxj`{+!*sNU_`7cGpO^Y!fk;B=AC99 zzLFpQnFOGw2Fld*#_qob=NqY0>?aC){q6#hZxRSYVtyWas7)N!++_uU@EfdFMy2aQTOP0=cqDD^Py3I z(B;hb&{4G{>Iq9QQ!~9rumcpw`AYEKA0}PXYlv$#NRk~p5g8db490)r3=wl39IZz+ z2zyeU^pbMLbn8UAhDnTudC}t<8tFEF|32w|vW+dC81bP@6{Q@Qm1?ZBt7>IW+DSJE zleX9#+6c8*^^(4a}A<9H0~a$3nK)P-JSBG z4=aBn7w77^?W4Dys`=>c2Isb5q!QyU!p*r0PlwJ)FqCRJx5*T#1xm+Woua?`O)$a~1_>@A$=t=_= zP=G(bBLLCZmUJf)t;@_|=AY0UK{x0oZetLPRfgIUXmB# zBJN6|$l*0fK*+?hkfqlU4o{m{F0{Ea67Fo;D+Cl+0)iykOJ{gh(|VJ%N)PrxhEXPR z107*y6#z9p8I0OgIE5kWKvYG2v_A=F{K-{^|UjkghZUYpahvn1;B5^DV!woMv+nN!q2|L(ViFw6Z<{K(x#Ug5k0 zF|N&hlO)S$$&M8!&~tvzYE58GRN$o(^}uNc58)o-TEx7M$+5Cqg$j`22O?O|DG@uK zF9}kLiJ##yyeSV@0RtAWdx$rXaATZHXO+8ikTu}T!Er2(Gm6^RXw;3Lm5R8abiGIz z5E+yZ_a#<`#{Y*M5s@`?F)j4#ATok@_JaP%32e5+4h>~~YqD2qq?wx~LQRLMO@x{! zY!pUQJDI(d05w772!Tgu@!1zmAk>>BMvdf&r~`Hi+Z+94GJAoKzfJnI+;CrO}n!6v7sFK3MfSsHhh9_Ms_9Z30%qIMkM0#3cf_{fkgJ3NUoL;MrgSa zJ`sM1O<1A;5#Ftv%80HM7>Jsbuk96TBf9ESJ2lJJM0C}sW~$MC6WLYYS`to9zK86p zZ>`g$R__{eyNdKw!^t7mcIro0679%B(;32P*m!b3-UT&qI~0_DM842U*+cX|e^@9Y z9&N%q$=Qo5-jH=gVQx2xq{>FCB{!BGPC!QD++vV>sxS&jsy?_XlBy4`s*)=0m5Fq_ zF0{}<(acJJC6)wncWO=UpHMC32V>q8O!Q`#MYGr8;g{x|a1ED?A_u>lvnU5eXlv?7 zfxYii70?q}D6h@tHTP|b!JO6RF2#dFrlR{UMJ?Q4awCCAV)<4I;$5Rum6<|Z@@?6E zge#MbIEIWt4II~UN2@GF;kwA)LCoB|%WF9ue4JAf5qI;a)1vbgH#!PCW|(YYd_S>T z4yREVztkt>y`FceUQ}7n9ogh&!e-UzIW=AB569<3Pn1uAo>E`r+(0#QYYT93~fD!D5 z9}^jjwf1?_~mHR zQ~Di|-8)U~`nzy@EDkAw1gfy#CiNcK)ONi?R_y?pQQ-3n{*n*Z_=)@!h=*Mf%%>-Cu*71nEXuwF@gz?$j4uGdfb5vPI}Vkyk>f)qw1oYDepectjmYXVLnd? z5_)0eFcut(2>oxh5|}u=7v`2@%9;2nm6azQ zB8@4~EA^U-@NMs6?98pH0rHnI2=->oRE>I<$ZXg|%H7Uz+ig7}@l5?uE;1X&=i)8% z%Q%63qhIPIr+MC){Zhvyk)OcAbtT>YoXoh7{Pf2gAP)XZud>mF9-7Ct-zdVF6-n

R+7jE-ap$ggc&|$aUsyGqX8u5G=&veHt|-=Wy0?jb@L6ES#4=S37QSlaDiu zqjh8%GoC+Nvvl9rI+#{_XLF7&K+Q-a5c_1@v!|ksPEjU&ZJ4ctxxm?-ykH3P<&7D~(3lL0fW+l1c*XtU5b&GS` zJ4QxB1q{D$by4C&;WE%q5Z{ zYBcYl8Y0pCwk(C7rEE}ct+^x~>lC8RDw;-I-w`DeJh5eGA=)S9BoMDTr?|__))2~E zL|U?bnz`2pNi`7vgqZCGNs6|q!K=3*<5LjI(d=%oIFD0vR_fB6s z3Y5O@gHgp7J<0LI%U|sC!4(3_i_8Co)>Gksp=E?t3KM3S68k(-cQCZ@G=+&#wE`3V z5!(eGu8R@-TqiB_1IUDdg{`vm?zTKQsM$r-5P4`VB;#dScJ>pIg|qI)?BZ2xc0nUV z#{9@;7ZRTL1I;d?O}d3CIPB$~r&zCho?2OYv(FUW?=ve854r#1q+s&Hn{u}zK;b3B z;Dy9Qsw#7H^ZAgQ%G~X2=Khj1-|xw#$WUpDpbnJo0so1Y0@{^)Ku^69E>PgO`xlH4 z@)jG@&;`d3Frzk`i0|DuIrYxu4)ixdnNv!Ic9*W>teePQP?C>W-rkT|MNA@k#4+;; zky>!n6d{TYc8){?i;dq&k2z~{6sC3|h`OmQzQ0AaC5U=a?Gy}qP;+3f@1`y;swGmC z;#%hvY7OpPt1_rnR6~xv($m%o0Wm%H;-7x4ar(^kup+^+_m^7*7mWlZL4MTIYvpZz z!bpgSp!QEFw2b`Z7Apm*<7^8tSd-ui2$$Q>j+XP}L~k@E8c58^OlFTmxWcs}XA?YK z4!(i>L~16p*t*FzYlz#Cmi44gDXN)o7GEy8ODKIu&@B_ycU@?~H4H53&V(xBoVsd@ z2v5F+(0gWO?mIw@+4+A%vK6ysPx-M}7X+p}(~u0#05Aq8y{j7HIDf+}TeZXv2of_& zth=w3#OjF3U~GA0&YjHeQ057<_Un?_EBl-LP9rb@GzbnUzNJ*(CdND_dzr-AXKfI$ zJry{da|K!U=2G&lK!vq#$gEFYPfc>ZIndNxDq;AkNy|$WIJ#+dkjcZq==~FIr&0NR)7 zx}*f={!~(K^65b|GFn9=gUO5`RYAU@7fMmp81ays^lFP6u1SL4n1r}d&ved+MxF^R zlxV3@_qtmDk1q<0UmnYSP6ZkBW8J>6BqGOnSmhY=YlRIw%H|@+=EC_Cb!- z?oK^3=p89)w1GUNB786(EnTkMtEAd`4Q#wy_J6K*li=}Ge>xgIXe}L*cubg6`9TSx z{+fw8FK2>Ccta%MsJYosH8=$ip1r%FEEx94{t*P-A%gK5utcQ<|<3~B!tn}HpbzycUh4wuS;+}+kW-w-`4=Je23+%o`zCBp3UzBYvmQN1Wd4UNmv; zMbB03KmMGslGj!d=4EL`Ut?FpZxzn3D9?r9EfZN{H8QExN-MG@%+VX&e+c~dv6KnS zQ7|mmNF9iBx+chd77|#yewh`#94{ZuOIXChR_&xbeD%C!rOf9tnc5V2Qq>4iP`fK**73p-$l<2HOEMLPKwXhioc9vNKg%KI|nA-P}5 z_rkS32ot~(_x-4CulY6}v$t4ojju#U!gN)$Yw;(@npr3)LU{sHo5CZrk z$|t<5%l+DoLbli`7m|`h+5km*)&HcX_N3BD$_U9DYKo<>H%pl!JsYIrp48W1uqm?F z-=PUTDJQ7&f+lQF)#U3uVe6b4)cHFJG%qx{Rj$J`@GDWx?i*^`!3b_0M5icR6&F#6%8^)>=0*&;$x?2_ z_%HIf@?yDz#WQy#D!DLs87_@xUJY&>8g3PYatmUcw#@yCsq6EN&gHrxtdjK##0Z+m zNi=y-xFfDr6k@?`8ImWrY)H7l;mh@cjk%~B;h{}eQdPD!ipwV`&W#uya6;UOahmQ5 z5#UnjL>gYXQVhQU)@}4ZAQLyP7cyZkLhMI=6dM^?c9rB>cF5A3g58PLH)7MQc--qk z#A2Ifa`QJLLI${|rC`%+D8z8CL=;xr5(v>0nsrt55=$*9n&?IAz->afn$MmUqKS@E` zLDxjyL|VL#Q{r)qkKo1h`*P`bdM*P%3qiz~Tdfuy(?las*QzP%6;~nnypWM?0v$ZMx35nW8+P)-Vwis;2 z*g`hbCAvPljMXCE5Ns)&R_hrUs~KT$dYgnAN!Gm*%3R6BCd7$jOJdm8SWB)9Go1mn zTGFzWrO=JN<=qm4lrag`b3K0tq%PraX{v$01G#{(<=sIkqD!4z70*V9u0_Wd#5`;j zmd0AzWKlw` zq9&pQmP*rPRYI+|NkU6ogLFwLt>dNf35X&Z8NLg@dkw$4PjSI~^Z^bC$*fp;>`e?4 zz0QD^S1l$04dg&nEGB$GF`j7& z+I(ozlZPffd}z|INwRI{yC!^|bXPE81y&i{nhOM8x{oB;wt(Y*3_Zo3&vzTy_1U4gWAJ|3t z0283!c|4F9o`MIb(X|i2gEvKwGYt0SHSpjy@L)-ak|cu%62evlh>#h@1IQ0}0QmtA zAV1&%Boy#~E;UG(EFLt12kBVS z-6e`L;~lfz@F7umEB-NE$}ovyU;JarP~nRJVYc-j*|*BDLBzvT{}G>e2A{(HLj7en zYJN{@r1f{{viWCO|B=PE{-><}$o;lFn4n-WWfWm~}S`aj=C`i(a`-uyB^>iYV>-!Jdq%(NQorE)lEPi1V_|q!q{c<+|Ltx`85Q*|K2E=c3^Y|6ssHz%O7fSYp+6D}_>W7d zxkwUD73l+Eq*=*hP4W5xH-0ScO@;?J?SuR*{ONaTyfv}r=t{FBYR!@2cAHzOW+lD* zs+#G%=u9$8_yz)mU1(-lGVTvxqbMgRwi@Fa#Sqzn?%3MFtAnw<57*p>1sQ!R^w56M ztYQThUT)<|g}cJy?h4Lda$b7ckqb>#*DUg<<*I7RAGV6Mv3p^qpJBby$K^gjH{l0k zp1D_W2(Phv(Z@Qs?J>%$cj74KTrMM1Qv=atse`C`S$ByT1R$7Gx`|D|3{s#O>dbPw9D!TAg4Pge9+ziTsR`Cm9dq13IFYJueijj(Q8-e zchdW+O094-=@-YuG)>r%aph`z63Wy8`2P7HS2vR{@LR?S0IQ#e!0_li41b#3JPdP( zLQn2&<*oZYekBe22T#&Aas__-5lPQ&B*DttvIBEmCqN`V&TQ%r@&FLB+|>IM#R`TP z*r=#~2sca%-kG!bgot-zgWSB-Dl9`mH|uw-5aM9W+6IyZbHdI!Z@eJNcKTp+ZHpps z<-z@ZZ6trNCJYPh1HIL3Lcc#)8I~^}XxZ>@#&kOD?sN9`RmtVc!kS|PzDN9<#mxFc z%i4AWduTJfyqBY~hmJN3rIY@zyW{{jWqg!LkjcuFL6Z;CjKj)%^#{_EAnjK!}iJTzr)uf84`igXH>6xe6A8IY2YSVHx0Q&Iq%6p18eO= z{oi&X-qhPEkO2M^BZwmHhdYUb$sp_xU{WuVyM-HLY7F`^5Q41jxp;O0#-Mtn7JFY# z%#IijFJ}@(N*B-0?QgP|=5-%Sji5}VaU9CA2Ibh@VKfoTBN;C3a7|^Lpr>ODs%>*h z=Y;NLo=(l=t6OOnTTrQIRTUVSc1V0bX>tO#pi)WfPqjbGQ`mn=UnXM;YMN8SRpbg= z#j==DXmT3^KvANHeMb)apI|F=-{P3x5X!8lQvwL8_1I%>7GAVmpk%qqzs+qMNktir z9U-or*b^6>@6m^;&f;U@cwB||!f+y0q4AI#e^;a~=0aey?x<@4MD|adHDKb6H?KKnLe4*{Ys+`bKEHn{*q;Kx=)YK%l$+E z$7VTiJg&*z{|w}z-n<6(#pfkm99{Qx8y}+Xl?JZ*obTbi^@tCV5gM~&pzuWLS&Bp7 zV^fA6KNE2UMPTe4D^a=*(lc2be>Cacxh7u>Je%k&U58qS4}ds0J_ z^;eaJT8Gm8Ku+V$o1`WRePTo0v9v%ojiu!jxo>uca)9FY>-@df{p=Bu3R=1F60${e z;hiLO>m~Ik39ML#ZAfIXQTA#SM9NrbV{`AIz=(TCenk-gqkfFEku# z9R+5nMk#POGgq+0cM58~DNQ4zhL`Q{ns=9+18`Nqw6H~_!HKK!ufO8OI#$D0yI(r|o zNQYM&8SZX-^QpsiC56Zk?Dz9#7z>3H#fPsVCpVbL{+V<)1TK6JlN7JV>abft+JdV> zb|+*N$YysC$d0(LIKlRykZpSbNHb1z)p2EbwL-M%Rp_Au2BMz^WD91tI7f*)A_8dR zQbQn_JV@`$gY*;DH7dNu@N>oXnS0{dlQ$R(Zde)F4K!k$sECYqNAEmFK7EFxx3UnF z)&E^Pbiqr{!A9b{*iOV-c0l&ib3&P`%Tz*(-gzQ4e~;?BRe@|g0E{ifaP;95q4{K^ zM^-v37Z4lyE+miaTcP=6cbHr*A>J0sWI+XTrEO@wv~6|-X*x9 zk*L==D{iQlT0`6;X%gN6IRo(>&;#j-YM#{rapSv4VG~Hy#T+6eL>%gGWwb)!k9!7l z2*u-%Tk4PemP?W)5581Rr7%8JY!m8V6tF^DWzVqjD()=mnJ_xhy7i$2-(-kv0JHq| z$7KWfRWrRUwpT+$E)H7EO}m(qY>+DUwnyo(iK(_mSM{n!yI75lI!KMn z4~j{-UhP{rtf(fnuL65d%mW*QlFmR`pQxW+mO93Wd_tLvC8cgUe7$jSQ^UG#QLx#> zlwseJ2$~?RgMT!`cnge$L>-E;sCE$;y<)XSG7{;hMcinZgP0n_(!{|?xPZKY5pei` z^>rjXr|5PyV&`7bH-X5aZ^C|QI(#Eb%^-iM{!}EHl+!rZn_Gx42^4LG} z+?^P}!rdv~Cn0OFaY1r14YSlAVFiI`8LXc&P4}Hz2p?<`mf6DW=`H23N}?W7Pq7sM z5ZPF33$rKLOF(V(FixP?A$MOwc|FPPw9H;Kv)7opz|yrPvJ*gjZCf-zmfQO_S<)_; zFE^)Kf`Y-yyQzz%QF;XCORd1$D4JQGLOw3F#(?_TpdmD(vQAZ!)n$@9vDp%KFNSW% z$)Nl?3B*`r^g5Hw?KXn=1K|7vz0S`cEiioh02p*2cC&}T-ODtn4OBBf@TA(rKEGMe z7ra-#k2}s$-wO9;t(gRWCxO4p_Ho6z=yle!$Z@we;SQ3j7($VWx#4dSG@$R>V-5nFAanv32Uz3)E*Ab>;G$Cx z0*{c-+}ncya3NL!90USB(p|@XAaD`NG?Qat<8%kV=In?KMVrF*)MRmxQs5X;MSe0{ zx&i5J+&#G}>7s=wfCm~wa=EMA`;?vw)I$+JLxmkY6bnrsE%C7dkK2PT=Cyv}f)sVr z4gT-obCNFHep_xg0Al;CJZ*SS?(Zs^Xt3vmp6(~}`O3Yc0nGiJS`eKKql5j0{}YY+Jeb$M98~SgLDjw-RPD<_)xI25 zJ>+SkjDX?LszwjlD`_j!7V~-~89ijLB%_Dym2^K9gSLaN89n5C@j7An79^=1r=op9&p1xCFX$nsqJ2TnIFa*%>LI7XucBw13b?5ra%v^onOK$>^1MT5r;7F^ zmc3E6FX$oh$9CW58?};;9K^~fA@oM z4b;~7(FyNU=n(u2Y1pht{OA!?Vy-e<6M7_`D?3MzKiw7>D;i)a@HNv)>Rj8x`L+P@ zTulpM+rr6KU2(cpP_;{_6$!ZE%N@`3*U0TwnRv?Lb=O)Cmx7=QnH>_3&gcw*GM>}q zIW9ZmNjxzp$?s&{dl+|t=y{Wa7{V+OZ-EO3lEc=)=M8XLwt?&SN^$oYv4gc5ON2rc zj?1kznFZwXtAA<+e+Q(v#p^(6>MQ&mm^y{OgF>wj!aKyhkJ~160YrY(CrS9HK1mwI zvvAxJZHp3B3G0*In#b;|WzOAqIVU8Ck(w(*Za)BRZHc2M1_Fw4H8GGe@~eO92L296 zP2q28D#G7^sn79uQ0f?2M_oRh;JH9bpV<`q-abiT&RX;7St&7=zI)hi8(OV~sbP_JHT zQ2eJR0rl#Y2E{#-fO_>xgW@+!0&62(QWWv${_B1E613-EQ(QOCyL`Fc)=e*kZ$aAdgJyz!OJ7H8QB%DHg=%=SP()V2QE&{#(J+_hXozg4LB_9`73T8rA zz?@5ZC7E+cuOxFW>6K*8CB2f&xkQuX5Ma(F@U+4=8r#Txo;jCX%DKccEe78&N! z7IQASlyiw?TFklRQqCooX)))LOF5TVrp25~F6CTenHF;{;r6qDX)))LC7eqv(-QFc zMaXXD>B5gZ--{pFcYkku_jxbI_l-6`!1pejAK?39n;+o&{Wd?q_q%O=fbX~SUWD(8 z%6Vir{K(q$Ibd|JGe~g$$n_v$gZ0Sm^lcD2hR=;^kN=R;gMifK?DoqCOp`jYp}p>S=mfT3Sn` zJz}v+34#W^R7C5wD%uM(jS7n8VwL>fpS7Q7=9y#y0nh)G{=Y|GWS(a~`@Ys*d+oK> zUMn&z*%7Hpc4RO4Nd*=L>pLF8VP!lsy$%x+-~WE#P=Mc2s-UyZrh``_Zu}a-iwq&i zQQe5_&DR0MbZqsc$ffdEH9)RFB12fg9+ZKOd>CQ)>?I4SXwRd{%4Y7>J#ILm2qU*V zaKm_r!=Z3@BazvMT!6UsjB(6Q2@J2#jPfk91a5GhT-*@paR{ZGIOju^s7je@>awfp zQhNMkqJvDAU82q;Ty=5fO2r4c?8m~pLVS?(>^&48U zeujK}kp27&!~J+J@68h`x)@7Wvdy&l{p}SWguSOT`#8A?_%b|^K2bM#LIF=W_hZoH z$5Coypo*i^PWJG4+Uz|vo@@LJ!FVq9Gvvo}j-MeI&q;oU{CLLr8G`YAlJ}zV1l`qu zVxx(lB>P0!OK{43JiF~jAdUBO0QKA(ygT>=@lG6n&Mmm;gajs81n|s!ttxsNMvcCy z!tm_Y7FNfstE-2XrLIK%@$W~-wG(at@fV0sj^$%?K2IH`1+tVUKj+CZi(F4hFst|$ zlaE)KL(Zq7D6$Q$qe!ddbOni@ZF8?Vo{kp#@?5z#_V-2X#`2WJommMX*YME@)+Hv-1#ok0Hx*W%~EwG zd%XLU<>(oXwt^lZM30Cea_Heqi3M+tV{d6~D3l02KLp>`y1|s73Jv{8G@G+#GEWt( z{eR706U)aBsqI$5-syr|Wsgsx8!3J~5$CbV&O$R5>&!;*(ScX~D|E3lwpcLXw?n_O zu*0vn7%3_qh3Ven>}aIRioJ|S+z!Y`id*R{r4N!v{))0c`wohMkijbVNi$7%XFrO$ zo=aA|9f5_)I_lFu6P+@X*1f1fg0cn(x`$;Ge$-ok%*W;#cN2&Dc0Fx5GSX@rc4pv{ zHG7uTVgZ;=-VISAx^)NJ$G0X>hrvttSh-D%@H#u%Z@KC01TC@w%%vz7a|b)bJiwYY z*O-rU&b7(sP7cip)q%jr0MAG8&3(Qr#_SHQ?yB_h1iWZ?Q~1O>7?B4@AzlW}4WV48 z@A-x$*!{u#YN>q8gD_XARn&d|>=`Q`*{7_`k|QTP+jTd1W5aJb3|z~8i7Wg}VF%)T z>B0y-eEn=UmrdVHq-S)nZXOz;5nY4J@L^QQ>fWY_EDMH{O1Pn*=A}YG^dx?DotOeS z34TCwpZ^07s7x~}l2bo=%H5G~-vv^-1u=}gLcL+ReR*>Fhj+N}2nwMN*ds2V; zh&aE>1{k@e14>j_E)M_P{+!5MTIW-ur*J&JF?-o82vK_KWXxoyOU1NWFzDa?$Al+S zCl0)?AV(Wf+lf^SNxmtRjG$!cs%zlBtEt+JsHlCr6sf24_a|v@Ti7bL#657-==);G zzN%@Tu3F@Ma$%Ypkr;ix#cw>H<43Bx3PmJdP$7|zUQ-cXrEO-<+V$sR|7jN2eUllf zGJ6X(DSy?fjK@1Uack|x$}s%xjA{GNuhGufe7!Q)T7P3JwEhmc`{U+QX|coY50D7v zUhfj;3v&hi&7xU*T$D#EAyv9@e)g!D;MFqac!?a?1Yvj8o%(n@!(z=e5#=3ktlg&@ zNw}K~%`<*p-o&wmuLS>Is?KH4{!g(njf=Io*>a%~bF=d^A{eo`yeu?Yv6{lVCXh&< zUzx7OrsHiBN|#%5(LFe}p`^E^p=L|NvMeXPwIKzRG)RG#=SbFYgV-Veq{q&|NpFjt z^tRYZZ;PGuw)9p&ZPbhwv6-!FdnY~CJLxyQlYT-{Poa(pMSY=86-ypv6T)=6w$$_u z2Eh2FaI%x$S9wRMBZZTl^v>j+lO94G;^A^e`XcX~^qz`mh<3_5cAXOHJQ^sV{+0Kz zPzOJeopq#b2`ixd{h51kVu}8+CII<<`NN*`@0J%;Pcj0@HHWo{nsxE!^;`m4&n2MF za=VQsu8^BnOuZ!4JRzyJn^zP0i=>*rNUHhkOR5|EOF)s4x4( zO}&$Jhc9#?ZoFRYLR@EX=tGrk2jJGvS=P{nxR1L84t@SbAZ-$87C7|z7lA5V0*5~T zB9OzQ(1o~H4L{D{(C1$Sdcq}e=<_cEb=ZXILR_blRI^AH3Mij=)d8jHYI#1xD*2va z+8W=e6+5#~tJqel%{X_f7jm~cH4JK_#rDECC3{_;{p0sw-jj1-5`X$v_NQfC9|-uE z@7g>26-J05X|Tf!Hk5_lvZVLMmd(+4KJVe*`!T5ceJ49gH=9`&8y+yfjY!}+uO zUv~<(;Qg)F8QBNJ)8RNan#)BWWz*ywJbVb9)RcbyyE2@ZI08Tg6W8+JY__<*UdT@L zoVgr-Jmx(T*i$~G%PsEe36@pex*$^fw0{K!=j6T%l!thX)o$T!RLuDcPnub%Vi#|* zFkgMuzCZ+Sj-3?I66{~lM;vbpgK+5P*&`1XuUx?BMn z4aM=uVIjm05~ASn@|YN21;mSLi`N1Pe0np9LvFPd&U%85IiCyB<{87w2naw%TUNC% z)Dt)*J#@1|UU0|j3uaC8Z)R$BFcz5mB)z>8-Ur3SpW%BHI?$O~VS$P00f$thRP>nb z7R4hK^(NA#iZ*>y9dSlj6Ng8xzl4Edg*9AQQ1=}UyMP=}bIl%+Xcu&W@cXYU&@~nTpLWa@&T9wa05tqRDCts4Y9-b-I zvMF^Y%<`d-)Msm%!l8=N81|t$i&@m^I=k{MJ6x{i0F9rF&DkxV*#?PyL!ZWA)*Dw8ZK`oqp3aO%n@h(+wI%%!$Tivx*bW}7p_Goqib);jDntSNN{U!KA9dN`T z{$AsBCrBG1cLH6$pEpG4n#4TX<6~pl`Izn5({p5jiJ;-^^+zsKssV_e$FwX8AV2+>s zbHHD>e-3zKm(KxtA1L@6l6N7_ZSlbC337cAzhiuVLkaK5?6{kS@8hfT#)J_pJY-Cm z@Ww;h-h{Ljj0vwQceZ#U3-xwCRM_a84J9)d`_4l|+UjLyDwQ>b&6^OuMFML=S)t4S zyzI;Qj0Ncy85=^{Ae(j90IUnH10p*ydJ?iUfSz{n7Grt+GHJ?LnQSHLZy4!Kjy+nLH6AJ>EqO?tz9JJZ0^ ze95AUiD+~a6V+Zto4y(JE^kT5xe7P(7Z1;#cawy9SBwZtU2PoPB6`WE6ZPp6;g?pW zu$E>s2&G^`S*lYvBVIT1dfqlXhe zOYuAq3?bHAmpy*17T|*{Zmwah%l>4R*4?`7U2UOtm-;1Zj>}4GIaJ3y^F8G5D@D1* z;g|%z>rkDL;d(ZI_kX@_?W{L!s`_4Uy^Ds| zTd$&huD1(@XE$WrddqD_@a3s&HNmM?Cxe8!ey&4tyrEV<6+?|{@7 z`CE~~^%$01ALs8N_CNwUq5rfp(h!H=TZ`VCt}J|Oni6_GUlsTbH=Wi%{HvCqN(hwR zn_8QQkorYc-}G-h;H7X?Q!Nj8dR^6oTgER|>ESRQM(AM}4(G|5S34SW;*ApWorJ>UYa^J$mVNln z+JDyw&06QvKXT98$a`Q3xP9`B-CGk$k!Q1P6_;nYD8pwiK)$70ZqCm?w;`zohi8wt zdv55b*ZDWeI5N3gWch#q?&_qU*Abm3{P+uDe~-zG#m-gy4?>Msvz^QS>F8ea-m9YxQI@N52k|u~70+jAN6BQp=O*AlGgd1vpz&GwBPdy<*x0CV!CuiPGc#YtW$jLclS`ze7V zU03-#sVgWc2foy+?VUr-gSt%8@(7Mvf;vy}y@RPzbEEqCpf?=9oO>|qY#qK*Kgy>U z+;wMsjVbvddDE%G>#OP3g%<)bEZ*pqk(QH~Cs7au&CfKxN=GFL)zshx~)2y9?oY>p5;i8 z8^+u|(g`y4`JgmcMkrk`PlCwXa22Q}AWwqgAd9ALBI*b znSVl@iM9k(iE;fm?ufQZh7h&{+e;^y8}|E@?3$(w&r&s7W{=+a2LiL+ogT#R$0)Ak150G&J@=?9XT3mCF1U7Pxm4M5@~&hBO9I93`SaC zcP}C&k=C{DMZ|>hyB86ZNb5tqmD+soLtl@E-@{K%k_CwOf$X=g6NNji+CRd$i%`5GqhLZ$ zOs8H%arJkdFv@$JURE$=Xhz;ELl(kW!e^r(Lpr=jZcgFHD7=-gW1(*lDf}CB$d9V$ zzCOs;@ZrVErY;RC#kxtv4T5BT5s3JH8lN6SXGnK?o?Y;pMQb!hPlKya@}@wkLxT!? zom~!LX4-Tw7F39|$N`#gp^M%H4AeEP1*+!IvtC$(t5IX2=8@HoF7^DDz6WJjTp?S1 zoLzKt7XPQE&n~(h+p}namnuTTWG*(f2=X~vru z&thT-@R7Zg6!hS}qSKPI$3Sbe3U8)}4mXem@HVf1_vJsVaIBlYB2KNBTSeIb$?QwP zIP4lsKRhcse{zB8pt&~duV+R1lk0JzM*ie_Bx%3zktBa|J(8sUmVPJf^ilrgNHfoh za!?%htav3iXa-~05qMU-NH=QGNClo1+3$-yD>m@Xxh?NmaWwD9;qsmpYk0?W5Cv4! zOa~9r-5Jt)m=1!^aMZBDZ)9&=?1<=4>7FyWgHKI9V6 zBKf9+i(Ep%bnr(mpXO}e2st#FU{ghC)uSYD||}aTQZ#`pZ)zrnKg{BOb@^j0oP?4+xa>xE-LV^ zgY9_T;H@Td?R;Zzuh&k4t~pWj5d4+Y<)$i^DH~xp+8w7oju1qRPrJL)}L_3Oa!dea%a)7Gkn%ygZT@qwA1 zTtx)eWMHeCU;eSW6S-iKBt3(wT!z-F*SmUr=`g*|}bY}1@2y_2RhZ+P&UG}+>){DnEk?+EU)8oU>r z(?q!>alQ}{{w()iLNZrYBss80~K8Ry|IHu5~;T6KsDV zYZEz|`$T%EC0^K$$JJSm>&CZ~2g)RCa7l#g#utcgg8fz(_FK!#?T)vdP3%6m+k5`b z-Xkg!*PZSw_*+5Da^30v9DfI;4icUxybIaHa76FTU=Lu^xcwcS{ScHT{q!X1$az{U z9sOpI9wQxEdWogu1|~@N_ma~{H}^0uJ-CP>Pv^nm) z4QS>kyeaLuy|xDSxqptr-}uI*a5&P!i@!Moin|yHwq>`RCg$b}V{Z0^V_|YJ&xnsE zh*#NO+Vm`hXzSVFkqlJgHE-rs9rrMFD?oZ8J#`EAVv*KQTSocEzg3^5^0=D615*Fa z--=Y6zXMZ8@^?^bD3u50t?Xt>^h^`0(lbq0?|P;QbUo7~S_&G-cTh)Yn2`ABrn#^z z;@>jIqs6#P-ET^fjic-`EP%j>O-*0s9aY3CEOWX=H}HZ|4r4%_uy zA~Oke*wl11@31VdU;Fml-{8Wco5NuL1*EsB`x~@n*h(?D1OG^6HWF9!Sg~V$ES0VA*z*R`RHoU_%=ZWIsihbliuR_I1oxPLp?w#}ll6v+< zwg{vpr5pGpBSOJINA1pLQ;HrlAUVJ{i`Xyoj)Yzg@XaC?nckP!3%T2Pxmm>4^Im0M z8%`M^i`b)i$0GJA9ORGGdo}M^#L7Xw2{49gHIjw^<886E78)YytwX7WjjZE7m@QYZ%^0*w1LzQ$m|7h;B=(kGZkPVK*ectA? zHCs}bpO~(Aj*>7O_DRBL`7}eNmTFWn1YvL-u4~pPx~=6F22c&caJWxF^uXn*!wTJ8 zMmL>r65;?19Y56 z$)d=B^YL$b6_pIwbMBlp z#G-Wlc-kevHQ)tH)A687fNS`M=oIl$TmrQF8zNN1M{x;o4d!2l_$V#`uHhRZRm4Ye z32+YI5Uq-|UZ#ZR2k>O_l#}dXBnbakX8hkD*x$wfVc;{jq4`1j{aU2u6zvH$uO+-3 zV)S_P8?btB!0J6zZmzquKjO(Ezc1tKVg~O6QWx;IBGtg(fvKbTJ1BJkJj8spCDF6B zcZs!EV;fbFc1DS``Vwg)OQaoKB5iOX&Dz|;eP5G(k50}_O;4n22%T;pq%=*WFGAFM zx$9l4OQrJQdGLjcI>escAUxZlo za(3z0o8Welbki=b;)qd@p3w$zT%3LH#DHHrBgC(XNyDjICn%JFd&x*b2N>yY;nM`c!u5=zYJ|p3! zDy;z25zM;jM(g2_8pXeXsmo}$alp4@y@Z8 zq=fWK+zd)&#{5o2J{|2oP(C&i&c{Z~`Plfp^RaP_?_=Y3N}G=jbAxatb>m%wx-o?2 zH0L$FZ3iw8l&<|o$&0Im>FT6z;vxERv7l_c2w{ks zB4MS5|B?!K5ZqSX zMyLR1kd0vL`P!{cG?hT|O6&l;IPzwF?Mu9j@}sR`M$UR`;`O9)kobsiGXUQtB;rphp-}(1XV(F8e7~mFD*j!@@n@wGJ1^T?`?CHa0axv}0 z(kvn_y>AAMTrhNYvi#v__p5CCT!=xOf*`S!YQYU6!Bdq-QaD}rWc_s6-R1Km%ns6j z5l+Y4AV`4y~3Cxz1wwsgTOcTzb0!-e$EhSNV(sOQjd`ay;CLE-e_ zh4eS_dO+s+z(V@d;q+mJ^xuZl4=AMnIGirz^XKhb;q(s{(x-;g_b;TM6Hb@4hhNX} z;q=2uN5+<`B~kdKMHRiTiodx-!}(mg&EueOIvIofZy;UE!^x#v{-=AV8-DyYoDPu= z>iKc+bgSoEz0<88-M?_{;=XUcxsieR^o!)aLu%aHvb>l7qtlaI?Vpe&kf+^Dc-!tp z!#$#v9f9(xvOYa!xLoQWY+aar_@m`=5ccs{%j>$C9le+33^jWNsXVLnB{|!{bo%X| zDwkp|7cq%#**n>xDZb9K!@DF9(zDBA+~jJ?p1DyOQlIET{RN+;T1#d7=ufO0-&Y^9 zPaj_1lO4_9XFVOqQSTfUx&Bvl6HfQTSHo_3Pn>i?#SIPR9ntQ!Zl0w4Qx419svC0{ z77eaXpRn(;SB5WJyFW%w`|h1q3u(`Nza8!fw$e~NSdqrW8T1P{a)N!*Z`8+Q%Qd>U5L+;Q# zy&AK(_4PsP>j{8x4BewAk1FBY$Ey>S%F%iiMLGwG_H^!{jlrK+1zY`W^VWkS*PqEC z?Y@5e$yYZ&09tYxLH0!m@*}NdC|%nTvX38AF{^4Y9wBI8=2>I*zg90Rd5L`MSDLT` zEMc=H%%+kthgiZk_2*D~B#vF#m|=QsmH+mjYm&g{zCvq$|HeRtsQN{#NlN@NgUZy_ zpDbaM+B(P*HbRESe8?VWsp@_8XmJ@j2hjmW-KnbOUQGDNG}Qs)MN~6$?3lgm#Fm^Wx{}$Nf>jmJ=Uwvh_bcTT6bNYVzP4b%PJJ1#0*MYbGTr@3kL!aLyxWRL0CEm z@k~EdGS@;G>jxM^R;l{NupyFlO(^RsW&ILa+s05a!@e+IKQEPj{fzUDP$9LF<5q*K zpIwoxkEwnLH(9?P%6hA^ZY7~@%$^37L;U*fB~DMrlpBb~SRvY@|5pDB60HCGS=KvL z{}9W%e<-UAesbSc{h68FGDN-Z*Sw$Wyf<%!2>hqMUdx|J zZTkMD4TRs|{^0dWzL-DodCkXx66f+vKX_{7sn8E5SXRop<1Fti20{M4iOb{i^YpQz z{3OUytofRKG4^Uu$$?g~9<=dE59nT&QwRL@9YEL?#ihN|E&u7^bO*7URZpm2LH$(7x5L8euAeKFf6s8b>(4@^uQz4k zEFSall1WqU8PbCZ9;bwdNO1dYkZk?Ct9N-_H_zSLJN*u&UlUGuSUO-Ob|zN?#gIcloQ7 z{*!RJYuD1h9Zq-ksP){m-sul2{oHW6tKabQgmAj6U&e#EqYCM>-?2^pdQmnUy-m3S zcadx27gXF7FJB3-)E4jDQz)W6-N`RH_tcby-_>CFT@B^m6Bqohwu1}I5b#-~mz8hg z^#UA(?di^w%l@(lhrSDNGV(b)@6nzHoG;&#A8O>lxk`slc_o2+O=K3xEjz}|2-w!g zXTNp>rD6Mqt{wyr9GmMqsl-?ILix+asA{#kfo(~fMQ=Y0f#BfV<)AJ;dxgsSKIypQ z=f<0v*p~FNL^H&7_xKU<%oSC{LmZr4vB7tdw=z9vIvq$ax|+Xy8kPMiTdGXcw&VEPR-q)wV(RS3Xk>Bk${!DD=&xH%)nflMObS|CJ z5slQ~8fx<voQ^>_9=3#l}<-`77p`>!25 zHNUgZv`TYz)^)4);pTV7r8f9Oy;mozv)D<9$P$dV`JKI|eX#kR!B;$jUm(o%rajrU z%$2KbTG@3^TX_EcV?(`mJmuYq>Zwj%FO8ZsJ`kN`T*ykjlgieH@-45Bp96TzlH0Mp5EX+9-R=+ELq58 zL>rUdgT6uR?AOjX5qC*{Wi0=oWsgvvp;VP?K5B zW27b{Hkq6o{14ex@Dt|ks_FDZ=8iHjM2GJ$0WG?fqJO!xA}_??}tLT4i) ztyMgU@I;1i7Q~wIQwcANxRSF|^J(Nr;AFt=>wr({e8K;F!T+#){M9_49R1g6%j4-e z>OFE)qKUtp@Mg@4dv~;{v*|?|D&Fngt2bwq(D|M@8n$e%Bg5{{tS}|B_=(imATZ8e znDFM@U>~etcIgpj5Z5|QolCbWbG*4#Ma%uMCeoHOQA2N*sOT3n6^C>7cb>QFk)M?_ z(UynqEK%>kj!lX5Jk6B)+)(qLjUa6hw1G@n7#X%it@vH`$0IBC$dE;6FqVY3#D-L} zMAOfLuxk|A2>k^zx%*Yt(MKZCXO2FOHveSC=9}M)r!$&02v#s%ek=5EL1^~4DQ4sK zGSjiuY zm%kj$p{-_+d^uYf|pxg=rmyT7%y*cV(JzgF| z`0lmpCTe6zzp?&F_HG566w=SpAcf}N+E!5(Aiwtv*e=Yj_ZCeTjM9q)tgu~)p=Q1e{km}KR&6$ONUG~wZDYRV0u z)?C^Urt8-;yhq}Kv?aiK8)ks-P3>Tg0GY>mgQvg_>Z^+EBQ*}^o9T->o2c1Xz@SHGWNnz|!QQ(FlJ#vuGICDIEtUkSGm zBq}Q47UP}L4)o5W0a2?w{yTKb<3D{T5XY~mCcqawjJr7kLp5s+n>V>xq7(D16KSJ? ze%CN}V~X6Gb~9DfYOB@)c|<5w_{2==5MpP{6N0g#ZqRTeHS@x2;HnX}20oXF+_ll4 zuee(P!L<4FnJnLE$k4J8boZBVord#A-t*_L-GTn&BXWoI|L@W#73jY)yS5TQt77_3 zOr$*h&%Gb|-?-4Hw7uwmW1COoz#F5?!FtHVg|S2KaJ0>KgC1MJ{U3MBA*Hpt!!5ul zqrU}wjH>akRL=c9!>5Lt$3)%J^A>_E5M-m7VBsRS`dr8SJu1CKOQAsb+akkkA1{!9 z>v%EwXN@e(?n{3~Gw-Fm_$=^0y~uCzb=q%W2gvV7^VGChSATl^2IFpDgwVTIY>}~j z^dS8WnS&!f?u-0Wtb|AzA+;-AOz1tZltZ;@cjdJwGw z(hdpT7O?W84(Dg>!WJNp(84>P_KWKJoebJa&!~hB=l1|deiNQ`%csK08rF&J22kI@ z)F_(o?*<9(AxDNRa4U9!1`)77a8uwveTQZ$!h`YSwQC%?FOYwKJrt(Swt+nTx3#J@ z;kK^uG=(}-v_&>$!1RByHE?wQw}1^=16smuJEH$+T^>?ss3jfbZtxxx z_dol!Izi4`w3sy5{PaXIK_UWTf&jK{SDmdYVlz9$xc<)8XM+UC^uzmaPz{}}LK5Z7 zKE^Q>9%u#)3dill$9X$FM|HvfXwuwNPiX_h)+lWom@-Q$H8=M>DRfmAI%D#D4`An5 zM>$Hn*NGrV)56YHO{Er2q-KtlteM!6J>nzADQSSd?NHH)ujo7(b$Y2Ve<-&)o|wZ? zR8ZgyM?&)2=@E*mQ4Cj8rQz-bdwBPHO$-s5DaLuUl1XvnwJFlfc+dKn$M74a4r{Mn zqnS{DUkplr9_dlKRl!qO7)UY;414;L@i5JgXIOnv{G*YVG`*`cyPz#C$_l(3R6(mpM6Q1YKyXTJz-}?K-%;nu)ba0$%)GS#E0I}r9 ztfzaOgvXm%(;Z+0vRuiQJ6kU!o1W-$(=7h5G;l<%ar3f3U-_NU7O63nainHZnM+Ex zlRgolAs<-y5AxQy&aA6W`UqJ}Kd z<{4|@{#+Y<#I_H^3Fku|&-a<%3@S6X_mS3b^A*xLdxa(`zc;$^#*qKG0axS)tfxu! zHe&wHKr-(SnYUofvG#h7vzkl>I%Oe$2yy0*pI?83#=7z9kJOHNWYS3e$?)k%ZU9M6 z4j#Z^jq8@?+QGq}^$P`uJ2ds-e#P35ajJUn3Cw z8UXk;2+%JdWLqfYd~7;?(eQ)$63Hk+5WizFb!l zJJRu^cA2_L`!T9Z--_qT`t*#B{cXWK`QR(eli{l-W0uC>SkxgyXqy&h%7KqO7urls z5de*L@@qm}e&?xE{2BuCYebCS1%AKuIe_7D>Q{b$)CTQvlF&$*Ltg*&Ad52^X}O$i z(4}{;C0J(qqcv8B6Z2)zBB5bNDsK$fgNb~dK*PDM={n^=}`n@gm zYqRMH1|AlwWsnBu`m;EcU*q4v1eF{=`T8~frJ)K+jX%^L^M+dJ0jfgwYBZ^{G+na4JRCnJxCHMM@-lx7GKdN6KQ$lE&MM4D z&-v1LhljcwhIc#V%={)BDC8({nL|JE$ZMTxw#z2wcH z?iq6>>vxefBdywzF=LyHlZG3TUU}Ck!dKnt9keM{S>7}zJ+ZR+j{|k}{8Vn9`>_y5 zuf$ixZ|?k=`wu-!!)8Sk+#``W_|#&zWaD~vbz-lDn444jw$ zzEAOYX9o}}-*vT>=K=*&`<8Pp4?T&Fg9J8s9bYZe|Ji}an8C`bRe3sM{YjliThIM6 z=*#!5u32T_ZujKOw^C<^B-kMko7wDI{?!LM(7{;?#73g0m-)xuf z-}2pANWRc_(FKP6e7>GGzB8|o=eOj~$9p<@iksiBmPf}Wz17U?g139jYrekJMC$rl zzOH)fQ=J-EmQOs&5@*q_&38Wiz@qe1^6A~*(7=NH2j$b(k?!VI=fyvdM@xtQ5Ih)k zq>jT44gO3skl?F9kC`;z=wzkuCv=0$Wxsw{E&e zOQ-cmI0ip}w=1s3Jf|;Sta4TE%YT8ZgD&&^1@#cWSkdv(Q^!Zg;pZmqffZsF?1Dvh zRL%jxRZG`dZ#yVg!DzB&CCb@0huw!KN#2F zD2GrS-RJWYY>{eCCTLc+IQ$sy4(?UqN&-4ac|ux9viBUt#+^zfL0Ox~Kdkj}E7XCo zNsQr(u|>YANDVLO?cBV`ps!q$#u6!NDpDpodNbt39x66rg}yu z3PkYf81uoj%)oio24^l)?=@9nZ{uUrv;OSBZ{$XR*TMW4K7~F8TNtpz=1pVw(QATaAAfU8r3jxoDf={KG-5hG_=a9XJV5q%a>@CMriJ=iMeK^U*Nyh zFZ$=V2fW{8P7$IQ&@FI8JTr4J16sEwUbA)fvUWNK@tDkUb>MGbtSBSu56o*jyPE`D zCQ^iBj#m}|C?)R8%J8+2uA)#7ysYK*h~ zch)USJ?tNl{zmb;KV4M5<*Q`OM7JsW@pTG+?w1_U^e_aw=|R`F;O!!~d!J9H@2{53 zFX7ERuOWR)bvw^-PY!8subywu=S+__UtL{=m)MOAX%=Z3n#z<#T0TU7^m#hh4P+@F zm92JJ)NI@mnI$sAYoG;V`Z6Zu^L8LHOuuVXAHHRV?T)(41-<+4Xb5 z!>(kwxv;5l6XN)ZsGS)M*c+Z;zZayi_Aw1CPjLT+UsK`7u)5|kU6@J?d-PSf;FVEWG1^qn)x zH$h_k=P}^w>QV8`9J#y{_~$+2P7$A`#`Gek0{*t_FaGM14DlZr#I+e+VXp*CNcWC)CX*i%@y|VFt`i62tywhB6C^HheV|Q zx!jB*cv2S6o%Pit65jDun!I@2JAQ-~3hebvoKN3hJ&P>4C#ccQlba4e@8d!0B$Xf8 z^;@5B3r`m&q97U5mC|%gWxA-BRW~YkWxl=!rf^i;J2dwV1_mB!l1FhvysJ4FfqCEy zhLJm(sS6z;+Zt;-q;WBVWw+j)QLdTPpt{2Y!6RmHg)U(Pa23(o>p4Pq4cP}$6d7_N ziZ`bt(~z7xLr>(JQ>CU5DoU8e?>x!2u=rdoK^am#$vMJ^Tp2kTtwt*Wj0xUxvA z?kHgkqQPMRpn+kGrMi>pufVncDbljeTE1T6irW^U%R+QzM8jyC$H?^)3S%vwI;0_e z`Y5Qz@8d*{yI#H`o3E;Zw%(zJybDG)5DgDv66bb3SUPrGL-RGrR?;V*$E`cEzyL*B zW%|STMJvf(hob0N4bl5=O=tF)C*2^{@PdJm1p4u`lUtoOIh zA}`8d4UFVOB!*D3epom9y3L!6ghJq&g(J!Iw>8oeGxhs*H*Ef!6nf2~sLAwQY8=Aa z!B0c_gu(I6CU_1?4 z37)T-jObR&tiY@V{8#|!%pC1Wg7JT>(L^*omR_V3W=S}lz5UOY`fH5b++K7|9gtPG zPdRF$QiO>6EO^a(lw0O&`VPgdB!##ZS)NWQ?R4fNVi&z))s zbq4O#B2pdrK1aU{MBWvnva_Br(6#JIn>odaV!>!yVLWufxFP-RS-drjK6yl>`EC-7 z2hHWkExc$sn-a&pm zbF2l~Om8N=heY5jUtm!9^;*xmt76B%)XPJGmg4g(P!|(Cef-6 z@SCaQ7ou>U{bVNdxm3YKWSpu7>4 zr}hP_Ep=Xpemt|5A=StL%0tsZ4l&Cc-}DQsq{)=5_k1RH;w%}Kz~G1$L~5qABjbe4 zM-1)k_%Xrl$o~9~+qxSv)9Q#}#W^FMUObEOXP^GHTRETAWXxWnxh*0Qbp$q;qxoe{ zG~=ASFn(N@{Tf&-R}yt)+3{AfZ9CL0F!^T{j!h#1V=x~h(;lF!WeVP$Qv3T$JJ^bMv2kL zEgguj`5PVF(KJv_-VXxxn^%k~f@zC}&lZ;?4ki~axckJBWZEEtHz@L zX^kPsON@Rpa{Z_DGI~l?0+ol98_~#jmh+)5a?3-}mW?S_q~$>9va+{)R6BCyuEq{v z`AqF9Prkz&7e_a(D37%MT2gNn7_q~&wu zXJS@=&rKGZb4oaVH!)xa-szW@&zkW#{Kk(-FI7XU93@f1ck(s-%-XCg3(CijnK&P2 z9o)8>TI^tuPA)7}Tg&wnrnZqmZ7ow-acEFpzEDORkrv%M&!wpg`4iJ_oPW{W({3Mi zw>G=F|L|RZtSx7{x|{vFPgLDUsczd3=*BPeS=W=CQ_qX=?+5wskL&wsJ-=U>|E}^~ zHwX2el22D$u-tT&Yjd+B;}VUa!Fv{Hg+SF>;U@Z!psX3tu}`>D0>Da)ekIasHo=ow z`fc!Xf1no7HqvrB31CY%OKW<|D*1s3s*be0s}?gKdu(n&$2@}UnqIH7Ft@q0zwGEj z&z?1Lr)uD>loknzv?zWB06UW0dOe5N-18iI+N@nh7H-?I(qp35_JPX3fUI53q7T$M zI$!I7RMRy-n7<+U^lr_ohWet0Yhz`n)mS$(R(3WdjolEkDb%)4zEqqnISC%r4tlKT zZq?YG9{mV?Q?=NP{L<2gsb2>uS-hOy`fS z=+J7VKd1DcTlyzwhMLl~aSLYZ_zz$BWH)upRuv;v#AFggJr&0_Hbm*wEg0<(aC-JK zty759aFaoqJ~!TJygun1m~_LYK0S!TJS_ZgNHP}{dx1hEarOIUlKhiCPn`qA^Ci;f z3{H4wA^)Gixs)51>6762PsEAX%#m^Ls;WdL)`36_iEZNwwAtBx?l*?@=ycNxxaD-L z!y7xavsv7l{)0HC_7bsdU2boi^u~ec5U7{Y%;5#xf>j3I%`1kNTF;#W=rxCcse@t9 ziwj!K061H&Y(_WP$werpD;pllH6wv?BahlX6l_e zSObb@q`>5Q>E9l58@9w%xkk(E=y^ltYRO#KY8pB#s#Uh3v%dN~J>m9eAwJEXq)V7(+q z=_OHJrI*HI^>SJ@^~H{eaqD!bQYWg^kh7~t=;cC{8uI1pBlI#wrG_Ab&`VRbUQ*RZ zN7GG1vGy3y{79vud{#!0oU-rozK8!Ft78l1y~=-|QP1I&_d0?xt#E0xx9Yll~u@-68{)NV1K1&w8nMVlULMVt8yKu{4LU#QM zhXqH_r`*Z>nbc-3y-xrkfMaD$@y|X%x{WF|vH6j5o1okWmDi1L_SS`Tnf;oiX*JQ= zxjT4eE|5-&kF@dI$Z?)x)P+BcpNt(Y<33Yg$UP0&So|U0bGl3#V(HC(8-|`ca&Y zVpfv2X*6+Bx~i+s5cQ|!X!}bLQw5^P)(7$iDr*_GnSqJsx?*-P@y{JO$61B z2i0Pr+SDUJQ?E(L)^nUDyz3lWM<>e=${~>($v=Q~BF!CJ?HwaQe}#7<6a<>#jfZU1 zSL4cU?7kLxx86I^*7s=;3}kU49+hW9FOb5Cc2s`3x|-(;j+K~vXuUVyC<7sVNxazT zO$uUxSkB1J)zAvWb5$E-k;?k&qc%S|FNIDfz(5Vhj9!P)ijr;{d4`Z57cxQ2zNn8j^x zahgs2OE@t;uxta2kw;vG6?kSf^?4l_wphv8*IwU-VP2ts5@WS=QkUFow)|EP4uuox zfoFUMg=%_`A$fYgFYwkt*q7R64STI@I*d!N4Fvi_@4DC3U~b1r>G}_`DEIW&Mw(m-Op^&0@ve-gvlR># zz(DaEsDu(>sFG? zeLD9Xd6ZfHO=|0z-~X;&adhnc-Fn#=_1=?;-e?#RH#VjA#R)-n)+O(9Wv8NA^ktuV zZ+*5K`9=W{z8i%+YUKO#QPprLG+_OwnV8Ieqw4T}i{RTkkjRR7K!ouK#)bZR;Bzk5 z_gY-8cqp5b*C?8nx;Oi^c81Z}DvqBA37=(xtjFw+p49vhaqj9;`yV|_JNS4i-@bkqpW3IiJ z$#OQv6vR*ur3?OX6)|k-kJOPsxZ}I{;C-ReyT=XAPWX~6Z#H{2HB_k~bdMuGg2{ks zTV05DPpFEgZ&SBAV|Qz*;v~YV?jAol?TXG`(N20{Z)nT@{S08EEKKMMaKg zzxFKs>TEq4T;)MnCuy7>vu7i;i-*_IOf3=C(I4+|aQd3wgLQPf4<}2^m`sm#qE6P|z_8QMDaUV^%h{S#zd6JovSW$Lyva?kQT7;2dt~~Nl zQnU#5iwg*=)qC8x7-t!}1k258tRz>o`}D$UM>#b~#NP!6yz?@-=E=79SU zxGwz(Z3d7p-0H{v{4z3eD~pwhhmgX8Y*zsQ%}T3BjQ9y)l1Tqh6M(KoUGi+QqutUQ zr|;Afqz~!}w4$&mf8-YBCTrgorKXbACwPUpX6UEi(vs6Te!Uc8P;EUrQwk4w+xD|P zcwh3nKH$9(je_WA5xnQ_2;PaF@Jc3u zFB#~z%G;Ef@z?DlX&sm_x5WLMG@0Qfvczi$i6M~dl_fq>Ki(quamhH|3hO$VIhn<7 z3Imq7W${||qa|+Ty(KPHOMC;TGM2bYnCEAk<6al&$5%*1hFPM2#fE**2dzaqv*nMO zm1S{Mz%J&n9-#uJ$4_JqS@bus;w(20TCI>sZU34-Zl5?Ra3NG+Vi6Tk0mBOHTMaRO zcXk*tDyhLUg-w_cpn_1}17hIs*_|<;7;Lj{uy=zUHtVxj2((4i06r0a@P3`;_&TH17^8!r~WSPTt*|{{)C6jI7 zT!3eIv1@-Qy`SH>vIj_S@j?2*yBtVc!XP~wX@vOV>y%h(KQ92Nu%$mo0EZot_?_Ls z=V{lZ);aoxAJC7#p|iYQqQA?}spH%Bc6n#7VY~c1!+^{Izkd_3KgO(;qWYorUA)Vy zfZOE-mf2JCkl(dk-m2Rk)d$}GqCSAOy8ghvUx0s}nOkhY*Cg3z8L7m~z`G_o$m^B$>^?4XA4{)i`{s1PTF+L{ zvn|4{XRS)sv(kaKezv=wmEB*@R&!>*cky$u^rxDKomtN+V1#>J_Nr6zP_^}}@%!X@ z$LrbZ5kysr^(@d7uV=A`!)any*Yo{oI*LFVtmm)(3*n@D=mdKUi{4e@V%lk|HZ=z#(fscM(5`>8_# z=Nioybu9K#z!Hl{IxA!@6VQug|L&LihQIM|;@W(c9p=p~S);}5)S}E<+4}8uKEsPc zf^`3wR@h5?!rm9Brn-vGYvR=W^V%W%V9~tv7kxlJw1F3MYARq0o)9|5sjWCQ41A5L z_mNG;B7EqZQ&X*uQ`-(7AGCNXEq1+7py&PD&+o^Yru6#%Ns0B}u`BEUN^ao&v+d^t zF>GGCun#QgbN#D8Vf_y&aB{o0{;j(Ht^aufe$o0z!s#E@2eX_zTi@oeL-(|wZ}A_q zOMlw~_>26NfBZZLe7R+3S+`Rz-L}F9z8&u}8P&pmu6pISwUR&byJYTD*~>3z6x1)h za3mXf8CWh1SgRtQv)FPBIyt7)`RqV41B*Un&R{ZQ!DZ*KVXijM?1M!HTn%Pw={9)T zgkk8Vbp#pEXPjk?(wlQ$0X0(V1=_H^{omYExc%QX!TyiU?$Tds-b(EMi!QTG2{h`Ho~S^Go{S4`DZ=>PTgrB&fL2{U>B-5x=}Cy07~UsIx#TxJ;Qz2s zQZ}|b`0Jico}@hL!~Y&7_Dxb`u>(n2J+3!N(I-fX%V7dvpQM<$Si;|4B*pT2cF#a0 z#nrIHrAjQsju;{-N-vNUGePw-F0)aVUb4pRog5dbZYLjhE^smj-1bK>LrxiXKwyeb zjw;{?jN>;-)0k^cDqxJ(dD=$l8N~>TjJAt4)>L0~rVaYCy&k-mEKOqaO1=WWlHafT zmM29p2reQn!TIw$|LKscNS?IXN3QTbWZPpT8S3{QWAzC3+m$D+Oh7Dp$&>8xQKTPIC3LJvM0o5yJwO`hhn8dc z+)H0@+8`%S^7TV?2B$@;x1b-2D>1JhN+gOl3-{63?vQ?nHLP<)fl1g|>5?xw+7PBR4O9qWgzx)7XoSnMfhu$K0tr4ss~ z2Je~teFQZ9{n{3R+R4RBD-P=J#@60@&~)swF>JYyQ4xhA+xa~Q`#X7WNVm3A zQM#>uPY3&-X|9SC2Y6bo1bh&4^XCNc#XPcMM84>NZ}RXW%>lK#v+5$1bk4E1t1&=G zsGMvM#$(o)kPwd3TJn_&8UHkUdL7KClnY!|Mlmp0o$=<0DJ@_aXH)thfOGowrOH^D zo9e>XBB&u>i(r*y4!QJ2aODX%DZOwd#6=XJO;rF~iKk6Pfl(f6dQSJhieZhBzC+Uh z(x{V8m(Z>IsPnA)w9Sq?pK{4LnO>x1`s8a9tS|0>>Z=k2^AO@--`%6tV`;VP=>msY zp#R2S7SRhGdZ|zJLX)S*?7lcVFWLeEdU5mI67(YO<4phc$+w?SL@$iOxXUUbdhw6c zCtv&mIIu=*padt`C%sSs+YoFOA6Va;UTCuW%@bI4+v6lb5^HI}*pl?ZS>X8R)4uon z!xr`ccCg?7_&X)``#DJTKM`h$~+&swy219(17bX{%sMf}^^VtCrty?y<`_s2STjs%zC z-*yN6!TrwwPtC|q!BYindtaBmlgSRlQxvJ+{F~Jycp4q+OMejW3D17mU$t-(q6n0M zecV1bJ5Uzc$Grym`N!MGjeHuk@RwC)%$d=??XRv9zzXI#^Lf?#LZt(j?8j>X%C6bR zSrr1wX+qMThH!1!M@IgS*vI|pXMMou;+smqXUlE@pSGvM@cFOf`i9TUKH#Ht!RMh} zhmTdU9r#>K)xE&B>-@~IL^~^5M*%;x{M!yrMfOrN6N#Vn z0q-X>CE)$8zb^ZPcQ0kz5y$oe-o0d2|BL6{J68kmYnY#%g0~9ThG@#Q>yLV$@V4r< z3vXYIcL*)@1@Az=(l`Hl?z|qr4)~qFq#dw}_?=?Yo{HqGsa$c8BADM^k&daN;9>I0H@~ROuQ9@p|WB&EqKkNgZ!@gMpp7PWprpK2* z_Je;tYSeDWzrOn@@cfURg{KPGa$T3*rw2TDihs3w1kdgAuk%0I1D^fhUswE~2Plt( z)XM1L#2Xwa57oP``W!bxa5RqgA9lIpibulC(Vw|H#L4P1wkxK(_;SbIf>sIURp|gF zdy!6vyT-g)6@o`8=GE*8v-?o{j`*W~z^A&s5BS`9T?zOc@sEekldHn;`IxS7^#PxK z`hbtp1)r^>b{Rfa#rENI8@2BUKF;1hpoep_+zcZ?%)F7GYR9)z1YUOy&D z^c|no6|WUEpi&8MZ4noR{b8`A+Um_TH1)7=satFkSdf#-D1d#SPpv&t-Y=~T&HR4p zPcieEMegjMoaL)=xcRi0Tdp@Cmcoii%Vy~lZdm8}O9*I9&p-NZZ#rY`%H>nCWuFmT zYJ!{}J*CyAhU~>P;*v!fma?{z^ufM@|iMR$>knKKmtN-|NN`F@0p zR!`r|nX^Y%E5m68rn`rIdjE_WU;AzkkOt@JD`q*67M-Wp7V8tGWhlOH*6V!r=qGpc z^VNx5qhG39yE}k!@p)PWY$e+H>Y0MfF|SY5$++M80jo}+?(;nDpRcA!^jPw~S^w=< zx8B+VzyK{N~KUnY0SC?4ttNqJo{g-(zvfcLdK3vU%DtnW?& zN4+n2TXoxox4)lHq@~jE?*D#X)7Asz!G6AQYN`F)C+Yp)&%gB1zCphG?dMnB3;g3d zhJW#Xt^!5-dBvgcg-~D@_jA?S@BREg4tX!UpPRE<@Ao?OzHJVBoPk(r%dn4sOO|1s zzGWC5cz#98oV~LPQVs?Fi}!}~_3bbi>9%)$mQFDoiY>#)VyEjM`e9%g_Sug(6d2A{ zhlIfF1%fN(nQ2hhgaDTZTa@BzyKP!?>VSr?pn^m{HEu)3@w5aXG zIY%lPoD3B1Bj@*v9kPU5@xD@o0>OSU>#`F2#Ri{6=ySg)+)5TBjC}ElgNsnWw<>ZU zcfbAOM4b37yQ++Z=WeW3o$s32ZBwjvc_ZnBJ>^ z!FFBt$O2SNxvI^n-^OHCk5;rwA>kKXLgIZVuM;F!e#Dr-p7OgL>&uV2t`B(Lb4dw! z)`#F}UE030kiQOh@DwilS^+K&>FpopEadxl0nZ^j3r`g=LJd5bX`it-c!rGrcdVDN zdIZnX%JPCdc4bvbc=pTQTBFbz?(92l+A9;BD?E(P2|BeA%yc4T{Em+$czsT&rufv;F*Y{2wtXpgB#lu8| zLmXMbK0mLo>YE;4dTkG22lRLozRY{k<3wov_Jbb3HFUS5$1mRrct5yf@D|f!74Yft zwnOu<-FbR!_4J1x&!rU(yrAMl)TVF`FDT%VR` z|KS-KvfIJ)*!jS7_Rhjn1$=m3)q`c)DR^2vJA~(OalXCb*{}We-K%?mG_U_4L{u+% z_;7!T_Fw;TaAY^%V$b?90Dfr4050BQRiLoN?pa`?c1_=D)%Cr_vTl9(=pBxgDq%04 zKkx3)#pYgD^#FNr-fcVIfxJlHIbx^voqO%qH^_It^X^$c0{##082-iQT@^6+2l~zw zj8B2f(y3q<^qs1;U*}y(SoSbhtH59N&%egLSM~sY;IHfEa~<%D{O{fE1AnLdb>;T% z8~(ei$gAOUyA=2miSAhcj%ir(%x9a)_|2ex1|10`}|CdU@ zzs0}*zEkk`D*g%Ke>?Dh1#p&}l@Gno^>5Yn5B^QGRapQ1u!kRdc@MY; z_ib+@DxCQIkGR3NL(=e-;VZ@M62m|2%0kEYkhJFS+wQ+d-zM>=sPiSREGQiSWq*7F zpxL!63s!}IQtHaWq&Dt*^wS=`fBW+#m-c{Dz@KewEU`Y%@Zq#m>+`2&|9tCn(OlN2 zuZ`(HeO7_O`ivg*KG&yJ*T41o`{CjB$$f~1p69bH3$3*A!bMYhpg?dw+c4gtK+*Z^ zJRb#oeWch96jP=>&-+t#_6dRUg12pe`M)b=ybwO0Nx{8y&hQhyxq@?RQ&5LvzfeYH zefd*WM|?X4b5vuV@12wE%pv!E2gsk{h*K}fhy0ZkpU+glARnC1ZUG<#=1i6myWsg= zwYu|}Z=E0@hE!N4Ukh6N7okAjpX$!Q|Kh&je@Y4XPu^+xUxdAj{2%_4!2cHDf9B4@ zUj>Tb|KkNJz|2m!Y25vwVR$fEKVi2^m-V`BNQTkfs;5AM_ zreLpC$g;m%$;L{2J#~*G_@_mWLaV0!LSHn3L}tH3Z{`iZ7OTjO&5Kct%)sncLojo? zgr-#8K~riUWv!81iFK2EvmfE2Ub$GMpQWlSQWKknRgB&VJk@5PT$lYeQ|d2bjmm3P zH%$NRcQ7rU0ymYb-vYcmBiVlTxV-nQQ7W zG}fbUMiwH-jzUA1wKasXgV2aXByrd=*RW%MhaGt0ayTID7)V+}=Ja0J5!!vgjUD z-s1rafR-h&UsSy;3=OL^W}JIr4+nP=&dI^uUruzGA-nm!gS)jpW_;Hr8cpy`5Hs_% zZX1YQTNih>jQ&<#?^)E70%m{PsJ|wGW)&tEr$(TY}Dqc4s5vkZ;n<}(m!a0(2*(88dY%$ez<@hPjyR*km4`a z5T02JhKaq9!qJCd^ac4r?k(^lPd|F~>+i&r?z$`g-SDM9`^DG`dQgpEzj(Nz#C~!A z?y+CIaiihD!u1XZMhVQBfoE)dU;BkBE4^PFxBo8f7pm}oa=%zSWC#02f8ag-{666Q z{0SxC-LZSXd)qf1yf+lVJO1YTg10Iw4e#|scM0CA@P88Clj+6|_=C`X;2X2=a5Fgd z+#Z{O;{euYpNlyJ&fGo>;;tHKCAs`aW_yk0h!^vsp z*-xIHSU|)uJ%Ny@b3T&^gQm_wOsee1qIMOC%nmrukE$O%IL~3~a4F7HV+OM{3t-mt z7Q?Le2W=?UOQ_4Ke>KdSqcK2T)F&p>4b0~}?Hin@5*f9-IO8qR>rzz~I6W9ovL)a#=FkwL4E>zzt0}$Fw9KBf_N|o`;se5?3YW7 zbF*$kFj(y#@fr`l7F;+%h_(Ie62&H*D&WgBx|nfarm^!T*jA4u(xpwXeS5zf1k|v7 z7}Dte?I$ly=mF5c`uf5#4xnM{>$WlOJT+mO6KVl~II`VuQu zrgJ9(2_?g3IEj_*GT(bX4`3&>+PPgub@#c;$UnN1%7pe8k=*=xCs>HKx&!D$?=33W zU;2#?zdNlDd}utT1U_u>`HS5dAI_fX@Zs}C`0(RDzAt=GWqsnqH{KsUsP6ZV4}W`Z zd-!mA(w$F!Cw?R8ttiQFl!0dKjoRKy^BX@nwFkfP6kQj;F=DhsmKD6``HjiGsYw@! zKEF|5G;CYu)%Gr*4e^;$WhH3*tU#g1F#CRKx{P z5x(E=dET?U=bm%#J@?M{Ib;9KoqO(imvf%q`|R)YqLE5*)lzWO1EsepDXsLO~GPWab2E15{*ywEY1{#%W-u#9m4gM%OT?%EOl@sQ7=j8=)n!7#G8SV)73SR# zlBUrl`RZYm-wZ~@NC#AFq#wD@KSfA&?lTK=E23_I;6{-1Ld za5`Jp|8v%hDusK4V$jOSti!Q^LjE6iR+|6kw;-2|t(`GeVQhH;qh;+JsMGvEpLFE= ze}*+Ua|7oiMce;mo6&-}|Bph*xn9=l%G`DPC~~gAcaPE48AivF8DMl=eE5ydA@VwY z1=}Jm(#oz}gI_dX&)^rfrB2OEfwIWHSGEH|A6q#0K0Ekoe0?A0-z8`H?r+{HZb=5i|alq-=3F#irVvI zF@$B$YrWl)_Iqt{NQk5t$cjOHbWbIzZ0&MgH2n=pB085VF z0_R_SmRqV%JqrZBq&R`?{a$PU0-Ie}zxc$Xad|sEq`N|ygzkQ?Pd^5!^Xgl|USF@S zV5AaU^j3U4VEcv;wO#*B+wMwj%YQS^#EjHl7f%gYJ{h~`zY(v_XXw9~b_M{2jHCBR zLC=44(^HB%ampn3->|bNdmS=jP3~$Twj7`k^xquQ8(zB>H1vZ6IO5LFIx+#pcJ^J7 zy)KjJi%G=$Z@B(7-{@0vbpeHPb?Pyg0PP;GLH?WD^amkOxcNpcwF-)HWC<<{c+5EU zRNItvBICMCN97wyLegiHZ`5*{V59XMVQHcvKneKeLd8aZJio6+@*6he6wfzeXTB1^ zW=08+Odk+uWp3!u4RLn70%JvW^n zEAUie`vy7A4z7czjt-W*tXoMOFj=>0hX>o!*9BLmicS&qw3zj)Cw^sh25t`S1@C)c zfTGUFbcHk0RUxvezrjN0ROon!&Ie|%mV72@10i?u>mke3lp@>=W3m*X=6|^P;0f?? z%7HQXcz1^gd`vd(n$qzx|KaYBkG7uyAIo%|2oe2!Ti3^oI7r&D@xcZbKGv`51bnd9 z1o-$J#>~fuy;-0G2#Y!Y?|=|E-2H)1qg*bxiCFa;QYHd>i87Bt#Cdk+eq3Xjd#SJb ztN{E&t@NG_atE=n@@*@xSG(YM1Iun8-tG-+eF}FNMd|^gd>2+ zA4F<;VHtii9s!@JbXomk;%ESkIO@NPYW6XSf1k!`&314SM z82+K>r_TJFtKKJs4ATxPBK754`13zC16#bXTH2u)@{{oaY(u^^-K6N8#t^!Zrq3 zv}L*Xo}oZ5^K|H;ylX23!|(9j3-k^!DFRd{6=}{Yp3FNuU?G++-&R z40CnE8srT=!-q;Y5EqIBdcT4ZX>Yl~Ol~RNj8lsW^imOn(n?P@a=E7+gKu*iTKObU zS!H_Jp36|EiXw?$!FV`@B$)#2%=huK6EDy!n@&^CqI&0Jq*CU_0~1Y|nd<7rZc5jj zJf^qVGU%n^K!L46ESSbgAXR`PNi=|u1BX6I8ZaeCd9TE`XO=VY9Ek6RX0(FHnd$xR z?l&z9KP$fxgP(KzMBry&cf`+WM=O3Vv+y(Ou8Q!(&Pv12@t{^E_~A&Mi=Ri|jKWW8 z@q_jOA>rfd6F;nu&?inytWR8r`h#57T}YqU<46dWuMs>EhDEGC!3M5AvD}j?$@K~8 zr?@_WA;S7Z6VK0SbPyk8#JE2nKr z{5SXbt|5x=4fkXU+pCYRQi|`u@2>CiSQAh_KrTwkV`e6YGKK=m69~u7%#wjKGB7eJ z$-mP`u0%)Vw8pimnj{1uc_#yHnCTw8(}aPYHcBR676rEu46` zWew6<$p%Vir|?bSAt`sB!+hYpoX0C!*=|TFsb8y}xZ{iXaSFddGRj3K%MXHBze-C; z$+Iw3_)z3l>>SA5xG`QVPC-7rsrl{Ehr-d@3pZed9`b-Vba-wsb#--WJ)Avbz7F3d zZ%8$-uAWHmLpt-r{y3_5s-J%gkvZ;g+@TMLsAIc6LDSv98y zlMrOfFUD=I|1>y7%uJ_9FmxuMn-*Mk0ZPvyQppkC| zdGPve5|^L9ctlY{!3^VjV|Q2!^u5XZ^c9tW;}t7~3m2@Tq4jn=cnp*3)& zFqS2`85`>wkWzWBj#6jVfLydv96kOldIk71nF9Fp@LQBW^DB(aI)1n*j=}nQDc?l{YJQHtGT+sZ#O*k<{}Jfx^lXJ%-aljc^66 zmC$N?!r1_P7&%TR55V1IilNNEx@pVCn8s1`6@?$t%O5w8)fceRW!Hfl7H;i`bXXJGYR z3>I@

|M~Uz-#uNwLdnUr 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

3WN}la2>u{|#!yCM;6c`_0`;lt&6O}&iWldQ z&`ckGmnx2LRxaa;=pka$UMhoIi@H_#ff5I4V!!BiBtluYQ)JgeLl)#dT^2chNV>BV0ZRp!&TnOPPpA>~S6%390^z8f|}l*DAkTRQA6Z}ZvJ z>AU^a^NX9S-+#C~y}0@2_y5{oUCVh7Hp`P|TN=4Nx@vt?`aSz#vwqr8~ zcAxHu8ZCa~t4HVmdUg8h@`F2Cjt8;LH0WRs{EtlO=tQv)9UZ@}XWrD1gh$gl0<{s{ z(G~?QuuSb(5R^oWE@X?nkyb(@yWRjK!|_NdC)J8%^Z*e3gkm9wD%F%#qcbIFy?30%7P;gR9*6~`q1aRiVnV8OS4snGK?J1RuiL(&01(f2e@Jz1r{p zEM*WK#1UiE6w&}#VA0=D=QI)?K`l{})HF7So7mrcPypW*0RMHm|F;5psIjv@hlhjS zc+S|F9v2`?;iN{hcR39r(or6FU;oF2wLWzUQS6${4ky*x#`Osk8n32)fW`HYVOJll z#1GC-+v52Kt9~SoH>?F3o=pOzbrN;hjedM%|C)~E^?EIPrg{~1^q|%8& z)XinbgQOjLWx!=NR#iYvIne1fBu&v_YB_zqCbu&5uvE98=3>7N@xDzPw}EYW9(qtl zfnxFIk)f%DHEAA5cLi!-T`+3r#N9{#>;293oBeSmcnd~zXym~eNATF@ z2LOR~q=5nv@MXSFb+h{Y_4-sCa3&HfdKi_LoMDU${jL&IcA0Af>8Ej7KdJLf&8CZD z)#_LnNX_4n`+y0GLQ5<&4-&?K&!dDS&w#T*VLSm8gzOB1q_TzYN?2xA>AW9g$=eM1 z{Gwv^L7N7YdH8^~huB8ElPx{EzPa+h_lspN6vFBW?yT|0puG-`p|b<^S)T;ur153e z>ERi`!1W<9F)-2`8W*;c;($s}9Sa>#5HopupavRym2mK5Y8>S>Nh%KmX~1jDj3vX^ zA=Q}&Z0e8c88Zn(PM8~p5Sghbrc~*mX6^H#edA9`G?oPt30&?gbRi7Il;o@~Bw7ZY z2)^5;XbT@dI6CtqK^6o`I0cLXy%GfI#9;TB8Yg(eg0~Scacw#dC$+l~NNK?6F1Jkg zZj>FEr;SkXZ-daV_ko^aw!%akooi>Q>$obV&hwuTDuXw6bDZ5YA|}Z;jcvfIBWmz& zDMc(`agSaa!i!pv`w#I~azC`Nhn{K)UOEn!U}V{1$9DqvrQqxv@IDZ!&-19~UND3N zI4Yw~UL{WBmgb4xWCFb^OF@7?5wQJ+rG417-X?=bM}|9Yc8{)A7yI|9!?>!AFE75t zMDF0joOpNH*ZcE|qJQg!@3*3&=)R;Xf8Hg!_f7Io8x;CsalE_+(k1Yp%3OKVp(`@} zHsl-(23G9P-RGns+<;EiI-NGY*bpStz>R?JIOot3*Y{)2hZoo(G@wf)pz#lC8wpDq z2SV_YO4y(~Y|isRoU)s$;XcfVAKd<7zkP7Cca7@$HjLe+x+#k_GGd_EJP1vPI7Hg7 z-BmIRE5oJpghbl05wIXQSgM7<8pwVNe>0pYAlZ_KV{7#YA5@CB|FD%D+r{5)k*Ak$ zr$s|Z0$+#cdH$$;J01DOCSQn$&C+qJ@EQIL8KMJpwkb3eE#(4rZG$Q>bmO43n8kh4zn3l9rX} za=c;}h%2Q%k57JO_y(F!f!9H%67vK#MgW!7b&Ad#uHNHM5on&EtPWV zchbFVuQ7V#P&Td$)UT_$o;+KB!^%e^X<+pCiYfJjO#sC(lq9q&ZGf5*(W^&S`{Q@# z*T3HH{4rdqL(EF4k|2mCcPMMkZEGyR+BT&U#*8g_(on88z|@mN)PiO^MTm`8c8}}5g8&@*KzwBT5VmRz^jOJd z`E{5UtGez4j87h2>@F^^&-VK_AKd+e*ZSRgAl=q~Pk?y-94bb(Jw(-B7)7rQTxFtF zY97k!LE8^$(sDO2qRuLvqH1_Ou{!`P0zdFKpy*hlDNSll5Qfkgl3{W?al$krI~~AL zN*gjY*k15P`hIpMN;pT@2NTs@Mn)7TD zAW_brpJH7T2cyR<5J0(2f~GjU*TcSl9~KXx^2xLNsgL#P`dZKvJ|Zb71creK;g?-v za;8IY4gC4XNgz*$5@OW6HQ^>FbMJ&|z}a@fm$-m=_o{)Kw;M-gdJ6`8q%Kv6Q3PU; zQ9S6QhK+nrVlGPrsN>81)}+u@T(%%YbcO+>p06Hj*O~F)UT{+78|qP+0O!%*LR(Wm#T~BU9|+iy$aa`{DFa*02)CyPm^#iftihOijehp+7G|s&(NmL zq^5ew)=n3KtvP$MyLo*dIX}I}0j~ZXzP91OZu!mi#vQ%?d!OC^#o*$jmsgic-`(|t z+7qjOpZO|253Bow>TA7c2xP`uo#^ajjY1avk9s0KJuFNA4cjqAvVKyNC^#9|v@L4e z%)EJOjmK~`k?)j~YRBp52Pmp-Nl4ISHkC?-f16h}O^%L@bji50nr{6~k$#h*b2}s5 zROV*V&=6|=c22`_Mihj8np}ftBtIoM^RuK!s(cNtQ$mueqefDgF_3$CJ0kQDb~-G( z`$zkK_gD>Sw#Y3x-gUwpk*PkMjhim6epEhZH*r|xhepN89JlbuNB9-2f=Unb>ior= zoIxCjZgO(Aw(JKwdxi#?&S48E8;n?BtIm2K^8R^z{PxZ6;`sOPcfWmod;={1re$~i z!~W{~w`Vt}Vf6d!>&pZ0^ZoWMb2-LuO4v0=KS+p)EP!PYz{Xi&t)vh=dMuGaYTnKN;@GVhOs&hKpM<{+TRCC1)Gr zfY6RD%){=uEAJnqyd}74{(xspfYhI9UVXs1h{{2FSul(-8k$z2qGu!odGT%eLm_SjY}%p2m)1-C z|7_(oKBylyvS!;@PoV_#(l}g!69J>->vT+2;o*l~NV|W3amc{y7GbN^U2Ax#Lj@~p zRWJcGz}~R{u*^yos=SA<@tkzD9WK^J($W=p&Z>XRyw@biD)HDH!F|Sl z7N%#I(IsU;QnGL0!I(7jAH0vmK|Y93WEpYn3KhzeeHqZ8dA#_m~7NH?f zt^Hs@jXr^|?BY}tt_}93*ExXvG7EnQvMFK|)?m5V0~Gn!Pz&*UL1Csw5HZgIgXe2I zbJ*Jd{q6qh_w{XrMJq4FU)!3f0(lgtX5iEec|(fmIbyg0uV`{!kEYJWY>O)4G~xjV z0=iAoJ}4q&9#M4uufN@{7=l1fJ>+C6o+21V2H+m-XyJCub)4Id0=gZ6zaHU zC=;rY9G6iGuHAMew?(8+bbZ8gnaE+ZFU=4^M4;lzV2RFopyXRd9+=Z^>u?iu{6yyV z`s(t+>pv{?H45Va4*#mncE>x3s<%8#n>+oO4f01-&9?9R)OQ!xH@l0QQ$#~u+u@Uk zW&i5<_4(yrP|ao=j9JJsj0Nyl9-8?S(@4B3K+ja5uoijbA~(#61D z{`K|E3&q*g& z^TQR!ef#4B0i(4w^~s*~VQQ0kf&njg&SFLS^Zs zt-kP3b3SNP|B#ut*L{m~t?#?Nar-Y9vgree>`yM2Tm+qHW`hT|dXKF23t(rSm=YV% zQ*hm7Ju$o@e6+q(n*K81cFY0*C-(x46}b?_m6DyrX8ojiRFA6wU|#JtO4b%5{e-*+ zu`%ir#XPyCK}RXsZCI1n))FAtb+@S%t%*D0qPU6-2oB}6QWmKqkR$XEQ4R8BEUsmt zpYkyYc=88C6=6q+Lx`+Q^gzz}WRRz%dQkOkIsh2=ps*Ey@fq$l<3014Ktfv}Z)??) zkc_hjadR_lDQvGAMfm>3z5nAv$325b`X~3>p~pBYHBr(UzsXa< z==yGumuLsKlU7K_$o5hN8AajMMi^xlkOn==U4Ut-pW}c3MbuSi$zYPR18&XX$$_bz zEA|bo+Wx7aYX=XZ?#=J_9r1{`VtEyDN*BB_<#@t$6Qqq+T4B+`YEOLd;Zgp)Nz{eI zgIIalqGVep415P9HfLr-p)N59zQZUmldNnq!g&7zhAsF(Ui(N}UYmB%?>*9t?X+R% z`=h@oi}4T~Hh7$AUmG|9F{`p|O(4@(S(0;@Qu`kQ(*2!2#B|;VmQM#HoIeO=O##6% z&=4Smu?ZiLDKQjje##C*f(+7czvhp+>h}-j{Yw3l)o5n7NiCuYni)KyZULp+SO+m7 za1f)F>%jrse{uTqYIn8ifOi+WUndmEwA&}vsYaRB3TI)cfWlwgFm7j?0fV&XXu~z? zD5cEib6u!iVYZ3YFm}M+*h2D1)IFG8X!!a`zXZk2`~z{q^g|_c|iqVYD0j+lOw(9Wh;m49Yv)#V2=~) zE0=-EaAV;)%RbS1{ml-$a}N@Uvu}|o8`eu=05)*$mtvggsAE(s=RKi6j}#`DeG6?# zz$boC?aMi%(Pp6ozS`tomLcn9kf=BC-0@VTBybKICp?R1Kr-Oo#TRa^juSs9nC@g7 zRe*`_*Dr*V<)dVTd>h3VbhBcFP-Up0;3PgIR{ARYnv-kt+)cZ`evMwsTvCS*>34WW zp?h4U?1_-;uux_XhR-H`v6)}OH*W@6pGAL@saYSG1mp0ia~0+h`Ri{6B-<3GXN@_d zA^bZ06ef-Ups(Ur0o)iJhCm%jsx>c71mal7eIoxO+K*1N)L;4Hx-A<9YZl2=0` zefAmDQwm%^Y3vvh?`-l$%d7$B2oRQz(G@Pi4P=2O&w<)9hU6px@5~)o&otjeSW)1t zNp!HTBM)*)=2yoTH-ACT04^L-V$7O6O9`VYK?AWa!Ru=5oB5OlJAfr=CcPH z0hW3LMC$rasSV&|)OCAzhgRrN#cmWgYV8_nMT_xAA;yx<>0`){o}gv$AXW!hY$J+n zdAzzzgS%!*k?R>1R(hKXIw2P|NGDmubzVDxV8)Lt-dP1V?Hz3s{$Rz=IQQBD!?Wh2HA0Et;XyK{fP3p01Gm*3`!Ojd2H$aWs%-!>?95odD!eo$%6ING@x7 zz+BGyNm3P(g-9_|9O`LcpT-oB*{TpozOvqpY797$V#5;C`qeFB3Zdo_g;-6SWReLG zE;aBzdJvWWOeVTs8mHBctf0P8>QHXLfeD;&J5m;Zu56togXu^U1fQNF7=v++$zvyJ zS3H0o6rp8y_6Ei3N7t{24&|EU&N9?;({@2<_5fS_Le z#rw))-ge%6%be_J&X|S}XCw|92kvxMG8+;4ZUW)~HT##7k&xz1IZddX>Ovc>4^zyU z>FY#6nWyXiaz^us!OjyEQ1$jf|7VP?)B<`wf?E(}= zK_DqHwcPAw6s=rKb!Hy9jL?v!amznn0{jC^+)8|?ILkn}Xu_N*OXo%kO6Fk@)UOSp znE^q56(D*CLGmx8>`{8UmmUNy7tN3A31NO;4cY7;FC?Zlc5;~LzQ2QM)W+uJ(I^?^ zG;4ExZ+$wZg=`qN7!W`2n4|#+!H!wi~ zqr=V|_=5j>_QTh|Ko7S6yp2>n-$ShwTTmun7fsGqFiJfLOhi~_3IN2F=wv#tiAE@s z>G4$U{8$Vuc2+G4Pj5wKP6#K9Dk@YvdMuIgvqvXq@2-D8zrR=SYQyArALfj0F}%2I z1^+_Qq>*CMrdcyy$E(jWML_wQa=X4cz4-OTldYUN zl$X1!xazl_AegP>Fe_YM7O9qwAuDdeAKWHjTaXt`XSRSoVMuQ*H6NG!D9(V z)xDW`lj9;*)h${=lkm+QbC4N6sWaIGw4$W+j1yP4!0l8lN+zugjhqU08o^MOWOqU> zOvVF$uvEE%!$KOJ-TG^&g(bFLtxligvaC(;+`Jvc$83q=7#yFH&95;HzB^m|o(4yM zZ(`bKr$wAuPfLtgt+iRUCCe0X6EWwNs!=3+b07jc4r=N@9ixf63M5}-Y1fF3%>Q_uv@Ozd&XS&HB5F$o~#)}Oa=8$sM zGD9e~Nh$c0woo)igdMEganQ;x{HMcMbW(s3j!>=oZG9bzmh~Ds76ElFf^csmiRF^2 zGmws1IAMMSHxdkez=M0d*Xli>K<@JN$v)x2!@bxQ9G(D}_dUIFZ4UphQbhJ^%p+h2 z>_FJKKm!?m(W!Re9i+mnalT83^5vK7JBi|tt^rfk4|^$grfJj7<)c6O?#=N(jXrJ9 zUHc zabo7sjDT}Z&2L#{5H){#cg2d*C(r&|i1;aGFn$ikz_^@jwR3|VTf^Tb?*bDF0y$!N zSkp$cB@e)%np@-mc-6yV^tmM`9JSIrlYZzzJbmhCo8b#VCCf#AQYoBG&K^^<5bA&r zGtxUcszjm?++E!qMH)U_4r}#9Ng+p=FLf{*1=}l-jUvK}PDD#jj-X0jwLP6fHD)0_ zRQkO8^dqf0FAU{`stULjnnDmE--QA&67rB#F(RY0W?KQJuZJsi*ssJtSRt@74Jw-* z0!(1J$t3%OXxfhLG%ReqjC79S{NTQ~)wn9cK62$w2jJG|Bn%kQjvXB^&VZ$Ih=?_- zx(Z6@>jR+Vuz(_ZsusO@#2ehhwb<%@50E%FMH9gLB;2ZEr ziP%V%T0&#nI3T9b47B+`$~OOh&bC8;WE}&UrOMCD?tSL$7BszPh488nr7zA6i~;|8 zpJ-m^Kk0nAI;o5GiNWb~_P`|*_+(Sz29q+1ibjR$Y$)9xzK}(aQXEkS5_Vn|_L>Qp z0_uT+;t#~(Va451hljYcF*bp!hh4j^{q$lFlK{E=M<)9ybNF@o=FwCa@+lP)YURputZ+Hsm4of zhdhfU(-l|kG09jdzb?C_zwJ2^W(1K9j& zUhB*?R<9<9U;{M4p8&WZ5HCB8OWT(pgI}Hc+q{+alZ^e8oDgyQhBX-4hzDaw2(k0RmIcEXdPXY zT@dRQ!skZQ`|7Pue15ijbG<+LnI>TUI<}?;rD<((mW5Bd${Pm-81AsMoStFIL}*+; z8J$#%VJBFQQphn~3o^F2fYCKLnO_Afi7w=@u7EdzhxdbR9s#ie6?8cjh#Nj9Bh zV8~IFr-lWv0m5`Xj}OYr2cnKi^iPTiOU-B!OatrF1iE1m3+NGk4*IpsP1wAD8_H&p z@D4g1-aHKx@X^LFfyX8k*J&bzw9EBTofzVTPj~V`@bB?ov2B1=HWX5bQF+9#hPSg5 zqyQ49=ukc^-uP{ZIE1U)e(1Jqyx++qP~uCP_rV|;eb6gu%FM@V-c-vpmz{*es`=%u zf|yd^V-7eUsrIb*AO=Z6hd>R#70cVK0TLW3BT2 z?}+(eSx;ELpO7SYuA@OR-1h#&o6hU<0CknAj#LIl@D=<+?+K%4t>^(eYE2eH4rT!h z!Q=hysN!B)gFlDb^Z=&*QG9xrOdb@H%lf4Pm)iAuw1*fcn4{j*q>BWo1XfR^hSa`{ z+qAsBd}9?eOITyH;nf}PWF82KVyr0P7vvV`{C`TjcOT2LvkKq^HeepcHbTMzf(8*F zB)9r8(+>fXXQuraYsQRb#t(_0TwQgmyKr|^(N#TmM>qhJ*80|`dZ9m3*=1T5+bty#wqb=X z$o&{W^1I6FZh0oJA3PwL2h1VuGBG1rN38@ZAl1D9HC!PNHc=lLes{J8g_0b9lRpFQ z*^l))Obr0Lu~07C;6i}j@T5OLy~?XX`d{gb1O z+#paIUiXEFyA)leYVJWAg=txMgAjp%ChSNf6y?>>3U_w~5#;30d-O4rx12=4mm&$l zj@7I5AC0XffrOw%;yK{EvT6BSQBkxbvF?;g3T!+(W|2lKj|g~&s6{TU#`zYZBSSv7f^4NfGUaRh zDX}0Dku;lRB!D*MV1gqlEVW|K@AO0|Hqw)`>JvCA%1;X!IDIp>RCkU4VN12aF8XdJiTSs*AD zSbN_65p%YA-y0DeWJ4lJHY|8roGSl7yfacmEEs!VBrW9?gr&cAGH`jKB*FrlfEUXx z1cJp7nVLV*12a-IcGj1<*dli9lGF}N)Bpyl$i_Ne6Begx9TTQZUt-By$eK7$ zQ-n|g!;-$HR#0R2HZP#SHfiT3H53YUi?B`#QX(49<1!+J^I&ALlqFsHP=MR*U+7M=#0cRZK}`b%;tbOBhw#YBn%grgYx zj~*C}rLuKBR{Wk)7OEmuKx9zcfC{9RKrrH>TBlVrn+Y1-am!hB%ZqsJqGa)nVgo7; zU=(*XuJ@`7!4*JQfls!L{RgYd=w|0ZHEN2KlrydDf^6B1@DQN1Gz^JJ5u*pC%cR>Q zvQ$X|jT+~Tbcv1HjN=4-mNhU76SP~ccdD@aXCb7~l~(Defe5@w?KqV`hyZyh_qHCz zlM!^Wg@g6GVLw0!PtxlEavu>SvX;e0Kz(Ft^2*#h_|{;pqeB;UQL%t=(HpXG1V0EA z!KV<|j-krk&E1qNB>QQY1c0w9mfx9cde(VRwu1ce-o^vT3YjTa5WC%ssCV8etunR% z&M1(u1lnfv_2)Z4^rTS&4-}L%zGXC(C}`4rS`$i!7B&;NJ-r^}J7GLn)Iq?4Zic*r zfX{j`607yH-Q`L!Ew&Y6Zs^Ht=nEl3u7Gt(s<+<4^bvPBk6pD_rH zd~9m9T_c?a*2v7&%PRd18Le5&p-PNVwdXy0w8f^fsZJ5q{6t1ek47j2nH&*B{-rAg z1Y6yOrqH@X;H2WH1ydSC$mwuEmz7p~jQNauajqpjgADl_k2|>$^rJiwi`It9y?+3y z%0?Q77?LY)ox4MBpH+4`)Ig7}S#qZ3!tZAt<#Z9QtqA#{Va zUfM4ZkKeARU`Zq}f&bd4lD#RjL9X#g)UGXa?{&uBbzJo)e?9V0+nD?k$d4mW?@(q( zVp+O1LpvRd_$e+Y@uc%?Aq6BgnBF};K+Q?U$ibNxb90^x#nt{Bx1 zA;IxJ!sRxOTtJ@KZW( zeOwcn-4sR6Bb`tK*lWxd=Zbg&h%yah(37IN2$7YAbVtg=fqn94J5wA=Y_=d4wMnUi z7i$}s0GwfhnnF0?0v``L+B7-UH_n98UN4Iy97NMf=A`{+W^5Cp#2*i%N1KM|*T0WY z5s?C}gleHWUK$)J@DUyooe1rftLh=<%oze}o94tbt7-CDuZx=T-&nBYh*${T#ma9M zJnX#UzIEfR^*zqKDd77K$Me=h;CK_39c~>e_AOTFMx^b6O@!iD%TBc_Hf=MW;yEg& z8x>cmA^5Aj=1(Wa@!hksdCu!M0Eu@V!+tsKz%ir*xW#a;-)?IP+|Iol4KN_$E;1pE z5YU^rADXNBBD0W-00@R*oCn<&MkjD{L3GdIffVpb6x#dyUq{IfL@`A#zC$aX^M9kF zxnIB=0uAz$PJi+C>e1@pVzst>ug~$*kDgvU{LEWlxTi(H;pN-+-hAatC;}Eo-NhQC z055ty30Zs!;h~BZi9po;(!&8j*cLNXtQTAG=R$P!@5H76s!0qABaxj5RFb8mg0NH2 zSOFw^Q199w8L_^pVE+({61SdVyBkG8_!z^=R!bE}W<>~!H{gfek&*{B?c8$gh__kjh>zSPktN?FIEO`8jUzk8 z{zzGX@I&H)X-L~0d5mfh;#kNkw+3=GM4qsuKQiGkl?7A_g@Bfd1Gk-xZP&=1-x5mXg4EPwbYupJ5R{5r;==L`1Hc)cU$( zqr(6NNlQ|>iU^r9fVO-XY1(d>+~9R4Vw+YQ{n-I-@IB06|1?!h6O+TmV0n4G@AC0^*P zD8aZvR>uNKENi2XB#Qg{$KzGM zZpc25>bYBX;9=^vRIyQ8qIgnWftp4sT0h003NMtqfYj=0T$CZ(mGSLYiI=91A!o%l zB38@OhTnZIlv`F$p{^$l0Ps*k94;F0M`e)0EHRGJ@;oij0QWbMU5@44qafEwTUU{_ zihqcfASdv+OS(T;MAnHb&&&KmH0 zZ8O}wJa=Uq95(sT;X;T9&6lJacjS|R3(`LZqs-(`(Bx6wa{|}EzsSIdbMX}v^CCTFXDS^58sf&2_Rr*1}~1))su1Wb~8EG!gprGfzW#O5ym?LSjY3`BPO=xa1$ zfauDvB~=muw^qMjV+8rM1UM4Yyf`lc;lXo>OVUnUo60D+!EdDLC?WubjT^^zZSas4 zbqY&jV07p)Sm)toY7K2wwl}wu_W|yaJ3=1vrXNRL#_KPtBGFG4ad2G|UcabOCrxo( z8ICU)o6L!LgLA4!*z*__goAZWQScpY)8)3nDwcetY=A<>(kZtl`Ws0KptYRDBuVN9 za2T;8z>+KCHfO+AQPw3$x?`mgT>=3QAAWWJ_~2w+ADOONxdDy4{=zAveQbJZAXK=e z{$a;d%BW65L<%61cYC58C~eQ<)}`SL$2$;eTV;yqWSN!?=8u3b-h<@z;6JgYEm~Y; z)RQoxPUB&nsB<8WU~>d_1}(GHiW(hv$}^KJoQT8_An8&&$&{j=O$kol+*uXRDg^~e z<7+)qz=qPa$3oc+LP;Vq0lhK*9`{6ht2IF1o^=T~UFq9rXS+mkX@gWsBH%>ewm55p zH{;Gqo0w-V5{~GuzwK#$P0$sCTnhrQ6<#V6B`4+JpeO)IYS$XcO7TN(j!wAHC`^~g zj(HETfYW`@ivl0en-AC`EqdbOEcBvXB~qYc%5H{4R<^~@L)T7l&d8yc0h#Lwx4_lc z3Q%l*Q@g4xNz5n8j{nF=P?dx_7WL9ygP5ulyP-X(*#Rq}$;E?1y8*)M)p>VW+_>GA zVjOX-^b)w3%FTj3xHHHox-}b!XJXYEY&xn-iJ^q*21Y7L(|y$85CyDTOh*F&8j+^e zyKla>|EbU4+uvWD=yDd6AD0nRO$2s?7w#Xy4dIud1w)P!VPj#Rj6xY$V#OsiC!6U9 zj6A_$(=^l>!CbRth@AL#k~irgid`q@z~%Nw>I0wknjloK2F#4&wwQ$oP30+S0Qi?t zNsYY5d7){2jxq?hAtgv%uZ`yhi;?uc)L~QjuiJ0`nZ=(`J_NInJlS#R&#Z)|8+JK; zLPYs?uws|CSg?}ceDPo)!wmAwDlEOWZ0{+2KmgMxs@cyHs|cB832>}G6Kx?xnszkk zCeOB%bBGuKv*wIBlqv|yjpM=Suur42z>w+%2zzA9^p`$cVhhKXE5er4xeZdB#KaWV zz-USbLNA(S4oIeIRP}_Ba&1-&8o+hiy~-{s4Dge>fS4C@IRhP2f7|!OX;u}0Ao#ru zw@F7`2!vvv(MXl5KHjdZ%DUG6Vv-++vN(Dl+)G^M%@WfA*~tbbCg<*;?JWAOBdWJF z5~mK$EdI)!EkP?By_uMvQgZosETI){QZzg^k{PV(7`Js(2_=Jy{aNMc4HITi*E z$0JW)d6;RMC0lq%A&y)f8>j@kG+;u|15FhOrG%A!N?jy;e(Ee^ zcr=i>S|jA{miwZDIDKN*tFmXft}Ur5;{L-44S=wsTw92#&1on)5aV1<@U42p&9`OSDWxg>k-#O

e6^R_Y5A;Q_G#+bKwhPZgOS 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 X+y3@rJC6UAJ9Xvw^40-c-|qb%d+?1) literal 0 HcmV?d00001 diff --git a/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp1.ii b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp1.ii new file mode 100644 index 0000000..c232dbd --- /dev/null +++ b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp1.ii @@ -0,0 +1,36265 @@ +# 0 "CMakeCUDACompilerId.cu" +# 0 "" +# 0 "" +# 1 "/usr/include/stdc-predef.h" 1 3 4 +# 0 "" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 1 +# 61 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +#pragma GCC diagnostic push + + +#pragma GCC diagnostic ignored "-Wunused-function" +# 82 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_config.h" 1 +# 216 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_config.h" +# 1 "/usr/include/features.h" 1 3 4 +# 415 "/usr/include/features.h" 3 4 +# 1 "/usr/include/features-time64.h" 1 3 4 +# 20 "/usr/include/features-time64.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 21 "/usr/include/features-time64.h" 2 3 4 +# 1 "/usr/include/bits/timesize.h" 1 3 4 +# 19 "/usr/include/bits/timesize.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/bits/timesize.h" 2 3 4 +# 22 "/usr/include/features-time64.h" 2 3 4 +# 416 "/usr/include/features.h" 2 3 4 +# 524 "/usr/include/features.h" 3 4 +# 1 "/usr/include/sys/cdefs.h" 1 3 4 +# 730 "/usr/include/sys/cdefs.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 731 "/usr/include/sys/cdefs.h" 2 3 4 +# 1 "/usr/include/bits/long-double.h" 1 3 4 +# 732 "/usr/include/sys/cdefs.h" 2 3 4 +# 525 "/usr/include/features.h" 2 3 4 +# 548 "/usr/include/features.h" 3 4 +# 1 "/usr/include/gnu/stubs.h" 1 3 4 +# 10 "/usr/include/gnu/stubs.h" 3 4 +# 1 "/usr/include/gnu/stubs-64.h" 1 3 4 +# 11 "/usr/include/gnu/stubs.h" 2 3 4 +# 549 "/usr/include/features.h" 2 3 4 +# 217 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_config.h" 2 +# 83 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + + + + + + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 56 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" 1 +# 59 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 64 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" +# 1 "/usr/include/ctype.h" 1 3 4 +# 26 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/bits/types.h" 1 3 4 +# 27 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/bits/types.h" 2 3 4 +# 1 "/usr/include/bits/timesize.h" 1 3 4 +# 19 "/usr/include/bits/timesize.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/bits/timesize.h" 2 3 4 +# 29 "/usr/include/bits/types.h" 2 3 4 + + + +# 31 "/usr/include/bits/types.h" 3 4 +typedef unsigned char __u_char; +typedef unsigned short int __u_short; +typedef unsigned int __u_int; +typedef unsigned long int __u_long; + + +typedef signed char __int8_t; +typedef unsigned char __uint8_t; +typedef signed short int __int16_t; +typedef unsigned short int __uint16_t; +typedef signed int __int32_t; +typedef unsigned int __uint32_t; + +typedef signed long int __int64_t; +typedef unsigned long int __uint64_t; + + + + + + +typedef __int8_t __int_least8_t; +typedef __uint8_t __uint_least8_t; +typedef __int16_t __int_least16_t; +typedef __uint16_t __uint_least16_t; +typedef __int32_t __int_least32_t; +typedef __uint32_t __uint_least32_t; +typedef __int64_t __int_least64_t; +typedef __uint64_t __uint_least64_t; + + + +typedef long int __quad_t; +typedef unsigned long int __u_quad_t; + + + + + + + +typedef long int __intmax_t; +typedef unsigned long int __uintmax_t; +# 141 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/typesizes.h" 1 3 4 +# 142 "/usr/include/bits/types.h" 2 3 4 +# 1 "/usr/include/bits/time64.h" 1 3 4 +# 143 "/usr/include/bits/types.h" 2 3 4 + + +typedef unsigned long int __dev_t; +typedef unsigned int __uid_t; +typedef unsigned int __gid_t; +typedef unsigned long int __ino_t; +typedef unsigned long int __ino64_t; +typedef unsigned int __mode_t; +typedef unsigned long int __nlink_t; +typedef long int __off_t; +typedef long int __off64_t; +typedef int __pid_t; +typedef struct { int __val[2]; } __fsid_t; +typedef long int __clock_t; +typedef unsigned long int __rlim_t; +typedef unsigned long int __rlim64_t; +typedef unsigned int __id_t; +typedef long int __time_t; +typedef unsigned int __useconds_t; +typedef long int __suseconds_t; +typedef long int __suseconds64_t; + +typedef int __daddr_t; +typedef int __key_t; + + +typedef int __clockid_t; + + +typedef void * __timer_t; + + +typedef long int __blksize_t; + + + + +typedef long int __blkcnt_t; +typedef long int __blkcnt64_t; + + +typedef unsigned long int __fsblkcnt_t; +typedef unsigned long int __fsblkcnt64_t; + + +typedef unsigned long int __fsfilcnt_t; +typedef unsigned long int __fsfilcnt64_t; + + +typedef long int __fsword_t; + +typedef long int __ssize_t; + + +typedef long int __syscall_slong_t; + +typedef unsigned long int __syscall_ulong_t; + + + +typedef __off64_t __loff_t; +typedef char *__caddr_t; + + +typedef long int __intptr_t; + + +typedef unsigned int __socklen_t; + + + + +typedef int __sig_atomic_t; +# 27 "/usr/include/ctype.h" 2 3 4 + +extern "C" { +# 39 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/bits/endian.h" 1 3 4 +# 35 "/usr/include/bits/endian.h" 3 4 +# 1 "/usr/include/bits/endianness.h" 1 3 4 +# 36 "/usr/include/bits/endian.h" 2 3 4 +# 40 "/usr/include/ctype.h" 2 3 4 + + + + + + +enum +{ + _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), + _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), + _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), + _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), + _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), + _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), + _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), + _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), + _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), + _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), + _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), + _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8)) +}; +# 79 "/usr/include/ctype.h" 3 4 +extern const unsigned short int **__ctype_b_loc (void) + noexcept (true) __attribute__ ((__const__)); +extern const __int32_t **__ctype_tolower_loc (void) + noexcept (true) __attribute__ ((__const__)); +extern const __int32_t **__ctype_toupper_loc (void) + noexcept (true) __attribute__ ((__const__)); +# 108 "/usr/include/ctype.h" 3 4 +extern int isalnum (int) noexcept (true); +extern int isalpha (int) noexcept (true); +extern int iscntrl (int) noexcept (true); +extern int isdigit (int) noexcept (true); +extern int islower (int) noexcept (true); +extern int isgraph (int) noexcept (true); +extern int isprint (int) noexcept (true); +extern int ispunct (int) noexcept (true); +extern int isspace (int) noexcept (true); +extern int isupper (int) noexcept (true); +extern int isxdigit (int) noexcept (true); + + + +extern int tolower (int __c) noexcept (true); + + +extern int toupper (int __c) noexcept (true); + + + + +extern int isblank (int) noexcept (true); + + + + +extern int isctype (int __c, int __mask) noexcept (true); + + + + + + +extern int isascii (int __c) noexcept (true); + + + +extern int toascii (int __c) noexcept (true); + + + +extern int _toupper (int) noexcept (true); +extern int _tolower (int) noexcept (true); +# 237 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/bits/types/locale_t.h" 1 3 4 +# 22 "/usr/include/bits/types/locale_t.h" 3 4 +# 1 "/usr/include/bits/types/__locale_t.h" 1 3 4 +# 27 "/usr/include/bits/types/__locale_t.h" 3 4 +struct __locale_struct +{ + + struct __locale_data *__locales[13]; + + + const unsigned short int *__ctype_b; + const int *__ctype_tolower; + const int *__ctype_toupper; + + + const char *__names[13]; +}; + +typedef struct __locale_struct *__locale_t; +# 23 "/usr/include/bits/types/locale_t.h" 2 3 4 + +typedef __locale_t locale_t; +# 238 "/usr/include/ctype.h" 2 3 4 +# 251 "/usr/include/ctype.h" 3 4 +extern int isalnum_l (int, locale_t) noexcept (true); +extern int isalpha_l (int, locale_t) noexcept (true); +extern int iscntrl_l (int, locale_t) noexcept (true); +extern int isdigit_l (int, locale_t) noexcept (true); +extern int islower_l (int, locale_t) noexcept (true); +extern int isgraph_l (int, locale_t) noexcept (true); +extern int isprint_l (int, locale_t) noexcept (true); +extern int ispunct_l (int, locale_t) noexcept (true); +extern int isspace_l (int, locale_t) noexcept (true); +extern int isupper_l (int, locale_t) noexcept (true); +extern int isxdigit_l (int, locale_t) noexcept (true); + +extern int isblank_l (int, locale_t) noexcept (true); + + + +extern int __tolower_l (int __c, locale_t __l) noexcept (true); +extern int tolower_l (int __c, locale_t __l) noexcept (true); + + +extern int __toupper_l (int __c, locale_t __l) noexcept (true); +extern int toupper_l (int __c, locale_t __l) noexcept (true); +# 327 "/usr/include/ctype.h" 3 4 +} +# 65 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 2 +# 60 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" 2 +# 68 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" + +# 68 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" +enum __attribute__((device_builtin)) cudaRoundMode +{ + cudaRoundNearest, + cudaRoundZero, + cudaRoundPosInf, + cudaRoundMinInf +}; +# 57 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 1 +# 59 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 60 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" 1 +# 65 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 66 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" 2 +# 104 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +struct __attribute__((device_builtin)) char1 +{ + signed char x; +}; + +struct __attribute__((device_builtin)) uchar1 +{ + unsigned char x; +}; + + +struct __attribute__((device_builtin)) __attribute__((aligned(2))) char2 +{ + signed char x, y; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(2))) uchar2 +{ + unsigned char x, y; +}; + +struct __attribute__((device_builtin)) char3 +{ + signed char x, y, z; +}; + +struct __attribute__((device_builtin)) uchar3 +{ + unsigned char x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(4))) char4 +{ + signed char x, y, z, w; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(4))) uchar4 +{ + unsigned char x, y, z, w; +}; + +struct __attribute__((device_builtin)) short1 +{ + short x; +}; + +struct __attribute__((device_builtin)) ushort1 +{ + unsigned short x; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(4))) short2 +{ + short x, y; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(4))) ushort2 +{ + unsigned short x, y; +}; + +struct __attribute__((device_builtin)) short3 +{ + short x, y, z; +}; + +struct __attribute__((device_builtin)) ushort3 +{ + unsigned short x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(8))) short4 { short x; short y; short z; short w; }; +struct __attribute__((device_builtin)) __attribute__((aligned(8))) ushort4 { unsigned short x; unsigned short y; unsigned short z; unsigned short w; }; + +struct __attribute__((device_builtin)) int1 +{ + int x; +}; + +struct __attribute__((device_builtin)) uint1 +{ + unsigned int x; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(8))) int2 { int x; int y; }; +struct __attribute__((device_builtin)) __attribute__((aligned(8))) uint2 { unsigned int x; unsigned int y; }; + +struct __attribute__((device_builtin)) int3 +{ + int x, y, z; +}; + +struct __attribute__((device_builtin)) uint3 +{ + unsigned int x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) int4 +{ + int x, y, z, w; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) uint4 +{ + unsigned int x, y, z, w; +}; + +struct __attribute__((device_builtin)) long1 +{ + long int x; +}; + +struct __attribute__((device_builtin)) ulong1 +{ + unsigned long x; +}; + + + + + + +struct __attribute__((device_builtin)) __attribute__((aligned(2*sizeof(long int)))) long2 +{ + long int x, y; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(2*sizeof(unsigned long int)))) ulong2 +{ + unsigned long int x, y; +}; + + + +struct __attribute__((device_builtin)) long3 +{ + long int x, y, z; +}; + +struct __attribute__((device_builtin)) ulong3 +{ + unsigned long int x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) long4 +{ + long int x, y, z, w; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) ulong4 +{ + unsigned long int x, y, z, w; +}; + +struct __attribute__((device_builtin)) float1 +{ + float x; +}; +# 280 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +struct __attribute__((device_builtin)) __attribute__((aligned(8))) float2 { float x; float y; }; + + + + +struct __attribute__((device_builtin)) float3 +{ + float x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) float4 +{ + float x, y, z, w; +}; + +struct __attribute__((device_builtin)) longlong1 +{ + long long int x; +}; + +struct __attribute__((device_builtin)) ulonglong1 +{ + unsigned long long int x; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) longlong2 +{ + long long int x, y; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) ulonglong2 +{ + unsigned long long int x, y; +}; + +struct __attribute__((device_builtin)) longlong3 +{ + long long int x, y, z; +}; + +struct __attribute__((device_builtin)) ulonglong3 +{ + unsigned long long int x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) longlong4 +{ + long long int x, y, z ,w; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) ulonglong4 +{ + unsigned long long int x, y, z, w; +}; + +struct __attribute__((device_builtin)) double1 +{ + double x; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) double2 +{ + double x, y; +}; + +struct __attribute__((device_builtin)) double3 +{ + double x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) double4 +{ + double x, y, z, w; +}; +# 367 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +typedef __attribute__((device_builtin)) struct char1 char1; +typedef __attribute__((device_builtin)) struct uchar1 uchar1; +typedef __attribute__((device_builtin)) struct char2 char2; +typedef __attribute__((device_builtin)) struct uchar2 uchar2; +typedef __attribute__((device_builtin)) struct char3 char3; +typedef __attribute__((device_builtin)) struct uchar3 uchar3; +typedef __attribute__((device_builtin)) struct char4 char4; +typedef __attribute__((device_builtin)) struct uchar4 uchar4; +typedef __attribute__((device_builtin)) struct short1 short1; +typedef __attribute__((device_builtin)) struct ushort1 ushort1; +typedef __attribute__((device_builtin)) struct short2 short2; +typedef __attribute__((device_builtin)) struct ushort2 ushort2; +typedef __attribute__((device_builtin)) struct short3 short3; +typedef __attribute__((device_builtin)) struct ushort3 ushort3; +typedef __attribute__((device_builtin)) struct short4 short4; +typedef __attribute__((device_builtin)) struct ushort4 ushort4; +typedef __attribute__((device_builtin)) struct int1 int1; +typedef __attribute__((device_builtin)) struct uint1 uint1; +typedef __attribute__((device_builtin)) struct int2 int2; +typedef __attribute__((device_builtin)) struct uint2 uint2; +typedef __attribute__((device_builtin)) struct int3 int3; +typedef __attribute__((device_builtin)) struct uint3 uint3; +typedef __attribute__((device_builtin)) struct int4 int4; +typedef __attribute__((device_builtin)) struct uint4 uint4; +typedef __attribute__((device_builtin)) struct long1 long1; +typedef __attribute__((device_builtin)) struct ulong1 ulong1; +typedef __attribute__((device_builtin)) struct long2 long2; +typedef __attribute__((device_builtin)) struct ulong2 ulong2; +typedef __attribute__((device_builtin)) struct long3 long3; +typedef __attribute__((device_builtin)) struct ulong3 ulong3; +typedef __attribute__((device_builtin)) struct long4 long4; +typedef __attribute__((device_builtin)) struct ulong4 ulong4; +typedef __attribute__((device_builtin)) struct float1 float1; +typedef __attribute__((device_builtin)) struct float2 float2; +typedef __attribute__((device_builtin)) struct float3 float3; +typedef __attribute__((device_builtin)) struct float4 float4; +typedef __attribute__((device_builtin)) struct longlong1 longlong1; +typedef __attribute__((device_builtin)) struct ulonglong1 ulonglong1; +typedef __attribute__((device_builtin)) struct longlong2 longlong2; +typedef __attribute__((device_builtin)) struct ulonglong2 ulonglong2; +typedef __attribute__((device_builtin)) struct longlong3 longlong3; +typedef __attribute__((device_builtin)) struct ulonglong3 ulonglong3; +typedef __attribute__((device_builtin)) struct longlong4 longlong4; +typedef __attribute__((device_builtin)) struct ulonglong4 ulonglong4; +typedef __attribute__((device_builtin)) struct double1 double1; +typedef __attribute__((device_builtin)) struct double2 double2; +typedef __attribute__((device_builtin)) struct double3 double3; +typedef __attribute__((device_builtin)) struct double4 double4; +# 426 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +struct __attribute__((device_builtin)) dim3 +{ + unsigned int x, y, z; + + + __attribute__((host)) __attribute__((device)) constexpr dim3(unsigned int vx = 1, unsigned int vy = 1, unsigned int vz = 1) : x(vx), y(vy), z(vz) {} + __attribute__((host)) __attribute__((device)) constexpr dim3(uint3 v) : x(v.x), y(v.y), z(v.z) {} + __attribute__((host)) __attribute__((device)) constexpr operator uint3(void) const { return uint3{x, y, z}; } + + + + + + +}; + +typedef __attribute__((device_builtin)) struct dim3 dim3; +# 62 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 2 +# 83 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 1 3 4 +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/syslimits.h" 1 3 4 + + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 1 3 4 +# 210 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 3 4 +# 1 "/usr/include/limits.h" 1 3 4 +# 26 "/usr/include/limits.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/limits.h" 2 3 4 +# 195 "/usr/include/limits.h" 3 4 +# 1 "/usr/include/bits/posix1_lim.h" 1 3 4 +# 27 "/usr/include/bits/posix1_lim.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/bits/posix1_lim.h" 2 3 4 +# 161 "/usr/include/bits/posix1_lim.h" 3 4 +# 1 "/usr/include/bits/local_lim.h" 1 3 4 +# 38 "/usr/include/bits/local_lim.h" 3 4 +# 1 "/usr/include/linux/limits.h" 1 3 4 +# 39 "/usr/include/bits/local_lim.h" 2 3 4 +# 81 "/usr/include/bits/local_lim.h" 3 4 +# 1 "/usr/include/bits/pthread_stack_min-dynamic.h" 1 3 4 +# 23 "/usr/include/bits/pthread_stack_min-dynamic.h" 3 4 + +# 23 "/usr/include/bits/pthread_stack_min-dynamic.h" 3 4 +extern "C" { +extern long int __sysconf (int __name) noexcept (true); +} +# 82 "/usr/include/bits/local_lim.h" 2 3 4 +# 162 "/usr/include/bits/posix1_lim.h" 2 3 4 +# 196 "/usr/include/limits.h" 2 3 4 + + + +# 1 "/usr/include/bits/posix2_lim.h" 1 3 4 +# 200 "/usr/include/limits.h" 2 3 4 + + + +# 1 "/usr/include/bits/xopen_lim.h" 1 3 4 +# 64 "/usr/include/bits/xopen_lim.h" 3 4 +# 1 "/usr/include/bits/uio_lim.h" 1 3 4 +# 65 "/usr/include/bits/xopen_lim.h" 2 3 4 +# 204 "/usr/include/limits.h" 2 3 4 +# 211 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 2 3 4 +# 8 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/syslimits.h" 2 3 4 +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 2 3 4 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 2 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 145 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 4 +typedef long int ptrdiff_t; +# 214 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 4 +typedef long unsigned int size_t; +# 425 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 4 +typedef struct { + long long __max_align_ll __attribute__((__aligned__(__alignof__(long long)))); + long double __max_align_ld __attribute__((__aligned__(__alignof__(long double)))); +# 436 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 4 +} max_align_t; + + + + + + + typedef decltype(nullptr) nullptr_t; +# 85 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 2 +# 205 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + +# 205 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +enum __attribute__((device_builtin)) cudaError +{ + + + + + + cudaSuccess = 0, + + + + + + cudaErrorInvalidValue = 1, + + + + + + cudaErrorMemoryAllocation = 2, + + + + + + cudaErrorInitializationError = 3, + + + + + + + cudaErrorCudartUnloading = 4, + + + + + + + cudaErrorProfilerDisabled = 5, + + + + + + + + cudaErrorProfilerNotInitialized = 6, + + + + + + + cudaErrorProfilerAlreadyStarted = 7, + + + + + + + cudaErrorProfilerAlreadyStopped = 8, + + + + + + + + cudaErrorInvalidConfiguration = 9, + + + + + + cudaErrorInvalidPitchValue = 12, + + + + + + cudaErrorInvalidSymbol = 13, + + + + + + + + cudaErrorInvalidHostPointer = 16, + + + + + + + + cudaErrorInvalidDevicePointer = 17, + + + + + cudaErrorInvalidTexture = 18, + + + + + + cudaErrorInvalidTextureBinding = 19, + + + + + + + cudaErrorInvalidChannelDescriptor = 20, + + + + + + cudaErrorInvalidMemcpyDirection = 21, +# 336 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorAddressOfConstant = 22, +# 345 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorTextureFetchFailed = 23, +# 354 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorTextureNotBound = 24, +# 363 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSynchronizationError = 25, + + + + + cudaErrorInvalidFilterSetting = 26, + + + + + + cudaErrorInvalidNormSetting = 27, + + + + + + + + cudaErrorMixedDeviceExecution = 28, + + + + + + + + cudaErrorNotYetImplemented = 31, +# 399 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorMemoryValueTooLarge = 32, + + + + + + cudaErrorStubLibrary = 34, + + + + + + + cudaErrorInsufficientDriver = 35, + + + + + + + cudaErrorCallRequiresNewerDriver = 36, + + + + + + cudaErrorInvalidSurface = 37, + + + + + + cudaErrorDuplicateVariableName = 43, + + + + + + cudaErrorDuplicateTextureName = 44, + + + + + + cudaErrorDuplicateSurfaceName = 45, +# 453 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorDevicesUnavailable = 46, +# 466 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorIncompatibleDriverContext = 49, + + + + + + cudaErrorMissingConfiguration = 52, +# 481 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorPriorLaunchFailure = 53, + + + + + + cudaErrorLaunchMaxDepthExceeded = 65, + + + + + + + + cudaErrorLaunchFileScopedTex = 66, + + + + + + + + cudaErrorLaunchFileScopedSurf = 67, +# 519 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSyncDepthExceeded = 68, +# 531 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorLaunchPendingCountExceeded = 69, + + + + + + cudaErrorInvalidDeviceFunction = 98, + + + + + + cudaErrorNoDevice = 100, + + + + + + + cudaErrorInvalidDevice = 101, + + + + + cudaErrorDeviceNotLicensed = 102, +# 564 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSoftwareValidityNotEstablished = 103, + + + + + cudaErrorStartupFailure = 127, + + + + + cudaErrorInvalidKernelImage = 200, +# 584 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorDeviceUninitialized = 201, + + + + + cudaErrorMapBufferObjectFailed = 205, + + + + + cudaErrorUnmapBufferObjectFailed = 206, + + + + + + cudaErrorArrayIsMapped = 207, + + + + + cudaErrorAlreadyMapped = 208, + + + + + + + + cudaErrorNoKernelImageForDevice = 209, + + + + + cudaErrorAlreadyAcquired = 210, + + + + + cudaErrorNotMapped = 211, + + + + + + cudaErrorNotMappedAsArray = 212, + + + + + + cudaErrorNotMappedAsPointer = 213, + + + + + + cudaErrorECCUncorrectable = 214, + + + + + + cudaErrorUnsupportedLimit = 215, + + + + + + cudaErrorDeviceAlreadyInUse = 216, + + + + + + cudaErrorPeerAccessUnsupported = 217, + + + + + + cudaErrorInvalidPtx = 218, + + + + + cudaErrorInvalidGraphicsContext = 219, + + + + + + cudaErrorNvlinkUncorrectable = 220, + + + + + + + cudaErrorJitCompilerNotFound = 221, + + + + + + + cudaErrorUnsupportedPtxVersion = 222, + + + + + + + cudaErrorJitCompilationDisabled = 223, + + + + + cudaErrorUnsupportedExecAffinity = 224, + + + + + + cudaErrorUnsupportedDevSideSync = 225, +# 719 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorContained = 226, + + + + + cudaErrorInvalidSource = 300, + + + + + cudaErrorFileNotFound = 301, + + + + + cudaErrorSharedObjectSymbolNotFound = 302, + + + + + cudaErrorSharedObjectInitFailed = 303, + + + + + cudaErrorOperatingSystem = 304, + + + + + + + cudaErrorInvalidResourceHandle = 400, + + + + + + cudaErrorIllegalState = 401, + + + + + + + + cudaErrorLossyQuery = 402, + + + + + + + cudaErrorSymbolNotFound = 500, + + + + + + + + cudaErrorNotReady = 600, + + + + + + + + cudaErrorIllegalAddress = 700, +# 797 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorLaunchOutOfResources = 701, +# 808 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorLaunchTimeout = 702, + + + + + + cudaErrorLaunchIncompatibleTexturing = 703, + + + + + + + cudaErrorPeerAccessAlreadyEnabled = 704, + + + + + + + cudaErrorPeerAccessNotEnabled = 705, +# 841 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSetOnActiveProcess = 708, + + + + + + + cudaErrorContextIsDestroyed = 709, + + + + + + + cudaErrorAssert = 710, + + + + + + + cudaErrorTooManyPeers = 711, + + + + + + cudaErrorHostMemoryAlreadyRegistered = 712, + + + + + + cudaErrorHostMemoryNotRegistered = 713, +# 883 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorHardwareStackError = 714, + + + + + + + + cudaErrorIllegalInstruction = 715, +# 900 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorMisalignedAddress = 716, +# 911 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorInvalidAddressSpace = 717, + + + + + + + + cudaErrorInvalidPc = 718, +# 930 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorLaunchFailure = 719, +# 939 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorCooperativeLaunchTooLarge = 720, + + + + + + + + cudaErrorTensorMemoryLeak = 721, + + + + + cudaErrorNotPermitted = 800, + + + + + + cudaErrorNotSupported = 801, +# 967 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSystemNotReady = 802, + + + + + + + cudaErrorSystemDriverMismatch = 803, +# 983 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorCompatNotSupportedOnDevice = 804, + + + + + cudaErrorMpsConnectionFailed = 805, + + + + + cudaErrorMpsRpcFailure = 806, + + + + + + cudaErrorMpsServerNotReady = 807, + + + + + cudaErrorMpsMaxClientsReached = 808, + + + + + cudaErrorMpsMaxConnectionsReached = 809, + + + + + cudaErrorMpsClientTerminated = 810, + + + + + cudaErrorCdpNotSupported = 811, + + + + + cudaErrorCdpVersionMismatch = 812, + + + + + cudaErrorStreamCaptureUnsupported = 900, + + + + + + cudaErrorStreamCaptureInvalidated = 901, + + + + + + cudaErrorStreamCaptureMerge = 902, + + + + + cudaErrorStreamCaptureUnmatched = 903, + + + + + + cudaErrorStreamCaptureUnjoined = 904, + + + + + + + cudaErrorStreamCaptureIsolation = 905, + + + + + + cudaErrorStreamCaptureImplicit = 906, + + + + + + cudaErrorCapturedEvent = 907, + + + + + + + cudaErrorStreamCaptureWrongThread = 908, + + + + + cudaErrorTimeout = 909, + + + + + + cudaErrorGraphExecUpdateFailure = 910, +# 1099 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorExternalDevice = 911, + + + + + + cudaErrorInvalidClusterSize = 912, + + + + + + cudaErrorFunctionNotLoaded = 913, + + + + + + cudaErrorInvalidResourceType = 914, + + + + + + cudaErrorInvalidResourceConfiguration = 915, + + + + + cudaErrorUnknown = 999 + + + + + + + + , cudaErrorApiFailureBase = 10000 +}; + + + + +enum __attribute__((device_builtin)) cudaChannelFormatKind +{ + cudaChannelFormatKindSigned = 0, + cudaChannelFormatKindUnsigned = 1, + cudaChannelFormatKindFloat = 2, + cudaChannelFormatKindNone = 3, + cudaChannelFormatKindNV12 = 4, + cudaChannelFormatKindUnsignedNormalized8X1 = 5, + cudaChannelFormatKindUnsignedNormalized8X2 = 6, + cudaChannelFormatKindUnsignedNormalized8X4 = 7, + cudaChannelFormatKindUnsignedNormalized16X1 = 8, + cudaChannelFormatKindUnsignedNormalized16X2 = 9, + cudaChannelFormatKindUnsignedNormalized16X4 = 10, + cudaChannelFormatKindSignedNormalized8X1 = 11, + cudaChannelFormatKindSignedNormalized8X2 = 12, + cudaChannelFormatKindSignedNormalized8X4 = 13, + cudaChannelFormatKindSignedNormalized16X1 = 14, + cudaChannelFormatKindSignedNormalized16X2 = 15, + cudaChannelFormatKindSignedNormalized16X4 = 16, + cudaChannelFormatKindUnsignedBlockCompressed1 = 17, + cudaChannelFormatKindUnsignedBlockCompressed1SRGB = 18, + cudaChannelFormatKindUnsignedBlockCompressed2 = 19, + cudaChannelFormatKindUnsignedBlockCompressed2SRGB = 20, + cudaChannelFormatKindUnsignedBlockCompressed3 = 21, + cudaChannelFormatKindUnsignedBlockCompressed3SRGB = 22, + cudaChannelFormatKindUnsignedBlockCompressed4 = 23, + cudaChannelFormatKindSignedBlockCompressed4 = 24, + cudaChannelFormatKindUnsignedBlockCompressed5 = 25, + cudaChannelFormatKindSignedBlockCompressed5 = 26, + cudaChannelFormatKindUnsignedBlockCompressed6H = 27, + cudaChannelFormatKindSignedBlockCompressed6H = 28, + cudaChannelFormatKindUnsignedBlockCompressed7 = 29, + cudaChannelFormatKindUnsignedBlockCompressed7SRGB = 30, + cudaChannelFormatKindUnsignedNormalized1010102 = 31 + +}; + + + + +struct __attribute__((device_builtin)) cudaChannelFormatDesc +{ + int x; + int y; + int z; + int w; + enum cudaChannelFormatKind f; +}; + + + + +typedef struct cudaArray *cudaArray_t; + + + + +typedef const struct cudaArray *cudaArray_const_t; + +struct cudaArray; + + + + +typedef struct cudaMipmappedArray *cudaMipmappedArray_t; + + + + +typedef const struct cudaMipmappedArray *cudaMipmappedArray_const_t; + +struct cudaMipmappedArray; +# 1223 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct __attribute__((device_builtin)) cudaArraySparseProperties { + struct { + unsigned int width; + unsigned int height; + unsigned int depth; + } tileExtent; + unsigned int miptailFirstLevel; + unsigned long long miptailSize; + unsigned int flags; + unsigned int reserved[4]; +}; + + + + +struct __attribute__((device_builtin)) cudaArrayMemoryRequirements { + size_t size; + size_t alignment; + unsigned int reserved[4]; +}; + + + + +enum __attribute__((device_builtin)) cudaMemoryType +{ + cudaMemoryTypeUnregistered = 0, + cudaMemoryTypeHost = 1, + cudaMemoryTypeDevice = 2, + cudaMemoryTypeManaged = 3 +}; + + + + +enum __attribute__((device_builtin)) cudaMemcpyKind +{ + cudaMemcpyHostToHost = 0, + cudaMemcpyHostToDevice = 1, + cudaMemcpyDeviceToHost = 2, + cudaMemcpyDeviceToDevice = 3, + cudaMemcpyDefault = 4 +}; + + + + + + +struct __attribute__((device_builtin)) cudaPitchedPtr +{ + void *ptr; + size_t pitch; + size_t xsize; + size_t ysize; +}; + + + + + + +struct __attribute__((device_builtin)) cudaExtent +{ + size_t width; + size_t height; + size_t depth; +}; + + + + + + +struct __attribute__((device_builtin)) cudaPos +{ + size_t x; + size_t y; + size_t z; +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpy3DParms +{ + cudaArray_t srcArray; + struct cudaPos srcPos; + struct cudaPitchedPtr srcPtr; + + cudaArray_t dstArray; + struct cudaPos dstPos; + struct cudaPitchedPtr dstPtr; + + struct cudaExtent extent; + enum cudaMemcpyKind kind; +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpyNodeParams { + int flags; + int reserved[3]; + struct cudaMemcpy3DParms copyParams; +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpy3DPeerParms +{ + cudaArray_t srcArray; + struct cudaPos srcPos; + struct cudaPitchedPtr srcPtr; + int srcDevice; + + cudaArray_t dstArray; + struct cudaPos dstPos; + struct cudaPitchedPtr dstPtr; + int dstDevice; + + struct cudaExtent extent; +}; + + + + +struct __attribute__((device_builtin)) cudaMemsetParams { + void *dst; + size_t pitch; + unsigned int value; + unsigned int elementSize; + size_t width; + size_t height; +}; + + + + +struct __attribute__((device_builtin)) cudaMemsetParamsV2 { + void *dst; + size_t pitch; + unsigned int value; + unsigned int elementSize; + size_t width; + size_t height; +}; + + + + +enum __attribute__((device_builtin)) cudaAccessProperty { + cudaAccessPropertyNormal = 0, + cudaAccessPropertyStreaming = 1, + cudaAccessPropertyPersisting = 2 +}; +# 1392 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct __attribute__((device_builtin)) cudaAccessPolicyWindow { + void *base_ptr; + size_t num_bytes; + float hitRatio; + enum cudaAccessProperty hitProp; + enum cudaAccessProperty missProp; +}; +# 1410 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef void ( *cudaHostFn_t)(void *userData); + + + + +struct __attribute__((device_builtin)) cudaHostNodeParams { + cudaHostFn_t fn; + void* userData; +}; + + + + +struct __attribute__((device_builtin)) cudaHostNodeParamsV2 { + cudaHostFn_t fn; + void* userData; +}; + + + + +enum __attribute__((device_builtin)) cudaStreamCaptureStatus { + cudaStreamCaptureStatusNone = 0, + cudaStreamCaptureStatusActive = 1, + cudaStreamCaptureStatusInvalidated = 2 + +}; + + + + + +enum __attribute__((device_builtin)) cudaStreamCaptureMode { + cudaStreamCaptureModeGlobal = 0, + cudaStreamCaptureModeThreadLocal = 1, + cudaStreamCaptureModeRelaxed = 2 +}; + +enum __attribute__((device_builtin)) cudaSynchronizationPolicy { + cudaSyncPolicyAuto = 1, + cudaSyncPolicySpin = 2, + cudaSyncPolicyYield = 3, + cudaSyncPolicyBlockingSync = 4 +}; + + + + +enum __attribute__((device_builtin)) cudaClusterSchedulingPolicy { + cudaClusterSchedulingPolicyDefault = 0, + cudaClusterSchedulingPolicySpread = 1, + cudaClusterSchedulingPolicyLoadBalancing = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaStreamUpdateCaptureDependenciesFlags { + cudaStreamAddCaptureDependencies = 0x0, + cudaStreamSetCaptureDependencies = 0x1 +}; + + + + +enum __attribute__((device_builtin)) cudaUserObjectFlags { + cudaUserObjectNoDestructorSync = 0x1 +}; + + + + +enum __attribute__((device_builtin)) cudaUserObjectRetainFlags { + cudaGraphUserObjectMove = 0x1 +}; + + + + +struct cudaGraphicsResource; + + + + +enum __attribute__((device_builtin)) cudaGraphicsRegisterFlags +{ + cudaGraphicsRegisterFlagsNone = 0, + cudaGraphicsRegisterFlagsReadOnly = 1, + cudaGraphicsRegisterFlagsWriteDiscard = 2, + cudaGraphicsRegisterFlagsSurfaceLoadStore = 4, + cudaGraphicsRegisterFlagsTextureGather = 8 +}; + + + + +enum __attribute__((device_builtin)) cudaGraphicsMapFlags +{ + cudaGraphicsMapFlagsNone = 0, + cudaGraphicsMapFlagsReadOnly = 1, + cudaGraphicsMapFlagsWriteDiscard = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaGraphicsCubeFace +{ + cudaGraphicsCubeFacePositiveX = 0x00, + cudaGraphicsCubeFaceNegativeX = 0x01, + cudaGraphicsCubeFacePositiveY = 0x02, + cudaGraphicsCubeFaceNegativeY = 0x03, + cudaGraphicsCubeFacePositiveZ = 0x04, + cudaGraphicsCubeFaceNegativeZ = 0x05 +}; + + + + +enum __attribute__((device_builtin)) cudaResourceType +{ + cudaResourceTypeArray = 0x00, + cudaResourceTypeMipmappedArray = 0x01, + cudaResourceTypeLinear = 0x02, + cudaResourceTypePitch2D = 0x03 +}; + + + + +enum __attribute__((device_builtin)) cudaResourceViewFormat +{ + cudaResViewFormatNone = 0x00, + cudaResViewFormatUnsignedChar1 = 0x01, + cudaResViewFormatUnsignedChar2 = 0x02, + cudaResViewFormatUnsignedChar4 = 0x03, + cudaResViewFormatSignedChar1 = 0x04, + cudaResViewFormatSignedChar2 = 0x05, + cudaResViewFormatSignedChar4 = 0x06, + cudaResViewFormatUnsignedShort1 = 0x07, + cudaResViewFormatUnsignedShort2 = 0x08, + cudaResViewFormatUnsignedShort4 = 0x09, + cudaResViewFormatSignedShort1 = 0x0a, + cudaResViewFormatSignedShort2 = 0x0b, + cudaResViewFormatSignedShort4 = 0x0c, + cudaResViewFormatUnsignedInt1 = 0x0d, + cudaResViewFormatUnsignedInt2 = 0x0e, + cudaResViewFormatUnsignedInt4 = 0x0f, + cudaResViewFormatSignedInt1 = 0x10, + cudaResViewFormatSignedInt2 = 0x11, + cudaResViewFormatSignedInt4 = 0x12, + cudaResViewFormatHalf1 = 0x13, + cudaResViewFormatHalf2 = 0x14, + cudaResViewFormatHalf4 = 0x15, + cudaResViewFormatFloat1 = 0x16, + cudaResViewFormatFloat2 = 0x17, + cudaResViewFormatFloat4 = 0x18, + cudaResViewFormatUnsignedBlockCompressed1 = 0x19, + cudaResViewFormatUnsignedBlockCompressed2 = 0x1a, + cudaResViewFormatUnsignedBlockCompressed3 = 0x1b, + cudaResViewFormatUnsignedBlockCompressed4 = 0x1c, + cudaResViewFormatSignedBlockCompressed4 = 0x1d, + cudaResViewFormatUnsignedBlockCompressed5 = 0x1e, + cudaResViewFormatSignedBlockCompressed5 = 0x1f, + cudaResViewFormatUnsignedBlockCompressed6H = 0x20, + cudaResViewFormatSignedBlockCompressed6H = 0x21, + cudaResViewFormatUnsignedBlockCompressed7 = 0x22 +}; + + + + +struct __attribute__((device_builtin)) cudaResourceDesc { + enum cudaResourceType resType; + + union { + struct { + cudaArray_t array; + } array; + struct { + cudaMipmappedArray_t mipmap; + } mipmap; + struct { + void *devPtr; + struct cudaChannelFormatDesc desc; + size_t sizeInBytes; + } linear; + struct { + void *devPtr; + struct cudaChannelFormatDesc desc; + size_t width; + size_t height; + size_t pitchInBytes; + } pitch2D; + } res; +}; + + + + +struct __attribute__((device_builtin)) cudaResourceViewDesc +{ + enum cudaResourceViewFormat format; + size_t width; + size_t height; + size_t depth; + unsigned int firstMipmapLevel; + unsigned int lastMipmapLevel; + unsigned int firstLayer; + unsigned int lastLayer; +}; + + + + +struct __attribute__((device_builtin)) cudaPointerAttributes +{ + + + + + enum cudaMemoryType type; +# 1642 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + int device; + + + + + + void *devicePointer; +# 1657 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + void *hostPointer; +}; + + + + +struct __attribute__((device_builtin)) cudaFuncAttributes +{ + + + + + + size_t sharedSizeBytes; + + + + + + size_t constSizeBytes; + + + + + size_t localSizeBytes; + + + + + + + int maxThreadsPerBlock; + + + + + int numRegs; + + + + + + + int ptxVersion; + + + + + + + int binaryVersion; + + + + + + int cacheModeCA; + + + + + + + int maxDynamicSharedSizeBytes; +# 1729 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + int preferredShmemCarveout; + + + + + + int clusterDimMustBeSet; +# 1746 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + int requiredClusterWidth; + int requiredClusterHeight; + int requiredClusterDepth; + + + + + + int clusterSchedulingPolicyPreference; +# 1776 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + int nonPortableClusterSizeAllowed; + + + + + int reserved[16]; +}; + + + + +enum __attribute__((device_builtin)) cudaFuncAttribute +{ + cudaFuncAttributeMaxDynamicSharedMemorySize = 8, + cudaFuncAttributePreferredSharedMemoryCarveout = 9, + cudaFuncAttributeClusterDimMustBeSet = 10, + cudaFuncAttributeRequiredClusterWidth = 11, + cudaFuncAttributeRequiredClusterHeight = 12, + cudaFuncAttributeRequiredClusterDepth = 13, + cudaFuncAttributeNonPortableClusterSizeAllowed = 14, + cudaFuncAttributeClusterSchedulingPolicyPreference = 15, + cudaFuncAttributeMax +}; + + + + +enum __attribute__((device_builtin)) cudaFuncCache +{ + cudaFuncCachePreferNone = 0, + cudaFuncCachePreferShared = 1, + cudaFuncCachePreferL1 = 2, + cudaFuncCachePreferEqual = 3 +}; + + + + + +enum __attribute__((device_builtin)) cudaSharedMemConfig +{ + cudaSharedMemBankSizeDefault = 0, + cudaSharedMemBankSizeFourByte = 1, + cudaSharedMemBankSizeEightByte = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaSharedCarveout { + cudaSharedmemCarveoutDefault = -1, + cudaSharedmemCarveoutMaxShared = 100, + cudaSharedmemCarveoutMaxL1 = 0 +}; + + + + +enum __attribute__((device_builtin)) cudaComputeMode +{ + cudaComputeModeDefault = 0, + cudaComputeModeExclusive = 1, + cudaComputeModeProhibited = 2, + cudaComputeModeExclusiveProcess = 3 +}; + + + + +enum __attribute__((device_builtin)) cudaLimit +{ + cudaLimitStackSize = 0x00, + cudaLimitPrintfFifoSize = 0x01, + cudaLimitMallocHeapSize = 0x02, + cudaLimitDevRuntimeSyncDepth = 0x03, + cudaLimitDevRuntimePendingLaunchCount = 0x04, + cudaLimitMaxL2FetchGranularity = 0x05, + cudaLimitPersistingL2CacheSize = 0x06 +}; + + + + +enum __attribute__((device_builtin)) cudaMemoryAdvise +{ + cudaMemAdviseSetReadMostly = 1, + cudaMemAdviseUnsetReadMostly = 2, + cudaMemAdviseSetPreferredLocation = 3, + cudaMemAdviseUnsetPreferredLocation = 4, + cudaMemAdviseSetAccessedBy = 5, + cudaMemAdviseUnsetAccessedBy = 6 +}; + + + + +enum __attribute__((device_builtin)) cudaMemRangeAttribute +{ + cudaMemRangeAttributeReadMostly = 1, + cudaMemRangeAttributePreferredLocation = 2, + cudaMemRangeAttributeAccessedBy = 3, + cudaMemRangeAttributeLastPrefetchLocation = 4 + , cudaMemRangeAttributePreferredLocationType = 5 + , cudaMemRangeAttributePreferredLocationId = 6 + , cudaMemRangeAttributeLastPrefetchLocationType = 7 + , cudaMemRangeAttributeLastPrefetchLocationId = 8 +}; + + + + +enum __attribute__((device_builtin)) cudaFlushGPUDirectRDMAWritesOptions { + cudaFlushGPUDirectRDMAWritesOptionHost = 1<<0, + cudaFlushGPUDirectRDMAWritesOptionMemOps = 1<<1 +}; + + + + +enum __attribute__((device_builtin)) cudaGPUDirectRDMAWritesOrdering { + cudaGPUDirectRDMAWritesOrderingNone = 0, + cudaGPUDirectRDMAWritesOrderingOwner = 100, + cudaGPUDirectRDMAWritesOrderingAllDevices = 200 +}; + + + + +enum __attribute__((device_builtin)) cudaFlushGPUDirectRDMAWritesScope { + cudaFlushGPUDirectRDMAWritesToOwner = 100, + cudaFlushGPUDirectRDMAWritesToAllDevices = 200 +}; + + + + +enum __attribute__((device_builtin)) cudaFlushGPUDirectRDMAWritesTarget { + cudaFlushGPUDirectRDMAWritesTargetCurrentDevice +}; + + + + + +enum __attribute__((device_builtin)) cudaDeviceAttr +{ + cudaDevAttrMaxThreadsPerBlock = 1, + cudaDevAttrMaxBlockDimX = 2, + cudaDevAttrMaxBlockDimY = 3, + cudaDevAttrMaxBlockDimZ = 4, + cudaDevAttrMaxGridDimX = 5, + cudaDevAttrMaxGridDimY = 6, + cudaDevAttrMaxGridDimZ = 7, + cudaDevAttrMaxSharedMemoryPerBlock = 8, + cudaDevAttrTotalConstantMemory = 9, + cudaDevAttrWarpSize = 10, + cudaDevAttrMaxPitch = 11, + cudaDevAttrMaxRegistersPerBlock = 12, + cudaDevAttrClockRate = 13, + cudaDevAttrTextureAlignment = 14, + cudaDevAttrGpuOverlap = 15, + cudaDevAttrMultiProcessorCount = 16, + cudaDevAttrKernelExecTimeout = 17, + cudaDevAttrIntegrated = 18, + cudaDevAttrCanMapHostMemory = 19, + cudaDevAttrComputeMode = 20, + cudaDevAttrMaxTexture1DWidth = 21, + cudaDevAttrMaxTexture2DWidth = 22, + cudaDevAttrMaxTexture2DHeight = 23, + cudaDevAttrMaxTexture3DWidth = 24, + cudaDevAttrMaxTexture3DHeight = 25, + cudaDevAttrMaxTexture3DDepth = 26, + cudaDevAttrMaxTexture2DLayeredWidth = 27, + cudaDevAttrMaxTexture2DLayeredHeight = 28, + cudaDevAttrMaxTexture2DLayeredLayers = 29, + cudaDevAttrSurfaceAlignment = 30, + cudaDevAttrConcurrentKernels = 31, + cudaDevAttrEccEnabled = 32, + cudaDevAttrPciBusId = 33, + cudaDevAttrPciDeviceId = 34, + cudaDevAttrTccDriver = 35, + cudaDevAttrMemoryClockRate = 36, + cudaDevAttrGlobalMemoryBusWidth = 37, + cudaDevAttrL2CacheSize = 38, + cudaDevAttrMaxThreadsPerMultiProcessor = 39, + cudaDevAttrAsyncEngineCount = 40, + cudaDevAttrUnifiedAddressing = 41, + cudaDevAttrMaxTexture1DLayeredWidth = 42, + cudaDevAttrMaxTexture1DLayeredLayers = 43, + cudaDevAttrMaxTexture2DGatherWidth = 45, + cudaDevAttrMaxTexture2DGatherHeight = 46, + cudaDevAttrMaxTexture3DWidthAlt = 47, + cudaDevAttrMaxTexture3DHeightAlt = 48, + cudaDevAttrMaxTexture3DDepthAlt = 49, + cudaDevAttrPciDomainId = 50, + cudaDevAttrTexturePitchAlignment = 51, + cudaDevAttrMaxTextureCubemapWidth = 52, + cudaDevAttrMaxTextureCubemapLayeredWidth = 53, + cudaDevAttrMaxTextureCubemapLayeredLayers = 54, + cudaDevAttrMaxSurface1DWidth = 55, + cudaDevAttrMaxSurface2DWidth = 56, + cudaDevAttrMaxSurface2DHeight = 57, + cudaDevAttrMaxSurface3DWidth = 58, + cudaDevAttrMaxSurface3DHeight = 59, + cudaDevAttrMaxSurface3DDepth = 60, + cudaDevAttrMaxSurface1DLayeredWidth = 61, + cudaDevAttrMaxSurface1DLayeredLayers = 62, + cudaDevAttrMaxSurface2DLayeredWidth = 63, + cudaDevAttrMaxSurface2DLayeredHeight = 64, + cudaDevAttrMaxSurface2DLayeredLayers = 65, + cudaDevAttrMaxSurfaceCubemapWidth = 66, + cudaDevAttrMaxSurfaceCubemapLayeredWidth = 67, + cudaDevAttrMaxSurfaceCubemapLayeredLayers = 68, + cudaDevAttrMaxTexture1DLinearWidth = 69, + cudaDevAttrMaxTexture2DLinearWidth = 70, + cudaDevAttrMaxTexture2DLinearHeight = 71, + cudaDevAttrMaxTexture2DLinearPitch = 72, + cudaDevAttrMaxTexture2DMipmappedWidth = 73, + cudaDevAttrMaxTexture2DMipmappedHeight = 74, + cudaDevAttrComputeCapabilityMajor = 75, + cudaDevAttrComputeCapabilityMinor = 76, + cudaDevAttrMaxTexture1DMipmappedWidth = 77, + cudaDevAttrStreamPrioritiesSupported = 78, + cudaDevAttrGlobalL1CacheSupported = 79, + cudaDevAttrLocalL1CacheSupported = 80, + cudaDevAttrMaxSharedMemoryPerMultiprocessor = 81, + cudaDevAttrMaxRegistersPerMultiprocessor = 82, + cudaDevAttrManagedMemory = 83, + cudaDevAttrIsMultiGpuBoard = 84, + cudaDevAttrMultiGpuBoardGroupID = 85, + cudaDevAttrHostNativeAtomicSupported = 86, + cudaDevAttrSingleToDoublePrecisionPerfRatio = 87, + cudaDevAttrPageableMemoryAccess = 88, + cudaDevAttrConcurrentManagedAccess = 89, + cudaDevAttrComputePreemptionSupported = 90, + cudaDevAttrCanUseHostPointerForRegisteredMem = 91, + cudaDevAttrReserved92 = 92, + cudaDevAttrReserved93 = 93, + cudaDevAttrReserved94 = 94, + cudaDevAttrCooperativeLaunch = 95, + cudaDevAttrCooperativeMultiDeviceLaunch = 96, + cudaDevAttrMaxSharedMemoryPerBlockOptin = 97, + cudaDevAttrCanFlushRemoteWrites = 98, + cudaDevAttrHostRegisterSupported = 99, + cudaDevAttrPageableMemoryAccessUsesHostPageTables = 100, + cudaDevAttrDirectManagedMemAccessFromHost = 101, + cudaDevAttrMaxBlocksPerMultiprocessor = 106, + cudaDevAttrMaxPersistingL2CacheSize = 108, + cudaDevAttrMaxAccessPolicyWindowSize = 109, + cudaDevAttrReservedSharedMemoryPerBlock = 111, + cudaDevAttrSparseCudaArraySupported = 112, + cudaDevAttrHostRegisterReadOnlySupported = 113, + cudaDevAttrTimelineSemaphoreInteropSupported = 114, + cudaDevAttrMaxTimelineSemaphoreInteropSupported = 114, + cudaDevAttrMemoryPoolsSupported = 115, + cudaDevAttrGPUDirectRDMASupported = 116, + cudaDevAttrGPUDirectRDMAFlushWritesOptions = 117, + cudaDevAttrGPUDirectRDMAWritesOrdering = 118, + cudaDevAttrMemoryPoolSupportedHandleTypes = 119, + cudaDevAttrClusterLaunch = 120, + cudaDevAttrDeferredMappingCudaArraySupported = 121, + cudaDevAttrReserved122 = 122, + cudaDevAttrReserved123 = 123, + cudaDevAttrReserved124 = 124, + cudaDevAttrIpcEventSupport = 125, + cudaDevAttrMemSyncDomainCount = 126, + cudaDevAttrReserved127 = 127, + cudaDevAttrReserved128 = 128, + cudaDevAttrReserved129 = 129, + cudaDevAttrNumaConfig = 130, + cudaDevAttrNumaId = 131, + cudaDevAttrReserved132 = 132, + cudaDevAttrMpsEnabled = 133, + cudaDevAttrHostNumaId = 134, + cudaDevAttrD3D12CigSupported = 135, + cudaDevAttrGpuPciDeviceId = 139, + cudaDevAttrGpuPciSubsystemId = 140, + cudaDevAttrHostNumaMultinodeIpcSupported = 143, + cudaDevAttrMax +}; + + + + +enum __attribute__((device_builtin)) cudaMemPoolAttr +{ +# 2070 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaMemPoolReuseFollowEventDependencies = 0x1, + + + + + + + cudaMemPoolReuseAllowOpportunistic = 0x2, + + + + + + + + cudaMemPoolReuseAllowInternalDependencies = 0x3, +# 2096 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaMemPoolAttrReleaseThreshold = 0x4, + + + + + + cudaMemPoolAttrReservedMemCurrent = 0x5, + + + + + + + cudaMemPoolAttrReservedMemHigh = 0x6, + + + + + + cudaMemPoolAttrUsedMemCurrent = 0x7, + + + + + + + cudaMemPoolAttrUsedMemHigh = 0x8 +}; + + + + +enum __attribute__((device_builtin)) cudaMemLocationType { + cudaMemLocationTypeInvalid = 0, + cudaMemLocationTypeDevice = 1 + , cudaMemLocationTypeHost = 2 + , cudaMemLocationTypeHostNuma = 3 + , cudaMemLocationTypeHostNumaCurrent = 4 +}; + + + + + + + +struct __attribute__((device_builtin)) cudaMemLocation { + enum cudaMemLocationType type; + int id; +}; + + + + +enum __attribute__((device_builtin)) cudaMemAccessFlags { + cudaMemAccessFlagsProtNone = 0, + cudaMemAccessFlagsProtRead = 1, + cudaMemAccessFlagsProtReadWrite = 3 +}; + + + + +struct __attribute__((device_builtin)) cudaMemAccessDesc { + struct cudaMemLocation location; + enum cudaMemAccessFlags flags; +}; + + + + +enum __attribute__((device_builtin)) cudaMemAllocationType { + cudaMemAllocationTypeInvalid = 0x0, + + + + cudaMemAllocationTypePinned = 0x1, + cudaMemAllocationTypeMax = 0x7FFFFFFF +}; + + + + +enum __attribute__((device_builtin)) cudaMemAllocationHandleType { + cudaMemHandleTypeNone = 0x0, + cudaMemHandleTypePosixFileDescriptor = 0x1, + cudaMemHandleTypeWin32 = 0x2, + cudaMemHandleTypeWin32Kmt = 0x4, + cudaMemHandleTypeFabric = 0x8 +}; +# 2196 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct __attribute__((device_builtin)) cudaMemPoolProps { + enum cudaMemAllocationType allocType; + enum cudaMemAllocationHandleType handleTypes; + struct cudaMemLocation location; + + + + + + + void *win32SecurityAttributes; + size_t maxSize; + unsigned short usage; + unsigned char reserved[54]; +}; + + + + +struct __attribute__((device_builtin)) cudaMemPoolPtrExportData { + unsigned char reserved[64]; +}; + + + + +struct __attribute__((device_builtin)) cudaMemAllocNodeParams { + + + + + struct cudaMemPoolProps poolProps; + const struct cudaMemAccessDesc *accessDescs; + size_t accessDescCount; + size_t bytesize; + void *dptr; +}; + + + + +struct __attribute__((device_builtin)) cudaMemAllocNodeParamsV2 { + + + + + struct cudaMemPoolProps poolProps; + const struct cudaMemAccessDesc *accessDescs; + size_t accessDescCount; + size_t bytesize; + void *dptr; +}; + + + + +struct __attribute__((device_builtin)) cudaMemFreeNodeParams { + void *dptr; +}; + + + + +enum __attribute__((device_builtin)) cudaGraphMemAttributeType { + + + + + cudaGraphMemAttrUsedMemCurrent = 0x0, + + + + + + + cudaGraphMemAttrUsedMemHigh = 0x1, + + + + + + + cudaGraphMemAttrReservedMemCurrent = 0x2, + + + + + + + cudaGraphMemAttrReservedMemHigh = 0x3 +}; + + + + +enum __attribute__((device_builtin)) cudaMemcpyFlags { + cudaMemcpyFlagDefault = 0x0, + + + + + cudaMemcpyFlagPreferOverlapWithCompute = 0x1 +}; + +enum __attribute__((device_builtin)) cudaMemcpySrcAccessOrder { + + + + cudaMemcpySrcAccessOrderInvalid = 0x0, + + + + + cudaMemcpySrcAccessOrderStream = 0x1, +# 2320 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaMemcpySrcAccessOrderDuringApiCall = 0x2, +# 2329 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaMemcpySrcAccessOrderAny = 0x3, + + cudaMemcpySrcAccessOrderMax = 0x7FFFFFFF +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpyAttributes { + enum cudaMemcpySrcAccessOrder srcAccessOrder; + struct cudaMemLocation srcLocHint; + struct cudaMemLocation dstLocHint; + unsigned int flags; +}; + + + + +enum __attribute__((device_builtin)) cudaMemcpy3DOperandType { + cudaMemcpyOperandTypePointer = 0x1, + cudaMemcpyOperandTypeArray = 0x2, + cudaMemcpyOperandTypeMax = 0x7FFFFFFF +}; + + + + +struct __attribute__((device_builtin)) cudaOffset3D { + size_t x; + size_t y; + size_t z; +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpy3DOperand { + enum cudaMemcpy3DOperandType type; + union { + + + + struct { + void *ptr; + size_t rowLength; + size_t layerHeight; + struct cudaMemLocation locHint; + } ptr; + + + + + struct { + cudaArray_t array; + struct cudaOffset3D offset; + } array; + } op; +}; + +struct __attribute__((device_builtin)) cudaMemcpy3DBatchOp { + struct cudaMemcpy3DOperand src; + struct cudaMemcpy3DOperand dst; + struct cudaExtent extent; + enum cudaMemcpySrcAccessOrder srcAccessOrder; + unsigned int flags; +}; + + + + + +enum __attribute__((device_builtin)) cudaDeviceP2PAttr { + cudaDevP2PAttrPerformanceRank = 1, + cudaDevP2PAttrAccessSupported = 2, + cudaDevP2PAttrNativeAtomicSupported = 3, + cudaDevP2PAttrCudaArrayAccessSupported = 4 +}; + + + + + + +struct __attribute__((device_builtin)) CUuuid_st { + char bytes[16]; +}; +typedef __attribute__((device_builtin)) struct CUuuid_st CUuuid; + +typedef __attribute__((device_builtin)) struct CUuuid_st cudaUUID_t; + + + + +struct __attribute__((device_builtin)) cudaDeviceProp +{ + char name[256]; + cudaUUID_t uuid; + char luid[8]; + unsigned int luidDeviceNodeMask; + size_t totalGlobalMem; + size_t sharedMemPerBlock; + int regsPerBlock; + int warpSize; + size_t memPitch; + int maxThreadsPerBlock; + int maxThreadsDim[3]; + int maxGridSize[3]; + int clockRate; + size_t totalConstMem; + int major; + int minor; + size_t textureAlignment; + size_t texturePitchAlignment; + int deviceOverlap; + int multiProcessorCount; + int kernelExecTimeoutEnabled; + int integrated; + int canMapHostMemory; + int computeMode; + int maxTexture1D; + int maxTexture1DMipmap; + int maxTexture1DLinear; + int maxTexture2D[2]; + int maxTexture2DMipmap[2]; + int maxTexture2DLinear[3]; + int maxTexture2DGather[2]; + int maxTexture3D[3]; + int maxTexture3DAlt[3]; + int maxTextureCubemap; + int maxTexture1DLayered[2]; + int maxTexture2DLayered[3]; + int maxTextureCubemapLayered[2]; + int maxSurface1D; + int maxSurface2D[2]; + int maxSurface3D[3]; + int maxSurface1DLayered[2]; + int maxSurface2DLayered[3]; + int maxSurfaceCubemap; + int maxSurfaceCubemapLayered[2]; + size_t surfaceAlignment; + int concurrentKernels; + int ECCEnabled; + int pciBusID; + int pciDeviceID; + int pciDomainID; + int tccDriver; + int asyncEngineCount; + int unifiedAddressing; + int memoryClockRate; + int memoryBusWidth; + int l2CacheSize; + int persistingL2CacheMaxSize; + int maxThreadsPerMultiProcessor; + int streamPrioritiesSupported; + int globalL1CacheSupported; + int localL1CacheSupported; + size_t sharedMemPerMultiprocessor; + int regsPerMultiprocessor; + int managedMemory; + int isMultiGpuBoard; + int multiGpuBoardGroupID; + int hostNativeAtomicSupported; + int singleToDoublePrecisionPerfRatio; + int pageableMemoryAccess; + int concurrentManagedAccess; + int computePreemptionSupported; + int canUseHostPointerForRegisteredMem; + int cooperativeLaunch; + int cooperativeMultiDeviceLaunch; + size_t sharedMemPerBlockOptin; + int pageableMemoryAccessUsesHostPageTables; + int directManagedMemAccessFromHost; + int maxBlocksPerMultiProcessor; + int accessPolicyMaxWindowSize; + size_t reservedSharedMemPerBlock; + int hostRegisterSupported; + int sparseCudaArraySupported; + int hostRegisterReadOnlySupported; + int timelineSemaphoreInteropSupported; + int memoryPoolsSupported; + int gpuDirectRDMASupported; + unsigned int gpuDirectRDMAFlushWritesOptions; + int gpuDirectRDMAWritesOrdering; + unsigned int memoryPoolSupportedHandleTypes; + int deferredMappingCudaArraySupported; + int ipcEventSupported; + int clusterLaunch; + int unifiedFunctionPointers; + int reserved[63]; +}; +# 2528 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef __attribute__((device_builtin)) struct __attribute__((device_builtin)) cudaIpcEventHandle_st +{ + char reserved[64]; +}cudaIpcEventHandle_t; + + + + +typedef __attribute__((device_builtin)) struct __attribute__((device_builtin)) cudaIpcMemHandle_st +{ + char reserved[64]; +}cudaIpcMemHandle_t; + + + + +typedef __attribute__((device_builtin)) struct __attribute__((device_builtin)) cudaMemFabricHandle_st +{ + char reserved[64]; +}cudaMemFabricHandle_t; + + + + +enum __attribute__((device_builtin)) cudaExternalMemoryHandleType { + + + + cudaExternalMemoryHandleTypeOpaqueFd = 1, + + + + cudaExternalMemoryHandleTypeOpaqueWin32 = 2, + + + + cudaExternalMemoryHandleTypeOpaqueWin32Kmt = 3, + + + + cudaExternalMemoryHandleTypeD3D12Heap = 4, + + + + cudaExternalMemoryHandleTypeD3D12Resource = 5, + + + + cudaExternalMemoryHandleTypeD3D11Resource = 6, + + + + cudaExternalMemoryHandleTypeD3D11ResourceKmt = 7, + + + + cudaExternalMemoryHandleTypeNvSciBuf = 8 +}; +# 2627 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct __attribute__((device_builtin)) cudaExternalMemoryHandleDesc { + + + + enum cudaExternalMemoryHandleType type; + union { + + + + + + int fd; +# 2654 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + + + + void *handle; + + + + + const void *name; + } win32; + + + + + const void *nvSciBufObject; + } handle; + + + + unsigned long long size; + + + + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalMemoryBufferDesc { + + + + unsigned long long offset; + + + + unsigned long long size; + + + + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalMemoryMipmappedArrayDesc { + + + + + unsigned long long offset; + + + + struct cudaChannelFormatDesc formatDesc; + + + + struct cudaExtent extent; + + + + + unsigned int flags; + + + + unsigned int numLevels; +}; + + + + +enum __attribute__((device_builtin)) cudaExternalSemaphoreHandleType { + + + + cudaExternalSemaphoreHandleTypeOpaqueFd = 1, + + + + cudaExternalSemaphoreHandleTypeOpaqueWin32 = 2, + + + + cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3, + + + + cudaExternalSemaphoreHandleTypeD3D12Fence = 4, + + + + cudaExternalSemaphoreHandleTypeD3D11Fence = 5, + + + + cudaExternalSemaphoreHandleTypeNvSciSync = 6, + + + + cudaExternalSemaphoreHandleTypeKeyedMutex = 7, + + + + cudaExternalSemaphoreHandleTypeKeyedMutexKmt = 8, + + + + cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9, + + + + cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10 +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreHandleDesc { + + + + enum cudaExternalSemaphoreHandleType type; + union { + + + + + + + int fd; +# 2804 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + + + + void *handle; + + + + + const void *name; + } win32; + + + + const void* nvSciSyncObj; + } handle; + + + + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalParams_v1 { + struct { + + + + struct { + + + + unsigned long long value; + } fence; + union { + + + + + void *fence; + unsigned long long reserved; + } nvSciSync; + + + + struct { + + + + unsigned long long key; + } keyedMutex; + } params; +# 2868 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitParams_v1 { + struct { + + + + struct { + + + + unsigned long long value; + } fence; + union { + + + + + void *fence; + unsigned long long reserved; + } nvSciSync; + + + + struct { + + + + unsigned long long key; + + + + unsigned int timeoutMs; + } keyedMutex; + } params; +# 2917 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalParams{ + struct { + + + + struct { + + + + unsigned long long value; + } fence; + union { + + + + + void *fence; + unsigned long long reserved; + } nvSciSync; + + + + struct { + + + + unsigned long long key; + } keyedMutex; + unsigned int reserved[12]; + } params; +# 2963 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned int flags; + unsigned int reserved[16]; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitParams { + struct { + + + + struct { + + + + unsigned long long value; + } fence; + union { + + + + + void *fence; + unsigned long long reserved; + } nvSciSync; + + + + struct { + + + + unsigned long long key; + + + + unsigned int timeoutMs; + } keyedMutex; + unsigned int reserved[10]; + } params; +# 3014 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned int flags; + unsigned int reserved[16]; +}; +# 3027 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef __attribute__((device_builtin)) enum cudaError cudaError_t; + + + + +typedef __attribute__((device_builtin)) struct CUstream_st *cudaStream_t; + + + + +typedef __attribute__((device_builtin)) struct CUevent_st *cudaEvent_t; + + + + +typedef __attribute__((device_builtin)) struct cudaGraphicsResource *cudaGraphicsResource_t; + + + + +typedef __attribute__((device_builtin)) struct CUexternalMemory_st *cudaExternalMemory_t; + + + + +typedef __attribute__((device_builtin)) struct CUexternalSemaphore_st *cudaExternalSemaphore_t; + + + + +typedef __attribute__((device_builtin)) struct CUgraph_st *cudaGraph_t; + + + + +typedef __attribute__((device_builtin)) struct CUgraphNode_st *cudaGraphNode_t; + + + + +typedef __attribute__((device_builtin)) struct CUuserObject_st *cudaUserObject_t; + + + + +typedef __attribute__((device_builtin)) unsigned long long cudaGraphConditionalHandle; + + + + +typedef __attribute__((device_builtin)) struct CUfunc_st *cudaFunction_t; + + + + +typedef __attribute__((device_builtin)) struct CUkern_st *cudaKernel_t; + + + + +enum __attribute__((device_builtin)) cudaJitOption +{ + + + + + + cudaJitMaxRegisters = 0, +# 3108 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitThreadsPerBlock = 1, + + + + + + + + cudaJitWallTime = 2, +# 3125 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitInfoLogBuffer = 3, +# 3134 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitInfoLogBufferSizeBytes = 4, +# 3143 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitErrorLogBuffer = 5, +# 3152 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitErrorLogBufferSizeBytes = 6, + + + + + + + + cudaJitOptimizationLevel = 7, + + + + + + + + cudaJitFallbackStrategy = 10, + + + + + + + + cudaJitGenerateDebugInfo = 11, + + + + + + + cudaJitLogVerbose = 12, + + + + + + + cudaJitGenerateLineInfo = 13, + + + + + + + + cudaJitCacheMode = 14, + + + + + + + cudaJitPositionIndependentCode = 30, +# 3218 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitMinCtaPerSm = 31, +# 3231 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitMaxThreadsPerBlock = 32, +# 3241 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitOverrideDirectiveValues = 33, +}; + + + + + +enum __attribute__((device_builtin)) cudaLibraryOption +{ + cudaLibraryHostUniversalFunctionAndDataTable = 0, +# 3261 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaLibraryBinaryIsPreserved = 1, +}; + +struct __attribute__((device_builtin)) cudalibraryHostUniversalFunctionAndDataTable +{ + void *functionTable; + size_t functionWindowSize; + void *dataTable; + size_t dataWindowSize; +}; + + + + +enum __attribute__((device_builtin)) cudaJit_CacheMode +{ + cudaJitCacheOptionNone = 0, + cudaJitCacheOptionCG, + cudaJitCacheOptionCA +}; + + + + +enum __attribute__((device_builtin)) cudaJit_Fallback +{ + cudaPreferPtx = 0, + + cudaPreferBinary +}; + + + + +typedef __attribute__((device_builtin)) struct CUlib_st *cudaLibrary_t; + + + + +typedef __attribute__((device_builtin)) struct CUmemPoolHandle_st *cudaMemPool_t; + + + + +enum __attribute__((device_builtin)) cudaCGScope { + cudaCGScopeInvalid = 0, + cudaCGScopeGrid = 1, + cudaCGScopeMultiGrid = 2 +}; + + + + +struct __attribute__((device_builtin)) cudaLaunchParams +{ + void *func; + dim3 gridDim; + dim3 blockDim; + void **args; + size_t sharedMem; + cudaStream_t stream; +}; + + + + +struct __attribute__((device_builtin)) cudaKernelNodeParams { + void* func; + dim3 gridDim; + dim3 blockDim; + unsigned int sharedMemBytes; + void **kernelParams; + void **extra; +}; + + + + +struct __attribute__((device_builtin)) cudaKernelNodeParamsV2 { + void* func; + + dim3 gridDim; + dim3 blockDim; + + + + + + unsigned int sharedMemBytes; + void **kernelParams; + void **extra; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalNodeParams { + cudaExternalSemaphore_t* extSemArray; + const struct cudaExternalSemaphoreSignalParams* paramsArray; + unsigned int numExtSems; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalNodeParamsV2 { + cudaExternalSemaphore_t* extSemArray; + const struct cudaExternalSemaphoreSignalParams* paramsArray; + unsigned int numExtSems; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitNodeParams { + cudaExternalSemaphore_t* extSemArray; + const struct cudaExternalSemaphoreWaitParams* paramsArray; + unsigned int numExtSems; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitNodeParamsV2 { + cudaExternalSemaphore_t* extSemArray; + const struct cudaExternalSemaphoreWaitParams* paramsArray; + unsigned int numExtSems; +}; + +enum __attribute__((device_builtin)) cudaGraphConditionalHandleFlags { + cudaGraphCondAssignDefault = 1 +}; + + + + +enum __attribute__((device_builtin)) cudaGraphConditionalNodeType { + cudaGraphCondTypeIf = 0, + cudaGraphCondTypeWhile = 1, + cudaGraphCondTypeSwitch = 2, +}; + + + + +struct __attribute__((device_builtin)) cudaConditionalNodeParams { + cudaGraphConditionalHandle handle; + + + enum cudaGraphConditionalNodeType type; + unsigned int size; + + cudaGraph_t *phGraph_out; +# 3432 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +}; + + + + +enum __attribute__((device_builtin)) cudaGraphNodeType { + cudaGraphNodeTypeKernel = 0x00, + cudaGraphNodeTypeMemcpy = 0x01, + cudaGraphNodeTypeMemset = 0x02, + cudaGraphNodeTypeHost = 0x03, + cudaGraphNodeTypeGraph = 0x04, + cudaGraphNodeTypeEmpty = 0x05, + cudaGraphNodeTypeWaitEvent = 0x06, + cudaGraphNodeTypeEventRecord = 0x07, + cudaGraphNodeTypeExtSemaphoreSignal = 0x08, + cudaGraphNodeTypeExtSemaphoreWait = 0x09, + cudaGraphNodeTypeMemAlloc = 0x0a, + cudaGraphNodeTypeMemFree = 0x0b, + cudaGraphNodeTypeConditional = 0x0d, +# 3467 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaGraphNodeTypeCount +}; + + + + +struct __attribute__((device_builtin)) cudaChildGraphNodeParams { + cudaGraph_t graph; + +}; + + + + +struct __attribute__((device_builtin)) cudaEventRecordNodeParams { + cudaEvent_t event; +}; + + + + +struct __attribute__((device_builtin)) cudaEventWaitNodeParams { + cudaEvent_t event; +}; + + + + +struct __attribute__((device_builtin)) cudaGraphNodeParams { + enum cudaGraphNodeType type; + int reserved0[3]; + + union { + long long reserved1[29]; + struct cudaKernelNodeParamsV2 kernel; + struct cudaMemcpyNodeParams memcpy; + struct cudaMemsetParamsV2 memset; + struct cudaHostNodeParamsV2 host; + struct cudaChildGraphNodeParams graph; + struct cudaEventWaitNodeParams eventWait; + struct cudaEventRecordNodeParams eventRecord; + struct cudaExternalSemaphoreSignalNodeParamsV2 extSemSignal; + struct cudaExternalSemaphoreWaitNodeParamsV2 extSemWait; + struct cudaMemAllocNodeParamsV2 alloc; + struct cudaMemFreeNodeParams free; + struct cudaConditionalNodeParams conditional; + }; + + long long reserved2; +}; + + + + +typedef __attribute__((device_builtin)) enum cudaGraphDependencyType_enum { + cudaGraphDependencyTypeDefault = 0, + cudaGraphDependencyTypeProgrammatic = 1 + + + + +} cudaGraphDependencyType; + + + + + + +typedef __attribute__((device_builtin)) struct cudaGraphEdgeData_st { + unsigned char from_port; +# 3546 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned char to_port; + + + + + + + unsigned char type; + + + unsigned char reserved[5]; + +} cudaGraphEdgeData; +# 3579 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef struct CUgraphExec_st* cudaGraphExec_t; + + + + +enum __attribute__((device_builtin)) cudaGraphExecUpdateResult { + cudaGraphExecUpdateSuccess = 0x0, + cudaGraphExecUpdateError = 0x1, + cudaGraphExecUpdateErrorTopologyChanged = 0x2, + cudaGraphExecUpdateErrorNodeTypeChanged = 0x3, + cudaGraphExecUpdateErrorFunctionChanged = 0x4, + cudaGraphExecUpdateErrorParametersChanged = 0x5, + cudaGraphExecUpdateErrorNotSupported = 0x6, + cudaGraphExecUpdateErrorUnsupportedFunctionChange = 0x7, + cudaGraphExecUpdateErrorAttributesChanged = 0x8 +}; + + + + +typedef __attribute__((device_builtin)) enum cudaGraphInstantiateResult { + cudaGraphInstantiateSuccess = 0, + cudaGraphInstantiateError = 1, + cudaGraphInstantiateInvalidStructure = 2, + cudaGraphInstantiateNodeOperationNotSupported = 3, + cudaGraphInstantiateMultipleDevicesNotSupported = 4, + cudaGraphInstantiateConditionalHandleUnused = 5 +} cudaGraphInstantiateResult; + + + + +typedef __attribute__((device_builtin)) struct cudaGraphInstantiateParams_st +{ + unsigned long long flags; + cudaStream_t uploadStream; + cudaGraphNode_t errNode_out; + cudaGraphInstantiateResult result_out; +} cudaGraphInstantiateParams; + + + + +typedef __attribute__((device_builtin)) struct cudaGraphExecUpdateResultInfo_st { + + + + enum cudaGraphExecUpdateResult result; + + + + + + + cudaGraphNode_t errorNode; + + + + + cudaGraphNode_t errorFromNode; +} cudaGraphExecUpdateResultInfo; + + + + +typedef struct CUgraphDeviceUpdatableNode_st* cudaGraphDeviceNode_t; + + + + +enum __attribute__((device_builtin)) cudaGraphKernelNodeField +{ + cudaGraphKernelNodeFieldInvalid = 0, + cudaGraphKernelNodeFieldGridDim, + cudaGraphKernelNodeFieldParam, + cudaGraphKernelNodeFieldEnabled +}; + + + + +struct __attribute__((device_builtin)) cudaGraphKernelNodeUpdate { + cudaGraphDeviceNode_t node; + enum cudaGraphKernelNodeField field; + union { + + dim3 gridDim; + + + + + struct { + const void *pValue; + size_t offset; + size_t size; + } param; + unsigned int isEnabled; + } updateData; +}; + + + + + +enum __attribute__((device_builtin)) cudaGetDriverEntryPointFlags { + cudaEnableDefault = 0x0, + cudaEnableLegacyStream = 0x1, + cudaEnablePerThreadDefaultStream = 0x2 +}; + + + + +enum __attribute__((device_builtin)) cudaDriverEntryPointQueryResult { + cudaDriverEntryPointSuccess = 0, + cudaDriverEntryPointSymbolNotFound = 1, + cudaDriverEntryPointVersionNotSufficent = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaGraphDebugDotFlags { + cudaGraphDebugDotFlagsVerbose = 1<<0, + cudaGraphDebugDotFlagsKernelNodeParams = 1<<2, + cudaGraphDebugDotFlagsMemcpyNodeParams = 1<<3, + cudaGraphDebugDotFlagsMemsetNodeParams = 1<<4, + cudaGraphDebugDotFlagsHostNodeParams = 1<<5, + cudaGraphDebugDotFlagsEventNodeParams = 1<<6, + cudaGraphDebugDotFlagsExtSemasSignalNodeParams = 1<<7, + cudaGraphDebugDotFlagsExtSemasWaitNodeParams = 1<<8, + cudaGraphDebugDotFlagsKernelNodeAttributes = 1<<9, + cudaGraphDebugDotFlagsHandles = 1<<10, + cudaGraphDebugDotFlagsConditionalNodeParams = 1<<15, +}; + + + + +enum __attribute__((device_builtin)) cudaGraphInstantiateFlags { + cudaGraphInstantiateFlagAutoFreeOnLaunch = 1 + , cudaGraphInstantiateFlagUpload = 2 + + + , cudaGraphInstantiateFlagDeviceLaunch = 4 + + + , cudaGraphInstantiateFlagUseNodePriority = 8 + +}; +# 3746 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef __attribute__((device_builtin)) enum cudaLaunchMemSyncDomain { + cudaLaunchMemSyncDomainDefault = 0, + cudaLaunchMemSyncDomainRemote = 1 +} cudaLaunchMemSyncDomain; +# 3762 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef __attribute__((device_builtin)) struct cudaLaunchMemSyncDomainMap_st { + unsigned char default_; + unsigned char remote; +} cudaLaunchMemSyncDomainMap; + + + + +typedef __attribute__((device_builtin)) enum cudaLaunchAttributeID { + cudaLaunchAttributeIgnore = 0 + , cudaLaunchAttributeAccessPolicyWindow = 1 + + , cudaLaunchAttributeCooperative = 2 + + , cudaLaunchAttributeSynchronizationPolicy = 3 + , cudaLaunchAttributeClusterDimension = 4 + + , cudaLaunchAttributeClusterSchedulingPolicyPreference = 5 + + , cudaLaunchAttributeProgrammaticStreamSerialization = 6 +# 3792 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributeProgrammaticEvent = 7 +# 3818 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributePriority = 8 + + , cudaLaunchAttributeMemSyncDomainMap = 9 + + , cudaLaunchAttributeMemSyncDomain = 10 + + , cudaLaunchAttributePreferredClusterDimension = 11 +# 3860 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributeLaunchCompletionEvent = 12 +# 3882 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributeDeviceUpdatableKernelNode = 13 +# 3910 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributePreferredSharedMemoryCarveout = 14 + + + + + + +} cudaLaunchAttributeID; + + + + +typedef __attribute__((device_builtin)) union cudaLaunchAttributeValue { + char pad[64]; + struct cudaAccessPolicyWindow accessPolicyWindow; + int cooperative; + + enum cudaSynchronizationPolicy syncPolicy; +# 3941 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + unsigned int x; + unsigned int y; + unsigned int z; + } clusterDim; + enum cudaClusterSchedulingPolicy clusterSchedulingPolicyPreference; + + + int programmaticStreamSerializationAllowed; +# 3960 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + cudaEvent_t event; + int flags; + int triggerAtBlockStart; + } programmaticEvent; + int priority; + cudaLaunchMemSyncDomainMap memSyncDomainMap; + + + cudaLaunchMemSyncDomain memSyncDomain; +# 3984 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + unsigned int x; + unsigned int y; + unsigned int z; + } preferredClusterDim; +# 3997 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + cudaEvent_t event; + int flags; + } launchCompletionEvent; + + + + + + + + struct { + int deviceUpdatable; + cudaGraphDeviceNode_t devNode; + } deviceUpdatableKernelNode; + unsigned int sharedMemCarveout; +} cudaLaunchAttributeValue; + + + + +typedef __attribute__((device_builtin)) struct cudaLaunchAttribute_st { + cudaLaunchAttributeID id; + char pad[8 - sizeof(cudaLaunchAttributeID)]; + cudaLaunchAttributeValue val; +} cudaLaunchAttribute; + + + + +typedef __attribute__((device_builtin)) struct cudaLaunchConfig_st { + dim3 gridDim; + dim3 blockDim; + size_t dynamicSmemBytes; + cudaStream_t stream; + cudaLaunchAttribute *attrs; + unsigned int numAttrs; +} cudaLaunchConfig_t; +# 4061 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +enum __attribute__((device_builtin)) cudaDeviceNumaConfig { + cudaDeviceNumaConfigNone = 0, + cudaDeviceNumaConfigNumaNode, +}; + + + + +typedef struct cudaAsyncCallbackEntry* cudaAsyncCallbackHandle_t; + +struct cudaAsyncCallbackEntry; + + + + +typedef __attribute__((device_builtin)) enum cudaAsyncNotificationType_enum { + cudaAsyncNotificationTypeOverBudget = 0x1 +} cudaAsyncNotificationType; + + + + +typedef __attribute__((device_builtin)) struct cudaAsyncNotificationInfo +{ + cudaAsyncNotificationType type; + union { + struct { + unsigned long long bytesOverBudget; + } overBudget; + } info; +} cudaAsyncNotificationInfo_t; + +typedef void (*cudaAsyncCallback)(cudaAsyncNotificationInfo_t*, void*, cudaAsyncCallbackHandle_t); +# 60 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_types.h" 1 +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_types.h" +enum __attribute__((device_builtin)) cudaSurfaceBoundaryMode +{ + cudaBoundaryModeZero = 0, + cudaBoundaryModeClamp = 1, + cudaBoundaryModeTrap = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaSurfaceFormatMode +{ + cudaFormatModeForced = 0, + cudaFormatModeAuto = 1 +}; + + + + +typedef __attribute__((device_builtin)) unsigned long long cudaSurfaceObject_t; +# 63 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_types.h" 1 +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_types.h" +enum __attribute__((device_builtin)) cudaTextureAddressMode +{ + cudaAddressModeWrap = 0, + cudaAddressModeClamp = 1, + cudaAddressModeMirror = 2, + cudaAddressModeBorder = 3 +}; + + + + +enum __attribute__((device_builtin)) cudaTextureFilterMode +{ + cudaFilterModePoint = 0, + cudaFilterModeLinear = 1 +}; + + + + +enum __attribute__((device_builtin)) cudaTextureReadMode +{ + cudaReadModeElementType = 0, + cudaReadModeNormalizedFloat = 1 +}; + + + + +struct __attribute__((device_builtin)) cudaTextureDesc +{ + + + + enum cudaTextureAddressMode addressMode[3]; + + + + enum cudaTextureFilterMode filterMode; + + + + enum cudaTextureReadMode readMode; + + + + int sRGB; + + + + float borderColor[4]; + + + + int normalizedCoords; + + + + unsigned int maxAnisotropy; + + + + enum cudaTextureFilterMode mipmapFilterMode; + + + + float mipmapLevelBias; + + + + float minMipmapLevelClamp; + + + + float maxMipmapLevelClamp; + + + + int disableTrilinearOptimization; + + + + int seamlessCubemap; +}; + + + + +typedef __attribute__((device_builtin)) unsigned long long cudaTextureObject_t; +# 64 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 2 +# 91 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/library_types.h" 1 +# 57 "/opt/cuda/bin/../targets/x86_64-linux/include/library_types.h" +typedef enum cudaDataType_t +{ + CUDA_R_16F = 2, + CUDA_C_16F = 6, + CUDA_R_16BF = 14, + CUDA_C_16BF = 15, + CUDA_R_32F = 0, + CUDA_C_32F = 4, + CUDA_R_64F = 1, + CUDA_C_64F = 5, + CUDA_R_4I = 16, + CUDA_C_4I = 17, + CUDA_R_4U = 18, + CUDA_C_4U = 19, + CUDA_R_8I = 3, + CUDA_C_8I = 7, + CUDA_R_8U = 8, + CUDA_C_8U = 9, + CUDA_R_16I = 20, + CUDA_C_16I = 21, + CUDA_R_16U = 22, + CUDA_C_16U = 23, + CUDA_R_32I = 10, + CUDA_C_32I = 11, + CUDA_R_32U = 12, + CUDA_C_32U = 13, + CUDA_R_64I = 24, + CUDA_C_64I = 25, + CUDA_R_64U = 26, + CUDA_C_64U = 27, + CUDA_R_8F_E4M3 = 28, + CUDA_R_8F_UE4M3 = CUDA_R_8F_E4M3, + CUDA_R_8F_E5M2 = 29, + CUDA_R_8F_UE8M0 = 30, + CUDA_R_6F_E2M3 = 31, + CUDA_R_6F_E3M2 = 32, + CUDA_R_4F_E2M1 = 33, +} cudaDataType; + + +typedef enum libraryPropertyType_t +{ + MAJOR_VERSION, + MINOR_VERSION, + PATCH_LEVEL +} libraryPropertyType; +# 92 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" 1 +# 61 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 1 +# 148 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 149 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 151 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" 1 +# 54 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h" 1 3 +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 308 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 + +# 308 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + typedef long unsigned int size_t; + typedef long int ptrdiff_t; + + + typedef decltype(nullptr) nullptr_t; + + +#pragma GCC visibility push(default) + + + extern "C++" __attribute__ ((__noreturn__, __always_inline__)) + inline void __terminate() noexcept + { + void terminate() noexcept __attribute__ ((__noreturn__,__cold__)); + terminate(); + } +#pragma GCC visibility pop +} +# 341 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +namespace __gnu_cxx +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +# 534 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ +#pragma GCC visibility push(default) + + + + + __attribute__((__always_inline__)) + constexpr inline bool + __is_constant_evaluated() noexcept + { + + + + + + return __builtin_is_constant_evaluated(); + + + + } +#pragma GCC visibility pop +} +# 573 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ +#pragma GCC visibility push(default) + + extern "C++" __attribute__ ((__noreturn__)) + void + __glibcxx_assert_fail + (const char* __file, int __line, const char* __function, + const char* __condition) + noexcept; +#pragma GCC visibility pop +} +# 604 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + __attribute__((__always_inline__,__visibility__("default"))) + inline void + __glibcxx_assert_fail() + { } +} +# 683 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3 +# 684 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3 +# 687 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 828 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace __gnu_cxx +{ + typedef __decltype(0.0bf16) __bfloat16_t; +} +# 890 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/pstl/pstl_config.h" 1 3 +# 891 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 2 3 +# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +# 1 "/usr/include/stdlib.h" 1 3 4 +# 26 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/stdlib.h" 2 3 4 + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 33 "/usr/include/stdlib.h" 2 3 4 + +extern "C" { + + + + + +# 1 "/usr/include/bits/waitflags.h" 1 3 4 +# 41 "/usr/include/stdlib.h" 2 3 4 +# 1 "/usr/include/bits/waitstatus.h" 1 3 4 +# 42 "/usr/include/stdlib.h" 2 3 4 +# 56 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/floatn.h" 1 3 4 +# 131 "/usr/include/bits/floatn.h" 3 4 +# 1 "/usr/include/bits/floatn-common.h" 1 3 4 +# 24 "/usr/include/bits/floatn-common.h" 3 4 +# 1 "/usr/include/bits/long-double.h" 1 3 4 +# 25 "/usr/include/bits/floatn-common.h" 2 3 4 +# 132 "/usr/include/bits/floatn.h" 2 3 4 +# 57 "/usr/include/stdlib.h" 2 3 4 + + +typedef struct + { + int quot; + int rem; + } div_t; + + + +typedef struct + { + long int quot; + long int rem; + } ldiv_t; + + + + + +__extension__ typedef struct + { + long long int quot; + long long int rem; + } lldiv_t; +# 98 "/usr/include/stdlib.h" 3 4 +extern size_t __ctype_get_mb_cur_max (void) noexcept (true) ; + + + +extern double atof (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern int atoi (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern long int atol (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +__extension__ extern long long int atoll (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +extern double strtod (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern float strtof (const char *__restrict __nptr, + char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern long double strtold (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 141 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float64 strtof64 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float128 strtof128 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float32x strtof32x (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float64x strtof64x (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 177 "/usr/include/stdlib.h" 3 4 +extern long int strtol (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern unsigned long int strtoul (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern long int strtol (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtol") + + + __attribute__ ((__nonnull__ (1))); +extern unsigned long int strtoul (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoul") + + + + __attribute__ ((__nonnull__ (1))); + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") + + + __attribute__ ((__nonnull__ (1))); +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") + + + + __attribute__ ((__nonnull__ (1))); + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") + + + __attribute__ ((__nonnull__ (1))); +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") + + + + __attribute__ ((__nonnull__ (1))); +# 278 "/usr/include/stdlib.h" 3 4 +extern int strfromd (char *__dest, size_t __size, const char *__format, + double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfromf (char *__dest, size_t __size, const char *__format, + float __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfroml (char *__dest, size_t __size, const char *__format, + long double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 298 "/usr/include/stdlib.h" 3 4 +extern int strfromf32 (char *__dest, size_t __size, const char * __format, + _Float32 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64 (char *__dest, size_t __size, const char * __format, + _Float64 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf128 (char *__dest, size_t __size, const char * __format, + _Float128 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf32x (char *__dest, size_t __size, const char * __format, + _Float32x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64x (char *__dest, size_t __size, const char * __format, + _Float64x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 340 "/usr/include/stdlib.h" 3 4 +extern long int strtol_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +extern unsigned long int strtoul_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + + + + + +extern long int strtol_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtol_l") + + + + __attribute__ ((__nonnull__ (1, 4))); +extern unsigned long int strtoul_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoul_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoll_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoull_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +# 415 "/usr/include/stdlib.h" 3 4 +extern double strtod_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern float strtof_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern long double strtold_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 436 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64 strtof64_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float128 strtof128_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float32x strtof32x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64x strtof64x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 505 "/usr/include/stdlib.h" 3 4 +extern char *l64a (long int __n) noexcept (true) ; + + +extern long int a64l (const char *__s) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + + +# 1 "/usr/include/sys/types.h" 1 3 4 +# 27 "/usr/include/sys/types.h" 3 4 +extern "C" { + + + + + +typedef __u_char u_char; +typedef __u_short u_short; +typedef __u_int u_int; +typedef __u_long u_long; +typedef __quad_t quad_t; +typedef __u_quad_t u_quad_t; +typedef __fsid_t fsid_t; + + +typedef __loff_t loff_t; + + + + +typedef __ino_t ino_t; + + + + + + +typedef __ino64_t ino64_t; + + + + +typedef __dev_t dev_t; + + + + +typedef __gid_t gid_t; + + + + +typedef __mode_t mode_t; + + + + +typedef __nlink_t nlink_t; + + + + +typedef __uid_t uid_t; + + + + + +typedef __off_t off_t; + + + + + + +typedef __off64_t off64_t; + + + + +typedef __pid_t pid_t; + + + + + +typedef __id_t id_t; + + + + +typedef __ssize_t ssize_t; + + + + + +typedef __daddr_t daddr_t; +typedef __caddr_t caddr_t; + + + + + +typedef __key_t key_t; + + + + +# 1 "/usr/include/bits/types/clock_t.h" 1 3 4 + + + + + + +typedef __clock_t clock_t; +# 127 "/usr/include/sys/types.h" 2 3 4 + +# 1 "/usr/include/bits/types/clockid_t.h" 1 3 4 + + + + + + +typedef __clockid_t clockid_t; +# 129 "/usr/include/sys/types.h" 2 3 4 +# 1 "/usr/include/bits/types/time_t.h" 1 3 4 +# 10 "/usr/include/bits/types/time_t.h" 3 4 +typedef __time_t time_t; +# 130 "/usr/include/sys/types.h" 2 3 4 +# 1 "/usr/include/bits/types/timer_t.h" 1 3 4 + + + + + + +typedef __timer_t timer_t; +# 131 "/usr/include/sys/types.h" 2 3 4 + + + +typedef __useconds_t useconds_t; + + + +typedef __suseconds_t suseconds_t; + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 145 "/usr/include/sys/types.h" 2 3 4 + + + +typedef unsigned long int ulong; +typedef unsigned short int ushort; +typedef unsigned int uint; + + + + +# 1 "/usr/include/bits/stdint-intn.h" 1 3 4 +# 24 "/usr/include/bits/stdint-intn.h" 3 4 +typedef __int8_t int8_t; +typedef __int16_t int16_t; +typedef __int32_t int32_t; +typedef __int64_t int64_t; +# 156 "/usr/include/sys/types.h" 2 3 4 + + +typedef __uint8_t u_int8_t; +typedef __uint16_t u_int16_t; +typedef __uint32_t u_int32_t; +typedef __uint64_t u_int64_t; + + +typedef int register_t __attribute__ ((__mode__ (__word__))); +# 176 "/usr/include/sys/types.h" 3 4 +# 1 "/usr/include/endian.h" 1 3 4 +# 35 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/bits/byteswap.h" 1 3 4 +# 33 "/usr/include/bits/byteswap.h" 3 4 +static __inline __uint16_t +__bswap_16 (__uint16_t __bsx) +{ + + return __builtin_bswap16 (__bsx); + + + +} + + + + + + +static __inline __uint32_t +__bswap_32 (__uint32_t __bsx) +{ + + return __builtin_bswap32 (__bsx); + + + +} +# 69 "/usr/include/bits/byteswap.h" 3 4 +__extension__ static __inline __uint64_t +__bswap_64 (__uint64_t __bsx) +{ + + return __builtin_bswap64 (__bsx); + + + +} +# 36 "/usr/include/endian.h" 2 3 4 +# 1 "/usr/include/bits/uintn-identity.h" 1 3 4 +# 32 "/usr/include/bits/uintn-identity.h" 3 4 +static __inline __uint16_t +__uint16_identity (__uint16_t __x) +{ + return __x; +} + +static __inline __uint32_t +__uint32_identity (__uint32_t __x) +{ + return __x; +} + +static __inline __uint64_t +__uint64_identity (__uint64_t __x) +{ + return __x; +} +# 37 "/usr/include/endian.h" 2 3 4 +# 177 "/usr/include/sys/types.h" 2 3 4 + + +# 1 "/usr/include/sys/select.h" 1 3 4 +# 30 "/usr/include/sys/select.h" 3 4 +# 1 "/usr/include/bits/select.h" 1 3 4 +# 31 "/usr/include/sys/select.h" 2 3 4 + + +# 1 "/usr/include/bits/types/sigset_t.h" 1 3 4 + + + +# 1 "/usr/include/bits/types/__sigset_t.h" 1 3 4 + + + + +typedef struct +{ + unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; +} __sigset_t; +# 5 "/usr/include/bits/types/sigset_t.h" 2 3 4 + + +typedef __sigset_t sigset_t; +# 34 "/usr/include/sys/select.h" 2 3 4 + + + +# 1 "/usr/include/bits/types/struct_timeval.h" 1 3 4 + + + + + + + +struct timeval +{ + + + + + __time_t tv_sec; + __suseconds_t tv_usec; + +}; +# 38 "/usr/include/sys/select.h" 2 3 4 + +# 1 "/usr/include/bits/types/struct_timespec.h" 1 3 4 +# 11 "/usr/include/bits/types/struct_timespec.h" 3 4 +struct timespec +{ + + + + __time_t tv_sec; + + + + + __syscall_slong_t tv_nsec; +# 31 "/usr/include/bits/types/struct_timespec.h" 3 4 +}; +# 40 "/usr/include/sys/select.h" 2 3 4 +# 49 "/usr/include/sys/select.h" 3 4 +typedef long int __fd_mask; +# 59 "/usr/include/sys/select.h" 3 4 +typedef struct + { + + + + __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; + + + + + + } fd_set; + + + + + + +typedef __fd_mask fd_mask; +# 91 "/usr/include/sys/select.h" 3 4 +extern "C" { +# 102 "/usr/include/sys/select.h" 3 4 +extern int select (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + struct timeval *__restrict __timeout); +# 127 "/usr/include/sys/select.h" 3 4 +extern int pselect (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + const struct timespec *__restrict __timeout, + const __sigset_t *__restrict __sigmask); +# 153 "/usr/include/sys/select.h" 3 4 +} +# 180 "/usr/include/sys/types.h" 2 3 4 + + + + + +typedef __blksize_t blksize_t; + + + + + + +typedef __blkcnt_t blkcnt_t; + + + +typedef __fsblkcnt_t fsblkcnt_t; + + + +typedef __fsfilcnt_t fsfilcnt_t; +# 219 "/usr/include/sys/types.h" 3 4 +typedef __blkcnt64_t blkcnt64_t; +typedef __fsblkcnt64_t fsblkcnt64_t; +typedef __fsfilcnt64_t fsfilcnt64_t; + + + + + +# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4 +# 23 "/usr/include/bits/pthreadtypes.h" 3 4 +# 1 "/usr/include/bits/thread-shared-types.h" 1 3 4 +# 44 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/pthreadtypes-arch.h" 1 3 4 +# 21 "/usr/include/bits/pthreadtypes-arch.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 22 "/usr/include/bits/pthreadtypes-arch.h" 2 3 4 +# 45 "/usr/include/bits/thread-shared-types.h" 2 3 4 + +# 1 "/usr/include/bits/atomic_wide_counter.h" 1 3 4 +# 25 "/usr/include/bits/atomic_wide_counter.h" 3 4 +typedef union +{ + __extension__ unsigned long long int __value64; + struct + { + unsigned int __low; + unsigned int __high; + } __value32; +} __atomic_wide_counter; +# 47 "/usr/include/bits/thread-shared-types.h" 2 3 4 + + + + +typedef struct __pthread_internal_list +{ + struct __pthread_internal_list *__prev; + struct __pthread_internal_list *__next; +} __pthread_list_t; + +typedef struct __pthread_internal_slist +{ + struct __pthread_internal_slist *__next; +} __pthread_slist_t; +# 76 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/struct_mutex.h" 1 3 4 +# 22 "/usr/include/bits/struct_mutex.h" 3 4 +struct __pthread_mutex_s +{ + int __lock; + unsigned int __count; + int __owner; + + unsigned int __nusers; + + + + int __kind; + + short __spins; + short __elision; + __pthread_list_t __list; +# 53 "/usr/include/bits/struct_mutex.h" 3 4 +}; +# 77 "/usr/include/bits/thread-shared-types.h" 2 3 4 +# 89 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/struct_rwlock.h" 1 3 4 +# 23 "/usr/include/bits/struct_rwlock.h" 3 4 +struct __pthread_rwlock_arch_t +{ + unsigned int __readers; + unsigned int __writers; + unsigned int __wrphase_futex; + unsigned int __writers_futex; + unsigned int __pad3; + unsigned int __pad4; + + int __cur_writer; + int __shared; + signed char __rwelision; + + + + + unsigned char __pad1[7]; + + + unsigned long int __pad2; + + + unsigned int __flags; +# 55 "/usr/include/bits/struct_rwlock.h" 3 4 +}; +# 90 "/usr/include/bits/thread-shared-types.h" 2 3 4 + + + + +struct __pthread_cond_s +{ + __atomic_wide_counter __wseq; + __atomic_wide_counter __g1_start; + unsigned int __g_size[2] ; + unsigned int __g1_orig_size; + unsigned int __wrefs; + unsigned int __g_signals[2]; + unsigned int __unused_initialized_1; + unsigned int __unused_initialized_2; +}; + +typedef unsigned int __tss_t; +typedef unsigned long int __thrd_t; + +typedef struct +{ + int __data ; +} __once_flag; +# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4 + + + +typedef unsigned long int pthread_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_mutexattr_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_condattr_t; + + + +typedef unsigned int pthread_key_t; + + + +typedef int pthread_once_t; + + +union pthread_attr_t +{ + char __size[56]; + long int __align; +}; + +typedef union pthread_attr_t pthread_attr_t; + + + + +typedef union +{ + struct __pthread_mutex_s __data; + char __size[40]; + long int __align; +} pthread_mutex_t; + + +typedef union +{ + struct __pthread_cond_s __data; + char __size[48]; + __extension__ long long int __align; +} pthread_cond_t; + + + + + +typedef union +{ + struct __pthread_rwlock_arch_t __data; + char __size[56]; + long int __align; +} pthread_rwlock_t; + +typedef union +{ + char __size[8]; + long int __align; +} pthread_rwlockattr_t; + + + + + +typedef volatile int pthread_spinlock_t; + + + + +typedef union +{ + char __size[32]; + long int __align; +} pthread_barrier_t; + +typedef union +{ + char __size[4]; + int __align; +} pthread_barrierattr_t; +# 228 "/usr/include/sys/types.h" 2 3 4 + + +} +# 515 "/usr/include/stdlib.h" 2 3 4 + + + + + + +extern long int random (void) noexcept (true); + + +extern void srandom (unsigned int __seed) noexcept (true); + + + + + +extern char *initstate (unsigned int __seed, char *__statebuf, + size_t __statelen) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern char *setstate (char *__statebuf) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + + +struct random_data + { + int32_t *fptr; + int32_t *rptr; + int32_t *state; + int rand_type; + int rand_deg; + int rand_sep; + int32_t *end_ptr; + }; + +extern int random_r (struct random_data *__restrict __buf, + int32_t *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern int srandom_r (unsigned int __seed, struct random_data *__buf) + noexcept (true) __attribute__ ((__nonnull__ (2))); + +extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, + size_t __statelen, + struct random_data *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (2, 4))); + +extern int setstate_r (char *__restrict __statebuf, + struct random_data *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern int rand (void) noexcept (true); + +extern void srand (unsigned int __seed) noexcept (true); + + + +extern int rand_r (unsigned int *__seed) noexcept (true); + + + + + + + +extern double drand48 (void) noexcept (true); +extern double erand48 (unsigned short int __xsubi[3]) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int lrand48 (void) noexcept (true); +extern long int nrand48 (unsigned short int __xsubi[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int mrand48 (void) noexcept (true); +extern long int jrand48 (unsigned short int __xsubi[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void srand48 (long int __seedval) noexcept (true); +extern unsigned short int *seed48 (unsigned short int __seed16v[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); +extern void lcong48 (unsigned short int __param[7]) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +struct drand48_data + { + unsigned short int __x[3]; + unsigned short int __old_x[3]; + unsigned short int __c; + unsigned short int __init; + __extension__ unsigned long long int __a; + + }; + + +extern int drand48_r (struct drand48_data *__restrict __buffer, + double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int erand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int lrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int nrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int mrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int jrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int srand48_r (long int __seedval, struct drand48_data *__buffer) + noexcept (true) __attribute__ ((__nonnull__ (2))); + +extern int seed48_r (unsigned short int __seed16v[3], + struct drand48_data *__buffer) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern int lcong48_r (unsigned short int __param[7], + struct drand48_data *__buffer) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern __uint32_t arc4random (void) + noexcept (true) ; + + +extern void arc4random_buf (void *__buf, size_t __size) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern __uint32_t arc4random_uniform (__uint32_t __upper_bound) + noexcept (true) ; + + + + +extern void *malloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) + __attribute__ ((__alloc_size__ (1))) ; + +extern void *calloc (size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) ; + + + + + + +extern void *realloc (void *__ptr, size_t __size) + noexcept (true) __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2))); + + +extern void free (void *__ptr) noexcept (true); + + + + + + + +extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__warn_unused_result__)) + __attribute__ ((__alloc_size__ (2, 3))) + __attribute__ ((__malloc__ (__builtin_free, 1))); + + +extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__malloc__ (reallocarray, 1))); + + + +# 1 "/usr/include/alloca.h" 1 3 4 +# 24 "/usr/include/alloca.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 25 "/usr/include/alloca.h" 2 3 4 + +extern "C" { + + + + + +extern void *alloca (size_t __size) noexcept (true); + + + + + +} +# 707 "/usr/include/stdlib.h" 2 3 4 + + + + + +extern void *valloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) + __attribute__ ((__alloc_size__ (1))) ; + + + + +extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) + noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + +extern void *aligned_alloc (size_t __alignment, size_t __size) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_align__ (1))) + __attribute__ ((__alloc_size__ (2))) ; + + + +extern void abort (void) noexcept (true) __attribute__ ((__noreturn__)) __attribute__ ((__cold__)); + + + +extern int atexit (void (*__func) (void)) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern "C++" int at_quick_exit (void (*__func) (void)) + noexcept (true) __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1))); +# 749 "/usr/include/stdlib.h" 3 4 +extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern void exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + + +extern void quick_exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + + +extern void _Exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + +extern char *getenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + +extern char *secure_getenv (const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + + + +extern int putenv (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern int setenv (const char *__name, const char *__value, int __replace) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + +extern int unsetenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern int clearenv (void) noexcept (true); +# 814 "/usr/include/stdlib.h" 3 4 +extern char *mktemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))); +# 827 "/usr/include/stdlib.h" 3 4 +extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 837 "/usr/include/stdlib.h" 3 4 +extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 849 "/usr/include/stdlib.h" 3 4 +extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; +# 859 "/usr/include/stdlib.h" 3 4 +extern int mkstemps64 (char *__template, int __suffixlen) + __attribute__ ((__nonnull__ (1))) ; +# 870 "/usr/include/stdlib.h" 3 4 +extern char *mkdtemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))) ; +# 881 "/usr/include/stdlib.h" 3 4 +extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 891 "/usr/include/stdlib.h" 3 4 +extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 901 "/usr/include/stdlib.h" 3 4 +extern int mkostemps (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 913 "/usr/include/stdlib.h" 3 4 +extern int mkostemps64 (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 923 "/usr/include/stdlib.h" 3 4 +extern int system (const char *__command) ; + + + + + +extern char *canonicalize_file_name (const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__malloc__)) + __attribute__ ((__malloc__ (__builtin_free, 1))) ; +# 940 "/usr/include/stdlib.h" 3 4 +extern char *realpath (const char *__restrict __name, + char *__restrict __resolved) noexcept (true) ; + + + + + + +typedef int (*__compar_fn_t) (const void *, const void *); + + +typedef __compar_fn_t comparison_fn_t; + + + +typedef int (*__compar_d_fn_t) (const void *, const void *, void *); + + + + +extern void *bsearch (const void *__key, const void *__base, + size_t __nmemb, size_t __size, __compar_fn_t __compar) + __attribute__ ((__nonnull__ (1, 2, 5))) ; + + + + + + + +extern void qsort (void *__base, size_t __nmemb, size_t __size, + __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4))); + +extern void qsort_r (void *__base, size_t __nmemb, size_t __size, + __compar_d_fn_t __compar, void *__arg) + __attribute__ ((__nonnull__ (1, 4))); + + + + +extern int abs (int __x) noexcept (true) __attribute__ ((__const__)) ; +extern long int labs (long int __x) noexcept (true) __attribute__ ((__const__)) ; + + +__extension__ extern long long int llabs (long long int __x) + noexcept (true) __attribute__ ((__const__)) ; + + + + + + +extern div_t div (int __numer, int __denom) + noexcept (true) __attribute__ ((__const__)) ; +extern ldiv_t ldiv (long int __numer, long int __denom) + noexcept (true) __attribute__ ((__const__)) ; + + +__extension__ extern lldiv_t lldiv (long long int __numer, + long long int __denom) + noexcept (true) __attribute__ ((__const__)) ; +# 1012 "/usr/include/stdlib.h" 3 4 +extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *gcvt (double __value, int __ndigit, char *__buf) + noexcept (true) __attribute__ ((__nonnull__ (3))) ; + + + + +extern char *qecvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qfcvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qgcvt (long double __value, int __ndigit, char *__buf) + noexcept (true) __attribute__ ((__nonnull__ (3))) ; + + + + +extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); +extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); + +extern int qecvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); +extern int qfcvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); + + + + + +extern int mblen (const char *__s, size_t __n) noexcept (true); + + +extern int mbtowc (wchar_t *__restrict __pwc, + const char *__restrict __s, size_t __n) noexcept (true); + + +extern int wctomb (char *__s, wchar_t __wchar) noexcept (true); + + + +extern size_t mbstowcs (wchar_t *__restrict __pwcs, + const char *__restrict __s, size_t __n) noexcept (true) + __attribute__ ((__access__ (__read_only__, 2))); + +extern size_t wcstombs (char *__restrict __s, + const wchar_t *__restrict __pwcs, size_t __n) + noexcept (true) + __attribute__ ((__access__ (__write_only__, 1, 3))) + __attribute__ ((__access__ (__read_only__, 2))); + + + + + + +extern int rpmatch (const char *__response) noexcept (true) __attribute__ ((__nonnull__ (1))) ; +# 1099 "/usr/include/stdlib.h" 3 4 +extern int getsubopt (char **__restrict __optionp, + char *const *__restrict __tokens, + char **__restrict __valuep) + noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))) ; + + + + + + + +extern int posix_openpt (int __oflag) ; + + + + + + + +extern int grantpt (int __fd) noexcept (true); + + + +extern int unlockpt (int __fd) noexcept (true); + + + + +extern char *ptsname (int __fd) noexcept (true) ; + + + + + + +extern int ptsname_r (int __fd, char *__buf, size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3))); + + +extern int getpt (void); + + + + + + +extern int getloadavg (double __loadavg[], int __nelem) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 1155 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/stdlib-float.h" 1 3 4 +# 1156 "/usr/include/stdlib.h" 2 3 4 +# 1167 "/usr/include/stdlib.h" 3 4 +} +# 80 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 2 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 +# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::abs; + + + inline long + abs(long __i) { return __builtin_labs(__i); } + + + + inline long long + abs(long long __x) { return __builtin_llabs (__x); } +# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 + inline constexpr double + abs(double __x) + { return __builtin_fabs(__x); } + + inline constexpr float + abs(float __x) + { return __builtin_fabsf(__x); } + + inline constexpr long double + abs(long double __x) + { return __builtin_fabsl(__x); } + + + + __extension__ inline constexpr __int128 + abs(__int128 __x) { return __x >= 0 ? __x : -__x; } +# 135 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 + __extension__ inline constexpr + __float128 + abs(__float128 __x) + { + + + + return __builtin_fabsf128(__x); + + + + + } + + + +} +} +# 82 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 2 3 +# 125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::div_t; + using ::ldiv_t; + + using ::abort; + + using ::aligned_alloc; + + using ::atexit; + + + using ::at_quick_exit; + + + using ::atof; + using ::atoi; + using ::atol; + using ::bsearch; + using ::calloc; + using ::div; + using ::exit; + using ::free; + using ::getenv; + using ::labs; + using ::ldiv; + using ::malloc; + + using ::mblen; + using ::mbstowcs; + using ::mbtowc; + + using ::qsort; + + + using ::quick_exit; + + + using ::rand; + using ::realloc; + using ::srand; + using ::strtod; + using ::strtol; + using ::strtoul; + using ::system; + + using ::wcstombs; + using ::wctomb; + + + + inline ldiv_t + div(long __i, long __j) noexcept { return ldiv(__i, __j); } + + + + +} +# 199 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + using ::lldiv_t; + + + + + + using ::_Exit; + + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wlong-long" + using ::llabs; + + inline lldiv_t + div(long long __n, long long __d) + { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; } + + using ::lldiv; +#pragma GCC diagnostic pop +# 234 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 + using ::atoll; + using ::strtoll; + using ::strtoull; + + using ::strtof; + using ::strtold; + + +} + +namespace std +{ + + using ::__gnu_cxx::lldiv_t; + + using ::__gnu_cxx::_Exit; + + using ::__gnu_cxx::llabs; + using ::__gnu_cxx::div; + using ::__gnu_cxx::lldiv; + + using ::__gnu_cxx::atoll; + using ::__gnu_cxx::strtof; + using ::__gnu_cxx::strtoll; + using ::__gnu_cxx::strtoull; + using ::__gnu_cxx::strtold; +} +# 278 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +} +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h" 2 3 + +using std::abort; +using std::atexit; +using std::exit; + + + using std::at_quick_exit; + + + using std::quick_exit; + + + using std::_Exit; + + + + +using std::div_t; +using std::ldiv_t; + +using std::abs; +using std::atof; +using std::atoi; +using std::atol; +using std::bsearch; +using std::calloc; +using std::div; +using std::free; +using std::getenv; +using std::labs; +using std::ldiv; +using std::malloc; + +using std::mblen; +using std::mbstowcs; +using std::mbtowc; + +using std::qsort; +using std::rand; +using std::realloc; +using std::srand; +using std::strtod; +using std::strtol; +using std::strtoul; +using std::system; + +using std::wcstombs; +using std::wctomb; +# 55 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" 2 +# 72 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" + +# 72 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern "C" { + + +struct cudaFuncAttributes; +# 112 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +inline __attribute__((device)) cudaError_t __cudaCDP2Malloc(void **p, size_t s) +{ + return cudaErrorUnknown; +} + +inline __attribute__((device)) cudaError_t __cudaCDP2FuncGetAttributes(struct cudaFuncAttributes *p, const void *c) +{ + return cudaErrorUnknown; +} + +inline __attribute__((device)) cudaError_t __cudaCDP2DeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device) +{ + return cudaErrorUnknown; +} + +inline __attribute__((device)) cudaError_t __cudaCDP2GetDevice(int *device) +{ + return cudaErrorUnknown; +} + +inline __attribute__((device)) cudaError_t __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func, int blockSize, size_t dynamicSmemSize) +{ + return cudaErrorUnknown; +} + +inline __attribute__((device)) cudaError_t __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *func, int blockSize, size_t dynamicSmemSize, unsigned int flags) +{ + return cudaErrorUnknown; +} + + + + + +} +# 173 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 174 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" 2 +# 184 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern "C" +{ + + + + + +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaDeviceSynchronizeDeprecationAvoidance(void); +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2DeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2DeviceGetLimit(size_t *pValue, enum cudaLimit limit); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2DeviceGetCacheConfig(enum cudaFuncCache *pCacheConfig); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2DeviceGetSharedMemConfig(enum cudaSharedMemConfig *pConfig); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2GetLastError(void); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2PeekAtLastError(void); +extern __attribute__((device)) __attribute__((cudart_builtin)) const char* __cudaCDP2GetErrorString(cudaError_t error); +extern __attribute__((device)) __attribute__((cudart_builtin)) const char* __cudaCDP2GetErrorName(cudaError_t error); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2GetDeviceCount(int *count); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2GetDevice(int *device); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2StreamCreateWithFlags(cudaStream_t *pStream, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2StreamDestroy(cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2StreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2StreamWaitEvent_ptsz(cudaStream_t stream, cudaEvent_t event, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventCreateWithFlags(cudaEvent_t *event, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventRecord(cudaEvent_t event, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventRecord_ptsz(cudaEvent_t event, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventRecordWithFlags_ptsz(cudaEvent_t event, cudaStream_t stream, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventDestroy(cudaEvent_t event); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2FuncGetAttributes(struct cudaFuncAttributes *attr, const void *func); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Free(void *devPtr); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Malloc(void **devPtr, size_t size); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2MemcpyAsync(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2MemcpyAsync_ptsz(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memcpy2DAsync(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memcpy2DAsync_ptsz(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memcpy3DAsync(const struct cudaMemcpy3DParms *p, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memcpy3DAsync_ptsz(const struct cudaMemcpy3DParms *p, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2MemsetAsync(void *devPtr, int value, size_t count, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2MemsetAsync_ptsz(void *devPtr, int value, size_t count, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memset2DAsync(void *devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memset2DAsync_ptsz(void *devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memset3DAsync(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memset3DAsync_ptsz(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2RuntimeGetVersion(int *runtimeVersion); +extern __attribute__((device)) __attribute__((cudart_builtin)) void * __cudaCDP2GetParameterBuffer(size_t alignment, size_t size); +extern __attribute__((device)) __attribute__((cudart_builtin)) void * __cudaCDP2GetParameterBufferV2(void *func, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2LaunchDevice_ptsz(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2LaunchDeviceV2_ptsz(void *parameterBuffer, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2LaunchDevice(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2LaunchDeviceV2(void *parameterBuffer, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func, int blockSize, size_t dynamicSmemSize); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *func, int blockSize, size_t dynamicSmemSize, unsigned int flags); + + +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream); +# 311 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static inline __attribute__((device)) __attribute__((cudart_builtin)) cudaGraphExec_t cudaGetCurrentGraphExec(void) +{ + unsigned long long current_graph_exec; + asm ("mov.u64 %0, %%current_graph_exec;" : "=l"(current_graph_exec)); + return (cudaGraphExec_t)current_graph_exec; +} +# 346 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetParam(cudaGraphDeviceNode_t node, size_t offset, const void *value , size_t size); +# 374 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetEnabled(cudaGraphDeviceNode_t node, bool enable); +# 401 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetGridDim(cudaGraphDeviceNode_t node, dim3 gridDim); +# 430 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeUpdatesApply(const cudaGraphKernelNodeUpdate *updates, size_t updateCount); +# 448 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static inline __attribute__((device)) __attribute__((cudart_builtin)) void cudaTriggerProgrammaticLaunchCompletion(void) +{ + asm volatile("griddepcontrol.launch_dependents;":::); +} +# 464 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static inline __attribute__((device)) __attribute__((cudart_builtin)) void cudaGridDependencySynchronize(void) +{ + asm volatile("griddepcontrol.wait;":::"memory"); +} +# 479 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) void cudaGraphSetConditional(cudaGraphConditionalHandle handle, unsigned int value); + + +extern __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long cudaCGGetIntrinsicHandle(enum cudaCGScope scope); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaCGSynchronize(unsigned long long handle, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaCGSynchronizeGrid(unsigned long long handle, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaCGGetSize(unsigned int *numThreads, unsigned int *numGrids, unsigned long long handle); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaCGGetRank(unsigned int *threadRank, unsigned int *gridRank, unsigned long long handle); +# 498 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device) +{ + return __cudaCDP2DeviceGetAttribute(value, attr, device); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetLimit(size_t *pValue, enum cudaLimit limit) +{ + return __cudaCDP2DeviceGetLimit(pValue, limit); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetCacheConfig(enum cudaFuncCache *pCacheConfig) +{ + return __cudaCDP2DeviceGetCacheConfig(pCacheConfig); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetSharedMemConfig(enum cudaSharedMemConfig *pConfig) +{ + return __cudaCDP2DeviceGetSharedMemConfig(pConfig); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGetLastError(void) +{ + return __cudaCDP2GetLastError(); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaPeekAtLastError(void) +{ + return __cudaCDP2PeekAtLastError(); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) const char* cudaGetErrorString(cudaError_t error) +{ + return __cudaCDP2GetErrorString(error); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) const char* cudaGetErrorName(cudaError_t error) +{ + return __cudaCDP2GetErrorName(error); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceCount(int *count) +{ + return __cudaCDP2GetDeviceCount(count); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGetDevice(int *device) +{ + return __cudaCDP2GetDevice(device); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithFlags(cudaStream_t *pStream, unsigned int flags) +{ + return __cudaCDP2StreamCreateWithFlags(pStream, flags); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaStreamDestroy(cudaStream_t stream) +{ + return __cudaCDP2StreamDestroy(stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) +{ + return __cudaCDP2StreamWaitEvent(stream, event, flags); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaStreamWaitEvent_ptsz(cudaStream_t stream, cudaEvent_t event, unsigned int flags) +{ + return __cudaCDP2StreamWaitEvent_ptsz(stream, event, flags); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaEventCreateWithFlags(cudaEvent_t *event, unsigned int flags) +{ + return __cudaCDP2EventCreateWithFlags(event, flags); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream) +{ + return __cudaCDP2EventRecord(event, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecord_ptsz(cudaEvent_t event, cudaStream_t stream) +{ + return __cudaCDP2EventRecord_ptsz(event, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) +{ + return __cudaCDP2EventRecordWithFlags(event, stream, flags); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecordWithFlags_ptsz(cudaEvent_t event, cudaStream_t stream, unsigned int flags) +{ + return __cudaCDP2EventRecordWithFlags_ptsz(event, stream, flags); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaEventDestroy(cudaEvent_t event) +{ + return __cudaCDP2EventDestroy(event); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetAttributes(struct cudaFuncAttributes *attr, const void *func) +{ + return __cudaCDP2FuncGetAttributes(attr, func); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaFree(void *devPtr) +{ + return __cudaCDP2Free(devPtr); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMalloc(void **devPtr, size_t size) +{ + return __cudaCDP2Malloc(devPtr, size); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpyAsync(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream) +{ + return __cudaCDP2MemcpyAsync(dst, src, count, kind, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpyAsync_ptsz(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream) +{ + return __cudaCDP2MemcpyAsync_ptsz(dst, src, count, kind, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy2DAsync(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream) +{ + return __cudaCDP2Memcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy2DAsync_ptsz(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream) +{ + return __cudaCDP2Memcpy2DAsync_ptsz(dst, dpitch, src, spitch, width, height, kind, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy3DAsync(const struct cudaMemcpy3DParms *p, cudaStream_t stream) +{ + return __cudaCDP2Memcpy3DAsync(p, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy3DAsync_ptsz(const struct cudaMemcpy3DParms *p, cudaStream_t stream) +{ + return __cudaCDP2Memcpy3DAsync_ptsz(p, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemsetAsync(void *devPtr, int value, size_t count, cudaStream_t stream) +{ + return __cudaCDP2MemsetAsync(devPtr, value, count, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemsetAsync_ptsz(void *devPtr, int value, size_t count, cudaStream_t stream) +{ + return __cudaCDP2MemsetAsync_ptsz(devPtr, value, count, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemset2DAsync(void *devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) +{ + return __cudaCDP2Memset2DAsync(devPtr, pitch, value, width, height, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemset2DAsync_ptsz(void *devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) +{ + return __cudaCDP2Memset2DAsync_ptsz(devPtr, pitch, value, width, height, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemset3DAsync(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream) +{ + return __cudaCDP2Memset3DAsync(pitchedDevPtr, value, extent, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemset3DAsync_ptsz(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream) +{ + return __cudaCDP2Memset3DAsync_ptsz(pitchedDevPtr, value, extent, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaRuntimeGetVersion(int *runtimeVersion) +{ + return __cudaCDP2RuntimeGetVersion(runtimeVersion); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func, int blockSize, size_t dynamicSmemSize) +{ + return __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSmemSize); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *func, int blockSize, size_t dynamicSmemSize, unsigned int flags) +{ + return __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSmemSize, flags); +} +# 714 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) void * cudaGetParameterBuffer(size_t alignment, size_t size) +{ + return __cudaCDP2GetParameterBuffer(alignment, size); +} + + + + + + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) void * cudaGetParameterBufferV2(void *func, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize) +{ + return __cudaCDP2GetParameterBufferV2(func, gridDimension, blockDimension, sharedMemSize); +} + + + + + + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDevice_ptsz(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream) +{ + return __cudaCDP2LaunchDevice_ptsz(func, parameterBuffer, gridDimension, blockDimension, sharedMemSize, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDeviceV2_ptsz(void *parameterBuffer, cudaStream_t stream) +{ + return __cudaCDP2LaunchDeviceV2_ptsz(parameterBuffer, stream); +} +# 800 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" + static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDevice(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream) + { + return __cudaCDP2LaunchDevice(func, parameterBuffer, gridDimension, blockDimension, sharedMemSize, stream); + } + + static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDeviceV2(void *parameterBuffer, cudaStream_t stream) + { + return __cudaCDP2LaunchDeviceV2(parameterBuffer, stream); + } +# 862 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +} + + + + + +template static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMalloc(T **devPtr, size_t size); +template static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetAttributes(struct cudaFuncAttributes *attr, T *entry); +template static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, T func, int blockSize, size_t dynamicSmemSize); +template static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, T func, int blockSize, size_t dynamicSmemSize, unsigned int flags); +# 901 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +template +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetParam(cudaGraphDeviceNode_t node, size_t offset, const T &value) +{ + return cudaGraphKernelNodeSetParam(node, offset, &value, sizeof(T)); +} +# 154 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 2 +# 287 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern "C" { +# 334 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceReset(void); +# 356 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceSynchronize(void); +# 442 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetLimit(enum cudaLimit limit, size_t value); +# 478 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetLimit(size_t *pValue, enum cudaLimit limit); +# 501 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t *maxWidthInElements, const struct cudaChannelFormatDesc *fmtDesc, int device); +# 535 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetCacheConfig(enum cudaFuncCache *pCacheConfig); +# 572 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority); +# 616 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetCacheConfig(enum cudaFuncCache cacheConfig); +# 643 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetByPCIBusId(int *device, const char *pciBusId); +# 673 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetPCIBusId(char *pciBusId, int len, int device); +# 724 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t *handle, cudaEvent_t event); +# 768 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcOpenEventHandle(cudaEvent_t *event, cudaIpcEventHandle_t handle); +# 813 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t *handle, void *devPtr); +# 880 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcOpenMemHandle(void **devPtr, cudaIpcMemHandle_t handle, unsigned int flags); +# 919 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcCloseMemHandle(void *devPtr); +# 951 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(enum cudaFlushGPUDirectRDMAWritesTarget target, enum cudaFlushGPUDirectRDMAWritesScope scope); +# 989 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback); +# 1012 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback); +# 1059 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetSharedMemConfig(enum cudaSharedMemConfig *pConfig); +# 1105 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaDeviceSetSharedMemConfig(enum cudaSharedMemConfig config); +# 1146 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadExit(void); +# 1172 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSynchronize(void); +# 1221 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSetLimit(enum cudaLimit limit, size_t value); +# 1254 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadGetLimit(size_t *pValue, enum cudaLimit limit); +# 1290 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadGetCacheConfig(enum cudaFuncCache *pCacheConfig); +# 1337 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSetCacheConfig(enum cudaFuncCache cacheConfig); +# 1402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetLastError(void); +# 1453 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaPeekAtLastError(void); +# 1469 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) const char* cudaGetErrorName(cudaError_t error); +# 1485 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) const char* cudaGetErrorString(cudaError_t error); +# 1514 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceCount(int *count); +# 1818 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceProperties_v2(struct cudaDeviceProp *prop, int device); +# 2024 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device); +# 2042 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t *memPool, int device); +# 2066 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool); +# 2086 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetMemPool(cudaMemPool_t *memPool, int device); +# 2148 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetNvSciSyncAttributes(void *nvSciSyncAttrList, int device, int flags); +# 2188 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetP2PAttribute(int *value, enum cudaDeviceP2PAttr attr, int srcDevice, int dstDevice); +# 2210 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaChooseDevice(int *device, const struct cudaDeviceProp *prop); +# 2239 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags); +# 2285 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetDevice(int device); +# 2307 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDevice(int *device); +# 2338 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetValidDevices(int *device_arr, int len); +# 2408 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetDeviceFlags( unsigned int flags ); +# 2453 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetDeviceFlags( unsigned int *flags ); +# 2497 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamCreate(cudaStream_t *pStream); +# 2533 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithFlags(cudaStream_t *pStream, unsigned int flags); +# 2585 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithPriority(cudaStream_t *pStream, unsigned int flags, int priority); +# 2613 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int *priority); +# 2639 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int *flags); +# 2676 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetId(cudaStream_t hStream, unsigned long long *streamId); +# 2702 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetDevice(cudaStream_t hStream, int *device); +# 2717 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaCtxResetPersistingL2Cache(void); +# 2737 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src); +# 2758 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetAttribute( + cudaStream_t hStream, cudaLaunchAttributeID attr, + cudaLaunchAttributeValue *value_out); +# 2782 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamSetAttribute( + cudaStream_t hStream, cudaLaunchAttributeID attr, + const cudaLaunchAttributeValue *value); +# 2816 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamDestroy(cudaStream_t stream); +# 2847 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags = 0); + + + + + + + +typedef void ( *cudaStreamCallback_t)(cudaStream_t stream, cudaError_t status, void *userData); +# 2922 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamAddCallback(cudaStream_t stream, + cudaStreamCallback_t callback, void *userData, unsigned int flags); +# 2946 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamSynchronize(cudaStream_t stream); +# 2971 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamQuery(cudaStream_t stream); +# 3055 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamAttachMemAsync(cudaStream_t stream, void *devPtr, size_t length = 0, unsigned int flags = 0x04); +# 3094 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamBeginCapture(cudaStream_t stream, enum cudaStreamCaptureMode mode); +# 3135 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t *dependencies, const cudaGraphEdgeData *dependencyData, size_t numDependencies, enum cudaStreamCaptureMode mode); +# 3186 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaThreadExchangeStreamCaptureMode(enum cudaStreamCaptureMode *mode); +# 3215 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t *pGraph); +# 3253 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamIsCapturing(cudaStream_t stream, enum cudaStreamCaptureStatus *pCaptureStatus); +# 3303 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamGetCaptureInfo_v2(cudaStream_t stream, enum cudaStreamCaptureStatus *captureStatus_out, unsigned long long *id_out = 0, cudaGraph_t *graph_out = 0, const cudaGraphNode_t **dependencies_out = 0, size_t *numDependencies_out = 0); +# 3362 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamGetCaptureInfo_v3(cudaStream_t stream, + enum cudaStreamCaptureStatus *captureStatus_out, unsigned long long *id_out = 0, + cudaGraph_t *graph_out = 0, const cudaGraphNode_t **dependencies_out = 0, + const cudaGraphEdgeData **edgeData_out = 0, size_t *numDependencies_out = 0); +# 3402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t *dependencies, size_t numDependencies, unsigned int flags = 0); +# 3437 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamUpdateCaptureDependencies_v2(cudaStream_t stream, cudaGraphNode_t *dependencies, const cudaGraphEdgeData *dependencyData, size_t numDependencies, unsigned int flags = 0); +# 3474 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventCreate(cudaEvent_t *event); +# 3511 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventCreateWithFlags(cudaEvent_t *event, unsigned int flags); +# 3552 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream = 0); +# 3600 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream = 0, unsigned int flags = 0); +# 3633 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventQuery(cudaEvent_t event); +# 3664 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventSynchronize(cudaEvent_t event); +# 3694 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventDestroy(cudaEvent_t event); +# 3739 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventElapsedTime(float *ms, cudaEvent_t start, cudaEvent_t end); +# 3787 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventElapsedTime_v2(float *ms, cudaEvent_t start, cudaEvent_t end); +# 3968 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaImportExternalMemory(cudaExternalMemory_t *extMem_out, const struct cudaExternalMemoryHandleDesc *memHandleDesc); +# 4023 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaExternalMemoryGetMappedBuffer(void **devPtr, cudaExternalMemory_t extMem, const struct cudaExternalMemoryBufferDesc *bufferDesc); +# 4083 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t *mipmap, cudaExternalMemory_t extMem, const struct cudaExternalMemoryMipmappedArrayDesc *mipmapDesc); +# 4107 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem); +# 4261 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t *extSem_out, const struct cudaExternalSemaphoreHandleDesc *semHandleDesc); +# 4344 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSignalExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t *extSemArray, const struct cudaExternalSemaphoreSignalParams *paramsArray, unsigned int numExtSems, cudaStream_t stream = 0); +# 4420 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaWaitExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t *extSemArray, const struct cudaExternalSemaphoreWaitParams *paramsArray, unsigned int numExtSems, cudaStream_t stream = 0); +# 4443 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem); +# 4511 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchKernel(const void *func, dim3 gridDim, dim3 blockDim, void **args, size_t sharedMem, cudaStream_t stream); +# 4574 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchKernelExC(const cudaLaunchConfig_t *config, const void *func, void **args); +# 4632 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchCooperativeKernel(const void *func, dim3 gridDim, dim3 blockDim, void **args, size_t sharedMem, cudaStream_t stream); +# 4733 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaLaunchCooperativeKernelMultiDevice(struct cudaLaunchParams *launchParamsList, unsigned int numDevices, unsigned int flags = 0); +# 4783 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFuncSetCacheConfig(const void *func, enum cudaFuncCache cacheConfig); +# 4818 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetAttributes(struct cudaFuncAttributes *attr, const void *func); +# 4877 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncSetAttribute(const void *func, enum cudaFuncAttribute attr, int value); +# 4903 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetName(const char **name, const void *func); +# 4926 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetParamInfo(const void *func, size_t paramIndex, size_t *paramOffset, size_t *paramSize); +# 4950 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaSetDoubleForDevice(double *d); +# 4974 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaSetDoubleForHost(double *d); +# 5040 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void *userData); +# 5114 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaFuncSetSharedMemConfig(const void *func, enum cudaSharedMemConfig config); +# 5171 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func, int blockSize, size_t dynamicSMemSize); +# 5201 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t *dynamicSmemSize, const void *func, int numBlocks, int blockSize); +# 5247 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *func, int blockSize, size_t dynamicSMemSize, unsigned int flags); +# 5283 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxPotentialClusterSize(int *clusterSize, const void *func, const cudaLaunchConfig_t *launchConfig); +# 5323 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveClusters(int *numClusters, const void *func, const cudaLaunchConfig_t *launchConfig); +# 5443 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMallocManaged(void **devPtr, size_t size, unsigned int flags = 0x01); +# 5476 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMalloc(void **devPtr, size_t size); +# 5513 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocHost(void **ptr, size_t size); +# 5556 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocPitch(void **devPtr, size_t *pitch, size_t width, size_t height); +# 5608 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocArray(cudaArray_t *array, const struct cudaChannelFormatDesc *desc, size_t width, size_t height = 0, unsigned int flags = 0); +# 5647 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFree(void *devPtr); +# 5670 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeHost(void *ptr); +# 5693 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeArray(cudaArray_t array); +# 5716 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray); +# 5782 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostAlloc(void **pHost, size_t size, unsigned int flags); +# 5879 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostRegister(void *ptr, size_t size, unsigned int flags); +# 5902 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostUnregister(void *ptr); +# 5947 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostGetDevicePointer(void **pDevice, void *pHost, unsigned int flags); +# 5969 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostGetFlags(unsigned int *pFlags, void *pHost); +# 6008 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMalloc3D(struct cudaPitchedPtr* pitchedDevPtr, struct cudaExtent extent); +# 6153 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMalloc3DArray(cudaArray_t *array, const struct cudaChannelFormatDesc* desc, struct cudaExtent extent, unsigned int flags = 0); +# 6298 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocMipmappedArray(cudaMipmappedArray_t *mipmappedArray, const struct cudaChannelFormatDesc* desc, struct cudaExtent extent, unsigned int numLevels, unsigned int flags = 0); +# 6331 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t *levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level); +# 6436 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3D(const struct cudaMemcpy3DParms *p); +# 6468 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3DPeer(const struct cudaMemcpy3DPeerParms *p); +# 6586 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy3DAsync(const struct cudaMemcpy3DParms *p, cudaStream_t stream = 0); +# 6613 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3DPeerAsync(const struct cudaMemcpy3DPeerParms *p, cudaStream_t stream = 0); +# 6647 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemGetInfo(size_t *free, size_t *total); +# 6673 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetInfo(struct cudaChannelFormatDesc *desc, struct cudaExtent *extent, unsigned int *flags, cudaArray_t array); +# 6702 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetPlane(cudaArray_t *pPlaneArray, cudaArray_t hArray, unsigned int planeIdx); +# 6725 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetMemoryRequirements(struct cudaArrayMemoryRequirements *memoryRequirements, cudaArray_t array, int device); +# 6749 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMipmappedArrayGetMemoryRequirements(struct cudaArrayMemoryRequirements *memoryRequirements, cudaMipmappedArray_t mipmap, int device); +# 6777 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaArrayGetSparseProperties(struct cudaArraySparseProperties *sparseProperties, cudaArray_t array); +# 6807 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaMipmappedArrayGetSparseProperties(struct cudaArraySparseProperties *sparseProperties, cudaMipmappedArray_t mipmap); +# 6852 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind); +# 6887 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyPeer(void *dst, int dstDevice, const void *src, int srcDevice, size_t count); +# 6936 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2D(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind); +# 6986 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind); +# 7036 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DFromArray(void *dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind); +# 7083 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, enum cudaMemcpyKind kind = cudaMemcpyDeviceToDevice); +# 7126 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyToSymbol(const void *symbol, const void *src, size_t count, size_t offset = 0, enum cudaMemcpyKind kind = cudaMemcpyHostToDevice); +# 7170 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyFromSymbol(void *dst, const void *symbol, size_t count, size_t offset = 0, enum cudaMemcpyKind kind = cudaMemcpyDeviceToHost); +# 7227 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpyAsync(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7262 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyPeerAsync(void *dst, int dstDevice, const void *src, int srcDevice, size_t count, cudaStream_t stream = 0); +# 7334 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyBatchAsync(void **dsts, void **srcs, size_t *sizes, size_t count, struct cudaMemcpyAttributes *attrs, size_t *attrsIdxs, size_t numAttrs, size_t *failIdx, cudaStream_t stream); +# 7402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3DBatchAsync(size_t numOps, struct cudaMemcpy3DBatchOp *opList, size_t *failIdx, unsigned long long flags, cudaStream_t stream); +# 7465 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy2DAsync(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7523 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7580 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DFromArrayAsync(void *dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7631 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyToSymbolAsync(const void *symbol, const void *src, size_t count, size_t offset, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7682 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyFromSymbolAsync(void *dst, const void *symbol, size_t count, size_t offset, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7711 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset(void *devPtr, int value, size_t count); +# 7745 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset2D(void *devPtr, size_t pitch, int value, size_t width, size_t height); +# 7791 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset3D(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent); +# 7827 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemsetAsync(void *devPtr, int value, size_t count, cudaStream_t stream = 0); +# 7868 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemset2DAsync(void *devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream = 0); +# 7921 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemset3DAsync(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream = 0); +# 7949 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSymbolAddress(void **devPtr, const void *symbol); +# 7976 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSymbolSize(size_t *size, const void *symbol); +# 8048 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPrefetchAsync(const void *devPtr, size_t count, int dstDevice, cudaStream_t stream = 0); +# 8129 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPrefetchAsync_v2(const void *devPtr, size_t count, struct cudaMemLocation location, unsigned int flags, cudaStream_t stream = 0); +# 8243 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemAdvise(const void *devPtr, size_t count, enum cudaMemoryAdvise advice, int device); +# 8366 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemAdvise_v2(const void *devPtr, size_t count, enum cudaMemoryAdvise advice, struct cudaMemLocation location); +# 8448 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemRangeGetAttribute(void *data, size_t dataSize, enum cudaMemRangeAttribute attribute, const void *devPtr, size_t count); +# 8491 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemRangeGetAttributes(void **data, size_t *dataSizes, enum cudaMemRangeAttribute *attributes, size_t numAttributes, const void *devPtr, size_t count); +# 8551 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t count, enum cudaMemcpyKind kind); +# 8593 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyFromArray(void *dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, enum cudaMemcpyKind kind); +# 8636 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, enum cudaMemcpyKind kind = cudaMemcpyDeviceToDevice); +# 8687 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 8737 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyFromArrayAsync(void *dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 8806 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocAsync(void **devPtr, size_t size, cudaStream_t hStream); +# 8832 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeAsync(void *devPtr, cudaStream_t hStream); +# 8857 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep); +# 8901 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, enum cudaMemPoolAttr attr, void *value ); +# 8949 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, enum cudaMemPoolAttr attr, void *value ); +# 8964 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const struct cudaMemAccessDesc *descList, size_t count); +# 8977 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolGetAccess(enum cudaMemAccessFlags *flags, cudaMemPool_t memPool, struct cudaMemLocation *location); +# 9021 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolCreate(cudaMemPool_t *memPool, const struct cudaMemPoolProps *poolProps); +# 9043 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool); +# 9079 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocFromPoolAsync(void **ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream); +# 9104 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolExportToShareableHandle( + void *shareableHandle, + cudaMemPool_t memPool, + enum cudaMemAllocationHandleType handleType, + unsigned int flags); +# 9131 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolImportFromShareableHandle( + cudaMemPool_t *memPool, + void *shareableHandle, + enum cudaMemAllocationHandleType handleType, + unsigned int flags); +# 9154 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolExportPointer(struct cudaMemPoolPtrExportData *exportData, void *ptr); +# 9183 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolImportPointer(void **ptr, cudaMemPool_t memPool, struct cudaMemPoolPtrExportData *exportData); +# 9336 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaPointerGetAttributes(struct cudaPointerAttributes *attributes, const void *ptr); +# 9377 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceCanAccessPeer(int *canAccessPeer, int device, int peerDevice); +# 9419 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags); +# 9441 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceDisablePeerAccess(int peerDevice); +# 9505 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource); +# 9540 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags); +# 9579 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t *resources, cudaStream_t stream = 0); +# 9614 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t *resources, cudaStream_t stream = 0); +# 9646 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceGetMappedPointer(void **devPtr, size_t *size, cudaGraphicsResource_t resource); +# 9684 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t *array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel); +# 9713 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t *mipmappedArray, cudaGraphicsResource_t resource); +# 9748 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetChannelDesc(struct cudaChannelFormatDesc *desc, cudaArray_const_t array); +# 9778 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) struct cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, enum cudaChannelFormatKind f); +# 10003 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaCreateTextureObject(cudaTextureObject_t *pTexObject, const struct cudaResourceDesc *pResDesc, const struct cudaTextureDesc *pTexDesc, const struct cudaResourceViewDesc *pResViewDesc); +# 10023 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject); +# 10043 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectResourceDesc(struct cudaResourceDesc *pResDesc, cudaTextureObject_t texObject); +# 10063 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectTextureDesc(struct cudaTextureDesc *pTexDesc, cudaTextureObject_t texObject); +# 10084 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectResourceViewDesc(struct cudaResourceViewDesc *pResViewDesc, cudaTextureObject_t texObject); +# 10129 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t *pSurfObject, const struct cudaResourceDesc *pResDesc); +# 10149 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject); +# 10168 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSurfaceObjectResourceDesc(struct cudaResourceDesc *pResDesc, cudaSurfaceObject_t surfObject); +# 10202 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDriverGetVersion(int *driverVersion); +# 10231 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaRuntimeGetVersion(int *runtimeVersion); +# 10278 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphCreate(cudaGraph_t *pGraph, unsigned int flags); +# 10377 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddKernelNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaKernelNodeParams *pNodeParams); +# 10410 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, struct cudaKernelNodeParams *pNodeParams); +# 10437 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const struct cudaKernelNodeParams *pNodeParams); +# 10457 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeCopyAttributes( + cudaGraphNode_t hSrc, + cudaGraphNode_t hDst); +# 10480 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeGetAttribute( + cudaGraphNode_t hNode, + cudaLaunchAttributeID attr, + cudaLaunchAttributeValue *value_out); +# 10504 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeSetAttribute( + cudaGraphNode_t hNode, + cudaLaunchAttributeID attr, + const cudaLaunchAttributeValue *value); +# 10555 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaMemcpy3DParms *pCopyParams); +# 10614 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNodeToSymbol( + cudaGraphNode_t *pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t *pDependencies, + size_t numDependencies, + const void* symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 10683 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNodeFromSymbol( + cudaGraphNode_t* pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t* pDependencies, + size_t numDependencies, + void* dst, + const void* symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 10751 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNode1D( + cudaGraphNode_t *pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t *pDependencies, + size_t numDependencies, + void* dst, + const void* src, + size_t count, + enum cudaMemcpyKind kind); +# 10783 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, struct cudaMemcpy3DParms *pNodeParams); +# 10810 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const struct cudaMemcpy3DParms *pNodeParams); +# 10849 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParamsToSymbol( + cudaGraphNode_t node, + const void* symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 10895 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParamsFromSymbol( + cudaGraphNode_t node, + void* dst, + const void* symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 10941 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParams1D( + cudaGraphNode_t node, + void* dst, + const void* src, + size_t count, + enum cudaMemcpyKind kind); +# 10989 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddMemsetNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaMemsetParams *pMemsetParams); +# 11012 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, struct cudaMemsetParams *pNodeParams); +# 11036 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const struct cudaMemsetParams *pNodeParams); +# 11078 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddHostNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaHostNodeParams *pNodeParams); +# 11101 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, struct cudaHostNodeParams *pNodeParams); +# 11125 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const struct cudaHostNodeParams *pNodeParams); +# 11166 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddChildGraphNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, cudaGraph_t childGraph); +# 11193 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t *pGraph); +# 11231 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies); +# 11275 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddEventRecordNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, cudaEvent_t event); +# 11302 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t *event_out); +# 11330 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event); +# 11377 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddEventWaitNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, cudaEvent_t event); +# 11404 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t *event_out); +# 11432 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event); +# 11482 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaExternalSemaphoreSignalNodeParams *nodeParams); +# 11515 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, struct cudaExternalSemaphoreSignalNodeParams *params_out); +# 11543 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const struct cudaExternalSemaphoreSignalNodeParams *nodeParams); +# 11593 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaExternalSemaphoreWaitNodeParams *nodeParams); +# 11626 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, struct cudaExternalSemaphoreWaitNodeParams *params_out); +# 11654 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const struct cudaExternalSemaphoreWaitNodeParams *nodeParams); +# 11732 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddMemAllocNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, struct cudaMemAllocNodeParams *nodeParams); +# 11759 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, struct cudaMemAllocNodeParams *params_out); +# 11820 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddMemFreeNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, void *dptr); +# 11844 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void *dptr_out); +# 11872 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGraphMemTrim(int device); +# 11909 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetGraphMemAttribute(int device, enum cudaGraphMemAttributeType attr, void* value); +# 11943 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetGraphMemAttribute(int device, enum cudaGraphMemAttributeType attr, void* value); +# 11971 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphClone(cudaGraph_t *pGraphClone, cudaGraph_t originalGraph); +# 11999 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t *pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph); +# 12030 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, enum cudaGraphNodeType *pType); +# 12061 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t *nodes, size_t *numNodes); +# 12092 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t *pRootNodes, size_t *pNumRootNodes); +# 12126 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t *from, cudaGraphNode_t *to, size_t *numEdges); +# 12166 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetEdges_v2(cudaGraph_t graph, cudaGraphNode_t *from, cudaGraphNode_t *to, cudaGraphEdgeData *edgeData, size_t *numEdges); +# 12197 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t *pDependencies, size_t *pNumDependencies); +# 12234 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependencies_v2(cudaGraphNode_t node, cudaGraphNode_t *pDependencies, cudaGraphEdgeData *edgeData, size_t *pNumDependencies); +# 12266 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t *pDependentNodes, size_t *pNumDependentNodes); +# 12304 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependentNodes_v2(cudaGraphNode_t node, cudaGraphNode_t *pDependentNodes, cudaGraphEdgeData *edgeData, size_t *pNumDependentNodes); +# 12335 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, size_t numDependencies); +# 12367 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, const cudaGraphEdgeData *edgeData, size_t numDependencies); +# 12398 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, size_t numDependencies); +# 12433 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphRemoveDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, const cudaGraphEdgeData *edgeData, size_t numDependencies); +# 12463 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node); +# 12534 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiate(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, unsigned long long flags = 0); +# 12607 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, unsigned long long flags = 0); +# 12714 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiateWithParams(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams *instantiateParams); +# 12739 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long *flags); +# 12799 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaKernelNodeParams *pNodeParams); +# 12850 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaMemcpy3DParms *pNodeParams); +# 12905 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParamsToSymbol( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + const void* symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 12968 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParamsFromSymbol( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + void* dst, + const void* symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 13029 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParams1D( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + void* dst, + const void* src, + size_t count, + enum cudaMemcpyKind kind); +# 13088 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaMemsetParams *pNodeParams); +# 13128 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaHostNodeParams *pNodeParams); +# 13175 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph); +# 13220 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event); +# 13265 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event); +# 13313 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const struct cudaExternalSemaphoreSignalNodeParams *nodeParams); +# 13361 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const struct cudaExternalSemaphoreWaitNodeParams *nodeParams); +# 13401 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled); +# 13435 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int *isEnabled); +# 13529 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo *resultInfo); +# 13554 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream); +# 13585 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream); +# 13608 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec); +# 13629 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDestroy(cudaGraph_t graph); +# 13648 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char *path, unsigned int flags); +# 13684 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaUserObjectCreate(cudaUserObject_t *object_out, void *ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags); +# 13708 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned int count = 1); +# 13736 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned int count = 1); +# 13764 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count = 1, unsigned int flags = 0); +# 13789 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count = 1); +# 13831 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, struct cudaGraphNodeParams *nodeParams); +# 13875 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddNode_v2(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, const cudaGraphEdgeData *dependencyData, size_t numDependencies, struct cudaGraphNodeParams *nodeParams); +# 13904 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeSetParams(cudaGraphNode_t node, struct cudaGraphNodeParams *nodeParams); +# 13953 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, struct cudaGraphNodeParams *nodeParams); +# 13980 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle *pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue = 0, unsigned int flags = 0); +# 14061 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetDriverEntryPoint(const char *symbol, void **funcPtr, unsigned long long flags, enum cudaDriverEntryPointQueryResult *driverStatus = +# 14061 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 3 4 + __null +# 14061 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + ); +# 14137 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetDriverEntryPointByVersion(const char *symbol, void **funcPtr, unsigned int cudaVersion, unsigned long long flags, enum cudaDriverEntryPointQueryResult *driverStatus = +# 14137 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 3 4 + __null +# 14137 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + ); +# 14212 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryLoadData(cudaLibrary_t *library, const void *code, + enum cudaJitOption *jitOptions, void **jitOptionsValues, unsigned int numJitOptions, + enum cudaLibraryOption *libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions); +# 14272 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryLoadFromFile(cudaLibrary_t *library, const char *fileName, + enum cudaJitOption *jitOptions, void **jitOptionsValues, unsigned int numJitOptions, + enum cudaLibraryOption *libraryOptions, void **libraryOptionValues, unsigned int numLibraryOptions); +# 14293 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryUnload(cudaLibrary_t library); +# 14318 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryGetKernel(cudaKernel_t *pKernel, cudaLibrary_t library, const char *name); +# 14352 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryGetGlobal(void **dptr, size_t *bytes, cudaLibrary_t library, const char *name); +# 14385 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryGetManaged(void **dptr, size_t *bytes, cudaLibrary_t library, const char *name); +# 14412 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryGetUnifiedFunction(void **fptr, cudaLibrary_t library, const char *symbol); +# 14434 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryGetKernelCount(unsigned int *count, cudaLibrary_t lib); +# 14456 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryEnumerateKernels(cudaKernel_t *kernels, unsigned int numKernels, cudaLibrary_t lib); +# 14525 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaKernelSetAttributeForDevice(cudaKernel_t kernel, enum cudaFuncAttribute attr, int value, int device); + + + + +extern __attribute__((host)) cudaError_t cudaGetExportTable(const void **ppExportTable, const cudaUUID_t *pExportTableId); +# 14716 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetFuncBySymbol(cudaFunction_t* functionPtr, const void* symbolPtr); +# 14740 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetKernel(cudaKernel_t *kernelPtr, const void *entryFuncAddr); +# 14918 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +} +# 62 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" 2 +# 120 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" +template __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(0, 0, 0, 0, cudaChannelFormatKindNone); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescHalf(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescHalf1(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescHalf2(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindFloat); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescHalf4(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindFloat); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(char) * 8; + + + + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); + +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(signed char) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned char) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(signed char) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned char) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(signed char) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned char) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(signed char) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned char) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(short) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(short) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(int) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned int) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(int) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned int) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(int) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned int) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(int) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned int) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +} +# 392 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(float) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(float) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(float) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindFloat); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(float) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindFloat); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescNV12(void) +{ + int e = (int)sizeof(char) * 8; + + return cudaCreateChannelDesc(e, e, e, 0, cudaChannelFormatKindNV12); +} + +template __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(0, 0, 0, 0, cudaChannelFormatKindNone); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindSignedNormalized8X1); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindSignedNormalized8X2); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindSignedNormalized8X4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindUnsignedNormalized8X1); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindUnsignedNormalized8X2); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedNormalized8X4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 0, 0, 0, cudaChannelFormatKindSignedNormalized16X1); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 0, 0, cudaChannelFormatKindSignedNormalized16X2); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 16, 16, cudaChannelFormatKindSignedNormalized16X4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 0, 0, 0, cudaChannelFormatKindUnsignedNormalized16X1); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 0, 0, cudaChannelFormatKindUnsignedNormalized16X2); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 16, 16, cudaChannelFormatKindUnsignedNormalized16X4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 0, cudaChannelFormatKindNV12); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(10, 10, 10, 2, cudaChannelFormatKindUnsignedNormalized1010102); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed1); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed1SRGB); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed2); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed2SRGB); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed3); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed3SRGB); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindUnsignedBlockCompressed4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindSignedBlockCompressed4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindUnsignedBlockCompressed5); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindSignedBlockCompressed5); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 16, 0, cudaChannelFormatKindUnsignedBlockCompressed6H); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 16, 0, cudaChannelFormatKindSignedBlockCompressed6H); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed7); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed7SRGB); +} +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" 1 +# 53 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 54 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 55 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" 2 +# 79 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static __inline__ __attribute__((host)) struct cudaPitchedPtr make_cudaPitchedPtr(void *d, size_t p, size_t xsz, size_t ysz) +{ + struct cudaPitchedPtr s; + + s.ptr = d; + s.pitch = p; + s.xsize = xsz; + s.ysize = ysz; + + return s; +} +# 106 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static __inline__ __attribute__((host)) struct cudaPos make_cudaPos(size_t x, size_t y, size_t z) +{ + struct cudaPos p; + + p.x = x; + p.y = y; + p.z = z; + + return p; +} +# 132 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static __inline__ __attribute__((host)) struct cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) +{ + struct cudaExtent e; + + e.width = w; + e.height = h; + e.depth = d; + + return e; +} +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 100 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + + + + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.h" 1 +# 77 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.h" +static __inline__ __attribute__((host)) __attribute__((device)) char1 make_char1(signed char x); + +static __inline__ __attribute__((host)) __attribute__((device)) uchar1 make_uchar1(unsigned char x); + +static __inline__ __attribute__((host)) __attribute__((device)) char2 make_char2(signed char x, signed char y); + +static __inline__ __attribute__((host)) __attribute__((device)) uchar2 make_uchar2(unsigned char x, unsigned char y); + +static __inline__ __attribute__((host)) __attribute__((device)) char3 make_char3(signed char x, signed char y, signed char z); + +static __inline__ __attribute__((host)) __attribute__((device)) uchar3 make_uchar3(unsigned char x, unsigned char y, unsigned char z); + +static __inline__ __attribute__((host)) __attribute__((device)) char4 make_char4(signed char x, signed char y, signed char z, signed char w); + +static __inline__ __attribute__((host)) __attribute__((device)) uchar4 make_uchar4(unsigned char x, unsigned char y, unsigned char z, unsigned char w); + +static __inline__ __attribute__((host)) __attribute__((device)) short1 make_short1(short x); + +static __inline__ __attribute__((host)) __attribute__((device)) ushort1 make_ushort1(unsigned short x); + +static __inline__ __attribute__((host)) __attribute__((device)) short2 make_short2(short x, short y); + +static __inline__ __attribute__((host)) __attribute__((device)) ushort2 make_ushort2(unsigned short x, unsigned short y); + +static __inline__ __attribute__((host)) __attribute__((device)) short3 make_short3(short x,short y, short z); + +static __inline__ __attribute__((host)) __attribute__((device)) ushort3 make_ushort3(unsigned short x, unsigned short y, unsigned short z); + +static __inline__ __attribute__((host)) __attribute__((device)) short4 make_short4(short x, short y, short z, short w); + +static __inline__ __attribute__((host)) __attribute__((device)) ushort4 make_ushort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w); + +static __inline__ __attribute__((host)) __attribute__((device)) int1 make_int1(int x); + +static __inline__ __attribute__((host)) __attribute__((device)) uint1 make_uint1(unsigned int x); + +static __inline__ __attribute__((host)) __attribute__((device)) int2 make_int2(int x, int y); + +static __inline__ __attribute__((host)) __attribute__((device)) uint2 make_uint2(unsigned int x, unsigned int y); + +static __inline__ __attribute__((host)) __attribute__((device)) int3 make_int3(int x, int y, int z); + +static __inline__ __attribute__((host)) __attribute__((device)) uint3 make_uint3(unsigned int x, unsigned int y, unsigned int z); + +static __inline__ __attribute__((host)) __attribute__((device)) int4 make_int4(int x, int y, int z, int w); + +static __inline__ __attribute__((host)) __attribute__((device)) uint4 make_uint4(unsigned int x, unsigned int y, unsigned int z, unsigned int w); + +static __inline__ __attribute__((host)) __attribute__((device)) long1 make_long1(long int x); + +static __inline__ __attribute__((host)) __attribute__((device)) ulong1 make_ulong1(unsigned long int x); + +static __inline__ __attribute__((host)) __attribute__((device)) long2 make_long2(long int x, long int y); + +static __inline__ __attribute__((host)) __attribute__((device)) ulong2 make_ulong2(unsigned long int x, unsigned long int y); + +static __inline__ __attribute__((host)) __attribute__((device)) long3 make_long3(long int x, long int y, long int z); + +static __inline__ __attribute__((host)) __attribute__((device)) ulong3 make_ulong3(unsigned long int x, unsigned long int y, unsigned long int z); + +static __inline__ __attribute__((host)) __attribute__((device)) long4 make_long4(long int x, long int y, long int z, long int w); + +static __inline__ __attribute__((host)) __attribute__((device)) ulong4 make_ulong4(unsigned long int x, unsigned long int y, unsigned long int z, unsigned long int w); + +static __inline__ __attribute__((host)) __attribute__((device)) float1 make_float1(float x); + +static __inline__ __attribute__((host)) __attribute__((device)) float2 make_float2(float x, float y); + +static __inline__ __attribute__((host)) __attribute__((device)) float3 make_float3(float x, float y, float z); + +static __inline__ __attribute__((host)) __attribute__((device)) float4 make_float4(float x, float y, float z, float w); + +static __inline__ __attribute__((host)) __attribute__((device)) longlong1 make_longlong1(long long int x); + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong1 make_ulonglong1(unsigned long long int x); + +static __inline__ __attribute__((host)) __attribute__((device)) longlong2 make_longlong2(long long int x, long long int y); + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong2 make_ulonglong2(unsigned long long int x, unsigned long long int y); + +static __inline__ __attribute__((host)) __attribute__((device)) longlong3 make_longlong3(long long int x, long long int y, long long int z); + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong3 make_ulonglong3(unsigned long long int x, unsigned long long int y, unsigned long long int z); + +static __inline__ __attribute__((host)) __attribute__((device)) longlong4 make_longlong4(long long int x, long long int y, long long int z, long long int w); + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong4 make_ulonglong4(unsigned long long int x, unsigned long long int y, unsigned long long int z, unsigned long long int w); + +static __inline__ __attribute__((host)) __attribute__((device)) double1 make_double1(double x); + +static __inline__ __attribute__((host)) __attribute__((device)) double2 make_double2(double x, double y); + +static __inline__ __attribute__((host)) __attribute__((device)) double3 make_double3(double x, double y, double z); + +static __inline__ __attribute__((host)) __attribute__((device)) double4 make_double4(double x, double y, double z, double w); + + + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.hpp" 1 +# 73 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.hpp" +static __inline__ __attribute__((host)) __attribute__((device)) char1 make_char1(signed char x) +{ + char1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uchar1 make_uchar1(unsigned char x) +{ + uchar1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) char2 make_char2(signed char x, signed char y) +{ + char2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uchar2 make_uchar2(unsigned char x, unsigned char y) +{ + uchar2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) char3 make_char3(signed char x, signed char y, signed char z) +{ + char3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uchar3 make_uchar3(unsigned char x, unsigned char y, unsigned char z) +{ + uchar3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) char4 make_char4(signed char x, signed char y, signed char z, signed char w) +{ + char4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uchar4 make_uchar4(unsigned char x, unsigned char y, unsigned char z, unsigned char w) +{ + uchar4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) short1 make_short1(short x) +{ + short1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ushort1 make_ushort1(unsigned short x) +{ + ushort1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) short2 make_short2(short x, short y) +{ + short2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ushort2 make_ushort2(unsigned short x, unsigned short y) +{ + ushort2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) short3 make_short3(short x,short y, short z) +{ + short3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ushort3 make_ushort3(unsigned short x, unsigned short y, unsigned short z) +{ + ushort3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) short4 make_short4(short x, short y, short z, short w) +{ + short4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ushort4 make_ushort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w) +{ + ushort4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) int1 make_int1(int x) +{ + int1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uint1 make_uint1(unsigned int x) +{ + uint1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) int2 make_int2(int x, int y) +{ + int2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uint2 make_uint2(unsigned int x, unsigned int y) +{ + uint2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) int3 make_int3(int x, int y, int z) +{ + int3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uint3 make_uint3(unsigned int x, unsigned int y, unsigned int z) +{ + uint3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) int4 make_int4(int x, int y, int z, int w) +{ + int4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uint4 make_uint4(unsigned int x, unsigned int y, unsigned int z, unsigned int w) +{ + uint4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) long1 make_long1(long int x) +{ + long1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulong1 make_ulong1(unsigned long int x) +{ + ulong1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) long2 make_long2(long int x, long int y) +{ + long2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulong2 make_ulong2(unsigned long int x, unsigned long int y) +{ + ulong2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) long3 make_long3(long int x, long int y, long int z) +{ + long3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulong3 make_ulong3(unsigned long int x, unsigned long int y, unsigned long int z) +{ + ulong3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) long4 make_long4(long int x, long int y, long int z, long int w) +{ + long4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulong4 make_ulong4(unsigned long int x, unsigned long int y, unsigned long int z, unsigned long int w) +{ + ulong4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) float1 make_float1(float x) +{ + float1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) float2 make_float2(float x, float y) +{ + float2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) float3 make_float3(float x, float y, float z) +{ + float3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) float4 make_float4(float x, float y, float z, float w) +{ + float4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) longlong1 make_longlong1(long long int x) +{ + longlong1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong1 make_ulonglong1(unsigned long long int x) +{ + ulonglong1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) longlong2 make_longlong2(long long int x, long long int y) +{ + longlong2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong2 make_ulonglong2(unsigned long long int x, unsigned long long int y) +{ + ulonglong2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) longlong3 make_longlong3(long long int x, long long int y, long long int z) +{ + longlong3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong3 make_ulonglong3(unsigned long long int x, unsigned long long int y, unsigned long long int z) +{ + ulonglong3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) longlong4 make_longlong4(long long int x, long long int y, long long int z, long long int w) +{ + longlong4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong4 make_ulonglong4(unsigned long long int x, unsigned long long int y, unsigned long long int z, unsigned long long int w) +{ + ulonglong4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) double1 make_double1(double x) +{ + double1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) double2 make_double2(double x, double y) +{ + double2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) double3 make_double3(double x, double y, double z) +{ + double3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) double4 make_double4(double x, double y, double z, double w) +{ + double4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} +# 177 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.h" 2 +# 106 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 117 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 1 +# 71 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 72 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 73 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 85 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +# 1 "/usr/include/string.h" 1 3 4 +# 26 "/usr/include/string.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/string.h" 2 3 4 + + +# 28 "/usr/include/string.h" 3 4 +extern "C" { + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 34 "/usr/include/string.h" 2 3 4 +# 43 "/usr/include/string.h" 3 4 +extern void *memcpy (void *__restrict __dest, const void *__restrict __src, + size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern void *memmove (void *__dest, const void *__src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern void *memccpy (void *__restrict __dest, const void *__restrict __src, + int __c, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__write_only__, 1, 4))); + + + + +extern void *memset (void *__s, int __c, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int memcmp (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 80 "/usr/include/string.h" 3 4 +extern int __memcmpeq (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + +extern "C++" +{ +extern void *memchr (void *__s, int __c, size_t __n) + noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const void *memchr (const void *__s, int __c, size_t __n) + noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 105 "/usr/include/string.h" 3 4 +} +# 115 "/usr/include/string.h" 3 4 +extern "C++" void *rawmemchr (void *__s, int __c) + noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const void *rawmemchr (const void *__s, int __c) + noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + + + +extern "C++" void *memrchr (void *__s, int __c, size_t __n) + noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__read_only__, 1, 3))); +extern "C++" const void *memrchr (const void *__s, int __c, size_t __n) + noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__read_only__, 1, 3))); +# 141 "/usr/include/string.h" 3 4 +extern char *strcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strcat (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncat (char *__restrict __dest, const char *__restrict __src, + size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern int strncmp (const char *__s1, const char *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcoll (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern size_t strxfrm (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 1, 3))); + + + + + + +extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + + +extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n, + locale_t __l) noexcept (true) __attribute__ ((__nonnull__ (2, 4))) + __attribute__ ((__access__ (__write_only__, 1, 3))); + + + + + +extern char *strdup (const char *__s) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); + + + + + + +extern char *strndup (const char *__string, size_t __n) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); +# 224 "/usr/include/string.h" 3 4 +extern "C++" +{ +extern char *strchr (char *__s, int __c) + noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *strchr (const char *__s, int __c) + noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 244 "/usr/include/string.h" 3 4 +} + + + + + + +extern "C++" +{ +extern char *strrchr (char *__s, int __c) + noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *strrchr (const char *__s, int __c) + noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 271 "/usr/include/string.h" 3 4 +} +# 281 "/usr/include/string.h" 3 4 +extern "C++" char *strchrnul (char *__s, int __c) + noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const char *strchrnul (const char *__s, int __c) + noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 293 "/usr/include/string.h" 3 4 +extern size_t strcspn (const char *__s, const char *__reject) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern size_t strspn (const char *__s, const char *__accept) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern "C++" +{ +extern char *strpbrk (char *__s, const char *__accept) + noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern const char *strpbrk (const char *__s, const char *__accept) + noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 321 "/usr/include/string.h" 3 4 +} + + + + + + +extern "C++" +{ +extern char *strstr (char *__haystack, const char *__needle) + noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern const char *strstr (const char *__haystack, const char *__needle) + noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 348 "/usr/include/string.h" 3 4 +} + + + + + + + +extern char *strtok (char *__restrict __s, const char *__restrict __delim) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern char *__strtok_r (char *__restrict __s, + const char *__restrict __delim, + char **__restrict __save_ptr) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + +extern char *strtok_r (char *__restrict __s, const char *__restrict __delim, + char **__restrict __save_ptr) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + + + + + +extern "C++" char *strcasestr (char *__haystack, const char *__needle) + noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern "C++" const char *strcasestr (const char *__haystack, + const char *__needle) + noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 389 "/usr/include/string.h" 3 4 +extern void *memmem (const void *__haystack, size_t __haystacklen, + const void *__needle, size_t __needlelen) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3))) + __attribute__ ((__access__ (__read_only__, 1, 2))) + __attribute__ ((__access__ (__read_only__, 3, 4))); + + + +extern void *__mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern void *mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern size_t strlen (const char *__s) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + +extern size_t strnlen (const char *__string, size_t __maxlen) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + +extern char *strerror (int __errnum) noexcept (true); +# 444 "/usr/include/string.h" 3 4 +extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3))); + + + + +extern const char *strerrordesc_np (int __err) noexcept (true); + +extern const char *strerrorname_np (int __err) noexcept (true); + + + + + +extern char *strerror_l (int __errnum, locale_t __l) noexcept (true); + + + +# 1 "/usr/include/strings.h" 1 3 4 +# 23 "/usr/include/strings.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 24 "/usr/include/strings.h" 2 3 4 + + + + + + +extern "C" { + + + +extern int bcmp (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern void bcopy (const void *__src, void *__dest, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern void bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern "C++" +{ +extern char *index (char *__s, int __c) + noexcept (true) __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *index (const char *__s, int __c) + noexcept (true) __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 66 "/usr/include/strings.h" 3 4 +} + + + + + + + +extern "C++" +{ +extern char *rindex (char *__s, int __c) + noexcept (true) __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *rindex (const char *__s, int __c) + noexcept (true) __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 94 "/usr/include/strings.h" 3 4 +} +# 104 "/usr/include/strings.h" 3 4 +extern int ffs (int __i) noexcept (true) __attribute__ ((__const__)); + + + + + +extern int ffsl (long int __l) noexcept (true) __attribute__ ((__const__)); +__extension__ extern int ffsll (long long int __ll) + noexcept (true) __attribute__ ((__const__)); + + + +extern int strcasecmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strncasecmp (const char *__s1, const char *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + + + + +extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + + + +extern int strncasecmp_l (const char *__s1, const char *__s2, + size_t __n, locale_t __loc) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4))); + + +} +# 463 "/usr/include/string.h" 2 3 4 + + + +extern void explicit_bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__write_only__, 1, 2))); + + + +extern char *strsep (char **__restrict __stringp, + const char *__restrict __delim) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern char *strsignal (int __sig) noexcept (true); + + + +extern const char *sigabbrev_np (int __sig) noexcept (true); + + +extern const char *sigdescr_np (int __sig) noexcept (true); + + + +extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern char *stpcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern char *__stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern char *stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern size_t strlcpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__write_only__, 1, 3))); + + + +extern size_t strlcat (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__read_write__, 1, 3))); + + + + +extern int strverscmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strfry (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void *memfrob (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__read_write__, 1, 2))); + + + + + + + +extern "C++" char *basename (char *__filename) + noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); +extern "C++" const char *basename (const char *__filename) + noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); +# 552 "/usr/include/string.h" 3 4 +} +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 1 "/usr/include/time.h" 1 3 4 +# 29 "/usr/include/time.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 30 "/usr/include/time.h" 2 3 4 + + + +# 1 "/usr/include/bits/time.h" 1 3 4 +# 73 "/usr/include/bits/time.h" 3 4 +# 1 "/usr/include/bits/timex.h" 1 3 4 +# 26 "/usr/include/bits/timex.h" 3 4 +struct timex +{ +# 58 "/usr/include/bits/timex.h" 3 4 + unsigned int modes; + __syscall_slong_t offset; + __syscall_slong_t freq; + __syscall_slong_t maxerror; + __syscall_slong_t esterror; + int status; + __syscall_slong_t constant; + __syscall_slong_t precision; + __syscall_slong_t tolerance; + struct timeval time; + __syscall_slong_t tick; + __syscall_slong_t ppsfreq; + __syscall_slong_t jitter; + int shift; + __syscall_slong_t stabil; + __syscall_slong_t jitcnt; + __syscall_slong_t calcnt; + __syscall_slong_t errcnt; + __syscall_slong_t stbcnt; + + int tai; + + + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; + +}; +# 74 "/usr/include/bits/time.h" 2 3 4 + +extern "C" { + + +extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) noexcept (true) __attribute__ ((__nonnull__ (2))); +# 90 "/usr/include/bits/time.h" 3 4 +} +# 34 "/usr/include/time.h" 2 3 4 + + + + + +# 1 "/usr/include/bits/types/struct_tm.h" 1 3 4 + + + + + + +struct tm +{ + int tm_sec; + int tm_min; + int tm_hour; + int tm_mday; + int tm_mon; + int tm_year; + int tm_wday; + int tm_yday; + int tm_isdst; + + + long int tm_gmtoff; + const char *tm_zone; + + + + +}; +# 40 "/usr/include/time.h" 2 3 4 +# 48 "/usr/include/time.h" 3 4 +# 1 "/usr/include/bits/types/struct_itimerspec.h" 1 3 4 + + + + + + + +struct itimerspec + { + struct timespec it_interval; + struct timespec it_value; + }; +# 49 "/usr/include/time.h" 2 3 4 +struct sigevent; +# 68 "/usr/include/time.h" 3 4 +extern "C" { + + + +extern clock_t clock (void) noexcept (true); + + + +extern time_t time (time_t *__timer) noexcept (true); + + +extern double difftime (time_t __time1, time_t __time0); + + +extern time_t mktime (struct tm *__tp) noexcept (true); +# 99 "/usr/include/time.h" 3 4 +extern size_t strftime (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp) + noexcept (true) __attribute__ ((__nonnull__ (1, 3, 4))); + + + + +extern char *strptime (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp) + noexcept (true); + + + + + + +extern size_t strftime_l (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp, + locale_t __loc) noexcept (true); + + + +extern char *strptime_l (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp, + locale_t __loc) noexcept (true); + + + + + + +extern struct tm *gmtime (const time_t *__timer) noexcept (true); + + + +extern struct tm *localtime (const time_t *__timer) noexcept (true); +# 154 "/usr/include/time.h" 3 4 +extern struct tm *gmtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) noexcept (true); + + + +extern struct tm *localtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) noexcept (true); +# 179 "/usr/include/time.h" 3 4 +extern char *asctime (const struct tm *__tp) noexcept (true); + + + +extern char *ctime (const time_t *__timer) noexcept (true); +# 197 "/usr/include/time.h" 3 4 +extern char *asctime_r (const struct tm *__restrict __tp, + char *__restrict __buf) noexcept (true); + + + +extern char *ctime_r (const time_t *__restrict __timer, + char *__restrict __buf) noexcept (true); +# 217 "/usr/include/time.h" 3 4 +extern char *__tzname[2]; +extern int __daylight; +extern long int __timezone; + + + + +extern char *tzname[2]; + + + +extern void tzset (void) noexcept (true); + + + +extern int daylight; +extern long int timezone; +# 246 "/usr/include/time.h" 3 4 +extern time_t timegm (struct tm *__tp) noexcept (true); +# 263 "/usr/include/time.h" 3 4 +extern time_t timelocal (struct tm *__tp) noexcept (true); + + + + + + + +extern int dysize (int __year) noexcept (true) __attribute__ ((__const__)); +# 281 "/usr/include/time.h" 3 4 +extern int nanosleep (const struct timespec *__requested_time, + struct timespec *__remaining); + + +extern int clock_getres (clockid_t __clock_id, struct timespec *__res) noexcept (true); + + +extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + +extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp) + noexcept (true) __attribute__ ((__nonnull__ (2))); +# 323 "/usr/include/time.h" 3 4 +extern int clock_nanosleep (clockid_t __clock_id, int __flags, + const struct timespec *__req, + struct timespec *__rem); +# 338 "/usr/include/time.h" 3 4 +extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) noexcept (true); + + + + +extern int timer_create (clockid_t __clock_id, + struct sigevent *__restrict __evp, + timer_t *__restrict __timerid) noexcept (true); + + +extern int timer_delete (timer_t __timerid) noexcept (true); + + + +extern int timer_settime (timer_t __timerid, int __flags, + const struct itimerspec *__restrict __value, + struct itimerspec *__restrict __ovalue) noexcept (true); + + +extern int timer_gettime (timer_t __timerid, struct itimerspec *__value) + noexcept (true); +# 376 "/usr/include/time.h" 3 4 +extern int timer_getoverrun (timer_t __timerid) noexcept (true); + + + + + + +extern int timespec_get (struct timespec *__ts, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 399 "/usr/include/time.h" 3 4 +extern int timespec_getres (struct timespec *__ts, int __base) + noexcept (true); +# 425 "/usr/include/time.h" 3 4 +extern int getdate_err; +# 434 "/usr/include/time.h" 3 4 +extern struct tm *getdate (const char *__string); +# 448 "/usr/include/time.h" 3 4 +extern int getdate_r (const char *__restrict __string, + struct tm *__restrict __resbufp); + + +} +# 87 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 + + +# 88 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern "C" +{ + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) clock_t clock(void) + + + + +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 +noexcept (true) +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void* memset(void*, int, size_t) +# 96 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 + noexcept (true) +# 96 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void* memcpy(void*, const void*, size_t) +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 + noexcept (true) +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; + +} +# 111 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/new" 1 3 +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/new" 3 + +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/new" 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/exception.h" 1 3 +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/exception.h" 3 + +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/exception.h" 3 + + + + +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/exception.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/exception.h" 3 + class exception + { + public: + exception() noexcept { } + virtual ~exception() noexcept; + + exception(const exception&) = default; + exception& operator=(const exception&) = default; + exception(exception&&) = default; + exception& operator=(exception&&) = default; + + + + + virtual const char* + what() const noexcept; + }; + + + +} + +} +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/new" 2 3 + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/new" 2 3 + +#pragma GCC visibility push(default) + +extern "C++" { + +namespace std +{ + + + + + + + class bad_alloc : public exception + { + public: + bad_alloc() throw() { } + + + bad_alloc(const bad_alloc&) = default; + bad_alloc& operator=(const bad_alloc&) = default; + + + + + virtual ~bad_alloc() throw(); + + + virtual const char* what() const throw(); + }; + + + class bad_array_new_length : public bad_alloc + { + public: + bad_array_new_length() throw() { } + + + + virtual ~bad_array_new_length() throw(); + + + virtual const char* what() const throw(); + }; + + + + enum class align_val_t: size_t {}; + + + struct nothrow_t + { + + explicit nothrow_t() = default; + + }; + + extern const nothrow_t nothrow; + + + + typedef void (*new_handler)(); + + + + new_handler set_new_handler(new_handler) throw(); + + + + new_handler get_new_handler() noexcept; + +} +# 131 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/new" 3 +[[__nodiscard__]] void* operator new(std::size_t) + __attribute__((__externally_visible__)); +[[__nodiscard__]] void* operator new[](std::size_t) + __attribute__((__externally_visible__)); +void operator delete(void*) noexcept + __attribute__((__externally_visible__)); +void operator delete[](void*) noexcept + __attribute__((__externally_visible__)); + +void operator delete(void*, std::size_t) noexcept + __attribute__((__externally_visible__)); +void operator delete[](void*, std::size_t) noexcept + __attribute__((__externally_visible__)); + +[[__nodiscard__]] void* operator new(std::size_t, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new[](std::size_t, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +void operator delete(void*, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__)); +void operator delete[](void*, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__)); + +[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t) + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +void operator delete(void*, std::align_val_t) + noexcept __attribute__((__externally_visible__)); +void operator delete(void*, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__)); +[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t) + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +void operator delete[](void*, std::align_val_t) + noexcept __attribute__((__externally_visible__)); +void operator delete[](void*, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__)); + +void operator delete(void*, std::size_t, std::align_val_t) + noexcept __attribute__((__externally_visible__)); +void operator delete[](void*, std::size_t, std::align_val_t) + noexcept __attribute__((__externally_visible__)); + + + + +[[__nodiscard__]] inline void* operator new(std::size_t, void* __p) noexcept +{ return __p; } +[[__nodiscard__]] inline void* operator new[](std::size_t, void* __p) noexcept +{ return __p; } + + +inline void operator delete (void*, void*) noexcept { } +inline void operator delete[](void*, void*) noexcept { } + +} + + +namespace std +{ + + + template + [[nodiscard]] constexpr _Tp* + launder(_Tp* __p) noexcept + { return __builtin_launder(__p); } + + + + + template + void launder(_Ret (*)(_Args...) noexcept (_NE)) = delete; + template + void launder(_Ret (*)(_Args......) noexcept (_NE)) = delete; + + void launder(void*) = delete; + void launder(const void*) = delete; + void launder(volatile void*) = delete; + void launder(const volatile void*) = delete; + + + + inline constexpr size_t hardware_destructive_interference_size = 64; + inline constexpr size_t hardware_constructive_interference_size = 64; + +} +# 236 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/new" 3 +#pragma GCC visibility pop +# 112 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 125 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + +# 125 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void* operator new(std:: size_t, void*) throw(); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void* operator new[](std:: size_t, void*) throw(); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete(void*, void*) throw(); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete[](void*, void*) throw(); + +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete(void*, std:: size_t) throw(); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete[](void*, std:: size_t) throw(); + + + + +# 1 "/usr/include/stdio.h" 1 3 4 +# 28 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 29 "/usr/include/stdio.h" 2 3 4 + + +# 30 "/usr/include/stdio.h" 3 4 +extern "C" { + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 35 "/usr/include/stdio.h" 2 3 4 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stdarg.h" 1 3 4 +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stdarg.h" 3 4 +typedef __builtin_va_list __gnuc_va_list; +# 38 "/usr/include/stdio.h" 2 3 4 + + +# 1 "/usr/include/bits/types/__fpos_t.h" 1 3 4 + + + + +# 1 "/usr/include/bits/types/__mbstate_t.h" 1 3 4 +# 13 "/usr/include/bits/types/__mbstate_t.h" 3 4 +typedef struct +{ + int __count; + union + { + unsigned int __wch; + char __wchb[4]; + } __value; +} __mbstate_t; +# 6 "/usr/include/bits/types/__fpos_t.h" 2 3 4 + + + + +typedef struct _G_fpos_t +{ + __off_t __pos; + __mbstate_t __state; +} __fpos_t; +# 41 "/usr/include/stdio.h" 2 3 4 +# 1 "/usr/include/bits/types/__fpos64_t.h" 1 3 4 +# 10 "/usr/include/bits/types/__fpos64_t.h" 3 4 +typedef struct _G_fpos64_t +{ + __off64_t __pos; + __mbstate_t __state; +} __fpos64_t; +# 42 "/usr/include/stdio.h" 2 3 4 +# 1 "/usr/include/bits/types/__FILE.h" 1 3 4 + + + +struct _IO_FILE; +typedef struct _IO_FILE __FILE; +# 43 "/usr/include/stdio.h" 2 3 4 +# 1 "/usr/include/bits/types/FILE.h" 1 3 4 + + + +struct _IO_FILE; + + +typedef struct _IO_FILE FILE; +# 44 "/usr/include/stdio.h" 2 3 4 +# 1 "/usr/include/bits/types/struct_FILE.h" 1 3 4 +# 36 "/usr/include/bits/types/struct_FILE.h" 3 4 +struct _IO_FILE; +struct _IO_marker; +struct _IO_codecvt; +struct _IO_wide_data; + + + + +typedef void _IO_lock_t; + + + + + +struct _IO_FILE +{ + int _flags; + + + char *_IO_read_ptr; + char *_IO_read_end; + char *_IO_read_base; + char *_IO_write_base; + char *_IO_write_ptr; + char *_IO_write_end; + char *_IO_buf_base; + char *_IO_buf_end; + + + char *_IO_save_base; + char *_IO_backup_base; + char *_IO_save_end; + + struct _IO_marker *_markers; + + struct _IO_FILE *_chain; + + int _fileno; + int _flags2:24; + + char _short_backupbuf[1]; + __off_t _old_offset; + + + unsigned short _cur_column; + signed char _vtable_offset; + char _shortbuf[1]; + + _IO_lock_t *_lock; + + + + + + + + __off64_t _offset; + + struct _IO_codecvt *_codecvt; + struct _IO_wide_data *_wide_data; + struct _IO_FILE *_freeres_list; + void *_freeres_buf; + struct _IO_FILE **_prevchain; + int _mode; + + char _unused2[15 * sizeof (int) - 5 * sizeof (void *)]; +}; +# 45 "/usr/include/stdio.h" 2 3 4 + + +# 1 "/usr/include/bits/types/cookie_io_functions_t.h" 1 3 4 +# 27 "/usr/include/bits/types/cookie_io_functions_t.h" 3 4 +typedef __ssize_t cookie_read_function_t (void *__cookie, char *__buf, + size_t __nbytes); + + + + + + + +typedef __ssize_t cookie_write_function_t (void *__cookie, const char *__buf, + size_t __nbytes); + + + + + + + +typedef int cookie_seek_function_t (void *__cookie, __off64_t *__pos, int __w); + + +typedef int cookie_close_function_t (void *__cookie); + + + + + + +typedef struct _IO_cookie_io_functions_t +{ + cookie_read_function_t *read; + cookie_write_function_t *write; + cookie_seek_function_t *seek; + cookie_close_function_t *close; +} cookie_io_functions_t; +# 48 "/usr/include/stdio.h" 2 3 4 + + + + + +typedef __gnuc_va_list va_list; +# 85 "/usr/include/stdio.h" 3 4 +typedef __fpos_t fpos_t; + + + + +typedef __fpos64_t fpos64_t; +# 129 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/bits/stdio_lim.h" 1 3 4 +# 130 "/usr/include/stdio.h" 2 3 4 +# 149 "/usr/include/stdio.h" 3 4 +extern FILE *stdin; +extern FILE *stdout; +extern FILE *stderr; + + + + + + +extern int remove (const char *__filename) noexcept (true); + +extern int rename (const char *__old, const char *__new) noexcept (true); + + + +extern int renameat (int __oldfd, const char *__old, int __newfd, + const char *__new) noexcept (true); +# 176 "/usr/include/stdio.h" 3 4 +extern int renameat2 (int __oldfd, const char *__old, int __newfd, + const char *__new, unsigned int __flags) noexcept (true); + + + + + + +extern int fclose (FILE *__stream) __attribute__ ((__nonnull__ (1))); +# 194 "/usr/include/stdio.h" 3 4 +extern FILE *tmpfile (void) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; +# 206 "/usr/include/stdio.h" 3 4 +extern FILE *tmpfile64 (void) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; + + + +extern char *tmpnam (char[20]) noexcept (true) ; + + + + +extern char *tmpnam_r (char __s[20]) noexcept (true) ; +# 228 "/usr/include/stdio.h" 3 4 +extern char *tempnam (const char *__dir, const char *__pfx) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (__builtin_free, 1))); + + + + + + +extern int fflush (FILE *__stream); +# 245 "/usr/include/stdio.h" 3 4 +extern int fflush_unlocked (FILE *__stream); +# 255 "/usr/include/stdio.h" 3 4 +extern int fcloseall (void); +# 264 "/usr/include/stdio.h" 3 4 +extern FILE *fopen (const char *__restrict __filename, + const char *__restrict __modes) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; + + + + +extern FILE *freopen (const char *__restrict __filename, + const char *__restrict __modes, + FILE *__restrict __stream) __attribute__ ((__nonnull__ (3))); +# 289 "/usr/include/stdio.h" 3 4 +extern FILE *fopen64 (const char *__restrict __filename, + const char *__restrict __modes) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; +extern FILE *freopen64 (const char *__restrict __filename, + const char *__restrict __modes, + FILE *__restrict __stream) __attribute__ ((__nonnull__ (3))); + + + + +extern FILE *fdopen (int __fd, const char *__modes) noexcept (true) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; + + + + + +extern FILE *fopencookie (void *__restrict __magic_cookie, + const char *__restrict __modes, + cookie_io_functions_t __io_funcs) noexcept (true) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; + + + + +extern FILE *fmemopen (void *__s, size_t __len, const char *__modes) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; + + + + +extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) noexcept (true) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; +# 334 "/usr/include/stdio.h" 3 4 +extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) noexcept (true) + __attribute__ ((__nonnull__ (1))); + + + +extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, + int __modes, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf, + size_t __size) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void setlinebuf (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + + +extern int fprintf (FILE *__restrict __stream, + const char *__restrict __format, ...) __attribute__ ((__nonnull__ (1))); + + + + +extern int printf (const char *__restrict __format, ...); + +extern int sprintf (char *__restrict __s, + const char *__restrict __format, ...) noexcept (true); + + + + + +extern int vfprintf (FILE *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg) __attribute__ ((__nonnull__ (1))); + + + + +extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg); + +extern int vsprintf (char *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg) noexcept (true); + + + +extern int snprintf (char *__restrict __s, size_t __maxlen, + const char *__restrict __format, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 3, 4))); + +extern int vsnprintf (char *__restrict __s, size_t __maxlen, + const char *__restrict __format, __gnuc_va_list __arg) + noexcept (true) __attribute__ ((__format__ (__printf__, 3, 0))); + + + + + +extern int vasprintf (char **__restrict __ptr, const char *__restrict __f, + __gnuc_va_list __arg) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))) ; +extern int __asprintf (char **__restrict __ptr, + const char *__restrict __fmt, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) ; +extern int asprintf (char **__restrict __ptr, + const char *__restrict __fmt, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) ; + + + + +extern int vdprintf (int __fd, const char *__restrict __fmt, + __gnuc_va_list __arg) + __attribute__ ((__format__ (__printf__, 2, 0))); +extern int dprintf (int __fd, const char *__restrict __fmt, ...) + __attribute__ ((__format__ (__printf__, 2, 3))); + + + + + + + +extern int fscanf (FILE *__restrict __stream, + const char *__restrict __format, ...) __attribute__ ((__nonnull__ (1))); + + + + +extern int scanf (const char *__restrict __format, ...) ; + +extern int sscanf (const char *__restrict __s, + const char *__restrict __format, ...) noexcept (true); +# 442 "/usr/include/stdio.h" 3 4 +extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc23_fscanf") + + __attribute__ ((__nonnull__ (1))); +extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc23_scanf") + ; +extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_sscanf") + + ; +# 490 "/usr/include/stdio.h" 3 4 +extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg) + __attribute__ ((__format__ (__scanf__, 2, 0))) __attribute__ ((__nonnull__ (1))); + + + + + +extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) + __attribute__ ((__format__ (__scanf__, 1, 0))) ; + + +extern int vsscanf (const char *__restrict __s, + const char *__restrict __format, __gnuc_va_list __arg) + noexcept (true) __attribute__ ((__format__ (__scanf__, 2, 0))); + + + + + + +extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfscanf") + + + + __attribute__ ((__format__ (__scanf__, 2, 0))) __attribute__ ((__nonnull__ (1))); +extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vscanf") + + __attribute__ ((__format__ (__scanf__, 1, 0))) ; +extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vsscanf") + + + + __attribute__ ((__format__ (__scanf__, 2, 0))); +# 575 "/usr/include/stdio.h" 3 4 +extern int fgetc (FILE *__stream) __attribute__ ((__nonnull__ (1))); +extern int getc (FILE *__stream) __attribute__ ((__nonnull__ (1))); + + + + + +extern int getchar (void); + + + + + + +extern int getc_unlocked (FILE *__stream) __attribute__ ((__nonnull__ (1))); +extern int getchar_unlocked (void); +# 600 "/usr/include/stdio.h" 3 4 +extern int fgetc_unlocked (FILE *__stream) __attribute__ ((__nonnull__ (1))); +# 611 "/usr/include/stdio.h" 3 4 +extern int fputc (int __c, FILE *__stream) __attribute__ ((__nonnull__ (2))); +extern int putc (int __c, FILE *__stream) __attribute__ ((__nonnull__ (2))); + + + + + +extern int putchar (int __c); +# 627 "/usr/include/stdio.h" 3 4 +extern int fputc_unlocked (int __c, FILE *__stream) __attribute__ ((__nonnull__ (2))); + + + + + + + +extern int putc_unlocked (int __c, FILE *__stream) __attribute__ ((__nonnull__ (2))); +extern int putchar_unlocked (int __c); + + + + + + +extern int getw (FILE *__stream) __attribute__ ((__nonnull__ (1))); + + +extern int putw (int __w, FILE *__stream) __attribute__ ((__nonnull__ (2))); + + + + + + + +extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream) + __attribute__ ((__access__ (__write_only__, 1, 2))) __attribute__ ((__nonnull__ (3))); +# 677 "/usr/include/stdio.h" 3 4 +extern char *fgets_unlocked (char *__restrict __s, int __n, + FILE *__restrict __stream) + __attribute__ ((__access__ (__write_only__, 1, 2))) __attribute__ ((__nonnull__ (3))); +# 689 "/usr/include/stdio.h" 3 4 +extern __ssize_t __getdelim (char **__restrict __lineptr, + size_t *__restrict __n, int __delimiter, + FILE *__restrict __stream) __attribute__ ((__nonnull__ (4))); +extern __ssize_t getdelim (char **__restrict __lineptr, + size_t *__restrict __n, int __delimiter, + FILE *__restrict __stream) __attribute__ ((__nonnull__ (4))); + + +extern __ssize_t getline (char **__restrict __lineptr, + size_t *__restrict __n, + FILE *__restrict __stream) __attribute__ ((__nonnull__ (3))); + + + + + + + +extern int fputs (const char *__restrict __s, FILE *__restrict __stream) + __attribute__ ((__nonnull__ (2))); + + + + + +extern int puts (const char *__s); + + + + + + +extern int ungetc (int __c, FILE *__stream) __attribute__ ((__nonnull__ (2))); + + + + + + +extern size_t fread (void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream) + __attribute__ ((__nonnull__ (4))); + + + + +extern size_t fwrite (const void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __s) __attribute__ ((__nonnull__ (4))); +# 745 "/usr/include/stdio.h" 3 4 +extern int fputs_unlocked (const char *__restrict __s, + FILE *__restrict __stream) __attribute__ ((__nonnull__ (2))); +# 756 "/usr/include/stdio.h" 3 4 +extern size_t fread_unlocked (void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream) + __attribute__ ((__nonnull__ (4))); +extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream) + __attribute__ ((__nonnull__ (4))); + + + + + + + +extern int fseek (FILE *__stream, long int __off, int __whence) + __attribute__ ((__nonnull__ (1))); + + + + +extern long int ftell (FILE *__stream) __attribute__ ((__nonnull__ (1))); + + + + +extern void rewind (FILE *__stream) __attribute__ ((__nonnull__ (1))); +# 793 "/usr/include/stdio.h" 3 4 +extern int fseeko (FILE *__stream, __off_t __off, int __whence) + __attribute__ ((__nonnull__ (1))); + + + + +extern __off_t ftello (FILE *__stream) __attribute__ ((__nonnull__ (1))); +# 819 "/usr/include/stdio.h" 3 4 +extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos) + __attribute__ ((__nonnull__ (1))); + + + + +extern int fsetpos (FILE *__stream, const fpos_t *__pos) __attribute__ ((__nonnull__ (1))); +# 841 "/usr/include/stdio.h" 3 4 +extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence) + __attribute__ ((__nonnull__ (1))); +extern __off64_t ftello64 (FILE *__stream) __attribute__ ((__nonnull__ (1))); +extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos) + __attribute__ ((__nonnull__ (1))); +extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos) __attribute__ ((__nonnull__ (1))); + + + +extern void clearerr (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern int feof (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern int ferror (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern void clearerr_unlocked (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); +extern int feof_unlocked (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); +extern int ferror_unlocked (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + + +extern void perror (const char *__s) __attribute__ ((__cold__)); + + + + +extern int fileno (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern int fileno_unlocked (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); +# 887 "/usr/include/stdio.h" 3 4 +extern int pclose (FILE *__stream) __attribute__ ((__nonnull__ (1))); + + + + + +extern FILE *popen (const char *__command, const char *__modes) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (pclose, 1))) ; + + + + + + +extern char *ctermid (char *__s) noexcept (true) + __attribute__ ((__access__ (__write_only__, 1))); + + + + + +extern char *cuserid (char *__s) + __attribute__ ((__access__ (__write_only__, 1))); + + + + +struct obstack; + + +extern int obstack_printf (struct obstack *__restrict __obstack, + const char *__restrict __format, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))); +extern int obstack_vprintf (struct obstack *__restrict __obstack, + const char *__restrict __format, + __gnuc_va_list __args) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))); + + + + + + + +extern void flockfile (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int ftrylockfile (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void funlockfile (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); +# 949 "/usr/include/stdio.h" 3 4 +extern int __uflow (FILE *); +extern int __overflow (FILE *, int); +# 973 "/usr/include/stdio.h" 3 4 +} +# 137 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h" 1 3 +# 138 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 + + + + + + +# 143 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern "C" +{ +extern + + + + + + + +__attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) int printf(const char*, ...); + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void* malloc(size_t) +# 157 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 + noexcept (true) +# 157 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void free(void*) +# 158 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 + noexcept (true) +# 158 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; +# 168 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +} + + + + + +# 1 "/usr/include/assert.h" 1 3 4 +# 64 "/usr/include/assert.h" 3 4 + +# 64 "/usr/include/assert.h" 3 4 +extern "C" { + + +extern void __assert_fail (const char *__assertion, const char *__file, + unsigned int __line, const char *__function) + noexcept (true) __attribute__ ((__noreturn__)) __attribute__ ((__cold__)); + + +extern void __assert_perror_fail (int __errnum, const char *__file, + unsigned int __line, const char *__function) + noexcept (true) __attribute__ ((__noreturn__)) __attribute__ ((__cold__)); + + + + +extern void __assert (const char *__assertion, const char *__file, int __line) + noexcept (true) __attribute__ ((__noreturn__)) __attribute__ ((__cold__)); + + +} +# 175 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 + + + +# 177 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern "C" +{ +# 205 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void __assert_fail( + const char *, const char *, unsigned int, const char *) + +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 + noexcept (true) +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; + + + + +} +# 267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void* operator new(std:: size_t) ; +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void* operator new[](std:: size_t) ; +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete(void*) throw(); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete[](void*) throw(); + +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete(void*, std:: size_t) throw(); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete[](void*, std:: size_t) throw(); + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void* operator new(std:: size_t, std::align_val_t); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void* operator new[](std:: size_t, std::align_val_t); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete(void*, std::align_val_t) noexcept; +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete[](void*, std::align_val_t) noexcept; +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete(void*, std:: size_t, std::align_val_t) noexcept; +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete[](void*, std:: size_t, std::align_val_t) noexcept; +# 303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 1 +# 114 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 115 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 116 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 126 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern "C" +{ +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) int abs(int a) +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) long int labs(long int a) +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 255 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) long long int llabs(long long int a) +# 255 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 255 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fabs(double x) +# 283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 306 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fabsf(float x) +# 306 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 306 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 317 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int min(const int a, const int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned int umin(const unsigned int a, const unsigned int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llmin(const long long int a, const long long int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned long long int ullmin(const unsigned long long int a, const unsigned long long int b); +# 359 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fminf(float x, float y) +# 359 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 359 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 379 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmin(double x, double y) +# 379 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 379 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 392 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int max(const int a, const int b); + + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned int umax(const unsigned int a, const unsigned int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llmax(const long long int a, const long long int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned long long int ullmax(const unsigned long long int a, const unsigned long long int b); +# 435 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmaxf(float x, float y) +# 435 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 435 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 455 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmax(double, double) +# 455 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 455 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sin(double x) +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 495 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cos(double x) +# 495 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 495 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 511 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincos(double x, double *sptr, double *cptr) +# 511 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 511 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 524 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincosf(float x, float *sptr, float *cptr) +# 524 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 524 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 547 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tan(double x) +# 547 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 547 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 571 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sqrt(double x) +# 571 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 571 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 597 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rsqrt(double x); +# 621 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rsqrtf(float x); +# 648 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log2(double x) +# 648 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 648 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 677 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp2(double x) +# 677 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 677 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 706 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float exp2f(float x) +# 706 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 706 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 737 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp10(double x) +# 737 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 737 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 764 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float exp10f(float x) +# 764 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 764 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 798 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double expm1(double x) +# 798 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 798 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 831 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float expm1f(float x) +# 831 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 831 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 858 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log2f(float x) +# 858 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 858 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 883 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log10(double x) +# 883 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 883 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 909 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log(double x) +# 909 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 909 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 936 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log1p(double x) +# 936 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 936 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 966 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log1pf(float x) +# 966 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 966 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 992 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double floor(double x) +# 992 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 992 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1021 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp(double x) +# 1021 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1021 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1040 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cosh(double x) +# 1040 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1040 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sinh(double x) +# 1060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1080 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tanh(double x) +# 1080 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1080 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double acosh(double x) +# 1104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1131 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float acoshf(float x) +# 1131 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1131 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1155 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double asinh(double x) +# 1155 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1155 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1179 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float asinhf(float x) +# 1179 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1179 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atanh(double x) +# 1204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1229 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atanhf(float x) +# 1229 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1229 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1247 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double ldexp(double x, int exp) +# 1247 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1247 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1262 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ldexpf(float x, int exp) +# 1262 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1262 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double logb(double x) +# 1283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1307 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float logbf(float x) +# 1307 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1307 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1331 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int ilogb(double x) +# 1331 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1331 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1355 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int ilogbf(float x) +# 1355 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1355 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1383 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double scalbn(double x, int n) +# 1383 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1383 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float scalbnf(float x, int n) +# 1411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1439 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double scalbln(double x, long int n) +# 1439 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1439 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1467 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float scalblnf(float x, long int n) +# 1467 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1467 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1499 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double frexp(double x, int *nptr) +# 1499 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1499 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1528 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float frexpf(float x, int *nptr) +# 1528 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1528 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1551 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double round(double x) +# 1551 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1551 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1577 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float roundf(float x) +# 1577 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1577 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1595 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lround(double x) +# 1595 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1595 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1613 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lroundf(float x) +# 1613 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1613 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1631 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llround(double x) +# 1631 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1631 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1649 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llroundf(float x) +# 1649 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1649 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1694 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rint(double x) +# 1694 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1694 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1719 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rintf(float x) +# 1719 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1719 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1736 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lrint(double x) +# 1736 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1736 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1753 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lrintf(float x) +# 1753 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1753 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1770 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llrint(double x) +# 1770 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1770 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1787 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llrintf(float x) +# 1787 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1787 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nearbyint(double x) +# 1811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1835 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nearbyintf(float x) +# 1835 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1835 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1859 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double ceil(double x) +# 1859 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1859 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1882 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double trunc(double x) +# 1882 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1882 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float truncf(float x) +# 1908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1930 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fdim(double x, double y) +# 1930 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1930 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1951 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fdimf(float x, float y) +# 1951 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1951 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atan2(double y, double x) +# 2034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atan(double x) +# 2060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double acos(double x) +# 2077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2099 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double asin(double x) +# 2099 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2099 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2130 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double hypot(double x, double y) +# 2130 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2130 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2156 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rhypot(double x, double y) +# 2156 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2156 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2187 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float hypotf(float x, float y) +# 2187 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2187 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2213 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rhypotf(float x, float y) +# 2213 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2213 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2231 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double norm3d(double a, double b, double c) +# 2231 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2231 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2249 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm3d(double a, double b, double c) +# 2249 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2249 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double norm4d(double a, double b, double c, double d) +# 2267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm4d(double a, double b, double c, double d) +# 2285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +__attribute__((device)) __attribute__((device_builtin)) double norm(int dim, double const * p) +# 2303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2321 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm(int dim, double const * p) +# 2321 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2321 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnormf(int dim, float const * p) +# 2340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2358 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +__attribute__((device)) __attribute__((device_builtin)) float normf(int dim, float const * p) +# 2358 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2358 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2377 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float norm3df(float a, float b, float c) +# 2377 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2377 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2395 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnorm3df(float a, float b, float c) +# 2395 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2395 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2413 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float norm4df(float a, float b, float c, float d) +# 2413 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2413 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2431 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnorm4df(float a, float b, float c, float d) +# 2431 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2431 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2459 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cbrt(double x) +# 2459 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2459 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2486 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cbrtf(float x) +# 2486 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2486 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2512 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rcbrt(double x); +# 2533 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rcbrtf(float x); +# 2556 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sinpi(double x) noexcept (true); +# 2579 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinpif(float x) noexcept (true); +# 2601 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cospi(double x) noexcept (true); +# 2623 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cospif(float x) noexcept (true); +# 2636 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincospi(double x, double *sptr, double *cptr); +# 2649 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincospif(float x, float *sptr, float *cptr); +# 2735 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double pow(double x, double y) +# 2735 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2735 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2759 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double modf(double x, double *iptr) +# 2759 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2759 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2786 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmod(double x, double y) +# 2786 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2786 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2816 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double remainder(double x, double y) +# 2816 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2816 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2849 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float remainderf(float x, float y) +# 2849 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2849 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2887 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double remquo(double x, double y, int *quo) +# 2887 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2887 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2925 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float remquof(float x, float y, int *quo) +# 2925 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2925 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2946 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double j0(double x) +# 2946 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2946 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2968 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float j0f(float x) +# 2968 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2968 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2995 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double j1(double x) +# 2995 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2995 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3022 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float j1f(float x) +# 3022 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3022 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3045 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double jn(int n, double x) +# 3045 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3045 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3068 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float jnf(int n, float x) +# 3068 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3068 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3095 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double y0(double x) +# 3095 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3095 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3122 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float y0f(float x) +# 3122 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3122 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3149 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double y1(double x) +# 3149 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3149 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3176 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float y1f(float x) +# 3176 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3176 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double yn(int n, double x) +# 3204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3232 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ynf(int n, float x) +# 3232 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3232 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3250 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double cyl_bessel_i0(double x) +# 3250 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3250 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float cyl_bessel_i0f(float x) +# 3267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double cyl_bessel_i1(double x) +# 3285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3302 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float cyl_bessel_i1f(float x) +# 3302 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3302 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erf(double x) +# 3328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erff(float x) +# 3353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3383 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfinv(double x); +# 3406 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfinvf(float x); +# 3430 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfc(double x) +# 3430 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3430 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3453 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcf(float x) +# 3453 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3453 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3485 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double lgamma(double x) +# 3485 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3485 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3513 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfcinv(double x); +# 3534 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcinvf(float x); +# 3556 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double normcdfinv(double x); +# 3578 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normcdfinvf(float x); +# 3597 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double normcdf(double x); +# 3616 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normcdff(float x); +# 3636 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfcx(double x); +# 3656 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcxf(float x); +# 3689 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float lgammaf(float x) +# 3689 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3689 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3718 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tgamma(double x) +# 3718 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3718 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3747 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tgammaf(float x) +# 3747 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3747 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3761 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double copysign(double x, double y) +# 3761 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3761 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3775 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float copysignf(float x, float y) +# 3775 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3775 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3794 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nextafter(double x, double y) +# 3794 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3794 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3813 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nextafterf(float x, float y) +# 3813 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3813 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3829 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nan(const char *tagp) +# 3829 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3829 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3845 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nanf(const char *tagp) +# 3845 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3845 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinff(float) +# 3852 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3852 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnanf(float) +# 3853 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3853 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3863 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finite(double) +# 3863 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3863 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finitef(float) +# 3864 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3864 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbit(double) +# 3865 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3865 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnan(double) +# 3866 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3866 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinf(double) +# 3867 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3867 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitf(float) +# 3870 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3870 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3921 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fma(double x, double y, double z) +# 3921 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3921 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmaf(float x, float y, float z) +# 3971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3982 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitl(long double) +# 3982 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3982 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finitel(long double) +# 3988 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3988 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinfl(long double) +# 3989 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3989 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnanl(long double) +# 3990 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3990 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float acosf(float x) +# 4034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4056 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float asinf(float x) +# 4056 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4056 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4083 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atanf(float x) +# 4083 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4083 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4163 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atan2f(float y, float x) +# 4163 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4163 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4182 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cosf(float x) +# 4182 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4182 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4202 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinf(float x) +# 4202 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4202 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4222 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tanf(float x) +# 4222 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4222 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4241 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float coshf(float x) +# 4241 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4241 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4261 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinhf(float x) +# 4261 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4261 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4281 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tanhf(float x) +# 4281 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4281 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4304 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float logf(float x) +# 4304 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4304 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4334 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float expf(float x) +# 4334 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4334 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4357 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log10f(float x) +# 4357 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4357 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4380 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float modff(float x, float *iptr) +# 4380 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4380 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4463 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float powf(float x, float y) +# 4463 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4463 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4487 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sqrtf(float x) +# 4487 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4487 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4510 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ceilf(float x) +# 4510 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4510 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4533 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float floorf(float x) +# 4533 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4533 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4559 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmodf(float x, float y) +# 4559 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4559 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4574 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +} + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/math.h" 1 3 +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/math.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/requires_hosted.h" 1 3 +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 1 3 +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 2 3 +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + struct __true_type { }; + struct __false_type { }; + + template + struct __truth_type + { typedef __false_type __type; }; + + template<> + struct __truth_type + { typedef __true_type __type; }; + + + + template + struct __traitor + { + enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; + typedef typename __truth_type<__value>::__type __type; + }; + + + template + struct __are_same + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __are_same<_Tp, _Tp> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_void + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_void + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_integer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 185 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 273 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +__extension__ template<> struct __is_integer<__int128> { enum { __value = 1 }; typedef __true_type __type; }; __extension__ template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; +# 290 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + template + struct __is_floating + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 367 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + template + struct __is_pointer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __is_pointer<_Tp*> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_arithmetic + : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > + { }; + + + + + template + struct __is_scalar + : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > + { }; + + + + + template + struct __is_char + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_byte + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + enum class byte : unsigned char; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 471 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + template struct iterator_traits; + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = __is_trivially_copyable(_Tp) }; + }; + + + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = 0 }; + }; + + + template + struct __memcpyable + { + enum { __value = 0 }; + }; + + template + struct __memcpyable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcpyable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + template + struct __memcmpable + { + enum { __value = 0 }; + }; + + + template + struct __memcmpable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + + template::__value + + > + struct __is_memcmp_ordered + { + static const bool __value = _Tp(-1) > _Tp(1); + }; + + template + struct __is_memcmp_ordered<_Tp, false> + { + static const bool __value = false; + }; + + + template + struct __is_memcmp_ordered_with + { + static const bool __value = __is_memcmp_ordered<_Tp>::__value + && __is_memcmp_ordered<_Up>::__value; + }; + + template + struct __is_memcmp_ordered_with<_Tp, _Up, false> + { + static const bool __value = false; + }; +# 580 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + template<> + struct __is_memcmp_ordered_with + { static constexpr bool __value = true; }; + + template + struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> + { static constexpr bool __value = false; }; + + template + struct __is_memcmp_ordered_with + { static constexpr bool __value = false; }; + + + + + + template + struct __is_move_iterator + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + template + + inline _Iterator + __miter_base(_Iterator __it) + { return __it; } + + +} +} +# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 + +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 + + + + +extern "C++" { + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct __enable_if + { }; + + template + struct __enable_if + { typedef _Tp __type; }; + + + + template + struct __conditional_type + { typedef _Iftrue __type; }; + + template + struct __conditional_type + { typedef _Iffalse __type; }; + + + + template + struct __add_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned short __type; }; + + template<> + struct __add_unsigned + { typedef unsigned int __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long long __type; }; + + + template<> + struct __add_unsigned; + + template<> + struct __add_unsigned; + + + + template + struct __remove_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef short __type; }; + + template<> + struct __remove_unsigned + { typedef int __type; }; + + template<> + struct __remove_unsigned + { typedef long __type; }; + + template<> + struct __remove_unsigned + { typedef long long __type; }; + + + template<> + struct __remove_unsigned; + + template<> + struct __remove_unsigned; + + + + template + constexpr + inline bool + __is_null_pointer(_Type* __ptr) + { return __ptr == 0; } + + template + constexpr + inline bool + __is_null_pointer(_Type) + { return false; } + + + constexpr bool + __is_null_pointer(std::nullptr_t) + { return true; } + + + + + template::__value> + struct __promote + { typedef double __type; }; + + + + + template + struct __promote<_Tp, false> + { }; + + template<> + struct __promote + { typedef long double __type; }; + + template<> + struct __promote + { typedef double __type; }; + + template<> + struct __promote + { typedef float __type; }; +# 225 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 + template + using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); + + + + template + using __promote_2 = __promote<__promoted_t<_Tp, _Up>>; + + template + using __promote_3 = __promote<__promoted_t<_Tp, _Up, _Vp>>; + + template + using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>; +# 269 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 + +} +} +# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 + +# 1 "/usr/include/math.h" 1 3 4 +# 27 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 28 "/usr/include/math.h" 2 3 4 + + + + + + +extern "C" { + + + + + +# 1 "/usr/include/bits/math-vector.h" 1 3 4 +# 25 "/usr/include/bits/math-vector.h" 3 4 +# 1 "/usr/include/bits/libm-simd-decl-stubs.h" 1 3 4 +# 26 "/usr/include/bits/math-vector.h" 2 3 4 +# 41 "/usr/include/math.h" 2 3 4 +# 156 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/flt-eval-method.h" 1 3 4 +# 157 "/usr/include/math.h" 2 3 4 +# 167 "/usr/include/math.h" 3 4 +typedef float float_t; +typedef double double_t; +# 208 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/fp-logb.h" 1 3 4 +# 209 "/usr/include/math.h" 2 3 4 +# 251 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/fp-fast.h" 1 3 4 +# 252 "/usr/include/math.h" 2 3 4 + + + +enum + { + FP_INT_UPWARD = + + 0, + FP_INT_DOWNWARD = + + 1, + FP_INT_TOWARDZERO = + + 2, + FP_INT_TONEARESTFROMZERO = + + 3, + FP_INT_TONEAREST = + + 4, + }; + + +# 1 "/usr/include/bits/mathcalls-macros.h" 1 3 4 +# 276 "/usr/include/math.h" 2 3 4 + + + + + +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassify (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbit (double __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinf (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finite (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnan (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsig (double __x, double __y) noexcept (true); + + +extern int __issignaling (double __value) noexcept (true) + __attribute__ ((__const__)); +# 282 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern double acos (double __x) noexcept (true); extern double __acos (double __x) noexcept (true); + + extern double asin (double __x) noexcept (true); extern double __asin (double __x) noexcept (true); + + extern double atan (double __x) noexcept (true); extern double __atan (double __x) noexcept (true); + + extern double atan2 (double __y, double __x) noexcept (true); extern double __atan2 (double __y, double __x) noexcept (true); + + + extern double cos (double __x) noexcept (true); extern double __cos (double __x) noexcept (true); + + extern double sin (double __x) noexcept (true); extern double __sin (double __x) noexcept (true); + + extern double tan (double __x) noexcept (true); extern double __tan (double __x) noexcept (true); + + + +extern double acospi (double __x) noexcept (true); extern double __acospi (double __x) noexcept (true); + +extern double asinpi (double __x) noexcept (true); extern double __asinpi (double __x) noexcept (true); + +extern double atanpi (double __x) noexcept (true); extern double __atanpi (double __x) noexcept (true); + +extern double atan2pi (double __y, double __x) noexcept (true); extern double __atan2pi (double __y, double __x) noexcept (true); + + + extern double cospi (double __x) noexcept (true); extern double __cospi (double __x) noexcept (true); + + extern double sinpi (double __x) noexcept (true); extern double __sinpi (double __x) noexcept (true); + + extern double tanpi (double __x) noexcept (true); extern double __tanpi (double __x) noexcept (true); + + + + + + extern double cosh (double __x) noexcept (true); extern double __cosh (double __x) noexcept (true); + + extern double sinh (double __x) noexcept (true); extern double __sinh (double __x) noexcept (true); + + extern double tanh (double __x) noexcept (true); extern double __tanh (double __x) noexcept (true); + + + + extern void sincos (double __x, double *__sinx, double *__cosx) noexcept (true); extern void __sincos (double __x, double *__sinx, double *__cosx) noexcept (true) + ; + + + + + extern double acosh (double __x) noexcept (true); extern double __acosh (double __x) noexcept (true); + + extern double asinh (double __x) noexcept (true); extern double __asinh (double __x) noexcept (true); + + extern double atanh (double __x) noexcept (true); extern double __atanh (double __x) noexcept (true); + + + + + + extern double exp (double __x) noexcept (true); extern double __exp (double __x) noexcept (true); + + +extern double frexp (double __x, int *__exponent) noexcept (true); extern double __frexp (double __x, int *__exponent) noexcept (true); + + +extern double ldexp (double __x, int __exponent) noexcept (true); extern double __ldexp (double __x, int __exponent) noexcept (true); + + + extern double log (double __x) noexcept (true); extern double __log (double __x) noexcept (true); + + + extern double log10 (double __x) noexcept (true); extern double __log10 (double __x) noexcept (true); + + +extern double modf (double __x, double *__iptr) noexcept (true); extern double __modf (double __x, double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern double exp10 (double __x) noexcept (true); extern double __exp10 (double __x) noexcept (true); + + +extern double exp2m1 (double __x) noexcept (true); extern double __exp2m1 (double __x) noexcept (true); + + +extern double exp10m1 (double __x) noexcept (true); extern double __exp10m1 (double __x) noexcept (true); + + +extern double log2p1 (double __x) noexcept (true); extern double __log2p1 (double __x) noexcept (true); + + +extern double log10p1 (double __x) noexcept (true); extern double __log10p1 (double __x) noexcept (true); + + + extern double logp1 (double __x) noexcept (true); extern double __logp1 (double __x) noexcept (true); + + + + + extern double expm1 (double __x) noexcept (true); extern double __expm1 (double __x) noexcept (true); + + + extern double log1p (double __x) noexcept (true); extern double __log1p (double __x) noexcept (true); + + +extern double logb (double __x) noexcept (true); extern double __logb (double __x) noexcept (true); + + + + + extern double exp2 (double __x) noexcept (true); extern double __exp2 (double __x) noexcept (true); + + + extern double log2 (double __x) noexcept (true); extern double __log2 (double __x) noexcept (true); + + + + + + + extern double pow (double __x, double __y) noexcept (true); extern double __pow (double __x, double __y) noexcept (true); + + +extern double sqrt (double __x) noexcept (true); extern double __sqrt (double __x) noexcept (true); + + + + extern double hypot (double __x, double __y) noexcept (true); extern double __hypot (double __x, double __y) noexcept (true); + + + + + extern double cbrt (double __x) noexcept (true); extern double __cbrt (double __x) noexcept (true); + + + + + + +extern double ceil (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double fabs (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double floor (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double fmod (double __x, double __y) noexcept (true); extern double __fmod (double __x, double __y) noexcept (true); +# 216 "/usr/include/bits/mathcalls.h" 3 4 +extern int finite (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern double drem (double __x, double __y) noexcept (true); extern double __drem (double __x, double __y) noexcept (true); + + + +extern double significand (double __x) noexcept (true); extern double __significand (double __x) noexcept (true); + + + + + + +extern double copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern double nan (const char *__tagb) noexcept (true); extern double __nan (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern double j0 (double) noexcept (true); extern double __j0 (double) noexcept (true); +extern double j1 (double) noexcept (true); extern double __j1 (double) noexcept (true); +extern double jn (int, double) noexcept (true); extern double __jn (int, double) noexcept (true); +extern double y0 (double) noexcept (true); extern double __y0 (double) noexcept (true); +extern double y1 (double) noexcept (true); extern double __y1 (double) noexcept (true); +extern double yn (int, double) noexcept (true); extern double __yn (int, double) noexcept (true); + + + + + + extern double erf (double) noexcept (true); extern double __erf (double) noexcept (true); + extern double erfc (double) noexcept (true); extern double __erfc (double) noexcept (true); +extern double lgamma (double) noexcept (true); extern double __lgamma (double) noexcept (true); + + + + +extern double tgamma (double) noexcept (true); extern double __tgamma (double) noexcept (true); + + + + + +extern double gamma (double) noexcept (true); extern double __gamma (double) noexcept (true); + + + + + + + +extern double lgamma_r (double, int *__signgamp) noexcept (true); extern double __lgamma_r (double, int *__signgamp) noexcept (true); + + + + + + +extern double rint (double __x) noexcept (true); extern double __rint (double __x) noexcept (true); + + +extern double nextafter (double __x, double __y) noexcept (true); extern double __nextafter (double __x, double __y) noexcept (true); + +extern double nexttoward (double __x, long double __y) noexcept (true); extern double __nexttoward (double __x, long double __y) noexcept (true); + + + + +extern double nextdown (double __x) noexcept (true); extern double __nextdown (double __x) noexcept (true); + +extern double nextup (double __x) noexcept (true); extern double __nextup (double __x) noexcept (true); + + + +extern double remainder (double __x, double __y) noexcept (true); extern double __remainder (double __x, double __y) noexcept (true); + + + +extern double scalbn (double __x, int __n) noexcept (true); extern double __scalbn (double __x, int __n) noexcept (true); + + + +extern int ilogb (double __x) noexcept (true); extern int __ilogb (double __x) noexcept (true); + + + + +extern long int llogb (double __x) noexcept (true); extern long int __llogb (double __x) noexcept (true); + + + + +extern double scalbln (double __x, long int __n) noexcept (true); extern double __scalbln (double __x, long int __n) noexcept (true); + + + +extern double nearbyint (double __x) noexcept (true); extern double __nearbyint (double __x) noexcept (true); + + + +extern double round (double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern double trunc (double __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern double remquo (double __x, double __y, int *__quo) noexcept (true); extern double __remquo (double __x, double __y, int *__quo) noexcept (true); + + + + + + +extern long int lrint (double __x) noexcept (true); extern long int __lrint (double __x) noexcept (true); +__extension__ +extern long long int llrint (double __x) noexcept (true); extern long long int __llrint (double __x) noexcept (true); + + + +extern long int lround (double __x) noexcept (true); extern long int __lround (double __x) noexcept (true); +__extension__ +extern long long int llround (double __x) noexcept (true); extern long long int __llround (double __x) noexcept (true); + + + +extern double fdim (double __x, double __y) noexcept (true); extern double __fdim (double __x, double __y) noexcept (true); + + + +extern double fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + +extern double fma (double __x, double __y, double __z) noexcept (true); extern double __fma (double __x, double __y, double __z) noexcept (true); + + + + +extern double roundeven (double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfp (double __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfp (double __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpx (double __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpx (double __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalize (double *__cx, const double *__x) noexcept (true); + + + + + + +extern double fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern double fmaximum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorder (const double *__x, const double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermag (const double *__x, const double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern double getpayload (const double *__x) noexcept (true); extern double __getpayload (const double *__x) noexcept (true); + + +extern int setpayload (double *__x, double __payload) noexcept (true); + + +extern int setpayloadsig (double *__x, double __payload) noexcept (true); + + + + + + + +extern double scalb (double __x, double __n) noexcept (true); extern double __scalb (double __x, double __n) noexcept (true); +# 283 "/usr/include/math.h" 2 3 4 +# 298 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyf (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitf (float __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinff (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitef (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanf (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigf (float __x, float __y) noexcept (true); + + +extern int __issignalingf (float __value) noexcept (true) + __attribute__ ((__const__)); +# 299 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern float acosf (float __x) noexcept (true); extern float __acosf (float __x) noexcept (true); + + extern float asinf (float __x) noexcept (true); extern float __asinf (float __x) noexcept (true); + + extern float atanf (float __x) noexcept (true); extern float __atanf (float __x) noexcept (true); + + extern float atan2f (float __y, float __x) noexcept (true); extern float __atan2f (float __y, float __x) noexcept (true); + + + extern float cosf (float __x) noexcept (true); extern float __cosf (float __x) noexcept (true); + + extern float sinf (float __x) noexcept (true); extern float __sinf (float __x) noexcept (true); + + extern float tanf (float __x) noexcept (true); extern float __tanf (float __x) noexcept (true); + + + +extern float acospif (float __x) noexcept (true); extern float __acospif (float __x) noexcept (true); + +extern float asinpif (float __x) noexcept (true); extern float __asinpif (float __x) noexcept (true); + +extern float atanpif (float __x) noexcept (true); extern float __atanpif (float __x) noexcept (true); + +extern float atan2pif (float __y, float __x) noexcept (true); extern float __atan2pif (float __y, float __x) noexcept (true); + + + extern float cospif (float __x) noexcept (true); extern float __cospif (float __x) noexcept (true); + + extern float sinpif (float __x) noexcept (true); extern float __sinpif (float __x) noexcept (true); + + extern float tanpif (float __x) noexcept (true); extern float __tanpif (float __x) noexcept (true); + + + + + + extern float coshf (float __x) noexcept (true); extern float __coshf (float __x) noexcept (true); + + extern float sinhf (float __x) noexcept (true); extern float __sinhf (float __x) noexcept (true); + + extern float tanhf (float __x) noexcept (true); extern float __tanhf (float __x) noexcept (true); + + + + extern void sincosf (float __x, float *__sinx, float *__cosx) noexcept (true); extern void __sincosf (float __x, float *__sinx, float *__cosx) noexcept (true) + ; + + + + + extern float acoshf (float __x) noexcept (true); extern float __acoshf (float __x) noexcept (true); + + extern float asinhf (float __x) noexcept (true); extern float __asinhf (float __x) noexcept (true); + + extern float atanhf (float __x) noexcept (true); extern float __atanhf (float __x) noexcept (true); + + + + + + extern float expf (float __x) noexcept (true); extern float __expf (float __x) noexcept (true); + + +extern float frexpf (float __x, int *__exponent) noexcept (true); extern float __frexpf (float __x, int *__exponent) noexcept (true); + + +extern float ldexpf (float __x, int __exponent) noexcept (true); extern float __ldexpf (float __x, int __exponent) noexcept (true); + + + extern float logf (float __x) noexcept (true); extern float __logf (float __x) noexcept (true); + + + extern float log10f (float __x) noexcept (true); extern float __log10f (float __x) noexcept (true); + + +extern float modff (float __x, float *__iptr) noexcept (true); extern float __modff (float __x, float *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern float exp10f (float __x) noexcept (true); extern float __exp10f (float __x) noexcept (true); + + +extern float exp2m1f (float __x) noexcept (true); extern float __exp2m1f (float __x) noexcept (true); + + +extern float exp10m1f (float __x) noexcept (true); extern float __exp10m1f (float __x) noexcept (true); + + +extern float log2p1f (float __x) noexcept (true); extern float __log2p1f (float __x) noexcept (true); + + +extern float log10p1f (float __x) noexcept (true); extern float __log10p1f (float __x) noexcept (true); + + + extern float logp1f (float __x) noexcept (true); extern float __logp1f (float __x) noexcept (true); + + + + + extern float expm1f (float __x) noexcept (true); extern float __expm1f (float __x) noexcept (true); + + + extern float log1pf (float __x) noexcept (true); extern float __log1pf (float __x) noexcept (true); + + +extern float logbf (float __x) noexcept (true); extern float __logbf (float __x) noexcept (true); + + + + + extern float exp2f (float __x) noexcept (true); extern float __exp2f (float __x) noexcept (true); + + + extern float log2f (float __x) noexcept (true); extern float __log2f (float __x) noexcept (true); + + + + + + + extern float powf (float __x, float __y) noexcept (true); extern float __powf (float __x, float __y) noexcept (true); + + +extern float sqrtf (float __x) noexcept (true); extern float __sqrtf (float __x) noexcept (true); + + + + extern float hypotf (float __x, float __y) noexcept (true); extern float __hypotf (float __x, float __y) noexcept (true); + + + + + extern float cbrtf (float __x) noexcept (true); extern float __cbrtf (float __x) noexcept (true); + + + + + + +extern float ceilf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float fabsf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float floorf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float fmodf (float __x, float __y) noexcept (true); extern float __fmodf (float __x, float __y) noexcept (true); +# 210 "/usr/include/bits/mathcalls.h" 3 4 +extern int isinff (float __value) noexcept (true) + __attribute__ ((__const__)); + + + + +extern int finitef (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern float dremf (float __x, float __y) noexcept (true); extern float __dremf (float __x, float __y) noexcept (true); + + + +extern float significandf (float __x) noexcept (true); extern float __significandf (float __x) noexcept (true); + + + + + + +extern float copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern float nanf (const char *__tagb) noexcept (true); extern float __nanf (const char *__tagb) noexcept (true); +# 246 "/usr/include/bits/mathcalls.h" 3 4 +extern int isnanf (float __value) noexcept (true) + __attribute__ ((__const__)); + + + + + +extern float j0f (float) noexcept (true); extern float __j0f (float) noexcept (true); +extern float j1f (float) noexcept (true); extern float __j1f (float) noexcept (true); +extern float jnf (int, float) noexcept (true); extern float __jnf (int, float) noexcept (true); +extern float y0f (float) noexcept (true); extern float __y0f (float) noexcept (true); +extern float y1f (float) noexcept (true); extern float __y1f (float) noexcept (true); +extern float ynf (int, float) noexcept (true); extern float __ynf (int, float) noexcept (true); + + + + + + extern float erff (float) noexcept (true); extern float __erff (float) noexcept (true); + extern float erfcf (float) noexcept (true); extern float __erfcf (float) noexcept (true); +extern float lgammaf (float) noexcept (true); extern float __lgammaf (float) noexcept (true); + + + + +extern float tgammaf (float) noexcept (true); extern float __tgammaf (float) noexcept (true); + + + + + +extern float gammaf (float) noexcept (true); extern float __gammaf (float) noexcept (true); + + + + + + + +extern float lgammaf_r (float, int *__signgamp) noexcept (true); extern float __lgammaf_r (float, int *__signgamp) noexcept (true); + + + + + + +extern float rintf (float __x) noexcept (true); extern float __rintf (float __x) noexcept (true); + + +extern float nextafterf (float __x, float __y) noexcept (true); extern float __nextafterf (float __x, float __y) noexcept (true); + +extern float nexttowardf (float __x, long double __y) noexcept (true); extern float __nexttowardf (float __x, long double __y) noexcept (true); + + + + +extern float nextdownf (float __x) noexcept (true); extern float __nextdownf (float __x) noexcept (true); + +extern float nextupf (float __x) noexcept (true); extern float __nextupf (float __x) noexcept (true); + + + +extern float remainderf (float __x, float __y) noexcept (true); extern float __remainderf (float __x, float __y) noexcept (true); + + + +extern float scalbnf (float __x, int __n) noexcept (true); extern float __scalbnf (float __x, int __n) noexcept (true); + + + +extern int ilogbf (float __x) noexcept (true); extern int __ilogbf (float __x) noexcept (true); + + + + +extern long int llogbf (float __x) noexcept (true); extern long int __llogbf (float __x) noexcept (true); + + + + +extern float scalblnf (float __x, long int __n) noexcept (true); extern float __scalblnf (float __x, long int __n) noexcept (true); + + + +extern float nearbyintf (float __x) noexcept (true); extern float __nearbyintf (float __x) noexcept (true); + + + +extern float roundf (float __x) noexcept (true) __attribute__ ((__const__)); + + + +extern float truncf (float __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern float remquof (float __x, float __y, int *__quo) noexcept (true); extern float __remquof (float __x, float __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf (float __x) noexcept (true); extern long int __lrintf (float __x) noexcept (true); +__extension__ +extern long long int llrintf (float __x) noexcept (true); extern long long int __llrintf (float __x) noexcept (true); + + + +extern long int lroundf (float __x) noexcept (true); extern long int __lroundf (float __x) noexcept (true); +__extension__ +extern long long int llroundf (float __x) noexcept (true); extern long long int __llroundf (float __x) noexcept (true); + + + +extern float fdimf (float __x, float __y) noexcept (true); extern float __fdimf (float __x, float __y) noexcept (true); + + + +extern float fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + +extern float fmaf (float __x, float __y, float __z) noexcept (true); extern float __fmaf (float __x, float __y, float __z) noexcept (true); + + + + +extern float roundevenf (float __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf (float __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf (float __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf (float __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef (float *__cx, const float *__x) noexcept (true); + + + + + + +extern float fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern float fmaximumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf (const float *__x, const float *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf (const float *__x, const float *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern float getpayloadf (const float *__x) noexcept (true); extern float __getpayloadf (const float *__x) noexcept (true); + + +extern int setpayloadf (float *__x, float __payload) noexcept (true); + + +extern int setpayloadsigf (float *__x, float __payload) noexcept (true); + + + + + + + +extern float scalbf (float __x, float __n) noexcept (true); extern float __scalbf (float __x, float __n) noexcept (true); +# 300 "/usr/include/math.h" 2 3 4 +# 367 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinfl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitel (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigl (long double __x, long double __y) noexcept (true); + + +extern int __issignalingl (long double __value) noexcept (true) + __attribute__ ((__const__)); +# 368 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern long double acosl (long double __x) noexcept (true); extern long double __acosl (long double __x) noexcept (true); + + extern long double asinl (long double __x) noexcept (true); extern long double __asinl (long double __x) noexcept (true); + + extern long double atanl (long double __x) noexcept (true); extern long double __atanl (long double __x) noexcept (true); + + extern long double atan2l (long double __y, long double __x) noexcept (true); extern long double __atan2l (long double __y, long double __x) noexcept (true); + + + extern long double cosl (long double __x) noexcept (true); extern long double __cosl (long double __x) noexcept (true); + + extern long double sinl (long double __x) noexcept (true); extern long double __sinl (long double __x) noexcept (true); + + extern long double tanl (long double __x) noexcept (true); extern long double __tanl (long double __x) noexcept (true); + + + +extern long double acospil (long double __x) noexcept (true); extern long double __acospil (long double __x) noexcept (true); + +extern long double asinpil (long double __x) noexcept (true); extern long double __asinpil (long double __x) noexcept (true); + +extern long double atanpil (long double __x) noexcept (true); extern long double __atanpil (long double __x) noexcept (true); + +extern long double atan2pil (long double __y, long double __x) noexcept (true); extern long double __atan2pil (long double __y, long double __x) noexcept (true); + + + extern long double cospil (long double __x) noexcept (true); extern long double __cospil (long double __x) noexcept (true); + + extern long double sinpil (long double __x) noexcept (true); extern long double __sinpil (long double __x) noexcept (true); + + extern long double tanpil (long double __x) noexcept (true); extern long double __tanpil (long double __x) noexcept (true); + + + + + + extern long double coshl (long double __x) noexcept (true); extern long double __coshl (long double __x) noexcept (true); + + extern long double sinhl (long double __x) noexcept (true); extern long double __sinhl (long double __x) noexcept (true); + + extern long double tanhl (long double __x) noexcept (true); extern long double __tanhl (long double __x) noexcept (true); + + + + extern void sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true) + ; + + + + + extern long double acoshl (long double __x) noexcept (true); extern long double __acoshl (long double __x) noexcept (true); + + extern long double asinhl (long double __x) noexcept (true); extern long double __asinhl (long double __x) noexcept (true); + + extern long double atanhl (long double __x) noexcept (true); extern long double __atanhl (long double __x) noexcept (true); + + + + + + extern long double expl (long double __x) noexcept (true); extern long double __expl (long double __x) noexcept (true); + + +extern long double frexpl (long double __x, int *__exponent) noexcept (true); extern long double __frexpl (long double __x, int *__exponent) noexcept (true); + + +extern long double ldexpl (long double __x, int __exponent) noexcept (true); extern long double __ldexpl (long double __x, int __exponent) noexcept (true); + + + extern long double logl (long double __x) noexcept (true); extern long double __logl (long double __x) noexcept (true); + + + extern long double log10l (long double __x) noexcept (true); extern long double __log10l (long double __x) noexcept (true); + + +extern long double modfl (long double __x, long double *__iptr) noexcept (true); extern long double __modfl (long double __x, long double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern long double exp10l (long double __x) noexcept (true); extern long double __exp10l (long double __x) noexcept (true); + + +extern long double exp2m1l (long double __x) noexcept (true); extern long double __exp2m1l (long double __x) noexcept (true); + + +extern long double exp10m1l (long double __x) noexcept (true); extern long double __exp10m1l (long double __x) noexcept (true); + + +extern long double log2p1l (long double __x) noexcept (true); extern long double __log2p1l (long double __x) noexcept (true); + + +extern long double log10p1l (long double __x) noexcept (true); extern long double __log10p1l (long double __x) noexcept (true); + + + extern long double logp1l (long double __x) noexcept (true); extern long double __logp1l (long double __x) noexcept (true); + + + + + extern long double expm1l (long double __x) noexcept (true); extern long double __expm1l (long double __x) noexcept (true); + + + extern long double log1pl (long double __x) noexcept (true); extern long double __log1pl (long double __x) noexcept (true); + + +extern long double logbl (long double __x) noexcept (true); extern long double __logbl (long double __x) noexcept (true); + + + + + extern long double exp2l (long double __x) noexcept (true); extern long double __exp2l (long double __x) noexcept (true); + + + extern long double log2l (long double __x) noexcept (true); extern long double __log2l (long double __x) noexcept (true); + + + + + + + extern long double powl (long double __x, long double __y) noexcept (true); extern long double __powl (long double __x, long double __y) noexcept (true); + + +extern long double sqrtl (long double __x) noexcept (true); extern long double __sqrtl (long double __x) noexcept (true); + + + + extern long double hypotl (long double __x, long double __y) noexcept (true); extern long double __hypotl (long double __x, long double __y) noexcept (true); + + + + + extern long double cbrtl (long double __x) noexcept (true); extern long double __cbrtl (long double __x) noexcept (true); + + + + + + +extern long double ceill (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double floorl (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmodl (long double __x, long double __y) noexcept (true); extern long double __fmodl (long double __x, long double __y) noexcept (true); +# 210 "/usr/include/bits/mathcalls.h" 3 4 +extern int isinfl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + + +extern int finitel (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern long double dreml (long double __x, long double __y) noexcept (true); extern long double __dreml (long double __x, long double __y) noexcept (true); + + + +extern long double significandl (long double __x) noexcept (true); extern long double __significandl (long double __x) noexcept (true); + + + + + + +extern long double copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double nanl (const char *__tagb) noexcept (true); extern long double __nanl (const char *__tagb) noexcept (true); +# 246 "/usr/include/bits/mathcalls.h" 3 4 +extern int isnanl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + + + +extern long double j0l (long double) noexcept (true); extern long double __j0l (long double) noexcept (true); +extern long double j1l (long double) noexcept (true); extern long double __j1l (long double) noexcept (true); +extern long double jnl (int, long double) noexcept (true); extern long double __jnl (int, long double) noexcept (true); +extern long double y0l (long double) noexcept (true); extern long double __y0l (long double) noexcept (true); +extern long double y1l (long double) noexcept (true); extern long double __y1l (long double) noexcept (true); +extern long double ynl (int, long double) noexcept (true); extern long double __ynl (int, long double) noexcept (true); + + + + + + extern long double erfl (long double) noexcept (true); extern long double __erfl (long double) noexcept (true); + extern long double erfcl (long double) noexcept (true); extern long double __erfcl (long double) noexcept (true); +extern long double lgammal (long double) noexcept (true); extern long double __lgammal (long double) noexcept (true); + + + + +extern long double tgammal (long double) noexcept (true); extern long double __tgammal (long double) noexcept (true); + + + + + +extern long double gammal (long double) noexcept (true); extern long double __gammal (long double) noexcept (true); + + + + + + + +extern long double lgammal_r (long double, int *__signgamp) noexcept (true); extern long double __lgammal_r (long double, int *__signgamp) noexcept (true); + + + + + + +extern long double rintl (long double __x) noexcept (true); extern long double __rintl (long double __x) noexcept (true); + + +extern long double nextafterl (long double __x, long double __y) noexcept (true); extern long double __nextafterl (long double __x, long double __y) noexcept (true); + +extern long double nexttowardl (long double __x, long double __y) noexcept (true); extern long double __nexttowardl (long double __x, long double __y) noexcept (true); + + + + +extern long double nextdownl (long double __x) noexcept (true); extern long double __nextdownl (long double __x) noexcept (true); + +extern long double nextupl (long double __x) noexcept (true); extern long double __nextupl (long double __x) noexcept (true); + + + +extern long double remainderl (long double __x, long double __y) noexcept (true); extern long double __remainderl (long double __x, long double __y) noexcept (true); + + + +extern long double scalbnl (long double __x, int __n) noexcept (true); extern long double __scalbnl (long double __x, int __n) noexcept (true); + + + +extern int ilogbl (long double __x) noexcept (true); extern int __ilogbl (long double __x) noexcept (true); + + + + +extern long int llogbl (long double __x) noexcept (true); extern long int __llogbl (long double __x) noexcept (true); + + + + +extern long double scalblnl (long double __x, long int __n) noexcept (true); extern long double __scalblnl (long double __x, long int __n) noexcept (true); + + + +extern long double nearbyintl (long double __x) noexcept (true); extern long double __nearbyintl (long double __x) noexcept (true); + + + +extern long double roundl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern long double truncl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double remquol (long double __x, long double __y, int *__quo) noexcept (true); extern long double __remquol (long double __x, long double __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintl (long double __x) noexcept (true); extern long int __lrintl (long double __x) noexcept (true); +__extension__ +extern long long int llrintl (long double __x) noexcept (true); extern long long int __llrintl (long double __x) noexcept (true); + + + +extern long int lroundl (long double __x) noexcept (true); extern long int __lroundl (long double __x) noexcept (true); +__extension__ +extern long long int llroundl (long double __x) noexcept (true); extern long long int __llroundl (long double __x) noexcept (true); + + + +extern long double fdiml (long double __x, long double __y) noexcept (true); extern long double __fdiml (long double __x, long double __y) noexcept (true); + + + +extern long double fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + +extern long double fmal (long double __x, long double __y, long double __z) noexcept (true); extern long double __fmal (long double __x, long double __y, long double __z) noexcept (true); + + + + +extern long double roundevenl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpl (long double __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizel (long double *__cx, const long double *__x) noexcept (true); + + + + + + +extern long double fmaxmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double fmaximuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderl (const long double *__x, const long double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagl (const long double *__x, const long double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern long double getpayloadl (const long double *__x) noexcept (true); extern long double __getpayloadl (const long double *__x) noexcept (true); + + +extern int setpayloadl (long double *__x, long double __payload) noexcept (true); + + +extern int setpayloadsigl (long double *__x, long double __payload) noexcept (true); + + + + + + + +extern long double scalbl (long double __x, long double __n) noexcept (true); extern long double __scalbl (long double __x, long double __n) noexcept (true); +# 369 "/usr/include/math.h" 2 3 4 +# 419 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float32 acosf32 (_Float32 __x) noexcept (true); extern _Float32 __acosf32 (_Float32 __x) noexcept (true); + + extern _Float32 asinf32 (_Float32 __x) noexcept (true); extern _Float32 __asinf32 (_Float32 __x) noexcept (true); + + extern _Float32 atanf32 (_Float32 __x) noexcept (true); extern _Float32 __atanf32 (_Float32 __x) noexcept (true); + + extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); + + + extern _Float32 cosf32 (_Float32 __x) noexcept (true); extern _Float32 __cosf32 (_Float32 __x) noexcept (true); + + extern _Float32 sinf32 (_Float32 __x) noexcept (true); extern _Float32 __sinf32 (_Float32 __x) noexcept (true); + + extern _Float32 tanf32 (_Float32 __x) noexcept (true); extern _Float32 __tanf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 acospif32 (_Float32 __x) noexcept (true); extern _Float32 __acospif32 (_Float32 __x) noexcept (true); + +extern _Float32 asinpif32 (_Float32 __x) noexcept (true); extern _Float32 __asinpif32 (_Float32 __x) noexcept (true); + +extern _Float32 atanpif32 (_Float32 __x) noexcept (true); extern _Float32 __atanpif32 (_Float32 __x) noexcept (true); + +extern _Float32 atan2pif32 (_Float32 __y, _Float32 __x) noexcept (true); extern _Float32 __atan2pif32 (_Float32 __y, _Float32 __x) noexcept (true); + + + extern _Float32 cospif32 (_Float32 __x) noexcept (true); extern _Float32 __cospif32 (_Float32 __x) noexcept (true); + + extern _Float32 sinpif32 (_Float32 __x) noexcept (true); extern _Float32 __sinpif32 (_Float32 __x) noexcept (true); + + extern _Float32 tanpif32 (_Float32 __x) noexcept (true); extern _Float32 __tanpif32 (_Float32 __x) noexcept (true); + + + + + + extern _Float32 coshf32 (_Float32 __x) noexcept (true); extern _Float32 __coshf32 (_Float32 __x) noexcept (true); + + extern _Float32 sinhf32 (_Float32 __x) noexcept (true); extern _Float32 __sinhf32 (_Float32 __x) noexcept (true); + + extern _Float32 tanhf32 (_Float32 __x) noexcept (true); extern _Float32 __tanhf32 (_Float32 __x) noexcept (true); + + + + extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true) + ; + + + + + extern _Float32 acoshf32 (_Float32 __x) noexcept (true); extern _Float32 __acoshf32 (_Float32 __x) noexcept (true); + + extern _Float32 asinhf32 (_Float32 __x) noexcept (true); extern _Float32 __asinhf32 (_Float32 __x) noexcept (true); + + extern _Float32 atanhf32 (_Float32 __x) noexcept (true); extern _Float32 __atanhf32 (_Float32 __x) noexcept (true); + + + + + + extern _Float32 expf32 (_Float32 __x) noexcept (true); extern _Float32 __expf32 (_Float32 __x) noexcept (true); + + +extern _Float32 frexpf32 (_Float32 __x, int *__exponent) noexcept (true); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) noexcept (true); + + +extern _Float32 ldexpf32 (_Float32 __x, int __exponent) noexcept (true); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) noexcept (true); + + + extern _Float32 logf32 (_Float32 __x) noexcept (true); extern _Float32 __logf32 (_Float32 __x) noexcept (true); + + + extern _Float32 log10f32 (_Float32 __x) noexcept (true); extern _Float32 __log10f32 (_Float32 __x) noexcept (true); + + +extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true); extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float32 exp10f32 (_Float32 __x) noexcept (true); extern _Float32 __exp10f32 (_Float32 __x) noexcept (true); + + +extern _Float32 exp2m1f32 (_Float32 __x) noexcept (true); extern _Float32 __exp2m1f32 (_Float32 __x) noexcept (true); + + +extern _Float32 exp10m1f32 (_Float32 __x) noexcept (true); extern _Float32 __exp10m1f32 (_Float32 __x) noexcept (true); + + +extern _Float32 log2p1f32 (_Float32 __x) noexcept (true); extern _Float32 __log2p1f32 (_Float32 __x) noexcept (true); + + +extern _Float32 log10p1f32 (_Float32 __x) noexcept (true); extern _Float32 __log10p1f32 (_Float32 __x) noexcept (true); + + + extern _Float32 logp1f32 (_Float32 __x) noexcept (true); extern _Float32 __logp1f32 (_Float32 __x) noexcept (true); + + + + + extern _Float32 expm1f32 (_Float32 __x) noexcept (true); extern _Float32 __expm1f32 (_Float32 __x) noexcept (true); + + + extern _Float32 log1pf32 (_Float32 __x) noexcept (true); extern _Float32 __log1pf32 (_Float32 __x) noexcept (true); + + +extern _Float32 logbf32 (_Float32 __x) noexcept (true); extern _Float32 __logbf32 (_Float32 __x) noexcept (true); + + + + + extern _Float32 exp2f32 (_Float32 __x) noexcept (true); extern _Float32 __exp2f32 (_Float32 __x) noexcept (true); + + + extern _Float32 log2f32 (_Float32 __x) noexcept (true); extern _Float32 __log2f32 (_Float32 __x) noexcept (true); + + + + + + + extern _Float32 powf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) noexcept (true); + + +extern _Float32 sqrtf32 (_Float32 __x) noexcept (true); extern _Float32 __sqrtf32 (_Float32 __x) noexcept (true); + + + + extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + + + extern _Float32 cbrtf32 (_Float32 __x) noexcept (true); extern _Float32 __cbrtf32 (_Float32 __x) noexcept (true); + + + + + + +extern _Float32 ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); +# 231 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 nanf32 (const char *__tagb) noexcept (true); extern _Float32 __nanf32 (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32 j0f32 (_Float32) noexcept (true); extern _Float32 __j0f32 (_Float32) noexcept (true); +extern _Float32 j1f32 (_Float32) noexcept (true); extern _Float32 __j1f32 (_Float32) noexcept (true); +extern _Float32 jnf32 (int, _Float32) noexcept (true); extern _Float32 __jnf32 (int, _Float32) noexcept (true); +extern _Float32 y0f32 (_Float32) noexcept (true); extern _Float32 __y0f32 (_Float32) noexcept (true); +extern _Float32 y1f32 (_Float32) noexcept (true); extern _Float32 __y1f32 (_Float32) noexcept (true); +extern _Float32 ynf32 (int, _Float32) noexcept (true); extern _Float32 __ynf32 (int, _Float32) noexcept (true); + + + + + + extern _Float32 erff32 (_Float32) noexcept (true); extern _Float32 __erff32 (_Float32) noexcept (true); + extern _Float32 erfcf32 (_Float32) noexcept (true); extern _Float32 __erfcf32 (_Float32) noexcept (true); +extern _Float32 lgammaf32 (_Float32) noexcept (true); extern _Float32 __lgammaf32 (_Float32) noexcept (true); + + + + +extern _Float32 tgammaf32 (_Float32) noexcept (true); extern _Float32 __tgammaf32 (_Float32) noexcept (true); +# 285 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32 lgammaf32_r (_Float32, int *__signgamp) noexcept (true); extern _Float32 __lgammaf32_r (_Float32, int *__signgamp) noexcept (true); + + + + + + +extern _Float32 rintf32 (_Float32 __x) noexcept (true); extern _Float32 __rintf32 (_Float32 __x) noexcept (true); + + +extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + + + + +extern _Float32 nextdownf32 (_Float32 __x) noexcept (true); extern _Float32 __nextdownf32 (_Float32 __x) noexcept (true); + +extern _Float32 nextupf32 (_Float32 __x) noexcept (true); extern _Float32 __nextupf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + +extern _Float32 scalbnf32 (_Float32 __x, int __n) noexcept (true); extern _Float32 __scalbnf32 (_Float32 __x, int __n) noexcept (true); + + + +extern int ilogbf32 (_Float32 __x) noexcept (true); extern int __ilogbf32 (_Float32 __x) noexcept (true); + + + + +extern long int llogbf32 (_Float32 __x) noexcept (true); extern long int __llogbf32 (_Float32 __x) noexcept (true); + + + + +extern _Float32 scalblnf32 (_Float32 __x, long int __n) noexcept (true); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) noexcept (true); + + + +extern _Float32 nearbyintf32 (_Float32 __x) noexcept (true); extern _Float32 __nearbyintf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32 truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf32 (_Float32 __x) noexcept (true); extern long int __lrintf32 (_Float32 __x) noexcept (true); +__extension__ +extern long long int llrintf32 (_Float32 __x) noexcept (true); extern long long int __llrintf32 (_Float32 __x) noexcept (true); + + + +extern long int lroundf32 (_Float32 __x) noexcept (true); extern long int __lroundf32 (_Float32 __x) noexcept (true); +__extension__ +extern long long int llroundf32 (_Float32 __x) noexcept (true); extern long long int __llroundf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + +extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); + + + + +extern _Float32 roundevenf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) noexcept (true); + + + + + + +extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 fmaximumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float32 getpayloadf32 (const _Float32 *__x) noexcept (true); extern _Float32 __getpayloadf32 (const _Float32 *__x) noexcept (true); + + +extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) noexcept (true); + + +extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) noexcept (true); +# 420 "/usr/include/math.h" 2 3 4 +# 436 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float64 acosf64 (_Float64 __x) noexcept (true); extern _Float64 __acosf64 (_Float64 __x) noexcept (true); + + extern _Float64 asinf64 (_Float64 __x) noexcept (true); extern _Float64 __asinf64 (_Float64 __x) noexcept (true); + + extern _Float64 atanf64 (_Float64 __x) noexcept (true); extern _Float64 __atanf64 (_Float64 __x) noexcept (true); + + extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); extern _Float64 __atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); + + + extern _Float64 cosf64 (_Float64 __x) noexcept (true); extern _Float64 __cosf64 (_Float64 __x) noexcept (true); + + extern _Float64 sinf64 (_Float64 __x) noexcept (true); extern _Float64 __sinf64 (_Float64 __x) noexcept (true); + + extern _Float64 tanf64 (_Float64 __x) noexcept (true); extern _Float64 __tanf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 acospif64 (_Float64 __x) noexcept (true); extern _Float64 __acospif64 (_Float64 __x) noexcept (true); + +extern _Float64 asinpif64 (_Float64 __x) noexcept (true); extern _Float64 __asinpif64 (_Float64 __x) noexcept (true); + +extern _Float64 atanpif64 (_Float64 __x) noexcept (true); extern _Float64 __atanpif64 (_Float64 __x) noexcept (true); + +extern _Float64 atan2pif64 (_Float64 __y, _Float64 __x) noexcept (true); extern _Float64 __atan2pif64 (_Float64 __y, _Float64 __x) noexcept (true); + + + extern _Float64 cospif64 (_Float64 __x) noexcept (true); extern _Float64 __cospif64 (_Float64 __x) noexcept (true); + + extern _Float64 sinpif64 (_Float64 __x) noexcept (true); extern _Float64 __sinpif64 (_Float64 __x) noexcept (true); + + extern _Float64 tanpif64 (_Float64 __x) noexcept (true); extern _Float64 __tanpif64 (_Float64 __x) noexcept (true); + + + + + + extern _Float64 coshf64 (_Float64 __x) noexcept (true); extern _Float64 __coshf64 (_Float64 __x) noexcept (true); + + extern _Float64 sinhf64 (_Float64 __x) noexcept (true); extern _Float64 __sinhf64 (_Float64 __x) noexcept (true); + + extern _Float64 tanhf64 (_Float64 __x) noexcept (true); extern _Float64 __tanhf64 (_Float64 __x) noexcept (true); + + + + extern void sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) noexcept (true); extern void __sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) noexcept (true) + ; + + + + + extern _Float64 acoshf64 (_Float64 __x) noexcept (true); extern _Float64 __acoshf64 (_Float64 __x) noexcept (true); + + extern _Float64 asinhf64 (_Float64 __x) noexcept (true); extern _Float64 __asinhf64 (_Float64 __x) noexcept (true); + + extern _Float64 atanhf64 (_Float64 __x) noexcept (true); extern _Float64 __atanhf64 (_Float64 __x) noexcept (true); + + + + + + extern _Float64 expf64 (_Float64 __x) noexcept (true); extern _Float64 __expf64 (_Float64 __x) noexcept (true); + + +extern _Float64 frexpf64 (_Float64 __x, int *__exponent) noexcept (true); extern _Float64 __frexpf64 (_Float64 __x, int *__exponent) noexcept (true); + + +extern _Float64 ldexpf64 (_Float64 __x, int __exponent) noexcept (true); extern _Float64 __ldexpf64 (_Float64 __x, int __exponent) noexcept (true); + + + extern _Float64 logf64 (_Float64 __x) noexcept (true); extern _Float64 __logf64 (_Float64 __x) noexcept (true); + + + extern _Float64 log10f64 (_Float64 __x) noexcept (true); extern _Float64 __log10f64 (_Float64 __x) noexcept (true); + + +extern _Float64 modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true); extern _Float64 __modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float64 exp10f64 (_Float64 __x) noexcept (true); extern _Float64 __exp10f64 (_Float64 __x) noexcept (true); + + +extern _Float64 exp2m1f64 (_Float64 __x) noexcept (true); extern _Float64 __exp2m1f64 (_Float64 __x) noexcept (true); + + +extern _Float64 exp10m1f64 (_Float64 __x) noexcept (true); extern _Float64 __exp10m1f64 (_Float64 __x) noexcept (true); + + +extern _Float64 log2p1f64 (_Float64 __x) noexcept (true); extern _Float64 __log2p1f64 (_Float64 __x) noexcept (true); + + +extern _Float64 log10p1f64 (_Float64 __x) noexcept (true); extern _Float64 __log10p1f64 (_Float64 __x) noexcept (true); + + + extern _Float64 logp1f64 (_Float64 __x) noexcept (true); extern _Float64 __logp1f64 (_Float64 __x) noexcept (true); + + + + + extern _Float64 expm1f64 (_Float64 __x) noexcept (true); extern _Float64 __expm1f64 (_Float64 __x) noexcept (true); + + + extern _Float64 log1pf64 (_Float64 __x) noexcept (true); extern _Float64 __log1pf64 (_Float64 __x) noexcept (true); + + +extern _Float64 logbf64 (_Float64 __x) noexcept (true); extern _Float64 __logbf64 (_Float64 __x) noexcept (true); + + + + + extern _Float64 exp2f64 (_Float64 __x) noexcept (true); extern _Float64 __exp2f64 (_Float64 __x) noexcept (true); + + + extern _Float64 log2f64 (_Float64 __x) noexcept (true); extern _Float64 __log2f64 (_Float64 __x) noexcept (true); + + + + + + + extern _Float64 powf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __powf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float64 sqrtf64 (_Float64 __x) noexcept (true); extern _Float64 __sqrtf64 (_Float64 __x) noexcept (true); + + + + extern _Float64 hypotf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __hypotf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + + + extern _Float64 cbrtf64 (_Float64 __x) noexcept (true); extern _Float64 __cbrtf64 (_Float64 __x) noexcept (true); + + + + + + +extern _Float64 ceilf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fabsf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 floorf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmodf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __fmodf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 231 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64 nanf64 (const char *__tagb) noexcept (true); extern _Float64 __nanf64 (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64 j0f64 (_Float64) noexcept (true); extern _Float64 __j0f64 (_Float64) noexcept (true); +extern _Float64 j1f64 (_Float64) noexcept (true); extern _Float64 __j1f64 (_Float64) noexcept (true); +extern _Float64 jnf64 (int, _Float64) noexcept (true); extern _Float64 __jnf64 (int, _Float64) noexcept (true); +extern _Float64 y0f64 (_Float64) noexcept (true); extern _Float64 __y0f64 (_Float64) noexcept (true); +extern _Float64 y1f64 (_Float64) noexcept (true); extern _Float64 __y1f64 (_Float64) noexcept (true); +extern _Float64 ynf64 (int, _Float64) noexcept (true); extern _Float64 __ynf64 (int, _Float64) noexcept (true); + + + + + + extern _Float64 erff64 (_Float64) noexcept (true); extern _Float64 __erff64 (_Float64) noexcept (true); + extern _Float64 erfcf64 (_Float64) noexcept (true); extern _Float64 __erfcf64 (_Float64) noexcept (true); +extern _Float64 lgammaf64 (_Float64) noexcept (true); extern _Float64 __lgammaf64 (_Float64) noexcept (true); + + + + +extern _Float64 tgammaf64 (_Float64) noexcept (true); extern _Float64 __tgammaf64 (_Float64) noexcept (true); +# 285 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64 lgammaf64_r (_Float64, int *__signgamp) noexcept (true); extern _Float64 __lgammaf64_r (_Float64, int *__signgamp) noexcept (true); + + + + + + +extern _Float64 rintf64 (_Float64 __x) noexcept (true); extern _Float64 __rintf64 (_Float64 __x) noexcept (true); + + +extern _Float64 nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + + + + +extern _Float64 nextdownf64 (_Float64 __x) noexcept (true); extern _Float64 __nextdownf64 (_Float64 __x) noexcept (true); + +extern _Float64 nextupf64 (_Float64 __x) noexcept (true); extern _Float64 __nextupf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 remainderf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __remainderf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + +extern _Float64 scalbnf64 (_Float64 __x, int __n) noexcept (true); extern _Float64 __scalbnf64 (_Float64 __x, int __n) noexcept (true); + + + +extern int ilogbf64 (_Float64 __x) noexcept (true); extern int __ilogbf64 (_Float64 __x) noexcept (true); + + + + +extern long int llogbf64 (_Float64 __x) noexcept (true); extern long int __llogbf64 (_Float64 __x) noexcept (true); + + + + +extern _Float64 scalblnf64 (_Float64 __x, long int __n) noexcept (true); extern _Float64 __scalblnf64 (_Float64 __x, long int __n) noexcept (true); + + + +extern _Float64 nearbyintf64 (_Float64 __x) noexcept (true); extern _Float64 __nearbyintf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 roundf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64 truncf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64 remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcept (true); extern _Float64 __remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf64 (_Float64 __x) noexcept (true); extern long int __lrintf64 (_Float64 __x) noexcept (true); +__extension__ +extern long long int llrintf64 (_Float64 __x) noexcept (true); extern long long int __llrintf64 (_Float64 __x) noexcept (true); + + + +extern long int lroundf64 (_Float64 __x) noexcept (true); extern long int __lroundf64 (_Float64 __x) noexcept (true); +__extension__ +extern long long int llroundf64 (_Float64 __x) noexcept (true); extern long long int __llroundf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 fdimf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __fdimf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + +extern _Float64 fmaxf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64 fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); extern _Float64 __fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); + + + + +extern _Float64 roundevenf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef64 (_Float64 *__cx, const _Float64 *__x) noexcept (true); + + + + + + +extern _Float64 fmaxmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64 fmaximumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf64 (const _Float64 *__x, const _Float64 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf64 (const _Float64 *__x, const _Float64 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float64 getpayloadf64 (const _Float64 *__x) noexcept (true); extern _Float64 __getpayloadf64 (const _Float64 *__x) noexcept (true); + + +extern int setpayloadf64 (_Float64 *__x, _Float64 __payload) noexcept (true); + + +extern int setpayloadsigf64 (_Float64 *__x, _Float64 __payload) noexcept (true); +# 437 "/usr/include/math.h" 2 3 4 +# 450 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyf128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitf128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinff128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitef128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanf128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern int __issignalingf128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); +# 451 "/usr/include/math.h" 2 3 4 + + +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float128 acosf128 (_Float128 __x) noexcept (true); extern _Float128 __acosf128 (_Float128 __x) noexcept (true); + + extern _Float128 asinf128 (_Float128 __x) noexcept (true); extern _Float128 __asinf128 (_Float128 __x) noexcept (true); + + extern _Float128 atanf128 (_Float128 __x) noexcept (true); extern _Float128 __atanf128 (_Float128 __x) noexcept (true); + + extern _Float128 atan2f128 (_Float128 __y, _Float128 __x) noexcept (true); extern _Float128 __atan2f128 (_Float128 __y, _Float128 __x) noexcept (true); + + + extern _Float128 cosf128 (_Float128 __x) noexcept (true); extern _Float128 __cosf128 (_Float128 __x) noexcept (true); + + extern _Float128 sinf128 (_Float128 __x) noexcept (true); extern _Float128 __sinf128 (_Float128 __x) noexcept (true); + + extern _Float128 tanf128 (_Float128 __x) noexcept (true); extern _Float128 __tanf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 acospif128 (_Float128 __x) noexcept (true); extern _Float128 __acospif128 (_Float128 __x) noexcept (true); + +extern _Float128 asinpif128 (_Float128 __x) noexcept (true); extern _Float128 __asinpif128 (_Float128 __x) noexcept (true); + +extern _Float128 atanpif128 (_Float128 __x) noexcept (true); extern _Float128 __atanpif128 (_Float128 __x) noexcept (true); + +extern _Float128 atan2pif128 (_Float128 __y, _Float128 __x) noexcept (true); extern _Float128 __atan2pif128 (_Float128 __y, _Float128 __x) noexcept (true); + + + extern _Float128 cospif128 (_Float128 __x) noexcept (true); extern _Float128 __cospif128 (_Float128 __x) noexcept (true); + + extern _Float128 sinpif128 (_Float128 __x) noexcept (true); extern _Float128 __sinpif128 (_Float128 __x) noexcept (true); + + extern _Float128 tanpif128 (_Float128 __x) noexcept (true); extern _Float128 __tanpif128 (_Float128 __x) noexcept (true); + + + + + + extern _Float128 coshf128 (_Float128 __x) noexcept (true); extern _Float128 __coshf128 (_Float128 __x) noexcept (true); + + extern _Float128 sinhf128 (_Float128 __x) noexcept (true); extern _Float128 __sinhf128 (_Float128 __x) noexcept (true); + + extern _Float128 tanhf128 (_Float128 __x) noexcept (true); extern _Float128 __tanhf128 (_Float128 __x) noexcept (true); + + + + extern void sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) noexcept (true); extern void __sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) noexcept (true) + ; + + + + + extern _Float128 acoshf128 (_Float128 __x) noexcept (true); extern _Float128 __acoshf128 (_Float128 __x) noexcept (true); + + extern _Float128 asinhf128 (_Float128 __x) noexcept (true); extern _Float128 __asinhf128 (_Float128 __x) noexcept (true); + + extern _Float128 atanhf128 (_Float128 __x) noexcept (true); extern _Float128 __atanhf128 (_Float128 __x) noexcept (true); + + + + + + extern _Float128 expf128 (_Float128 __x) noexcept (true); extern _Float128 __expf128 (_Float128 __x) noexcept (true); + + +extern _Float128 frexpf128 (_Float128 __x, int *__exponent) noexcept (true); extern _Float128 __frexpf128 (_Float128 __x, int *__exponent) noexcept (true); + + +extern _Float128 ldexpf128 (_Float128 __x, int __exponent) noexcept (true); extern _Float128 __ldexpf128 (_Float128 __x, int __exponent) noexcept (true); + + + extern _Float128 logf128 (_Float128 __x) noexcept (true); extern _Float128 __logf128 (_Float128 __x) noexcept (true); + + + extern _Float128 log10f128 (_Float128 __x) noexcept (true); extern _Float128 __log10f128 (_Float128 __x) noexcept (true); + + +extern _Float128 modff128 (_Float128 __x, _Float128 *__iptr) noexcept (true); extern _Float128 __modff128 (_Float128 __x, _Float128 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float128 exp10f128 (_Float128 __x) noexcept (true); extern _Float128 __exp10f128 (_Float128 __x) noexcept (true); + + +extern _Float128 exp2m1f128 (_Float128 __x) noexcept (true); extern _Float128 __exp2m1f128 (_Float128 __x) noexcept (true); + + +extern _Float128 exp10m1f128 (_Float128 __x) noexcept (true); extern _Float128 __exp10m1f128 (_Float128 __x) noexcept (true); + + +extern _Float128 log2p1f128 (_Float128 __x) noexcept (true); extern _Float128 __log2p1f128 (_Float128 __x) noexcept (true); + + +extern _Float128 log10p1f128 (_Float128 __x) noexcept (true); extern _Float128 __log10p1f128 (_Float128 __x) noexcept (true); + + + extern _Float128 logp1f128 (_Float128 __x) noexcept (true); extern _Float128 __logp1f128 (_Float128 __x) noexcept (true); + + + + + extern _Float128 expm1f128 (_Float128 __x) noexcept (true); extern _Float128 __expm1f128 (_Float128 __x) noexcept (true); + + + extern _Float128 log1pf128 (_Float128 __x) noexcept (true); extern _Float128 __log1pf128 (_Float128 __x) noexcept (true); + + +extern _Float128 logbf128 (_Float128 __x) noexcept (true); extern _Float128 __logbf128 (_Float128 __x) noexcept (true); + + + + + extern _Float128 exp2f128 (_Float128 __x) noexcept (true); extern _Float128 __exp2f128 (_Float128 __x) noexcept (true); + + + extern _Float128 log2f128 (_Float128 __x) noexcept (true); extern _Float128 __log2f128 (_Float128 __x) noexcept (true); + + + + + + + extern _Float128 powf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __powf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float128 sqrtf128 (_Float128 __x) noexcept (true); extern _Float128 __sqrtf128 (_Float128 __x) noexcept (true); + + + + extern _Float128 hypotf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __hypotf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + + + extern _Float128 cbrtf128 (_Float128 __x) noexcept (true); extern _Float128 __cbrtf128 (_Float128 __x) noexcept (true); + + + + + + +extern _Float128 ceilf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fabsf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 floorf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmodf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __fmodf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 231 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float128 copysignf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 nanf128 (const char *__tagb) noexcept (true); extern _Float128 __nanf128 (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float128 j0f128 (_Float128) noexcept (true); extern _Float128 __j0f128 (_Float128) noexcept (true); +extern _Float128 j1f128 (_Float128) noexcept (true); extern _Float128 __j1f128 (_Float128) noexcept (true); +extern _Float128 jnf128 (int, _Float128) noexcept (true); extern _Float128 __jnf128 (int, _Float128) noexcept (true); +extern _Float128 y0f128 (_Float128) noexcept (true); extern _Float128 __y0f128 (_Float128) noexcept (true); +extern _Float128 y1f128 (_Float128) noexcept (true); extern _Float128 __y1f128 (_Float128) noexcept (true); +extern _Float128 ynf128 (int, _Float128) noexcept (true); extern _Float128 __ynf128 (int, _Float128) noexcept (true); + + + + + + extern _Float128 erff128 (_Float128) noexcept (true); extern _Float128 __erff128 (_Float128) noexcept (true); + extern _Float128 erfcf128 (_Float128) noexcept (true); extern _Float128 __erfcf128 (_Float128) noexcept (true); +extern _Float128 lgammaf128 (_Float128) noexcept (true); extern _Float128 __lgammaf128 (_Float128) noexcept (true); + + + + +extern _Float128 tgammaf128 (_Float128) noexcept (true); extern _Float128 __tgammaf128 (_Float128) noexcept (true); +# 285 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float128 lgammaf128_r (_Float128, int *__signgamp) noexcept (true); extern _Float128 __lgammaf128_r (_Float128, int *__signgamp) noexcept (true); + + + + + + +extern _Float128 rintf128 (_Float128 __x) noexcept (true); extern _Float128 __rintf128 (_Float128 __x) noexcept (true); + + +extern _Float128 nextafterf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __nextafterf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + + + + +extern _Float128 nextdownf128 (_Float128 __x) noexcept (true); extern _Float128 __nextdownf128 (_Float128 __x) noexcept (true); + +extern _Float128 nextupf128 (_Float128 __x) noexcept (true); extern _Float128 __nextupf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 remainderf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __remainderf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + +extern _Float128 scalbnf128 (_Float128 __x, int __n) noexcept (true); extern _Float128 __scalbnf128 (_Float128 __x, int __n) noexcept (true); + + + +extern int ilogbf128 (_Float128 __x) noexcept (true); extern int __ilogbf128 (_Float128 __x) noexcept (true); + + + + +extern long int llogbf128 (_Float128 __x) noexcept (true); extern long int __llogbf128 (_Float128 __x) noexcept (true); + + + + +extern _Float128 scalblnf128 (_Float128 __x, long int __n) noexcept (true); extern _Float128 __scalblnf128 (_Float128 __x, long int __n) noexcept (true); + + + +extern _Float128 nearbyintf128 (_Float128 __x) noexcept (true); extern _Float128 __nearbyintf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 roundf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float128 truncf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 remquof128 (_Float128 __x, _Float128 __y, int *__quo) noexcept (true); extern _Float128 __remquof128 (_Float128 __x, _Float128 __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf128 (_Float128 __x) noexcept (true); extern long int __lrintf128 (_Float128 __x) noexcept (true); +__extension__ +extern long long int llrintf128 (_Float128 __x) noexcept (true); extern long long int __llrintf128 (_Float128 __x) noexcept (true); + + + +extern long int lroundf128 (_Float128 __x) noexcept (true); extern long int __lroundf128 (_Float128 __x) noexcept (true); +__extension__ +extern long long int llroundf128 (_Float128 __x) noexcept (true); extern long long int __llroundf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 fdimf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __fdimf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + +extern _Float128 fmaxf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float128 fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); extern _Float128 __fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + + + +extern _Float128 roundevenf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef128 (_Float128 *__cx, const _Float128 *__x) noexcept (true); + + + + + + +extern _Float128 fmaxmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 fmaximumf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimumf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmaximum_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmaximum_magf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_magf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmaximum_mag_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_mag_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf128 (const _Float128 *__x, const _Float128 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf128 (const _Float128 *__x, const _Float128 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float128 getpayloadf128 (const _Float128 *__x) noexcept (true); extern _Float128 __getpayloadf128 (const _Float128 *__x) noexcept (true); + + +extern int setpayloadf128 (_Float128 *__x, _Float128 __payload) noexcept (true); + + +extern int setpayloadsigf128 (_Float128 *__x, _Float128 __payload) noexcept (true); +# 454 "/usr/include/math.h" 2 3 4 +# 470 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float32x acosf32x (_Float32x __x) noexcept (true); extern _Float32x __acosf32x (_Float32x __x) noexcept (true); + + extern _Float32x asinf32x (_Float32x __x) noexcept (true); extern _Float32x __asinf32x (_Float32x __x) noexcept (true); + + extern _Float32x atanf32x (_Float32x __x) noexcept (true); extern _Float32x __atanf32x (_Float32x __x) noexcept (true); + + extern _Float32x atan2f32x (_Float32x __y, _Float32x __x) noexcept (true); extern _Float32x __atan2f32x (_Float32x __y, _Float32x __x) noexcept (true); + + + extern _Float32x cosf32x (_Float32x __x) noexcept (true); extern _Float32x __cosf32x (_Float32x __x) noexcept (true); + + extern _Float32x sinf32x (_Float32x __x) noexcept (true); extern _Float32x __sinf32x (_Float32x __x) noexcept (true); + + extern _Float32x tanf32x (_Float32x __x) noexcept (true); extern _Float32x __tanf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x acospif32x (_Float32x __x) noexcept (true); extern _Float32x __acospif32x (_Float32x __x) noexcept (true); + +extern _Float32x asinpif32x (_Float32x __x) noexcept (true); extern _Float32x __asinpif32x (_Float32x __x) noexcept (true); + +extern _Float32x atanpif32x (_Float32x __x) noexcept (true); extern _Float32x __atanpif32x (_Float32x __x) noexcept (true); + +extern _Float32x atan2pif32x (_Float32x __y, _Float32x __x) noexcept (true); extern _Float32x __atan2pif32x (_Float32x __y, _Float32x __x) noexcept (true); + + + extern _Float32x cospif32x (_Float32x __x) noexcept (true); extern _Float32x __cospif32x (_Float32x __x) noexcept (true); + + extern _Float32x sinpif32x (_Float32x __x) noexcept (true); extern _Float32x __sinpif32x (_Float32x __x) noexcept (true); + + extern _Float32x tanpif32x (_Float32x __x) noexcept (true); extern _Float32x __tanpif32x (_Float32x __x) noexcept (true); + + + + + + extern _Float32x coshf32x (_Float32x __x) noexcept (true); extern _Float32x __coshf32x (_Float32x __x) noexcept (true); + + extern _Float32x sinhf32x (_Float32x __x) noexcept (true); extern _Float32x __sinhf32x (_Float32x __x) noexcept (true); + + extern _Float32x tanhf32x (_Float32x __x) noexcept (true); extern _Float32x __tanhf32x (_Float32x __x) noexcept (true); + + + + extern void sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) noexcept (true); extern void __sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) noexcept (true) + ; + + + + + extern _Float32x acoshf32x (_Float32x __x) noexcept (true); extern _Float32x __acoshf32x (_Float32x __x) noexcept (true); + + extern _Float32x asinhf32x (_Float32x __x) noexcept (true); extern _Float32x __asinhf32x (_Float32x __x) noexcept (true); + + extern _Float32x atanhf32x (_Float32x __x) noexcept (true); extern _Float32x __atanhf32x (_Float32x __x) noexcept (true); + + + + + + extern _Float32x expf32x (_Float32x __x) noexcept (true); extern _Float32x __expf32x (_Float32x __x) noexcept (true); + + +extern _Float32x frexpf32x (_Float32x __x, int *__exponent) noexcept (true); extern _Float32x __frexpf32x (_Float32x __x, int *__exponent) noexcept (true); + + +extern _Float32x ldexpf32x (_Float32x __x, int __exponent) noexcept (true); extern _Float32x __ldexpf32x (_Float32x __x, int __exponent) noexcept (true); + + + extern _Float32x logf32x (_Float32x __x) noexcept (true); extern _Float32x __logf32x (_Float32x __x) noexcept (true); + + + extern _Float32x log10f32x (_Float32x __x) noexcept (true); extern _Float32x __log10f32x (_Float32x __x) noexcept (true); + + +extern _Float32x modff32x (_Float32x __x, _Float32x *__iptr) noexcept (true); extern _Float32x __modff32x (_Float32x __x, _Float32x *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float32x exp10f32x (_Float32x __x) noexcept (true); extern _Float32x __exp10f32x (_Float32x __x) noexcept (true); + + +extern _Float32x exp2m1f32x (_Float32x __x) noexcept (true); extern _Float32x __exp2m1f32x (_Float32x __x) noexcept (true); + + +extern _Float32x exp10m1f32x (_Float32x __x) noexcept (true); extern _Float32x __exp10m1f32x (_Float32x __x) noexcept (true); + + +extern _Float32x log2p1f32x (_Float32x __x) noexcept (true); extern _Float32x __log2p1f32x (_Float32x __x) noexcept (true); + + +extern _Float32x log10p1f32x (_Float32x __x) noexcept (true); extern _Float32x __log10p1f32x (_Float32x __x) noexcept (true); + + + extern _Float32x logp1f32x (_Float32x __x) noexcept (true); extern _Float32x __logp1f32x (_Float32x __x) noexcept (true); + + + + + extern _Float32x expm1f32x (_Float32x __x) noexcept (true); extern _Float32x __expm1f32x (_Float32x __x) noexcept (true); + + + extern _Float32x log1pf32x (_Float32x __x) noexcept (true); extern _Float32x __log1pf32x (_Float32x __x) noexcept (true); + + +extern _Float32x logbf32x (_Float32x __x) noexcept (true); extern _Float32x __logbf32x (_Float32x __x) noexcept (true); + + + + + extern _Float32x exp2f32x (_Float32x __x) noexcept (true); extern _Float32x __exp2f32x (_Float32x __x) noexcept (true); + + + extern _Float32x log2f32x (_Float32x __x) noexcept (true); extern _Float32x __log2f32x (_Float32x __x) noexcept (true); + + + + + + + extern _Float32x powf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __powf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32x sqrtf32x (_Float32x __x) noexcept (true); extern _Float32x __sqrtf32x (_Float32x __x) noexcept (true); + + + + extern _Float32x hypotf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __hypotf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + + + extern _Float32x cbrtf32x (_Float32x __x) noexcept (true); extern _Float32x __cbrtf32x (_Float32x __x) noexcept (true); + + + + + + +extern _Float32x ceilf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x floorf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); +# 231 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x nanf32x (const char *__tagb) noexcept (true); extern _Float32x __nanf32x (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32x j0f32x (_Float32x) noexcept (true); extern _Float32x __j0f32x (_Float32x) noexcept (true); +extern _Float32x j1f32x (_Float32x) noexcept (true); extern _Float32x __j1f32x (_Float32x) noexcept (true); +extern _Float32x jnf32x (int, _Float32x) noexcept (true); extern _Float32x __jnf32x (int, _Float32x) noexcept (true); +extern _Float32x y0f32x (_Float32x) noexcept (true); extern _Float32x __y0f32x (_Float32x) noexcept (true); +extern _Float32x y1f32x (_Float32x) noexcept (true); extern _Float32x __y1f32x (_Float32x) noexcept (true); +extern _Float32x ynf32x (int, _Float32x) noexcept (true); extern _Float32x __ynf32x (int, _Float32x) noexcept (true); + + + + + + extern _Float32x erff32x (_Float32x) noexcept (true); extern _Float32x __erff32x (_Float32x) noexcept (true); + extern _Float32x erfcf32x (_Float32x) noexcept (true); extern _Float32x __erfcf32x (_Float32x) noexcept (true); +extern _Float32x lgammaf32x (_Float32x) noexcept (true); extern _Float32x __lgammaf32x (_Float32x) noexcept (true); + + + + +extern _Float32x tgammaf32x (_Float32x) noexcept (true); extern _Float32x __tgammaf32x (_Float32x) noexcept (true); +# 285 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32x lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true); extern _Float32x __lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true); + + + + + + +extern _Float32x rintf32x (_Float32x __x) noexcept (true); extern _Float32x __rintf32x (_Float32x __x) noexcept (true); + + +extern _Float32x nextafterf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __nextafterf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + + + + +extern _Float32x nextdownf32x (_Float32x __x) noexcept (true); extern _Float32x __nextdownf32x (_Float32x __x) noexcept (true); + +extern _Float32x nextupf32x (_Float32x __x) noexcept (true); extern _Float32x __nextupf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x remainderf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __remainderf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + +extern _Float32x scalbnf32x (_Float32x __x, int __n) noexcept (true); extern _Float32x __scalbnf32x (_Float32x __x, int __n) noexcept (true); + + + +extern int ilogbf32x (_Float32x __x) noexcept (true); extern int __ilogbf32x (_Float32x __x) noexcept (true); + + + + +extern long int llogbf32x (_Float32x __x) noexcept (true); extern long int __llogbf32x (_Float32x __x) noexcept (true); + + + + +extern _Float32x scalblnf32x (_Float32x __x, long int __n) noexcept (true); extern _Float32x __scalblnf32x (_Float32x __x, long int __n) noexcept (true); + + + +extern _Float32x nearbyintf32x (_Float32x __x) noexcept (true); extern _Float32x __nearbyintf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x roundf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32x truncf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) noexcept (true); extern _Float32x __remquof32x (_Float32x __x, _Float32x __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf32x (_Float32x __x) noexcept (true); extern long int __lrintf32x (_Float32x __x) noexcept (true); +__extension__ +extern long long int llrintf32x (_Float32x __x) noexcept (true); extern long long int __llrintf32x (_Float32x __x) noexcept (true); + + + +extern long int lroundf32x (_Float32x __x) noexcept (true); extern long int __lroundf32x (_Float32x __x) noexcept (true); +__extension__ +extern long long int llroundf32x (_Float32x __x) noexcept (true); extern long long int __llroundf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x fdimf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fdimf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + +extern _Float32x fmaxf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32x fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); extern _Float32x __fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); + + + + +extern _Float32x roundevenf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef32x (_Float32x *__cx, const _Float32x *__x) noexcept (true); + + + + + + +extern _Float32x fmaxmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x fmaximumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf32x (const _Float32x *__x, const _Float32x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf32x (const _Float32x *__x, const _Float32x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float32x getpayloadf32x (const _Float32x *__x) noexcept (true); extern _Float32x __getpayloadf32x (const _Float32x *__x) noexcept (true); + + +extern int setpayloadf32x (_Float32x *__x, _Float32x __payload) noexcept (true); + + +extern int setpayloadsigf32x (_Float32x *__x, _Float32x __payload) noexcept (true); +# 471 "/usr/include/math.h" 2 3 4 +# 487 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float64x acosf64x (_Float64x __x) noexcept (true); extern _Float64x __acosf64x (_Float64x __x) noexcept (true); + + extern _Float64x asinf64x (_Float64x __x) noexcept (true); extern _Float64x __asinf64x (_Float64x __x) noexcept (true); + + extern _Float64x atanf64x (_Float64x __x) noexcept (true); extern _Float64x __atanf64x (_Float64x __x) noexcept (true); + + extern _Float64x atan2f64x (_Float64x __y, _Float64x __x) noexcept (true); extern _Float64x __atan2f64x (_Float64x __y, _Float64x __x) noexcept (true); + + + extern _Float64x cosf64x (_Float64x __x) noexcept (true); extern _Float64x __cosf64x (_Float64x __x) noexcept (true); + + extern _Float64x sinf64x (_Float64x __x) noexcept (true); extern _Float64x __sinf64x (_Float64x __x) noexcept (true); + + extern _Float64x tanf64x (_Float64x __x) noexcept (true); extern _Float64x __tanf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x acospif64x (_Float64x __x) noexcept (true); extern _Float64x __acospif64x (_Float64x __x) noexcept (true); + +extern _Float64x asinpif64x (_Float64x __x) noexcept (true); extern _Float64x __asinpif64x (_Float64x __x) noexcept (true); + +extern _Float64x atanpif64x (_Float64x __x) noexcept (true); extern _Float64x __atanpif64x (_Float64x __x) noexcept (true); + +extern _Float64x atan2pif64x (_Float64x __y, _Float64x __x) noexcept (true); extern _Float64x __atan2pif64x (_Float64x __y, _Float64x __x) noexcept (true); + + + extern _Float64x cospif64x (_Float64x __x) noexcept (true); extern _Float64x __cospif64x (_Float64x __x) noexcept (true); + + extern _Float64x sinpif64x (_Float64x __x) noexcept (true); extern _Float64x __sinpif64x (_Float64x __x) noexcept (true); + + extern _Float64x tanpif64x (_Float64x __x) noexcept (true); extern _Float64x __tanpif64x (_Float64x __x) noexcept (true); + + + + + + extern _Float64x coshf64x (_Float64x __x) noexcept (true); extern _Float64x __coshf64x (_Float64x __x) noexcept (true); + + extern _Float64x sinhf64x (_Float64x __x) noexcept (true); extern _Float64x __sinhf64x (_Float64x __x) noexcept (true); + + extern _Float64x tanhf64x (_Float64x __x) noexcept (true); extern _Float64x __tanhf64x (_Float64x __x) noexcept (true); + + + + extern void sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) noexcept (true); extern void __sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) noexcept (true) + ; + + + + + extern _Float64x acoshf64x (_Float64x __x) noexcept (true); extern _Float64x __acoshf64x (_Float64x __x) noexcept (true); + + extern _Float64x asinhf64x (_Float64x __x) noexcept (true); extern _Float64x __asinhf64x (_Float64x __x) noexcept (true); + + extern _Float64x atanhf64x (_Float64x __x) noexcept (true); extern _Float64x __atanhf64x (_Float64x __x) noexcept (true); + + + + + + extern _Float64x expf64x (_Float64x __x) noexcept (true); extern _Float64x __expf64x (_Float64x __x) noexcept (true); + + +extern _Float64x frexpf64x (_Float64x __x, int *__exponent) noexcept (true); extern _Float64x __frexpf64x (_Float64x __x, int *__exponent) noexcept (true); + + +extern _Float64x ldexpf64x (_Float64x __x, int __exponent) noexcept (true); extern _Float64x __ldexpf64x (_Float64x __x, int __exponent) noexcept (true); + + + extern _Float64x logf64x (_Float64x __x) noexcept (true); extern _Float64x __logf64x (_Float64x __x) noexcept (true); + + + extern _Float64x log10f64x (_Float64x __x) noexcept (true); extern _Float64x __log10f64x (_Float64x __x) noexcept (true); + + +extern _Float64x modff64x (_Float64x __x, _Float64x *__iptr) noexcept (true); extern _Float64x __modff64x (_Float64x __x, _Float64x *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float64x exp10f64x (_Float64x __x) noexcept (true); extern _Float64x __exp10f64x (_Float64x __x) noexcept (true); + + +extern _Float64x exp2m1f64x (_Float64x __x) noexcept (true); extern _Float64x __exp2m1f64x (_Float64x __x) noexcept (true); + + +extern _Float64x exp10m1f64x (_Float64x __x) noexcept (true); extern _Float64x __exp10m1f64x (_Float64x __x) noexcept (true); + + +extern _Float64x log2p1f64x (_Float64x __x) noexcept (true); extern _Float64x __log2p1f64x (_Float64x __x) noexcept (true); + + +extern _Float64x log10p1f64x (_Float64x __x) noexcept (true); extern _Float64x __log10p1f64x (_Float64x __x) noexcept (true); + + + extern _Float64x logp1f64x (_Float64x __x) noexcept (true); extern _Float64x __logp1f64x (_Float64x __x) noexcept (true); + + + + + extern _Float64x expm1f64x (_Float64x __x) noexcept (true); extern _Float64x __expm1f64x (_Float64x __x) noexcept (true); + + + extern _Float64x log1pf64x (_Float64x __x) noexcept (true); extern _Float64x __log1pf64x (_Float64x __x) noexcept (true); + + +extern _Float64x logbf64x (_Float64x __x) noexcept (true); extern _Float64x __logbf64x (_Float64x __x) noexcept (true); + + + + + extern _Float64x exp2f64x (_Float64x __x) noexcept (true); extern _Float64x __exp2f64x (_Float64x __x) noexcept (true); + + + extern _Float64x log2f64x (_Float64x __x) noexcept (true); extern _Float64x __log2f64x (_Float64x __x) noexcept (true); + + + + + + + extern _Float64x powf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __powf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64x sqrtf64x (_Float64x __x) noexcept (true); extern _Float64x __sqrtf64x (_Float64x __x) noexcept (true); + + + + extern _Float64x hypotf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __hypotf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + + + extern _Float64x cbrtf64x (_Float64x __x) noexcept (true); extern _Float64x __cbrtf64x (_Float64x __x) noexcept (true); + + + + + + +extern _Float64x ceilf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x floorf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 231 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x nanf64x (const char *__tagb) noexcept (true); extern _Float64x __nanf64x (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64x j0f64x (_Float64x) noexcept (true); extern _Float64x __j0f64x (_Float64x) noexcept (true); +extern _Float64x j1f64x (_Float64x) noexcept (true); extern _Float64x __j1f64x (_Float64x) noexcept (true); +extern _Float64x jnf64x (int, _Float64x) noexcept (true); extern _Float64x __jnf64x (int, _Float64x) noexcept (true); +extern _Float64x y0f64x (_Float64x) noexcept (true); extern _Float64x __y0f64x (_Float64x) noexcept (true); +extern _Float64x y1f64x (_Float64x) noexcept (true); extern _Float64x __y1f64x (_Float64x) noexcept (true); +extern _Float64x ynf64x (int, _Float64x) noexcept (true); extern _Float64x __ynf64x (int, _Float64x) noexcept (true); + + + + + + extern _Float64x erff64x (_Float64x) noexcept (true); extern _Float64x __erff64x (_Float64x) noexcept (true); + extern _Float64x erfcf64x (_Float64x) noexcept (true); extern _Float64x __erfcf64x (_Float64x) noexcept (true); +extern _Float64x lgammaf64x (_Float64x) noexcept (true); extern _Float64x __lgammaf64x (_Float64x) noexcept (true); + + + + +extern _Float64x tgammaf64x (_Float64x) noexcept (true); extern _Float64x __tgammaf64x (_Float64x) noexcept (true); +# 285 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64x lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true); extern _Float64x __lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true); + + + + + + +extern _Float64x rintf64x (_Float64x __x) noexcept (true); extern _Float64x __rintf64x (_Float64x __x) noexcept (true); + + +extern _Float64x nextafterf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __nextafterf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + + + + +extern _Float64x nextdownf64x (_Float64x __x) noexcept (true); extern _Float64x __nextdownf64x (_Float64x __x) noexcept (true); + +extern _Float64x nextupf64x (_Float64x __x) noexcept (true); extern _Float64x __nextupf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x remainderf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __remainderf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + +extern _Float64x scalbnf64x (_Float64x __x, int __n) noexcept (true); extern _Float64x __scalbnf64x (_Float64x __x, int __n) noexcept (true); + + + +extern int ilogbf64x (_Float64x __x) noexcept (true); extern int __ilogbf64x (_Float64x __x) noexcept (true); + + + + +extern long int llogbf64x (_Float64x __x) noexcept (true); extern long int __llogbf64x (_Float64x __x) noexcept (true); + + + + +extern _Float64x scalblnf64x (_Float64x __x, long int __n) noexcept (true); extern _Float64x __scalblnf64x (_Float64x __x, long int __n) noexcept (true); + + + +extern _Float64x nearbyintf64x (_Float64x __x) noexcept (true); extern _Float64x __nearbyintf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x roundf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64x truncf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) noexcept (true); extern _Float64x __remquof64x (_Float64x __x, _Float64x __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf64x (_Float64x __x) noexcept (true); extern long int __lrintf64x (_Float64x __x) noexcept (true); +__extension__ +extern long long int llrintf64x (_Float64x __x) noexcept (true); extern long long int __llrintf64x (_Float64x __x) noexcept (true); + + + +extern long int lroundf64x (_Float64x __x) noexcept (true); extern long int __lroundf64x (_Float64x __x) noexcept (true); +__extension__ +extern long long int llroundf64x (_Float64x __x) noexcept (true); extern long long int __llroundf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x fdimf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fdimf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + +extern _Float64x fmaxf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64x fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); extern _Float64x __fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + + + +extern _Float64x roundevenf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef64x (_Float64x *__cx, const _Float64x *__x) noexcept (true); + + + + + + +extern _Float64x fmaxmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x fmaximumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf64x (const _Float64x *__x, const _Float64x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf64x (const _Float64x *__x, const _Float64x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float64x getpayloadf64x (const _Float64x *__x) noexcept (true); extern _Float64x __getpayloadf64x (const _Float64x *__x) noexcept (true); + + +extern int setpayloadf64x (_Float64x *__x, _Float64x __payload) noexcept (true); + + +extern int setpayloadsigf64x (_Float64x *__x, _Float64x __payload) noexcept (true); +# 488 "/usr/include/math.h" 2 3 4 +# 535 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern float fadd (double __x, double __y) noexcept (true); + + +extern float fdiv (double __x, double __y) noexcept (true); + + +extern float ffma (double __x, double __y, double __z) noexcept (true); + + +extern float fmul (double __x, double __y) noexcept (true); + + +extern float fsqrt (double __x) noexcept (true); + + +extern float fsub (double __x, double __y) noexcept (true); +# 536 "/usr/include/math.h" 2 3 4 +# 556 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern float faddl (long double __x, long double __y) noexcept (true); + + +extern float fdivl (long double __x, long double __y) noexcept (true); + + +extern float ffmal (long double __x, long double __y, long double __z) noexcept (true); + + +extern float fmull (long double __x, long double __y) noexcept (true); + + +extern float fsqrtl (long double __x) noexcept (true); + + +extern float fsubl (long double __x, long double __y) noexcept (true); +# 557 "/usr/include/math.h" 2 3 4 +# 585 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern double daddl (long double __x, long double __y) noexcept (true); + + +extern double ddivl (long double __x, long double __y) noexcept (true); + + +extern double dfmal (long double __x, long double __y, long double __z) noexcept (true); + + +extern double dmull (long double __x, long double __y) noexcept (true); + + +extern double dsqrtl (long double __x) noexcept (true); + + +extern double dsubl (long double __x, long double __y) noexcept (true); +# 586 "/usr/include/math.h" 2 3 4 +# 666 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32divf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); + + +extern _Float32 f32mulf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32sqrtf32x (_Float32x __x) noexcept (true); + + +extern _Float32 f32subf32x (_Float32x __x, _Float32x __y) noexcept (true); +# 667 "/usr/include/math.h" 2 3 4 +# 676 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32divf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); + + +extern _Float32 f32mulf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32sqrtf64 (_Float64 __x) noexcept (true); + + +extern _Float32 f32subf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 677 "/usr/include/math.h" 2 3 4 +# 686 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32divf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + +extern _Float32 f32mulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32sqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float32 f32subf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 687 "/usr/include/math.h" 2 3 4 +# 696 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32divf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float32 f32mulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32sqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float32 f32subf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 697 "/usr/include/math.h" 2 3 4 +# 716 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xdivf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xfmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); + + +extern _Float32x f32xmulf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xsqrtf64 (_Float64 __x) noexcept (true); + + +extern _Float32x f32xsubf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 717 "/usr/include/math.h" 2 3 4 +# 726 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xdivf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xfmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + +extern _Float32x f32xmulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xsqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float32x f32xsubf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 727 "/usr/include/math.h" 2 3 4 +# 736 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xdivf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xfmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float32x f32xmulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xsqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float32x f32xsubf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 737 "/usr/include/math.h" 2 3 4 +# 756 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float64 f64addf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64divf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + +extern _Float64 f64mulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64sqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float64 f64subf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 757 "/usr/include/math.h" 2 3 4 +# 766 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float64 f64addf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64divf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float64 f64mulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64sqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float64 f64subf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 767 "/usr/include/math.h" 2 3 4 +# 786 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float64x f64xaddf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xdivf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xfmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float64x f64xmulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xsqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float64x f64xsubf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 787 "/usr/include/math.h" 2 3 4 +# 823 "/usr/include/math.h" 3 4 +extern int signgam; +# 903 "/usr/include/math.h" 3 4 +enum + { + FP_NAN = + + 0, + FP_INFINITE = + + 1, + FP_ZERO = + + 2, + FP_SUBNORMAL = + + 3, + FP_NORMAL = + + 4 + }; +# 1024 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/iscanonical.h" 1 3 4 +# 23 "/usr/include/bits/iscanonical.h" 3 4 +extern int __iscanonicall (long double __x) + noexcept (true) __attribute__ ((__const__)); +# 46 "/usr/include/bits/iscanonical.h" 3 4 +extern "C++" { +inline int iscanonical (float __val) { return ((void) (__typeof (__val)) (__val), 1); } +inline int iscanonical (double __val) { return ((void) (__typeof (__val)) (__val), 1); } +inline int iscanonical (long double __val) { return __iscanonicall (__val); } + +inline int iscanonical (_Float128 __val) { return ((void) (__typeof (__val)) (__val), 1); } + +} +# 1025 "/usr/include/math.h" 2 3 4 +# 1036 "/usr/include/math.h" 3 4 +extern "C++" { +inline int issignaling (float __val) { return __issignalingf (__val); } +inline int issignaling (double __val) { return __issignaling (__val); } +inline int +issignaling (long double __val) +{ + + + + return __issignalingl (__val); + +} + + + +inline int issignaling (_Float128 __val) { return __issignalingf128 (__val); } + +} +# 1067 "/usr/include/math.h" 3 4 +extern "C++" { +# 1098 "/usr/include/math.h" 3 4 +template inline bool +iszero (__T __val) +{ + return __val == 0; +} + +} +# 1333 "/usr/include/math.h" 3 4 +extern "C++" { +template struct __iseqsig_type; + +template<> struct __iseqsig_type +{ + static int __call (float __x, float __y) throw () + { + return __iseqsigf (__x, __y); + } +}; + +template<> struct __iseqsig_type +{ + static int __call (double __x, double __y) throw () + { + return __iseqsig (__x, __y); + } +}; + +template<> struct __iseqsig_type +{ + static int __call (long double __x, long double __y) throw () + { + + return __iseqsigl (__x, __y); + + + + } +}; + + +template<> struct __iseqsig_type<_Float32> +{ + static int __call (_Float32 __x, _Float32 __y) throw () + { + return __iseqsigf (__x, __y); + } +}; + + + +template<> struct __iseqsig_type<_Float64> +{ + static int __call (_Float64 __x, _Float64 __y) throw () + { + return __iseqsig (__x, __y); + } +}; + + + + + +template<> struct __iseqsig_type<_Float128> +{ + static int __call (_Float128 __x, _Float128 __y) throw () + { + + return __iseqsigf128 (__x, __y); + + + + } +}; + + + +template<> struct __iseqsig_type<_Float32x> +{ + static int __call (_Float32x __x, _Float32x __y) throw () + { + return __iseqsig (__x, __y); + } +}; + + + +template<> struct __iseqsig_type<_Float64x> +{ + static int __call (_Float64x __x, _Float64x __y) throw () + { + + return __iseqsigl (__x, __y); + + + + } +}; + + +template +inline int +iseqsig (_T1 __x, _T2 __y) throw () +{ + + typedef decltype (((__x) + (__y) + 0.0f)) _T3; + + + + return __iseqsig_type<_T3>::__call (__x, __y); +} + +} + + + + +} +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 +# 56 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 +# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::acos; + + + inline constexpr float + acos(float __x) + { return __builtin_acosf(__x); } + + inline constexpr long double + acos(long double __x) + { return __builtin_acosl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acos(_Tp __x) + { return __builtin_acos(__x); } + + using ::asin; + + + inline constexpr float + asin(float __x) + { return __builtin_asinf(__x); } + + inline constexpr long double + asin(long double __x) + { return __builtin_asinl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asin(_Tp __x) + { return __builtin_asin(__x); } + + using ::atan; + + + inline constexpr float + atan(float __x) + { return __builtin_atanf(__x); } + + inline constexpr long double + atan(long double __x) + { return __builtin_atanl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atan(_Tp __x) + { return __builtin_atan(__x); } + + using ::atan2; + + + inline constexpr float + atan2(float __y, float __x) + { return __builtin_atan2f(__y, __x); } + + inline constexpr long double + atan2(long double __y, long double __x) + { return __builtin_atan2l(__y, __x); } + + + using ::ceil; + + + inline constexpr float + ceil(float __x) + { return __builtin_ceilf(__x); } + + inline constexpr long double + ceil(long double __x) + { return __builtin_ceill(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ceil(_Tp __x) + { return __builtin_ceil(__x); } + + using ::cos; + + + inline constexpr float + cos(float __x) + { return __builtin_cosf(__x); } + + inline constexpr long double + cos(long double __x) + { return __builtin_cosl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cos(_Tp __x) + { return __builtin_cos(__x); } + + using ::cosh; + + + inline constexpr float + cosh(float __x) + { return __builtin_coshf(__x); } + + inline constexpr long double + cosh(long double __x) + { return __builtin_coshl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cosh(_Tp __x) + { return __builtin_cosh(__x); } + + using ::exp; + + + inline constexpr float + exp(float __x) + { return __builtin_expf(__x); } + + inline constexpr long double + exp(long double __x) + { return __builtin_expl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp(_Tp __x) + { return __builtin_exp(__x); } + + using ::fabs; + + + inline constexpr float + fabs(float __x) + { return __builtin_fabsf(__x); } + + inline constexpr long double + fabs(long double __x) + { return __builtin_fabsl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + fabs(_Tp __x) + { return __builtin_fabs(__x); } + + using ::floor; + + + inline constexpr float + floor(float __x) + { return __builtin_floorf(__x); } + + inline constexpr long double + floor(long double __x) + { return __builtin_floorl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + floor(_Tp __x) + { return __builtin_floor(__x); } + + using ::fmod; + + + inline constexpr float + fmod(float __x, float __y) + { return __builtin_fmodf(__x, __y); } + + inline constexpr long double + fmod(long double __x, long double __y) + { return __builtin_fmodl(__x, __y); } + + + using ::frexp; + + + inline float + frexp(float __x, int* __exp) + { return __builtin_frexpf(__x, __exp); } + + inline long double + frexp(long double __x, int* __exp) + { return __builtin_frexpl(__x, __exp); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + frexp(_Tp __x, int* __exp) + { return __builtin_frexp(__x, __exp); } + + using ::ldexp; + + + inline constexpr float + ldexp(float __x, int __exp) + { return __builtin_ldexpf(__x, __exp); } + + inline constexpr long double + ldexp(long double __x, int __exp) + { return __builtin_ldexpl(__x, __exp); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ldexp(_Tp __x, int __exp) + { return __builtin_ldexp(__x, __exp); } + + using ::log; + + + inline constexpr float + log(float __x) + { return __builtin_logf(__x); } + + inline constexpr long double + log(long double __x) + { return __builtin_logl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log(_Tp __x) + { return __builtin_log(__x); } + + using ::log10; + + + inline constexpr float + log10(float __x) + { return __builtin_log10f(__x); } + + inline constexpr long double + log10(long double __x) + { return __builtin_log10l(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log10(_Tp __x) + { return __builtin_log10(__x); } + + using ::modf; + + + inline float + modf(float __x, float* __iptr) + { return __builtin_modff(__x, __iptr); } + + inline long double + modf(long double __x, long double* __iptr) + { return __builtin_modfl(__x, __iptr); } + + + using ::pow; + + + inline constexpr float + pow(float __x, float __y) + { return __builtin_powf(__x, __y); } + + inline constexpr long double + pow(long double __x, long double __y) + { return __builtin_powl(__x, __y); } +# 400 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + using ::sin; + + + inline constexpr float + sin(float __x) + { return __builtin_sinf(__x); } + + inline constexpr long double + sin(long double __x) + { return __builtin_sinl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sin(_Tp __x) + { return __builtin_sin(__x); } + + using ::sinh; + + + inline constexpr float + sinh(float __x) + { return __builtin_sinhf(__x); } + + inline constexpr long double + sinh(long double __x) + { return __builtin_sinhl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sinh(_Tp __x) + { return __builtin_sinh(__x); } + + using ::sqrt; + + + inline constexpr float + sqrt(float __x) + { return __builtin_sqrtf(__x); } + + inline constexpr long double + sqrt(long double __x) + { return __builtin_sqrtl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sqrt(_Tp __x) + { return __builtin_sqrt(__x); } + + using ::tan; + + + inline constexpr float + tan(float __x) + { return __builtin_tanf(__x); } + + inline constexpr long double + tan(long double __x) + { return __builtin_tanl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tan(_Tp __x) + { return __builtin_tan(__x); } + + using ::tanh; + + + inline constexpr float + tanh(float __x) + { return __builtin_tanhf(__x); } + + inline constexpr long double + tanh(long double __x) + { return __builtin_tanhl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tanh(_Tp __x) + { return __builtin_tanh(__x); } +# 1053 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + atan2(_Tp __y, _Up __x) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return atan2(__type(__y), __type(__x)); + } + + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmod(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmod(__type(__x), __type(__y)); + } + + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + pow(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return pow(__type(__x), __type(__y)); + } +# 1100 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + constexpr int + fpclassify(float __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + constexpr int + fpclassify(double __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + constexpr int + fpclassify(long double __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + int>::__type + fpclassify(_Tp __x) + { return __x != 0 ? 4 : 2; } + + + + constexpr bool + isfinite(float __x) + { return __builtin_isfinite(__x); } + + constexpr bool + isfinite(double __x) + { return __builtin_isfinite(__x); } + + constexpr bool + isfinite(long double __x) + { return __builtin_isfinite(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isfinite(_Tp) + { return true; } + + + + constexpr bool + isinf(float __x) + { return __builtin_isinf(__x); } + + + + + + constexpr bool + isinf(double __x) + { return __builtin_isinf(__x); } + + + constexpr bool + isinf(long double __x) + { return __builtin_isinf(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isinf(_Tp) + { return false; } + + + + constexpr bool + isnan(float __x) + { return __builtin_isnan(__x); } + + + + + + constexpr bool + isnan(double __x) + { return __builtin_isnan(__x); } + + + constexpr bool + isnan(long double __x) + { return __builtin_isnan(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isnan(_Tp) + { return false; } + + + + constexpr bool + isnormal(float __x) + { return __builtin_isnormal(__x); } + + constexpr bool + isnormal(double __x) + { return __builtin_isnormal(__x); } + + constexpr bool + isnormal(long double __x) + { return __builtin_isnormal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isnormal(_Tp __x) + { return __x != 0 ? true : false; } + + + + + constexpr bool + signbit(float __x) + { return __builtin_signbit(__x); } + + constexpr bool + signbit(double __x) + { return __builtin_signbit(__x); } + + constexpr bool + signbit(long double __x) + { return __builtin_signbit(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + signbit(_Tp __x) + { return __x < 0 ? true : false; } + + + + constexpr bool + isgreater(float __x, float __y) + { return __builtin_isgreater(__x, __y); } + + constexpr bool + isgreater(double __x, double __y) + { return __builtin_isgreater(__x, __y); } + + constexpr bool + isgreater(long double __x, long double __y) + { return __builtin_isgreater(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isgreater(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isgreater(__type(__x), __type(__y)); + } + + + + constexpr bool + isgreaterequal(float __x, float __y) + { return __builtin_isgreaterequal(__x, __y); } + + constexpr bool + isgreaterequal(double __x, double __y) + { return __builtin_isgreaterequal(__x, __y); } + + constexpr bool + isgreaterequal(long double __x, long double __y) + { return __builtin_isgreaterequal(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isgreaterequal(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isgreaterequal(__type(__x), __type(__y)); + } + + + + constexpr bool + isless(float __x, float __y) + { return __builtin_isless(__x, __y); } + + constexpr bool + isless(double __x, double __y) + { return __builtin_isless(__x, __y); } + + constexpr bool + isless(long double __x, long double __y) + { return __builtin_isless(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isless(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isless(__type(__x), __type(__y)); + } + + + + constexpr bool + islessequal(float __x, float __y) + { return __builtin_islessequal(__x, __y); } + + constexpr bool + islessequal(double __x, double __y) + { return __builtin_islessequal(__x, __y); } + + constexpr bool + islessequal(long double __x, long double __y) + { return __builtin_islessequal(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + islessequal(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_islessequal(__type(__x), __type(__y)); + } + + + + constexpr bool + islessgreater(float __x, float __y) + { return __builtin_islessgreater(__x, __y); } + + constexpr bool + islessgreater(double __x, double __y) + { return __builtin_islessgreater(__x, __y); } + + constexpr bool + islessgreater(long double __x, long double __y) + { return __builtin_islessgreater(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + islessgreater(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_islessgreater(__type(__x), __type(__y)); + } + + + + constexpr bool + isunordered(float __x, float __y) + { return __builtin_isunordered(__x, __y); } + + constexpr bool + isunordered(double __x, double __y) + { return __builtin_isunordered(__x, __y); } + + constexpr bool + isunordered(long double __x, long double __y) + { return __builtin_isunordered(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isunordered(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isunordered(__type(__x), __type(__y)); + } +# 1820 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + using ::acosf; + + + using ::acosl; + + + + using ::asinf; + + + using ::asinl; + + + + using ::atanf; + + + using ::atanl; + + + + using ::atan2f; + + + using ::atan2l; + + + + using ::ceilf; + + + using ::ceill; + + + + using ::cosf; + + + using ::cosl; + + + + using ::coshf; + + + using ::coshl; + + + + using ::expf; + + + using ::expl; + + + + using ::fabsf; + + + using ::fabsl; + + + + using ::floorf; + + + using ::floorl; + + + + using ::fmodf; + + + using ::fmodl; + + + + using ::frexpf; + + + using ::frexpl; + + + + using ::ldexpf; + + + using ::ldexpl; + + + + using ::logf; + + + using ::logl; + + + + using ::log10f; + + + using ::log10l; + + + + using ::modff; + + + using ::modfl; + + + + using ::powf; + + + using ::powl; + + + + using ::sinf; + + + using ::sinl; + + + + using ::sinhf; + + + using ::sinhl; + + + + using ::sqrtf; + + + using ::sqrtl; + + + + using ::tanf; + + + using ::tanl; + + + + using ::tanhf; + + + using ::tanhl; +# 2085 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + using ::double_t; + using ::float_t; + + + + using ::acosh; + using ::acoshf; + using ::acoshl; + + using ::asinh; + using ::asinhf; + using ::asinhl; + + using ::atanh; + using ::atanhf; + using ::atanhl; + + using ::cbrt; + using ::cbrtf; + using ::cbrtl; + + using ::copysign; + using ::copysignf; + using ::copysignl; + + using ::erf; + using ::erff; + using ::erfl; + + using ::erfc; + using ::erfcf; + using ::erfcl; + + using ::exp2; + using ::exp2f; + using ::exp2l; + + using ::expm1; + using ::expm1f; + using ::expm1l; + + using ::fdim; + using ::fdimf; + using ::fdiml; + + using ::fma; + using ::fmaf; + using ::fmal; + + using ::fmax; + using ::fmaxf; + using ::fmaxl; + + using ::fmin; + using ::fminf; + using ::fminl; + + using ::hypot; + using ::hypotf; + using ::hypotl; + + using ::ilogb; + using ::ilogbf; + using ::ilogbl; + + using ::lgamma; + using ::lgammaf; + using ::lgammal; + + + using ::llrint; + using ::llrintf; + using ::llrintl; + + using ::llround; + using ::llroundf; + using ::llroundl; + + + using ::log1p; + using ::log1pf; + using ::log1pl; + + using ::log2; + using ::log2f; + using ::log2l; + + using ::logb; + using ::logbf; + using ::logbl; + + using ::lrint; + using ::lrintf; + using ::lrintl; + + using ::lround; + using ::lroundf; + using ::lroundl; + + using ::nan; + using ::nanf; + using ::nanl; + + using ::nearbyint; + using ::nearbyintf; + using ::nearbyintl; + + using ::nextafter; + using ::nextafterf; + using ::nextafterl; + + using ::nexttoward; + using ::nexttowardf; + using ::nexttowardl; + + using ::remainder; + using ::remainderf; + using ::remainderl; + + using ::remquo; + using ::remquof; + using ::remquol; + + using ::rint; + using ::rintf; + using ::rintl; + + using ::round; + using ::roundf; + using ::roundl; + + using ::scalbln; + using ::scalblnf; + using ::scalblnl; + + using ::scalbn; + using ::scalbnf; + using ::scalbnl; + + using ::tgamma; + using ::tgammaf; + using ::tgammal; + + using ::trunc; + using ::truncf; + using ::truncl; + + + + constexpr float + acosh(float __x) + { return __builtin_acoshf(__x); } + + constexpr long double + acosh(long double __x) + { return __builtin_acoshl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acosh(_Tp __x) + { return __builtin_acosh(__x); } + + + + constexpr float + asinh(float __x) + { return __builtin_asinhf(__x); } + + constexpr long double + asinh(long double __x) + { return __builtin_asinhl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asinh(_Tp __x) + { return __builtin_asinh(__x); } + + + + constexpr float + atanh(float __x) + { return __builtin_atanhf(__x); } + + constexpr long double + atanh(long double __x) + { return __builtin_atanhl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atanh(_Tp __x) + { return __builtin_atanh(__x); } + + + + constexpr float + cbrt(float __x) + { return __builtin_cbrtf(__x); } + + constexpr long double + cbrt(long double __x) + { return __builtin_cbrtl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cbrt(_Tp __x) + { return __builtin_cbrt(__x); } + + + + constexpr float + copysign(float __x, float __y) + { return __builtin_copysignf(__x, __y); } + + constexpr long double + copysign(long double __x, long double __y) + { return __builtin_copysignl(__x, __y); } + + + + constexpr float + erf(float __x) + { return __builtin_erff(__x); } + + constexpr long double + erf(long double __x) + { return __builtin_erfl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erf(_Tp __x) + { return __builtin_erf(__x); } + + + + constexpr float + erfc(float __x) + { return __builtin_erfcf(__x); } + + constexpr long double + erfc(long double __x) + { return __builtin_erfcl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erfc(_Tp __x) + { return __builtin_erfc(__x); } + + + + constexpr float + exp2(float __x) + { return __builtin_exp2f(__x); } + + constexpr long double + exp2(long double __x) + { return __builtin_exp2l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp2(_Tp __x) + { return __builtin_exp2(__x); } + + + + constexpr float + expm1(float __x) + { return __builtin_expm1f(__x); } + + constexpr long double + expm1(long double __x) + { return __builtin_expm1l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + expm1(_Tp __x) + { return __builtin_expm1(__x); } + + + + constexpr float + fdim(float __x, float __y) + { return __builtin_fdimf(__x, __y); } + + constexpr long double + fdim(long double __x, long double __y) + { return __builtin_fdiml(__x, __y); } + + + + constexpr float + fma(float __x, float __y, float __z) + { return __builtin_fmaf(__x, __y, __z); } + + constexpr long double + fma(long double __x, long double __y, long double __z) + { return __builtin_fmal(__x, __y, __z); } + + + + constexpr float + fmax(float __x, float __y) + { return __builtin_fmaxf(__x, __y); } + + constexpr long double + fmax(long double __x, long double __y) + { return __builtin_fmaxl(__x, __y); } + + + + constexpr float + fmin(float __x, float __y) + { return __builtin_fminf(__x, __y); } + + constexpr long double + fmin(long double __x, long double __y) + { return __builtin_fminl(__x, __y); } + + + + constexpr float + hypot(float __x, float __y) + { return __builtin_hypotf(__x, __y); } + + constexpr long double + hypot(long double __x, long double __y) + { return __builtin_hypotl(__x, __y); } + + + + constexpr int + ilogb(float __x) + { return __builtin_ilogbf(__x); } + + constexpr int + ilogb(long double __x) + { return __builtin_ilogbl(__x); } + + + + template + constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + int>::__type + ilogb(_Tp __x) + { return __builtin_ilogb(__x); } + + + + constexpr float + lgamma(float __x) + { return __builtin_lgammaf(__x); } + + constexpr long double + lgamma(long double __x) + { return __builtin_lgammal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + lgamma(_Tp __x) + { return __builtin_lgamma(__x); } + + + + constexpr long long + llrint(float __x) + { return __builtin_llrintf(__x); } + + constexpr long long + llrint(long double __x) + { return __builtin_llrintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llrint(_Tp __x) + { return __builtin_llrint(__x); } + + + + constexpr long long + llround(float __x) + { return __builtin_llroundf(__x); } + + constexpr long long + llround(long double __x) + { return __builtin_llroundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llround(_Tp __x) + { return __builtin_llround(__x); } + + + + constexpr float + log1p(float __x) + { return __builtin_log1pf(__x); } + + constexpr long double + log1p(long double __x) + { return __builtin_log1pl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log1p(_Tp __x) + { return __builtin_log1p(__x); } + + + + + constexpr float + log2(float __x) + { return __builtin_log2f(__x); } + + constexpr long double + log2(long double __x) + { return __builtin_log2l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log2(_Tp __x) + { return __builtin_log2(__x); } + + + + constexpr float + logb(float __x) + { return __builtin_logbf(__x); } + + constexpr long double + logb(long double __x) + { return __builtin_logbl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + logb(_Tp __x) + { return __builtin_logb(__x); } + + + + constexpr long + lrint(float __x) + { return __builtin_lrintf(__x); } + + constexpr long + lrint(long double __x) + { return __builtin_lrintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lrint(_Tp __x) + { return __builtin_lrint(__x); } + + + + constexpr long + lround(float __x) + { return __builtin_lroundf(__x); } + + constexpr long + lround(long double __x) + { return __builtin_lroundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lround(_Tp __x) + { return __builtin_lround(__x); } + + + + constexpr float + nearbyint(float __x) + { return __builtin_nearbyintf(__x); } + + constexpr long double + nearbyint(long double __x) + { return __builtin_nearbyintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nearbyint(_Tp __x) + { return __builtin_nearbyint(__x); } + + + + constexpr float + nextafter(float __x, float __y) + { return __builtin_nextafterf(__x, __y); } + + constexpr long double + nextafter(long double __x, long double __y) + { return __builtin_nextafterl(__x, __y); } + + + + constexpr float + nexttoward(float __x, long double __y) + { return __builtin_nexttowardf(__x, __y); } + + constexpr long double + nexttoward(long double __x, long double __y) + { return __builtin_nexttowardl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nexttoward(_Tp __x, long double __y) + { return __builtin_nexttoward(__x, __y); } + + + + constexpr float + remainder(float __x, float __y) + { return __builtin_remainderf(__x, __y); } + + constexpr long double + remainder(long double __x, long double __y) + { return __builtin_remainderl(__x, __y); } + + + + inline float + remquo(float __x, float __y, int* __pquo) + { return __builtin_remquof(__x, __y, __pquo); } + + inline long double + remquo(long double __x, long double __y, int* __pquo) + { return __builtin_remquol(__x, __y, __pquo); } + + + + constexpr float + rint(float __x) + { return __builtin_rintf(__x); } + + constexpr long double + rint(long double __x) + { return __builtin_rintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + rint(_Tp __x) + { return __builtin_rint(__x); } + + + + constexpr float + round(float __x) + { return __builtin_roundf(__x); } + + constexpr long double + round(long double __x) + { return __builtin_roundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + round(_Tp __x) + { return __builtin_round(__x); } + + + + constexpr float + scalbln(float __x, long __ex) + { return __builtin_scalblnf(__x, __ex); } + + constexpr long double + scalbln(long double __x, long __ex) + { return __builtin_scalblnl(__x, __ex); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbln(_Tp __x, long __ex) + { return __builtin_scalbln(__x, __ex); } + + + + constexpr float + scalbn(float __x, int __ex) + { return __builtin_scalbnf(__x, __ex); } + + constexpr long double + scalbn(long double __x, int __ex) + { return __builtin_scalbnl(__x, __ex); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbn(_Tp __x, int __ex) + { return __builtin_scalbn(__x, __ex); } + + + + constexpr float + tgamma(float __x) + { return __builtin_tgammaf(__x); } + + constexpr long double + tgamma(long double __x) + { return __builtin_tgammal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tgamma(_Tp __x) + { return __builtin_tgamma(__x); } + + + + constexpr float + trunc(float __x) + { return __builtin_truncf(__x); } + + constexpr long double + trunc(long double __x) + { return __builtin_truncl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + trunc(_Tp __x) + { return __builtin_trunc(__x); } +# 3682 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + copysign(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return copysign(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fdim(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fdim(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmax(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmax(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmin(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmin(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + hypot(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return hypot(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + nextafter(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return nextafter(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remainder(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remainder(__type(__x), __type(__y)); + } + + template + inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remquo(_Tp __x, _Up __y, int* __pquo) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remquo(__type(__x), __type(__y), __pquo); + } + + template + constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type + fma(_Tp __x, _Up __y, _Vp __z) + { + typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; + return fma(__type(__x), __type(__y), __type(__z)); + } + + + + + + + + template + inline _Tp + __hypot3(_Tp __x, _Tp __y, _Tp __z) + { + __x = std::abs(__x); + __y = std::abs(__y); + __z = std::abs(__z); + if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x) + return __a * std::sqrt((__x / __a) * (__x / __a) + + (__y / __a) * (__y / __a) + + (__z / __a) * (__z / __a)); + else + return {}; + } + + inline float + hypot(float __x, float __y, float __z) + { return std::__hypot3(__x, __y, __z); } + + inline double + hypot(double __x, double __y, double __z) + { return std::__hypot3(__x, __y, __z); } + + inline long double + hypot(long double __x, long double __y, long double __z) + { return std::__hypot3(__x, __y, __z); } + + template + __gnu_cxx::__promoted_t<_Tp, _Up, _Vp> + hypot(_Tp __x, _Up __y, _Vp __z) + { + using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>; + return std::__hypot3<__type>(__x, __y, __z); + } +# 3902 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + +} + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 1 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 1 3 +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h" 1 3 +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/exception_defines.h" 1 3 +# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + void + __throw_bad_exception(void) __attribute__((__noreturn__)); + + + void + __throw_bad_alloc(void) __attribute__((__noreturn__)); + + void + __throw_bad_array_new_length(void) __attribute__((__noreturn__)); + + + void + __throw_bad_cast(void) __attribute__((__noreturn__,__cold__)); + + void + __throw_bad_typeid(void) __attribute__((__noreturn__,__cold__)); + + + void + __throw_logic_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_domain_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_invalid_argument(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_length_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_out_of_range(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__,__cold__)) + __attribute__((__format__(__gnu_printf__, 1, 2))); + + void + __throw_runtime_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_range_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_overflow_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_underflow_error(const char*) __attribute__((__noreturn__,__cold__)); + + + void + __throw_ios_failure(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_ios_failure(const char*, int) __attribute__((__noreturn__,__cold__)); + + + void + __throw_system_error(int) __attribute__((__noreturn__,__cold__)); + + + void + __throw_future_error(int) __attribute__((__noreturn__,__cold__)); + + + void + __throw_bad_function_call() __attribute__((__noreturn__,__cold__)); +# 140 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h" 3 + +} +# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + template + struct __is_integer_nonstrict + : public std::__is_integer<_Tp> + { + using std::__is_integer<_Tp>::__value; + + + enum { __width = __value ? sizeof(_Tp) * 8 : 0 }; + }; + + template + struct __numeric_traits_integer + { + + static_assert(__is_integer_nonstrict<_Value>::__value, + "invalid specialization"); + + + + + static const bool __is_signed = (_Value)(-1) < 0; + static const int __digits + = __is_integer_nonstrict<_Value>::__width - __is_signed; + + + static const _Value __max = __is_signed + ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1) + : ~(_Value)0; + static const _Value __min = __is_signed ? -__max - 1 : (_Value)0; + }; + + template + const _Value __numeric_traits_integer<_Value>::__min; + + template + const _Value __numeric_traits_integer<_Value>::__max; + + template + const bool __numeric_traits_integer<_Value>::__is_signed; + + template + const int __numeric_traits_integer<_Value>::__digits; +# 137 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + template + using __int_traits = __numeric_traits_integer<_Tp>; +# 157 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + template + struct __numeric_traits_floating + { + + static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136); + + + static const bool __is_signed = true; + static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18); + static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932); + }; + + template + const int __numeric_traits_floating<_Value>::__max_digits10; + + template + const bool __numeric_traits_floating<_Value>::__is_signed; + + template + const int __numeric_traits_floating<_Value>::__digits10; + + template + const int __numeric_traits_floating<_Value>::__max_exponent10; + + + + + + + template + struct __numeric_traits + : public __numeric_traits_integer<_Value> + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; +# 238 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + +} +# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 1 3 +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + class reference_wrapper; +# 86 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct integral_constant + { + static constexpr _Tp value = __v; + using value_type = _Tp; + using type = integral_constant<_Tp, __v>; + constexpr operator value_type() const noexcept { return value; } + + + constexpr value_type operator()() const noexcept { return value; } + + }; +# 106 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + using __bool_constant = integral_constant; + + + + using true_type = __bool_constant; + + + using false_type = __bool_constant; + + + + + template + using bool_constant = __bool_constant<__v>; + + + + + + + template + struct enable_if + { }; + + + template + struct enable_if + { using type = _Tp; }; + + + template + using __enable_if_t = typename enable_if<_Cond, _Tp>::type; + + template + struct __conditional + { + template + using type = _Tp; + }; + + template<> + struct __conditional + { + template + using type = _Up; + }; + + + template + using __conditional_t + = typename __conditional<_Cond>::template type<_If, _Else>; + + + template + struct __type_identity + { using type = _Type; }; + + template + using __type_identity_t = typename __type_identity<_Tp>::type; + + namespace __detail + { + + template + using __first_t = _Tp; + + + template + auto __or_fn(int) -> __first_t...>; + + template + auto __or_fn(...) -> true_type; + + template + auto __and_fn(int) -> __first_t...>; + + template + auto __and_fn(...) -> false_type; + } + + + + + template + struct __or_ + : decltype(__detail::__or_fn<_Bn...>(0)) + { }; + + template + struct __and_ + : decltype(__detail::__and_fn<_Bn...>(0)) + { }; + + template + struct __not_ + : __bool_constant + { }; + + + + + + template + inline constexpr bool __or_v = __or_<_Bn...>::value; + template + inline constexpr bool __and_v = __and_<_Bn...>::value; + + namespace __detail + { + template + struct __disjunction_impl + { using type = _B1; }; + + template + struct __disjunction_impl<__enable_if_t, _B1, _B2, _Bn...> + { using type = typename __disjunction_impl::type; }; + + template + struct __conjunction_impl + { using type = _B1; }; + + template + struct __conjunction_impl<__enable_if_t, _B1, _B2, _Bn...> + { using type = typename __conjunction_impl::type; }; + } + + + template + struct conjunction + : __detail::__conjunction_impl::type + { }; + + template<> + struct conjunction<> + : true_type + { }; + + template + struct disjunction + : __detail::__disjunction_impl::type + { }; + + template<> + struct disjunction<> + : false_type + { }; + + template + struct negation + : __not_<_Pp>::type + { }; + + + + + template + inline constexpr bool conjunction_v = conjunction<_Bn...>::value; + + template + inline constexpr bool disjunction_v = disjunction<_Bn...>::value; + + template + inline constexpr bool negation_v = negation<_Pp>::value; + + + + + + template + struct is_reference; + template + struct is_function; + template + struct is_void; + template + struct remove_cv; + template + struct is_const; + + + template + struct __is_array_unknown_bounds; + + + + + template + constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>) + { return {}; } + + template + constexpr typename __or_< + is_reference<_NestedType>, + is_function<_NestedType>, + is_void<_NestedType>, + __is_array_unknown_bounds<_NestedType> + >::type __is_complete_or_unbounded(_TypeIdentity) + { return {}; } + + + template + using __remove_cv_t = typename remove_cv<_Tp>::type; + + + + + + template + struct is_void + : public false_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + + template + struct __is_integral_helper + : public false_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + + + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + __extension__ + template<> + struct __is_integral_helper<__int128> + : public true_type { }; + + __extension__ + template<> + struct __is_integral_helper + : public true_type { }; +# 460 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_integral + : public __is_integral_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct __is_floating_point_helper + : public false_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; +# 513 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template<> + struct __is_floating_point_helper<__float128> + : public true_type { }; + + + + + template + struct is_floating_point + : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type + { }; + + + + template + struct is_array + : public __bool_constant<__is_array(_Tp)> + { }; +# 545 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct __is_pointer_helper + : public false_type { }; + + template + struct __is_pointer_helper<_Tp*> + : public true_type { }; + + + template + struct is_pointer + : public __is_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_lvalue_reference + : public false_type { }; + + template + struct is_lvalue_reference<_Tp&> + : public true_type { }; + + + template + struct is_rvalue_reference + : public false_type { }; + + template + struct is_rvalue_reference<_Tp&&> + : public true_type { }; + + + + template + struct is_member_object_pointer + : public __bool_constant<__is_member_object_pointer(_Tp)> + { }; +# 601 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_member_function_pointer + : public __bool_constant<__is_member_function_pointer(_Tp)> + { }; +# 622 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_enum + : public __bool_constant<__is_enum(_Tp)> + { }; + + + template + struct is_union + : public __bool_constant<__is_union(_Tp)> + { }; + + + template + struct is_class + : public __bool_constant<__is_class(_Tp)> + { }; + + + + template + struct is_function + : public __bool_constant<__is_function(_Tp)> + { }; +# 661 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_null_pointer + : public false_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + + + template + struct __is_nullptr_t + : public is_null_pointer<_Tp> + { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead"))); + + + + + + + template + struct is_reference + : public __bool_constant<__is_reference(_Tp)> + { }; +# 715 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_arithmetic + : public __or_, is_floating_point<_Tp>>::type + { }; + + + template + struct is_fundamental + : public __or_, is_void<_Tp>, + is_null_pointer<_Tp>>::type + { }; + + + + template + struct is_object + : public __bool_constant<__is_object(_Tp)> + { }; +# 741 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_member_pointer; + + + template + struct is_scalar + : public __or_, is_enum<_Tp>, is_pointer<_Tp>, + is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type + { }; + + + template + struct is_compound + : public __bool_constant::value> { }; + + + + template + struct is_member_pointer + : public __bool_constant<__is_member_pointer(_Tp)> + { }; +# 779 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_same; + + + template + using __is_one_of = __or_...>; + + + __extension__ + template + using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, + signed char, signed short, signed int, signed long, + signed long long + + , signed __int128 +# 804 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + >; + + + __extension__ + template + using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>, + unsigned char, unsigned short, unsigned int, unsigned long, + unsigned long long + + , unsigned __int128 +# 824 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + >; + + + template + using __is_standard_integer + = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>; + + + template using __void_t = void; + + + + + + template + struct is_const + : public false_type { }; + + template + struct is_const<_Tp const> + : public true_type { }; + + + template + struct is_volatile + : public false_type { }; + + template + struct is_volatile<_Tp volatile> + : public true_type { }; + + + template + struct is_trivial + : public __bool_constant<__is_trivial(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copyable + : public __bool_constant<__is_trivially_copyable(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_standard_layout + : public __bool_constant<__is_standard_layout(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + template + struct + + is_pod + : public __bool_constant<__is_pod(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct + [[__deprecated__]] + is_literal_type + : public __bool_constant<__is_literal_type(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_empty + : public __bool_constant<__is_empty(_Tp)> + { }; + + + template + struct is_polymorphic + : public __bool_constant<__is_polymorphic(_Tp)> + { }; + + + + + template + struct is_final + : public __bool_constant<__is_final(_Tp)> + { }; + + + + template + struct is_abstract + : public __bool_constant<__is_abstract(_Tp)> + { }; + + + template::value> + struct __is_signed_helper + : public false_type { }; + + template + struct __is_signed_helper<_Tp, true> + : public __bool_constant<_Tp(-1) < _Tp(0)> + { }; + + + + template + struct is_signed + : public __is_signed_helper<_Tp>::type + { }; + + + template + struct is_unsigned + : public __and_, __not_>>::type + { }; + + + template + _Up + __declval(int); + + template + _Tp + __declval(long); + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)); + + template + struct remove_all_extents; + + + template + struct __is_array_known_bounds + : public false_type + { }; + + template + struct __is_array_known_bounds<_Tp[_Size]> + : public true_type + { }; + + template + struct __is_array_unknown_bounds + : public false_type + { }; + + template + struct __is_array_unknown_bounds<_Tp[]> + : public true_type + { }; +# 1006 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + struct __do_is_destructible_impl + { + template().~_Tp())> + static true_type __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_destructible_impl + : public __do_is_destructible_impl + { + using type = decltype(__test<_Tp>(0)); + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_destructible_safe; + + template + struct __is_destructible_safe<_Tp, false, false> + : public __is_destructible_impl::type>::type + { }; + + template + struct __is_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_destructible + : public __is_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + + struct __do_is_nt_destructible_impl + { + template + static __bool_constant().~_Tp())> + __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_nt_destructible_impl + : public __do_is_nt_destructible_impl + { + using type = decltype(__test<_Tp>(0)); + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_nt_destructible_safe; + + template + struct __is_nt_destructible_safe<_Tp, false, false> + : public __is_nt_destructible_impl::type>::type + { }; + + template + struct __is_nt_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_nt_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_nothrow_destructible + : public __is_nt_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_constructible_impl + = __bool_constant<__is_constructible(_Tp, _Args...)>; + + + + template + struct is_constructible + : public __is_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_default_constructible + : public __is_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct __add_lvalue_reference_helper + { using type = _Tp; }; + + template + struct __add_lvalue_reference_helper<_Tp, __void_t<_Tp&>> + { using type = _Tp&; }; + + template + using __add_lval_ref_t = typename __add_lvalue_reference_helper<_Tp>::type; + + + + template + struct is_copy_constructible + : public __is_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct __add_rvalue_reference_helper + { using type = _Tp; }; + + template + struct __add_rvalue_reference_helper<_Tp, __void_t<_Tp&&>> + { using type = _Tp&&; }; + + template + using __add_rval_ref_t = typename __add_rvalue_reference_helper<_Tp>::type; + + + + template + struct is_move_constructible + : public __is_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_constructible_impl + = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>; + + + + template + struct is_nothrow_constructible + : public __is_nothrow_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_default_constructible + : public __is_nothrow_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_copy_constructible + : public __is_nothrow_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_move_constructible + : public __is_nothrow_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_assignable_impl = __bool_constant<__is_assignable(_Tp, _Up)>; + + + + template + struct is_assignable + : public __is_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_copy_assignable + : public __is_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_move_assignable + : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_assignable_impl + = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>; + + + + template + struct is_nothrow_assignable + : public __is_nothrow_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_copy_assignable + : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_move_assignable + : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_trivially_constructible_impl + = __bool_constant<__is_trivially_constructible(_Tp, _Args...)>; + + + + template + struct is_trivially_constructible + : public __is_trivially_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_default_constructible + : public __is_trivially_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; +# 1319 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + struct __do_is_implicitly_default_constructible_impl + { + template + static void __helper(const _Tp&); + + template + static true_type __test(const _Tp&, + decltype(__helper({}))* = 0); + + static false_type __test(...); + }; + + template + struct __is_implicitly_default_constructible_impl + : public __do_is_implicitly_default_constructible_impl + { + using type = decltype(__test(declval<_Tp>())); + }; + + template + struct __is_implicitly_default_constructible_safe + : public __is_implicitly_default_constructible_impl<_Tp>::type + { }; + + template + struct __is_implicitly_default_constructible + : public __and_<__is_constructible_impl<_Tp>, + __is_implicitly_default_constructible_safe<_Tp>>::type + { }; + + + + template + struct is_trivially_copy_constructible + : public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_move_constructible + : public __is_trivially_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_trivially_assignable_impl + = __bool_constant<__is_trivially_assignable(_Tp, _Up)>; + + + + template + struct is_trivially_assignable + : public __is_trivially_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copy_assignable + : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_move_assignable + : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_destructible + : public __and_<__is_destructible_safe<_Tp>, + __bool_constant<__has_trivial_destructor(_Tp)>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + struct has_virtual_destructor + : public __bool_constant<__has_virtual_destructor(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct alignment_of + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct rank + : public integral_constant { }; + + template + struct rank<_Tp[_Size]> + : public integral_constant::value> { }; + + template + struct rank<_Tp[]> + : public integral_constant::value> { }; + + + template + struct extent + : public integral_constant { }; + + template + struct extent<_Tp[_Size], 0> + : public integral_constant { }; + + template + struct extent<_Tp[_Size], _Uint> + : public extent<_Tp, _Uint - 1>::type { }; + + template + struct extent<_Tp[], 0> + : public integral_constant { }; + + template + struct extent<_Tp[], _Uint> + : public extent<_Tp, _Uint - 1>::type { }; + + + + + + + template + struct is_same + : public __bool_constant<__is_same(_Tp, _Up)> + { }; +# 1491 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_base_of + : public __bool_constant<__is_base_of(_Base, _Derived)> + { }; + + + template + struct is_convertible + : public __bool_constant<__is_convertible(_From, _To)> + { }; +# 1540 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + using __is_array_convertible + = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; +# 1600 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++14-extensions" + template + struct __is_nothrow_new_constructible_impl + : __bool_constant< + noexcept(::new(std::declval()) _Tp(std::declval<_Args>()...)) + > + { }; + + template + inline constexpr bool __is_nothrow_new_constructible + = __and_, + __is_nothrow_new_constructible_impl<_Tp, _Args...>>::value; +#pragma GCC diagnostic pop + + + + + template + struct remove_const + { using type = _Tp; }; + + template + struct remove_const<_Tp const> + { using type = _Tp; }; + + + template + struct remove_volatile + { using type = _Tp; }; + + template + struct remove_volatile<_Tp volatile> + { using type = _Tp; }; + + + + template + struct remove_cv + { using type = __remove_cv(_Tp); }; +# 1659 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct add_const + { using type = _Tp const; }; + + + template + struct add_volatile + { using type = _Tp volatile; }; + + + template + struct add_cv + { using type = _Tp const volatile; }; + + + + template + using remove_const_t = typename remove_const<_Tp>::type; + + + template + using remove_volatile_t = typename remove_volatile<_Tp>::type; + + + template + using remove_cv_t = typename remove_cv<_Tp>::type; + + + template + using add_const_t = typename add_const<_Tp>::type; + + + template + using add_volatile_t = typename add_volatile<_Tp>::type; + + + template + using add_cv_t = typename add_cv<_Tp>::type; + + + + + + + template + struct remove_reference + { using type = __remove_reference(_Tp); }; +# 1721 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct add_lvalue_reference + { using type = __add_lval_ref_t<_Tp>; }; + + + template + struct add_rvalue_reference + { using type = __add_rval_ref_t<_Tp>; }; + + + + template + using remove_reference_t = typename remove_reference<_Tp>::type; + + + template + using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; + + + template + using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; + + + + + + + + template + struct __cv_selector; + + template + struct __cv_selector<_Unqualified, false, false> + { using __type = _Unqualified; }; + + template + struct __cv_selector<_Unqualified, false, true> + { using __type = volatile _Unqualified; }; + + template + struct __cv_selector<_Unqualified, true, false> + { using __type = const _Unqualified; }; + + template + struct __cv_selector<_Unqualified, true, true> + { using __type = const volatile _Unqualified; }; + + template::value, + bool _IsVol = is_volatile<_Qualified>::value> + class __match_cv_qualifiers + { + using __match = __cv_selector<_Unqualified, _IsConst, _IsVol>; + + public: + using __type = typename __match::__type; + }; + + + template + struct __make_unsigned + { using __type = _Tp; }; + + template<> + struct __make_unsigned + { using __type = unsigned char; }; + + template<> + struct __make_unsigned + { using __type = unsigned char; }; + + template<> + struct __make_unsigned + { using __type = unsigned short; }; + + template<> + struct __make_unsigned + { using __type = unsigned int; }; + + template<> + struct __make_unsigned + { using __type = unsigned long; }; + + template<> + struct __make_unsigned + { using __type = unsigned long long; }; + + + __extension__ + template<> + struct __make_unsigned<__int128> + { using __type = unsigned __int128; }; +# 1834 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template::value, + bool _IsEnum = __is_enum(_Tp)> + class __make_unsigned_selector; + + template + class __make_unsigned_selector<_Tp, true, false> + { + using __unsigned_type + = typename __make_unsigned<__remove_cv_t<_Tp>>::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + class __make_unsigned_selector_base + { + protected: + template struct _List { }; + + template + struct _List<_Tp, _Up...> : _List<_Up...> + { static constexpr size_t __size = sizeof(_Tp); }; + + template + struct __select; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, true> + { using __type = _Uint; }; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, false> + : __select<_Sz, _List<_UInts...>> + { }; + }; + + + template + class __make_unsigned_selector<_Tp, false, true> + : __make_unsigned_selector_base + { + + using _UInts = _List; + + using __unsigned_type = typename __select::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + + + + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; +# 1908 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + + + + + + template + struct make_unsigned + { using type = typename __make_unsigned_selector<_Tp>::__type; }; + + + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + + + + + template + struct __make_signed + { using __type = _Tp; }; + + template<> + struct __make_signed + { using __type = signed char; }; + + template<> + struct __make_signed + { using __type = signed char; }; + + template<> + struct __make_signed + { using __type = signed short; }; + + template<> + struct __make_signed + { using __type = signed int; }; + + template<> + struct __make_signed + { using __type = signed long; }; + + template<> + struct __make_signed + { using __type = signed long long; }; + + + __extension__ + template<> + struct __make_signed + { using __type = __int128; }; +# 1994 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template::value, + bool _IsEnum = __is_enum(_Tp)> + class __make_signed_selector; + + template + class __make_signed_selector<_Tp, true, false> + { + using __signed_type + = typename __make_signed<__remove_cv_t<_Tp>>::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __signed_type>::__type; + }; + + + template + class __make_signed_selector<_Tp, false, true> + { + using __unsigned_type = typename __make_unsigned_selector<_Tp>::__type; + + public: + using __type = typename __make_signed_selector<__unsigned_type>::__type; + }; + + + + + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; +# 2040 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + + + + + + template + struct make_signed + { using type = typename __make_signed_selector<_Tp>::__type; }; + + + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + + + + template + using make_signed_t = typename make_signed<_Tp>::type; + + + template + using make_unsigned_t = typename make_unsigned<_Tp>::type; + + + + + + template + struct remove_extent + { using type = _Tp; }; + + template + struct remove_extent<_Tp[_Size]> + { using type = _Tp; }; + + template + struct remove_extent<_Tp[]> + { using type = _Tp; }; + + + template + struct remove_all_extents + { using type = _Tp; }; + + template + struct remove_all_extents<_Tp[_Size]> + { using type = typename remove_all_extents<_Tp>::type; }; + + template + struct remove_all_extents<_Tp[]> + { using type = typename remove_all_extents<_Tp>::type; }; + + + + template + using remove_extent_t = typename remove_extent<_Tp>::type; + + + template + using remove_all_extents_t = typename remove_all_extents<_Tp>::type; + + + + + + + template + struct remove_pointer + { using type = __remove_pointer(_Tp); }; +# 2139 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct __add_pointer_helper + { using type = _Tp; }; + + template + struct __add_pointer_helper<_Tp, __void_t<_Tp*>> + { using type = _Tp*; }; + + + template + struct add_pointer + : public __add_pointer_helper<_Tp> + { }; + + template + struct add_pointer<_Tp&> + { using type = _Tp*; }; + + template + struct add_pointer<_Tp&&> + { using type = _Tp*; }; + + + + template + using remove_pointer_t = typename remove_pointer<_Tp>::type; + + + template + using add_pointer_t = typename add_pointer<_Tp>::type; + + + template + struct __aligned_storage_msa + { + union __type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__)) { } __align; + }; + }; +# 2194 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template::__type)> + struct + + aligned_storage + { + union type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__((_Align)))) { } __align; + }; + }; + + template + struct __strictest_alignment + { + static const size_t _S_alignment = 0; + static const size_t _S_size = 0; + }; + + template + struct __strictest_alignment<_Tp, _Types...> + { + static const size_t _S_alignment = + alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment + ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; + static const size_t _S_size = + sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size + ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 2240 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct + + aligned_union + { + private: + static_assert(sizeof...(_Types) != 0, "At least one type is required"); + + using __strictest = __strictest_alignment<_Types...>; + static const size_t _S_len = _Len > __strictest::_S_size + ? _Len : __strictest::_S_size; + public: + + static const size_t alignment_value = __strictest::_S_alignment; + + using type = typename aligned_storage<_S_len, alignment_value>::type; + }; + + template + const size_t aligned_union<_Len, _Types...>::alignment_value; +#pragma GCC diagnostic pop + + + + + + template + struct __decay_selector + : __conditional_t::value, + remove_cv<_Up>, + add_pointer<_Up>> + { }; + + template + struct __decay_selector<_Up[_Nm]> + { using type = _Up*; }; + + template + struct __decay_selector<_Up[]> + { using type = _Up*; }; + + + + + template + struct decay + { using type = typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&> + { using type = typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&&> + { using type = typename __decay_selector<_Tp>::type; }; + + + + + template + struct __strip_reference_wrapper + { + using __type = _Tp; + }; + + template + struct __strip_reference_wrapper > + { + using __type = _Tp&; + }; + + + template + using __decay_t = typename decay<_Tp>::type; + + template + using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; + + + + + + template + using _Require = __enable_if_t<__and_<_Cond...>::value>; + + + template + using __remove_cvref_t + = typename remove_cv::type>::type; + + + + + template + struct conditional + { using type = _Iftrue; }; + + + template + struct conditional + { using type = _Iffalse; }; + + + template + struct common_type; +# 2355 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct __success_type + { using type = _Tp; }; + + struct __failure_type + { }; + + struct __do_common_type_impl + { + template + using __cond_t + = decltype(true ? std::declval<_Tp>() : std::declval<_Up>()); + + + + template + static __success_type<__decay_t<__cond_t<_Tp, _Up>>> + _S_test(int); +# 2382 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + static __failure_type + _S_test_2(...); + + template + static decltype(_S_test_2<_Tp, _Up>(0)) + _S_test(...); + }; + + + template<> + struct common_type<> + { }; + + + template + struct common_type<_Tp0> + : public common_type<_Tp0, _Tp0> + { }; + + + template, typename _Dp2 = __decay_t<_Tp2>> + struct __common_type_impl + { + + + using type = common_type<_Dp1, _Dp2>; + }; + + template + struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> + : private __do_common_type_impl + { + + + using type = decltype(_S_test<_Tp1, _Tp2>(0)); + }; + + + template + struct common_type<_Tp1, _Tp2> + : public __common_type_impl<_Tp1, _Tp2>::type + { }; + + template + struct __common_type_pack + { }; + + template + struct __common_type_fold; + + + template + struct common_type<_Tp1, _Tp2, _Rp...> + : public __common_type_fold, + __common_type_pack<_Rp...>> + { }; + + + + + template + struct __common_type_fold<_CTp, __common_type_pack<_Rp...>, + __void_t> + : public common_type + { }; + + + template + struct __common_type_fold<_CTp, _Rp, void> + { }; + + template + struct __underlying_type_impl + { + using type = __underlying_type(_Tp); + }; + + template + struct __underlying_type_impl<_Tp, false> + { }; + + + + template + struct underlying_type + : public __underlying_type_impl<_Tp> + { }; + + + template + struct __declval_protector + { + static const bool __stop = false; + }; + + + + + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)) + { + static_assert(__declval_protector<_Tp>::__stop, + "declval() must not be used!"); + return __declval<_Tp>(0); + } + + + template + struct result_of; + + + + + struct __invoke_memfun_ref { }; + struct __invoke_memfun_deref { }; + struct __invoke_memobj_ref { }; + struct __invoke_memobj_deref { }; + struct __invoke_other { }; + + + template + struct __result_of_success : __success_type<_Tp> + { using __invoke_type = _Tag; }; + + + struct __result_of_memfun_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_ref + : private __result_of_memfun_ref_impl + { + using type = decltype(_S_test<_MemPtr, _Arg, _Args...>(0)); + }; + + + struct __result_of_memfun_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_deref + : private __result_of_memfun_deref_impl + { + using type = decltype(_S_test<_MemPtr, _Arg, _Args...>(0)); + }; + + + struct __result_of_memobj_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>() + ), __invoke_memobj_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_ref + : private __result_of_memobj_ref_impl + { + using type = decltype(_S_test<_MemPtr, _Arg>(0)); + }; + + + struct __result_of_memobj_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>() + ), __invoke_memobj_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_deref + : private __result_of_memobj_deref_impl + { + using type = decltype(_S_test<_MemPtr, _Arg>(0)); + }; + + template + struct __result_of_memobj; + + template + struct __result_of_memobj<_Res _Class::*, _Arg> + { + using _Argval = __remove_cvref_t<_Arg>; + using _MemPtr = _Res _Class::*; + using type = typename __conditional_t<__or_, + is_base_of<_Class, _Argval>>::value, + __result_of_memobj_ref<_MemPtr, _Arg>, + __result_of_memobj_deref<_MemPtr, _Arg> + >::type; + }; + + template + struct __result_of_memfun; + + template + struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> + { + using _Argval = typename remove_reference<_Arg>::type; + using _MemPtr = _Res _Class::*; + using type = typename __conditional_t::value, + __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, + __result_of_memfun_deref<_MemPtr, _Arg, _Args...> + >::type; + }; + + + + + + + template> + struct __inv_unwrap + { + using type = _Tp; + }; + + template + struct __inv_unwrap<_Tp, reference_wrapper<_Up>> + { + using type = _Up&; + }; + + template + struct __result_of_impl + { + using type = __failure_type; + }; + + template + struct __result_of_impl + : public __result_of_memobj<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type> + { }; + + template + struct __result_of_impl + : public __result_of_memfun<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type, _Args...> + { }; + + + struct __result_of_other_impl + { + template + static __result_of_success()(std::declval<_Args>()...) + ), __invoke_other> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_impl + : private __result_of_other_impl + { + using type = decltype(_S_test<_Functor, _ArgTypes...>(0)); + }; + + + template + struct __invoke_result + : public __result_of_impl< + is_member_object_pointer< + typename remove_reference<_Functor>::type + >::value, + is_member_function_pointer< + typename remove_reference<_Functor>::type + >::value, + _Functor, _ArgTypes... + >::type + { }; + + + template + using __invoke_result_t = typename __invoke_result<_Fn, _Args...>::type; + + + template + struct result_of<_Functor(_ArgTypes...)> + : public __invoke_result<_Functor, _ArgTypes...> + { } __attribute__ ((__deprecated__ ("use '" "std::invoke_result" "' instead"))); + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + template::__type)> + using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; + + template + using aligned_union_t = typename aligned_union<_Len, _Types...>::type; +#pragma GCC diagnostic pop + + + template + using decay_t = typename decay<_Tp>::type; + + + template + using enable_if_t = typename enable_if<_Cond, _Tp>::type; + + + template + using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; + + + template + using common_type_t = typename common_type<_Tp...>::type; + + + template + using underlying_type_t = typename underlying_type<_Tp>::type; + + + template + using result_of_t = typename result_of<_Tp>::type; + + + + + template using void_t = void; +# 2759 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template class _Op, typename... _Args> + struct __detector + { + using type = _Default; + using __is_detected = false_type; + }; + + + template class _Op, + typename... _Args> + struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> + { + using type = _Op<_Args...>; + using __is_detected = true_type; + }; + + template class _Op, + typename... _Args> + using __detected_or = __detector<_Default, void, _Op, _Args...>; + + + + template class _Op, + typename... _Args> + using __detected_or_t + = typename __detected_or<_Default, _Op, _Args...>::type; +# 2801 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct __is_swappable; + + template + struct __is_nothrow_swappable; + + template + struct __is_tuple_like_impl : false_type + { }; + + + template + struct __is_tuple_like + : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type + { }; + + + template + + inline + _Require<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>> + swap(_Tp&, _Tp&) + noexcept(__and_, + is_nothrow_move_assignable<_Tp>>::value); + + template + + inline + __enable_if_t<__is_swappable<_Tp>::value> + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value); + + + namespace __swappable_details { + using std::swap; + + struct __do_is_swappable_impl + { + template(), std::declval<_Tp&>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_impl + : public __swappable_details::__do_is_swappable_impl + { + using type = decltype(__test<_Tp>(0)); + }; + + template + struct __is_nothrow_swappable_impl + : public __swappable_details::__do_is_nothrow_swappable_impl + { + using type = decltype(__test<_Tp>(0)); + }; + + template + struct __is_swappable + : public __is_swappable_impl<_Tp>::type + { }; + + template + struct __is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { }; + + + + + + + template + struct is_swappable + : public __is_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_v = + is_swappable<_Tp>::value; + + + template + inline constexpr bool is_nothrow_swappable_v = + is_nothrow_swappable<_Tp>::value; + + + + namespace __swappable_with_details { + using std::swap; + + struct __do_is_swappable_with_impl + { + template(), std::declval<_Up>())), + typename + = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_with_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) + && + noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_with_impl + : public __swappable_with_details::__do_is_swappable_with_impl + { + using type = decltype(__test<_Tp, _Up>(0)); + }; + + + template + struct __is_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_swappable_impl + { + using type = decltype(__test<_Tp&>(0)); + }; + + template + struct __is_nothrow_swappable_with_impl + : public __swappable_with_details::__do_is_nothrow_swappable_with_impl + { + using type = decltype(__test<_Tp, _Up>(0)); + }; + + + template + struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_nothrow_swappable_impl + { + using type = decltype(__test<_Tp&>(0)); + }; + + + + template + struct is_swappable_with + : public __is_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable_with + : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_with_v = + is_swappable_with<_Tp, _Up>::value; + + + template + inline constexpr bool is_nothrow_swappable_with_v = + is_nothrow_swappable_with<_Tp, _Up>::value; +# 3023 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template::value, typename = void> + struct __is_invocable_impl + : false_type + { + using __nothrow_conv = false_type; + }; + + + template + struct __is_invocable_impl<_Result, _Ret, + true, + __void_t> + : true_type + { + using __nothrow_conv = true_type; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + + template + struct __is_invocable_impl<_Result, _Ret, + false, + __void_t> + { + private: + + using _Res_t = typename _Result::type; + + + + static _Res_t _S_get() noexcept; + + + template + static void _S_conv(__type_identity_t<_Tp>) noexcept; + + + template(_S_get())), + typename = decltype(_S_conv<_Tp>(_S_get())), + + bool _Dangle = __reference_converts_from_temporary(_Tp, _Res_t) + + + + > + static __bool_constant<_Nothrow && !_Dangle> + _S_test(int); + + template + static false_type + _S_test(...); + + public: + + using type = decltype(_S_test<_Ret, true>(1)); + + + using __nothrow_conv = decltype(_S_test<_Ret>(1)); + }; +#pragma GCC diagnostic pop + + template + struct __is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { }; + + template + constexpr bool __call_is_nt(__invoke_memfun_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept((std::declval<_Up>().*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memfun_deref) + { + return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept(std::declval<_Up>().*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_deref) + { + return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_other) + { + return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); + } + + template + struct __call_is_nothrow + : __bool_constant< + std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) + > + { }; + + template + using __call_is_nothrow_ + = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; + + + template + struct __is_nothrow_invocable + : __and_<__is_invocable<_Fn, _Args...>, + __call_is_nothrow_<_Fn, _Args...>>::type + { }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + struct __nonesuchbase {}; + struct __nonesuch : private __nonesuchbase { + ~__nonesuch() = delete; + __nonesuch(__nonesuch const&) = delete; + void operator=(__nonesuch const&) = delete; + }; +#pragma GCC diagnostic pop + + + + + template + struct invoke_result + : public __invoke_result<_Functor, _ArgTypes...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}), + "_Functor must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; + + + template + struct is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + struct is_invocable_r + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_invocable + : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + + + + template + using __is_nt_invocable_impl + = typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv; + + + + template + struct is_nothrow_invocable_r + : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; +# 3251 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template + inline constexpr bool is_void_v = is_void<_Tp>::value; +template + inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; +template + inline constexpr bool is_integral_v = is_integral<_Tp>::value; +template + inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; + + +template + inline constexpr bool is_array_v = __is_array(_Tp); +# 3272 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template + inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; +template + inline constexpr bool is_lvalue_reference_v = false; +template + inline constexpr bool is_lvalue_reference_v<_Tp&> = true; +template + inline constexpr bool is_rvalue_reference_v = false; +template + inline constexpr bool is_rvalue_reference_v<_Tp&&> = true; + + +template + inline constexpr bool is_member_object_pointer_v = + __is_member_object_pointer(_Tp); + + + + + + + +template + inline constexpr bool is_member_function_pointer_v = + __is_member_function_pointer(_Tp); + + + + + + +template + inline constexpr bool is_enum_v = __is_enum(_Tp); +template + inline constexpr bool is_union_v = __is_union(_Tp); +template + inline constexpr bool is_class_v = __is_class(_Tp); + + + +template + inline constexpr bool is_reference_v = __is_reference(_Tp); +# 3323 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template + inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; +template + inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; + + +template + inline constexpr bool is_object_v = __is_object(_Tp); + + + + + +template + inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; +template + inline constexpr bool is_compound_v = !is_fundamental_v<_Tp>; + + +template + inline constexpr bool is_member_pointer_v = __is_member_pointer(_Tp); + + + + + +template + inline constexpr bool is_const_v = false; +template + inline constexpr bool is_const_v = true; + + +template + inline constexpr bool is_function_v = __is_function(_Tp); +# 3366 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template + inline constexpr bool is_volatile_v = false; +template + inline constexpr bool is_volatile_v = true; + +template + inline constexpr bool is_trivial_v = __is_trivial(_Tp); +template + inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp); +template + inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp); +template + + inline constexpr bool is_pod_v = __is_pod(_Tp); +template + [[__deprecated__]] + inline constexpr bool is_literal_type_v = __is_literal_type(_Tp); +template + inline constexpr bool is_empty_v = __is_empty(_Tp); +template + inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp); +template + inline constexpr bool is_abstract_v = __is_abstract(_Tp); +template + inline constexpr bool is_final_v = __is_final(_Tp); + +template + inline constexpr bool is_signed_v = is_signed<_Tp>::value; +template + inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; + +template + inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...); +template + inline constexpr bool is_default_constructible_v = __is_constructible(_Tp); +template + inline constexpr bool is_copy_constructible_v + = __is_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_move_constructible_v + = __is_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Up); +template + inline constexpr bool is_copy_assignable_v + = __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t); +template + inline constexpr bool is_move_assignable_v + = __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; + +template + inline constexpr bool is_trivially_constructible_v + = __is_trivially_constructible(_Tp, _Args...); +template + inline constexpr bool is_trivially_default_constructible_v + = __is_trivially_constructible(_Tp); +template + inline constexpr bool is_trivially_copy_constructible_v + = __is_trivially_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_constructible_v + = __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_trivially_assignable_v + = __is_trivially_assignable(_Tp, _Up); +template + inline constexpr bool is_trivially_copy_assignable_v + = __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_assignable_v + = __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>); +# 3461 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template + inline constexpr bool is_trivially_destructible_v = + is_trivially_destructible<_Tp>::value; + + +template + inline constexpr bool is_nothrow_constructible_v + = __is_nothrow_constructible(_Tp, _Args...); +template + inline constexpr bool is_nothrow_default_constructible_v + = __is_nothrow_constructible(_Tp); +template + inline constexpr bool is_nothrow_copy_constructible_v + = __is_nothrow_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_constructible_v + = __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_assignable_v + = __is_nothrow_assignable(_Tp, _Up); +template + inline constexpr bool is_nothrow_copy_assignable_v + = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_assignable_v + = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_destructible_v = + is_nothrow_destructible<_Tp>::value; + +template + inline constexpr bool has_virtual_destructor_v + = __has_virtual_destructor(_Tp); + +template + inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; + +template + inline constexpr size_t rank_v = 0; +template + inline constexpr size_t rank_v<_Tp[_Size]> = 1 + rank_v<_Tp>; +template + inline constexpr size_t rank_v<_Tp[]> = 1 + rank_v<_Tp>; + +template + inline constexpr size_t extent_v = 0; +template + inline constexpr size_t extent_v<_Tp[_Size], 0> = _Size; +template + inline constexpr size_t extent_v<_Tp[_Size], _Idx> = extent_v<_Tp, _Idx - 1>; +template + inline constexpr size_t extent_v<_Tp[], 0> = 0; +template + inline constexpr size_t extent_v<_Tp[], _Idx> = extent_v<_Tp, _Idx - 1>; + + +template + inline constexpr bool is_same_v = __is_same(_Tp, _Up); + + + + + + +template + inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived); + +template + inline constexpr bool is_convertible_v = __is_convertible(_From, _To); + + + + +template + inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_v + = is_nothrow_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_invocable_r_v + = is_invocable_r<_Ret, _Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_r_v + = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; + + + + + + + template + struct has_unique_object_representations + : bool_constant<__has_unique_object_representations( + remove_cv_t> + )> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool has_unique_object_representations_v + = has_unique_object_representations<_Tp>::value; + + + + + + + template + struct is_aggregate + : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> + { }; + + + + + + + template + inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>); +# 4017 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + +} +# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 1 3 +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + inline constexpr _Tp* + __addressof(_Tp& __r) noexcept + { return __builtin_addressof(__r); } +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Tp&&>(__t); } +# 81 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type&& __t) noexcept + { + static_assert(!std::is_lvalue_reference<_Tp>::value, + "std::forward must not be used to convert an rvalue to an lvalue"); + return static_cast<_Tp&&>(__t); + } +# 134 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr typename std::remove_reference<_Tp>::type&& + move(_Tp&& __t) noexcept + { return static_cast::type&&>(__t); } + + + template + struct __move_if_noexcept_cond + : public __and_<__not_>, + is_copy_constructible<_Tp>>::type { }; +# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr + __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&> + move_if_noexcept(_Tp& __x) noexcept + { return std::move(__x); } +# 172 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + [[__nodiscard__]] + inline constexpr _Tp* + addressof(_Tp& __r) noexcept + { return std::__addressof(__r); } + + + + template + const _Tp* addressof(const _Tp&&) = delete; + + + template + + inline _Tp + __exchange(_Tp& __obj, _Up&& __new_val) + { + _Tp __old_val = std::move(__obj); + __obj = std::forward<_Up>(__new_val); + return __old_val; + } +# 216 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + + inline + + typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>>::value>::type + + + + swap(_Tp& __a, _Tp& __b) + noexcept(__and_, is_nothrow_move_assignable<_Tp>>::value) + + { + + + + + _Tp __tmp = std::move(__a); + __a = std::move(__b); + __b = std::move(__tmp); + } + + + + + template + + inline + + typename enable_if<__is_swappable<_Tp>::value>::type + + + + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value) + { + for (size_t __n = 0; __n < _Nm; ++__n) + swap(__a[__n], __b[__n]); + } + + + +} +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 1 3 +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 + +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct tuple_size; + + + + + + template::type, + typename = typename enable_if::value>::type, + size_t = tuple_size<_Tp>::value> + using __enable_if_has_tuple_size = _Tp; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + + template + inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value; + + + + template + struct tuple_element; + + + template + using __tuple_element_t = typename tuple_element<__i, _Tp>::type; + + template + struct tuple_element<__i, const _Tp> + { + using type = const __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, volatile _Tp> + { + using type = volatile __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, const volatile _Tp> + { + using type = const volatile __tuple_element_t<__i, _Tp>; + }; + + + + + + template + constexpr size_t + __find_uniq_type_in_pack() + { + constexpr size_t __sz = sizeof...(_Types); + constexpr bool __found[__sz] = { __is_same(_Tp, _Types) ... }; + size_t __n = __sz; + for (size_t __i = 0; __i < __sz; ++__i) + { + if (__found[__i]) + { + if (__n < __sz) + return __sz; + __n = __i; + } + } + return __n; + } +# 134 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 + template + using tuple_element_t = typename tuple_element<__i, _Tp>::type; + + + + + template struct _Index_tuple { }; + + + template + struct _Build_index_tuple + { +# 154 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 + using __type = _Index_tuple<__integer_pack(_Num)...>; + + }; + + + + + template + struct integer_sequence + { + + + + typedef _Tp value_type; + static constexpr size_t size() noexcept { return sizeof...(_Idx); } + }; + + + template + using make_integer_sequence + + + + = integer_sequence<_Tp, __integer_pack(_Num)...>; + + + + template + using index_sequence = integer_sequence; + + + template + using make_index_sequence = make_integer_sequence; + + + template + using index_sequence_for = make_index_sequence; + + + + + struct in_place_t { + explicit in_place_t() = default; + }; + + inline constexpr in_place_t in_place{}; + + template struct in_place_type_t + { + explicit in_place_type_t() = default; + }; + + template + inline constexpr in_place_type_t<_Tp> in_place_type{}; + + template struct in_place_index_t + { + explicit in_place_index_t() = default; + }; + + template + inline constexpr in_place_index_t<_Idx> in_place_index{}; + + template + inline constexpr bool __is_in_place_type_v = false; + + template + inline constexpr bool __is_in_place_type_v> = true; + + template + using __is_in_place_type = bool_constant<__is_in_place_type_v<_Tp>>; + + template + inline constexpr bool __is_in_place_index_v = false; + + template + inline constexpr bool __is_in_place_index_v> = true; + + + + + template + struct _Nth_type + { using type = __type_pack_element<_Np, _Types...>; }; +# 283 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 + +} +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + struct piecewise_construct_t { explicit piecewise_construct_t() = default; }; + + + inline constexpr piecewise_construct_t piecewise_construct = + piecewise_construct_t(); + + + + + template + struct pair; + + template + class tuple; + + + + + + template + struct array; + + template + struct _Index_tuple; + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(pair<_Tp1, _Tp2>& __in) noexcept; + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(pair<_Tp1, _Tp2>&& __in) noexcept; + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(const pair<_Tp1, _Tp2>& __in) noexcept; + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(const pair<_Tp1, _Tp2>&& __in) noexcept; + + template + constexpr __tuple_element_t<__i, tuple<_Elements...>>& + get(tuple<_Elements...>& __t) noexcept; + + template + constexpr const __tuple_element_t<__i, tuple<_Elements...>>& + get(const tuple<_Elements...>& __t) noexcept; + + template + constexpr __tuple_element_t<__i, tuple<_Elements...>>&& + get(tuple<_Elements...>&& __t) noexcept; + + template + constexpr const __tuple_element_t<__i, tuple<_Elements...>>&& + get(const tuple<_Elements...>&& __t) noexcept; + + template + constexpr _Tp& + get(array<_Tp, _Nm>&) noexcept; + + template + constexpr _Tp&& + get(array<_Tp, _Nm>&&) noexcept; + + template + constexpr const _Tp& + get(const array<_Tp, _Nm>&) noexcept; + + template + constexpr const _Tp&& + get(const array<_Tp, _Nm>&&) noexcept; + + + + + + + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return __and_, + is_constructible<_T2, const _U2&>>::value; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return __and_, + is_convertible>::value; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return __and_, + is_constructible<_T2, _U2&&>>::value; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return __and_, + is_convertible<_U2&&, _T2>>::value; + } + }; + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return false; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return false; + } + }; +# 260 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template class __pair_base + { + + template friend struct pair; + __pair_base() = default; + ~__pair_base() = default; + __pair_base(const __pair_base&) = default; + __pair_base& operator=(const __pair_base&) = delete; + + }; +# 283 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + struct pair + : public __pair_base<_T1, _T2> + { + typedef _T1 first_type; + typedef _T2 second_type; + + _T1 first; + _T2 second; + + + constexpr pair(const pair&) = default; + constexpr pair(pair&&) = default; + + template + + pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); + + + void + swap(pair& __p) + noexcept(__and_<__is_nothrow_swappable<_T1>, + __is_nothrow_swappable<_T2>>::value) + { + using std::swap; + swap(first, __p.first); + swap(second, __p.second); + } +# 331 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + private: + template + + pair(tuple<_Args1...>&, tuple<_Args2...>&, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); + public: +# 719 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template , + __is_implicitly_default_constructible<_U2>> + ::value, bool>::type = true> + constexpr pair() + : first(), second() { } + + template , + is_default_constructible<_U2>, + __not_< + __and_<__is_implicitly_default_constructible<_U1>, + __is_implicitly_default_constructible<_U2>>>> + ::value, bool>::type = false> + explicit constexpr pair() + : first(), second() { } + + + + using _PCCP = _PCC; + + + + template() + && _PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + template() + && !_PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + + template + using _PCCFP = _PCC::value + || !is_same<_T2, _U2>::value, + _T1, _T2>; + + + template::template + _ConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) + { ; } + + template::template + _ConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) + { ; } +# 803 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + private: + + + + struct __zero_as_null_pointer_constant + { + __zero_as_null_pointer_constant(int __zero_as_null_pointer_constant::*) + { } + template::value>> + __zero_as_null_pointer_constant(_Tp) = delete; + }; + + public: + + + + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + is_convertible<_U1, _T1>>::value, + bool> = true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + constexpr + pair(_U1&& __x, __zero_as_null_pointer_constant, ...) + : first(std::forward<_U1>(__x)), second(nullptr) + { ; } + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + __not_>>::value, + bool> = false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + explicit constexpr + pair(_U1&& __x, __zero_as_null_pointer_constant, ...) + : first(std::forward<_U1>(__x)), second(nullptr) + { ; } + + template, + __not_>, + is_constructible<_T2, _U2>, + __not_>, + is_convertible<_U2, _T2>>::value, + bool> = true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + constexpr + pair(__zero_as_null_pointer_constant, _U2&& __y, ...) + : first(nullptr), second(std::forward<_U2>(__y)) + { ; } + + template, + __not_>, + is_constructible<_T2, _U2>, + __not_>, + __not_>>::value, + bool> = false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + explicit constexpr + pair(__zero_as_null_pointer_constant, _U2&& __y, ...) + : first(nullptr), second(std::forward<_U2>(__y)) + { ; } + + + + template() + && _PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) + { ; } + + template() + && !_PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) + { ; } + + + template::template + _MoveConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) + { ; } + + template::template + _MoveConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) + { ; } + + + + pair& + operator=(__conditional_t<__and_, + is_copy_assignable<_T2>>::value, + const pair&, const __nonesuch&> __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + pair& + operator=(__conditional_t<__and_, + is_move_assignable<_T2>>::value, + pair&&, __nonesuch&&> __p) + noexcept(__and_, + is_nothrow_move_assignable<_T2>>::value) + { + first = std::forward(__p.first); + second = std::forward(__p.second); + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, const _U2&>>::value, + pair&>::type + operator=(const pair<_U1, _U2>& __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, _U2&&>>::value, + pair&>::type + operator=(pair<_U1, _U2>&& __p) + { + first = std::forward<_U1>(__p.first); + second = std::forward<_U2>(__p.second); + return *this; + } +# 995 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + }; + + + + + template pair(_T1, _T2) -> pair<_T1, _T2>; +# 1031 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + inline constexpr bool + operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first == __y.first && __x.second == __y.second; } +# 1043 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + inline constexpr bool + operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first < __y.first + || (!(__y.first < __x.first) && __x.second < __y.second); } + + + template + inline constexpr bool + operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x == __y); } + + + template + inline constexpr bool + operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __y < __x; } + + + template + inline constexpr bool + operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__y < __x); } + + + template + inline constexpr bool + operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x < __y); } +# 1080 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + inline + + + typename enable_if<__and_<__is_swappable<_T1>, + __is_swappable<_T2>>::value>::type + + + + swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } +# 1103 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + typename enable_if, + __is_swappable<_T2>>::value>::type + swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete; +# 1129 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + constexpr pair::__type, + typename __decay_and_strip<_T2>::__type> + make_pair(_T1&& __x, _T2&& __y) + { + typedef typename __decay_and_strip<_T1>::__type __ds_type1; + typedef typename __decay_and_strip<_T2>::__type __ds_type2; + typedef pair<__ds_type1, __ds_type2> __pair_type; + return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y)); + } +# 1152 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + struct __is_tuple_like_impl> : true_type + { }; + + + + template + struct tuple_size> + : public integral_constant { }; + + + template + struct tuple_element<0, pair<_Tp1, _Tp2>> + { typedef _Tp1 type; }; + + + template + struct tuple_element<1, pair<_Tp1, _Tp2>> + { typedef _Tp2 type; }; + + + + template + struct tuple_element<__i, tuple<_Types...>>; + + + template + inline constexpr size_t tuple_size_v> = 2; + + template + inline constexpr size_t tuple_size_v> = 2; + + template + inline constexpr bool __is_pair = false; + + template + inline constexpr bool __is_pair> = true; + + + + template + struct __pair_get; + + template<> + struct __pair_get<0> + { + template + static constexpr _Tp1& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr _Tp1&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp1>(__pair.first); } + + template + static constexpr const _Tp1& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr const _Tp1&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.first); } + }; + + template<> + struct __pair_get<1> + { + template + static constexpr _Tp2& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr _Tp2&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp2>(__pair.second); } + + template + static constexpr const _Tp2& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr const _Tp2&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.second); } + }; + + + + + + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__get(__in); } + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__move_get(std::move(__in)); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(const pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__const_get(__in); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(const pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__const_move_get(std::move(__in)); } + + + + template + constexpr _Tp& + get(pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr const _Tp& + get(const pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr _Tp&& + get(pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr const _Tp&& + get(const pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr _Tp& + get(pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr const _Tp& + get(const pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr _Tp&& + get(pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } + + template + constexpr const _Tp&& + get(const pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } +# 1332 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + +} +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 1 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 + +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 +# 74 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 93 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 + struct input_iterator_tag { }; + + + struct output_iterator_tag { }; + + + struct forward_iterator_tag : public input_iterator_tag { }; + + + + struct bidirectional_iterator_tag : public forward_iterator_tag { }; + + + + struct random_access_iterator_tag : public bidirectional_iterator_tag { }; +# 125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 + template + struct [[__deprecated__]] iterator + { + + typedef _Category iterator_category; + + typedef _Tp value_type; + + typedef _Distance difference_type; + + typedef _Pointer pointer; + + typedef _Reference reference; + }; +# 149 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits; + + + + + template> + struct __iterator_traits { }; + + + + template + struct __iterator_traits<_Iterator, + __void_t> + { + typedef typename _Iterator::iterator_category iterator_category; + typedef typename _Iterator::value_type value_type; + typedef typename _Iterator::difference_type difference_type; + typedef typename _Iterator::pointer pointer; + typedef typename _Iterator::reference reference; + }; + + + template + struct iterator_traits + : public __iterator_traits<_Iterator> { }; +# 209 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits<_Tp*> + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef _Tp* pointer; + typedef _Tp& reference; + }; + + + template + struct iterator_traits + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef const _Tp* pointer; + typedef const _Tp& reference; + }; + + + + + + + template + __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_Iter>::iterator_category + __iterator_category(const _Iter&) + { return typename iterator_traits<_Iter>::iterator_category(); } + + + + + template + using __iter_category_t + = typename iterator_traits<_Iter>::iterator_category; + + template + using _RequireInputIter = + __enable_if_t, + input_iterator_tag>::value>; + + template> + struct __is_random_access_iter + : is_base_of + { + typedef is_base_of _Base; + enum { __value = _Base::value }; + }; + + + + + + + + +} +# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 1 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 + +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/concept_check.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/concept_check.h" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/concept_check.h" 3 +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/debug/assertions.h" 1 3 +# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template struct _List_iterator; + template struct _List_const_iterator; + + + template + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + __distance(_InputIterator __first, _InputIterator __last, + input_iterator_tag) + { + + + + typename iterator_traits<_InputIterator>::difference_type __n = 0; + while (__first != __last) + { + ++__first; + ++__n; + } + return __n; + } + + template + __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_RandomAccessIterator>::difference_type + __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, + random_access_iterator_tag) + { + + + + return __last - __first; + } + + + + template + ptrdiff_t + __distance(std::_List_iterator<_Tp>, + std::_List_iterator<_Tp>, + input_iterator_tag); + + template + ptrdiff_t + __distance(std::_List_const_iterator<_Tp>, + std::_List_const_iterator<_Tp>, + input_iterator_tag); + + + + + template + void + __distance(_OutputIterator, _OutputIterator, output_iterator_tag) = delete; +# 144 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 + template + [[__nodiscard__]] __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + distance(_InputIterator __first, _InputIterator __last) + { + + return std::__distance(__first, __last, + std::__iterator_category(__first)); + } + + template + inline constexpr void + __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) + { + + + do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) std::__glibcxx_assert_fail(); } while (false); + while (__n--) + ++__i; + } + + template + inline constexpr void + __advance(_BidirectionalIterator& __i, _Distance __n, + bidirectional_iterator_tag) + { + + + + if (__n > 0) + while (__n--) + ++__i; + else + while (__n++) + --__i; + } + + template + inline constexpr void + __advance(_RandomAccessIterator& __i, _Distance __n, + random_access_iterator_tag) + { + + + + if (__builtin_constant_p(__n) && __n == 1) + ++__i; + else if (__builtin_constant_p(__n) && __n == -1) + --__i; + else + __i += __n; + } + + + + template + void + __advance(_OutputIterator&, _Distance, output_iterator_tag) = delete; +# 217 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 + template + __attribute__((__always_inline__)) + inline constexpr void + advance(_InputIterator& __i, _Distance __n) + { + + typename iterator_traits<_InputIterator>::difference_type __d = __n; + std::__advance(__i, __d, std::__iterator_category(__i)); + } + + + + template + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _InputIterator + next(_InputIterator __x, typename + iterator_traits<_InputIterator>::difference_type __n = 1) + { + + + std::advance(__x, __n); + return __x; + } + + template + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _BidirectionalIterator + prev(_BidirectionalIterator __x, typename + iterator_traits<_BidirectionalIterator>::difference_type __n = 1) + { + + + + std::advance(__x, -__n); + return __x; + } + + + + +} +# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 1 3 +# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/ptr_traits.h" 1 3 +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/ptr_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + class __undefined; + + + + template + struct __get_first_arg + { using type = __undefined; }; + + template class _SomeTemplate, typename _Tp, + typename... _Types> + struct __get_first_arg<_SomeTemplate<_Tp, _Types...>> + { using type = _Tp; }; + + + + template + struct __replace_first_arg + { }; + + template class _SomeTemplate, typename _Up, + typename _Tp, typename... _Types> + struct __replace_first_arg<_SomeTemplate<_Tp, _Types...>, _Up> + { using type = _SomeTemplate<_Up, _Types...>; }; + + + template + struct __ptr_traits_elem : __get_first_arg<_Ptr> + { }; + + + + + + + + template + struct __ptr_traits_elem<_Ptr, __void_t> + { using type = typename _Ptr::element_type; }; + + + template + using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type; + + + + + template::value> + struct __ptr_traits_ptr_to + { + using pointer = _Ptr; + using element_type = _Elt; + + + + + + + + static pointer + pointer_to(element_type& __r) + + + + + + { return pointer::pointer_to(__r); } + }; + + + template + struct __ptr_traits_ptr_to<_Ptr, _Elt, true> + { }; + + + template + struct __ptr_traits_ptr_to<_Tp*, _Tp, false> + { + using pointer = _Tp*; + using element_type = _Tp; + + + + + + + static pointer + pointer_to(element_type& __r) noexcept + { return std::addressof(__r); } + }; + + template + struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt> + { + private: + template + using __diff_t = typename _Tp::difference_type; + + template + using __rebind = __type_identity>; + + public: + + using pointer = _Ptr; + + + using element_type = _Elt; + + + using difference_type = __detected_or_t; + + + template + using rebind = typename __detected_or_t<__replace_first_arg<_Ptr, _Up>, + __rebind, _Ptr, _Up>::type; + }; + + + + template + struct __ptr_traits_impl<_Ptr, __undefined> + { }; + + + + + + + + template + struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>> + { }; + + + + + + + + template + struct pointer_traits<_Tp*> : __ptr_traits_ptr_to<_Tp*, _Tp> + { + + typedef _Tp* pointer; + + typedef _Tp element_type; + + typedef ptrdiff_t difference_type; + + template using rebind = _Up*; + }; + + + template + using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>; + + template + constexpr _Tp* + __to_address(_Tp* __ptr) noexcept + { + static_assert(!std::is_function<_Tp>::value, "not a function pointer"); + return __ptr; + } + + + template + constexpr typename std::pointer_traits<_Ptr>::element_type* + __to_address(const _Ptr& __ptr) + { return std::__to_address(__ptr.operator->()); } +# 257 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/ptr_traits.h" 3 + +} +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 2 3 +# 85 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 106 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + +# 106 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 128 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class reverse_iterator + : public iterator::iterator_category, + typename iterator_traits<_Iterator>::value_type, + typename iterator_traits<_Iterator>::difference_type, + typename iterator_traits<_Iterator>::pointer, + typename iterator_traits<_Iterator>::reference> + { + template + friend class reverse_iterator; +# 147 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + protected: + _Iterator current; + + typedef iterator_traits<_Iterator> __traits_type; + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::pointer pointer; + + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; +# 178 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + constexpr + reverse_iterator() + noexcept(noexcept(_Iterator())) + : current() + { } + + + + + explicit constexpr + reverse_iterator(iterator_type __x) + noexcept(noexcept(_Iterator(__x))) + : current(__x) + { } + + + + + constexpr + reverse_iterator(const reverse_iterator& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + reverse_iterator& operator=(const reverse_iterator&) = default; + + + + + + + template + + + + constexpr + reverse_iterator(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + template + + + + + constexpr + reverse_iterator& + operator=(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(current = __x.current)) + { + current = __x.current; + return *this; + } + + + + + + [[__nodiscard__]] + constexpr iterator_type + base() const + noexcept(noexcept(_Iterator(current))) + { return current; } +# 255 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + { + _Iterator __tmp = current; + return *--__tmp; + } + + + + + + + [[__nodiscard__]] + constexpr pointer + operator->() const + + + + + { + + + _Iterator __tmp = current; + --__tmp; + return _S_to_pointer(__tmp); + } + + + + + + + constexpr reverse_iterator& + operator++() + { + --current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator++(int) + { + reverse_iterator __tmp = *this; + --current; + return __tmp; + } + + + + + + + constexpr reverse_iterator& + operator--() + { + ++current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator--(int) + { + reverse_iterator __tmp = *this; + ++current; + return __tmp; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator+(difference_type __n) const + { return reverse_iterator(current - __n); } + + + + + + + + constexpr reverse_iterator& + operator+=(difference_type __n) + { + current -= __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator-(difference_type __n) const + { return reverse_iterator(current + __n); } + + + + + + + + constexpr reverse_iterator& + operator-=(difference_type __n) + { + current += __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + { return *(*this + __n); } +# 415 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + private: + template + static constexpr _Tp* + _S_to_pointer(_Tp* __p) + { return __p; } + + template + static constexpr pointer + _S_to_pointer(_Tp __t) + { return __t.operator->(); } + }; +# 438 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator==(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y.base() < __x.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() == __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() > __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() != __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() < __y.base(); } + + template + inline constexpr bool + operator<=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() >= __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() <= __y.base(); } +# 615 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr auto + operator-(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + -> decltype(__y.base() - __x.base()) + { return __y.base() - __x.base(); } + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Iterator> + operator+(typename reverse_iterator<_Iterator>::difference_type __n, + const reverse_iterator<_Iterator>& __x) + { return reverse_iterator<_Iterator>(__x.base() - __n); } + + + + template + inline constexpr reverse_iterator<_Iterator> + __make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Iterator> + make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } +# 657 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + + auto + __niter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__niter_base(__it.base()))) + { return __make_reverse_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + : __is_move_iterator<_Iterator> + { }; + + template + + auto + __miter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__miter_base(__it.base()))) + { return __make_reverse_iterator(__miter_base(__it.base())); } +# 688 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class back_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + explicit + back_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 726 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + + back_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_back(__value); + return *this; + } + + + back_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_back(std::move(__value)); + return *this; + } + + + + [[__nodiscard__]] + back_insert_iterator& + operator*() + { return *this; } + + + + back_insert_iterator& + operator++() + { return *this; } + + + + back_insert_iterator + operator++(int) + { return *this; } + }; +# 773 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline back_insert_iterator<_Container> + back_inserter(_Container& __x) + { return back_insert_iterator<_Container>(__x); } +# 789 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class front_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + explicit + front_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 827 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + + front_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_front(__value); + return *this; + } + + + front_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_front(std::move(__value)); + return *this; + } + + + + [[__nodiscard__]] + front_insert_iterator& + operator*() + { return *this; } + + + + front_insert_iterator& + operator++() + { return *this; } + + + + front_insert_iterator + operator++(int) + { return *this; } + }; +# 874 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline front_insert_iterator<_Container> + front_inserter(_Container& __x) + { return front_insert_iterator<_Container>(__x); } +# 894 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class insert_iterator + : public iterator + { + + + + typedef typename _Container::iterator _Iter; + + protected: + _Container* container; + _Iter iter; + + public: + + typedef _Container container_type; +# 919 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + + insert_iterator(_Container& __x, _Iter __i) + : container(std::__addressof(__x)), iter(__i) {} +# 955 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + + insert_iterator& + operator=(const typename _Container::value_type& __value) + { + iter = container->insert(iter, __value); + ++iter; + return *this; + } + + + insert_iterator& + operator=(typename _Container::value_type&& __value) + { + iter = container->insert(iter, std::move(__value)); + ++iter; + return *this; + } + + + + [[__nodiscard__]] + insert_iterator& + operator*() + { return *this; } + + + + insert_iterator& + operator++() + { return *this; } + + + + insert_iterator& + operator++(int) + { return *this; } + }; + +#pragma GCC diagnostic pop +# 1014 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline insert_iterator<_Container> + inserter(_Container& __x, typename _Container::iterator __i) + { return insert_iterator<_Container>(__x, __i); } + + + + + +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 1037 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class __normal_iterator + { + protected: + _Iterator _M_current; + + typedef std::iterator_traits<_Iterator> __traits_type; + + + template + using __convertible_from + = std::__enable_if_t::value>; + + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; + typedef typename __traits_type::pointer pointer; + + + + + + constexpr __normal_iterator() noexcept + : _M_current(_Iterator()) { } + + explicit + __normal_iterator(const _Iterator& __i) noexcept + : _M_current(__i) { } + + + + template> + + __normal_iterator(const __normal_iterator<_Iter, _Container>& __i) + noexcept +# 1085 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + : _M_current(__i.base()) { } + + + + reference + operator*() const noexcept + { return *_M_current; } + + + pointer + operator->() const noexcept + { return _M_current; } + + + __normal_iterator& + operator++() noexcept + { + ++_M_current; + return *this; + } + + + __normal_iterator + operator++(int) noexcept + { return __normal_iterator(_M_current++); } + + + + __normal_iterator& + operator--() noexcept + { + --_M_current; + return *this; + } + + + __normal_iterator + operator--(int) noexcept + { return __normal_iterator(_M_current--); } + + + + reference + operator[](difference_type __n) const noexcept + { return _M_current[__n]; } + + + __normal_iterator& + operator+=(difference_type __n) noexcept + { _M_current += __n; return *this; } + + + __normal_iterator + operator+(difference_type __n) const noexcept + { return __normal_iterator(_M_current + __n); } + + + __normal_iterator& + operator-=(difference_type __n) noexcept + { _M_current -= __n; return *this; } + + + __normal_iterator + operator-(difference_type __n) const noexcept + { return __normal_iterator(_M_current - __n); } + + + const _Iterator& + base() const noexcept + { return _M_current; } + }; +# 1205 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline bool + operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator==(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + + + + + + template + + + [[__nodiscard__]] + inline auto + operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept + -> decltype(__lhs.base() - __rhs.base()) + + + + + + { return __lhs.base() - __rhs.base(); } + + template + [[__nodiscard__]] + inline typename __normal_iterator<_Iterator, _Container>::difference_type + operator-(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() - __rhs.base(); } + + template + [[__nodiscard__]] + inline __normal_iterator<_Iterator, _Container> + operator+(typename __normal_iterator<_Iterator, _Container>::difference_type + __n, const __normal_iterator<_Iterator, _Container>& __i) + noexcept + { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } + + +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + + _Iterator + __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it.base(); } + + + + + + + template + constexpr auto + __to_address(const __gnu_cxx::__normal_iterator<_Iterator, + _Container>& __it) noexcept + -> decltype(std::__to_address(__it.base())) + { return std::__to_address(__it.base()); } +# 1412 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + namespace __detail + { +# 1428 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + } +# 1439 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class move_iterator + + + + { + _Iterator _M_current; + + using __traits_type = iterator_traits<_Iterator>; + + using __base_ref = typename __traits_type::reference; + + + template + friend class move_iterator; +# 1478 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + public: + using iterator_type = _Iterator; +# 1490 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + + typedef _Iterator pointer; + + + using reference + = __conditional_t::value, + typename remove_reference<__base_ref>::type&&, + __base_ref>; + + + constexpr + move_iterator() + : _M_current() { } + + explicit constexpr + move_iterator(iterator_type __i) + : _M_current(std::move(__i)) { } + + template + + + + constexpr + move_iterator(const move_iterator<_Iter>& __i) + : _M_current(__i._M_current) { } + + template + + + + + constexpr + move_iterator& operator=(const move_iterator<_Iter>& __i) + { + _M_current = __i._M_current; + return *this; + } + + + [[__nodiscard__]] + constexpr iterator_type + base() const + { return _M_current; } +# 1548 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + + + + { return static_cast(*_M_current); } + + + [[__nodiscard__]] + constexpr pointer + operator->() const + { return _M_current; } + + constexpr move_iterator& + operator++() + { + ++_M_current; + return *this; + } + + constexpr move_iterator + operator++(int) + { + move_iterator __tmp = *this; + ++_M_current; + return __tmp; + } + + + + + + + + constexpr move_iterator& + operator--() + { + --_M_current; + return *this; + } + + constexpr move_iterator + operator--(int) + { + move_iterator __tmp = *this; + --_M_current; + return __tmp; + } + + [[__nodiscard__]] + constexpr move_iterator + operator+(difference_type __n) const + { return move_iterator(_M_current + __n); } + + constexpr move_iterator& + operator+=(difference_type __n) + { + _M_current += __n; + return *this; + } + + [[__nodiscard__]] + constexpr move_iterator + operator-(difference_type __n) const + { return move_iterator(_M_current - __n); } + + constexpr move_iterator& + operator-=(difference_type __n) + { + _M_current -= __n; + return *this; + } + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + + + + { return std::move(_M_current[__n]); } +# 1662 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + }; + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() == __y.base(); } +# 1683 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return !(__x == __y); } + + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() < __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + + { return __x.base() == __y.base(); } +# 1750 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() < __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + template + [[__nodiscard__]] + inline constexpr auto + operator-(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + -> decltype(__x.base() - __y.base()) + { return __x.base() - __y.base(); } + + template + [[__nodiscard__]] + inline constexpr move_iterator<_Iterator> + operator+(typename move_iterator<_Iterator>::difference_type __n, + const move_iterator<_Iterator>& __x) + + + + { return __x + __n; } + + template + [[__nodiscard__]] + inline constexpr move_iterator<_Iterator> + make_move_iterator(_Iterator __i) + { return move_iterator<_Iterator>(std::move(__i)); } + + template::value_type>::value, + _Iterator, move_iterator<_Iterator>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Iterator __i) + { return _ReturnType(__i); } + + + + template::value, + const _Tp*, move_iterator<_Tp*>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Tp* __i) + { return _ReturnType(__i); } +# 2964 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + + auto + __niter_base(move_iterator<_Iterator> __it) + -> decltype(make_move_iterator(__niter_base(__it.base()))) + { return make_move_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template + + auto + __miter_base(move_iterator<_Iterator> __it) + -> decltype(__miter_base(__it.base())) + { return __miter_base(__it.base()); } +# 2996 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + using __iter_key_t = remove_const_t< + + + + typename iterator_traits<_InputIterator>::value_type::first_type>; + + + template + using __iter_val_t + + + + = typename iterator_traits<_InputIterator>::value_type::second_type; + + + template + struct pair; + + template + using __iter_to_alloc_t + = pair, __iter_val_t<_InputIterator>>; + + + +} +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/debug/debug.h" 1 3 +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/debug/debug.h" 3 +namespace std +{ + namespace __debug { } +} + + + + +namespace __gnu_debug +{ + using namespace std::__debug; + + template + struct _Safe_iterator; +} +# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/predefined_ops.h" 1 3 +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/predefined_ops.h" 3 +namespace __gnu_cxx +{ +namespace __ops +{ + struct _Iter_less_iter + { + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 < *__it2; } + }; + + constexpr + inline _Iter_less_iter + __iter_less_iter() + { return _Iter_less_iter(); } + + struct _Iter_less_val + { + + constexpr _Iter_less_val() = default; + + + + + + explicit + _Iter_less_val(_Iter_less_iter) { } + + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it < __val; } + }; + + + inline _Iter_less_val + __iter_less_val() + { return _Iter_less_val(); } + + + inline _Iter_less_val + __iter_comp_val(_Iter_less_iter) + { return _Iter_less_val(); } + + struct _Val_less_iter + { + + constexpr _Val_less_iter() = default; + + + + + + explicit + _Val_less_iter(_Iter_less_iter) { } + + template + + bool + operator()(_Value& __val, _Iterator __it) const + { return __val < *__it; } + }; + + + inline _Val_less_iter + __val_less_iter() + { return _Val_less_iter(); } + + + inline _Val_less_iter + __val_comp_iter(_Iter_less_iter) + { return _Val_less_iter(); } + + struct _Iter_equal_to_iter + { + template + + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 == *__it2; } + }; + + + inline _Iter_equal_to_iter + __iter_equal_to_iter() + { return _Iter_equal_to_iter(); } + + struct _Iter_equal_to_val + { + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it == __val; } + }; + + + inline _Iter_equal_to_val + __iter_equal_to_val() + { return _Iter_equal_to_val(); } + + + inline _Iter_equal_to_val + __iter_comp_val(_Iter_equal_to_iter) + { return _Iter_equal_to_val(); } + + template + struct _Iter_comp_iter + { + _Compare _M_comp; + + explicit constexpr + _Iter_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) + { return bool(_M_comp(*__it1, *__it2)); } + }; + + template + constexpr + inline _Iter_comp_iter<_Compare> + __iter_comp_iter(_Compare __comp) + { return _Iter_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_comp_val + { + _Compare _M_comp; + + + explicit + _Iter_comp_val(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Iterator __it, _Value& __val) + { return bool(_M_comp(*__it, __val)); } + }; + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Compare __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Iter_comp_iter<_Compare> __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + struct _Val_comp_iter + { + _Compare _M_comp; + + + explicit + _Val_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Value& __val, _Iterator __it) + { return bool(_M_comp(__val, *__it)); } + }; + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Compare __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Iter_comp_iter<_Compare> __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_equals_val + { + _Value& _M_value; + + + explicit + _Iter_equals_val(_Value& __value) + : _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return *__it == _M_value; } + }; + + template + + inline _Iter_equals_val<_Value> + __iter_equals_val(_Value& __val) + { return _Iter_equals_val<_Value>(__val); } + + template + struct _Iter_equals_iter + { + _Iterator1 _M_it1; + + + explicit + _Iter_equals_iter(_Iterator1 __it1) + : _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return *__it2 == *_M_it1; } + }; + + template + + inline _Iter_equals_iter<_Iterator> + __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) + { return _Iter_equals_iter<_Iterator>(__it); } + + template + struct _Iter_pred + { + _Predicate _M_pred; + + + explicit + _Iter_pred(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_pred<_Predicate> + __pred_iter(_Predicate __pred) + { return _Iter_pred<_Predicate>(std::move(__pred)); } + + template + struct _Iter_comp_to_val + { + _Compare _M_comp; + _Value& _M_value; + + + _Iter_comp_to_val(_Compare __comp, _Value& __value) + : _M_comp(std::move(__comp)), _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_comp(*__it, _M_value)); } + }; + + template + _Iter_comp_to_val<_Compare, _Value> + + __iter_comp_val(_Compare __comp, _Value &__val) + { + return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val); + } + + template + struct _Iter_comp_to_iter + { + _Compare _M_comp; + _Iterator1 _M_it1; + + + _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) + : _M_comp(std::move(__comp)), _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return bool(_M_comp(*__it2, *_M_it1)); } + }; + + template + + inline _Iter_comp_to_iter<_Compare, _Iterator> + __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) + { + return _Iter_comp_to_iter<_Compare, _Iterator>( + std::move(__comp._M_comp), __it); + } + + template + struct _Iter_negate + { + _Predicate _M_pred; + + + explicit + _Iter_negate(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return !bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_negate<_Predicate> + __negate(_Iter_pred<_Predicate> __pred) + { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } + +} +} +# 72 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 + +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/concepts" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/concepts" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/concepts" 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/concepts" 2 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 2 3 +# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 + template + constexpr _Tp + __rotl(_Tp __x, int __s) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) == 0) + { + + + constexpr unsigned __uNd = _Nd; + const unsigned __r = __s; + return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd)); + } + const int __r = __s % _Nd; + if (__r == 0) + return __x; + else if (__r > 0) + return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); + else + return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); + } + + template + constexpr _Tp + __rotr(_Tp __x, int __s) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) == 0) + { + + + constexpr unsigned __uNd = _Nd; + const unsigned __r = __s; + return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd)); + } + const int __r = __s % _Nd; + if (__r == 0) + return __x; + else if (__r > 0) + return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); + else + return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); + } + + template + constexpr int + __countl_zero(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + if (__x == 0) + return _Nd; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + { + constexpr int __diff = _Nd_u - _Nd; + return __builtin_clz(__x) - __diff; + } + else if constexpr (_Nd <= _Nd_ul) + { + constexpr int __diff = _Nd_ul - _Nd; + return __builtin_clzl(__x) - __diff; + } + else if constexpr (_Nd <= _Nd_ull) + { + constexpr int __diff = _Nd_ull - _Nd; + return __builtin_clzll(__x) - __diff; + } + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + unsigned long long __high = __x >> _Nd_ull; + if (__high != 0) + { + constexpr int __diff = (2 * _Nd_ull) - _Nd; + return __builtin_clzll(__high) - __diff; + } + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + return (_Nd - _Nd_ull) + __builtin_clzll(__low); + } + } + + template + constexpr int + __countl_one(_Tp __x) noexcept + { + return std::__countl_zero<_Tp>((_Tp)~__x); + } + + template + constexpr int + __countr_zero(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + if (__x == 0) + return _Nd; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + return __builtin_ctz(__x); + else if constexpr (_Nd <= _Nd_ul) + return __builtin_ctzl(__x); + else if constexpr (_Nd <= _Nd_ull) + return __builtin_ctzll(__x); + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + if (__low != 0) + return __builtin_ctzll(__low); + unsigned long long __high = __x >> _Nd_ull; + return __builtin_ctzll(__high) + _Nd_ull; + } + } + + template + constexpr int + __countr_one(_Tp __x) noexcept + { + return std::__countr_zero((_Tp)~__x); + } + + template + constexpr int + __popcount(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + return __builtin_popcount(__x); + else if constexpr (_Nd <= _Nd_ul) + return __builtin_popcountl(__x); + else if constexpr (_Nd <= _Nd_ull) + return __builtin_popcountll(__x); + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + unsigned long long __high = __x >> _Nd_ull; + return __builtin_popcountll(__low) + __builtin_popcountll(__high); + } + } + + template + constexpr bool + __has_single_bit(_Tp __x) noexcept + { return std::__popcount(__x) == 1; } + + template + constexpr _Tp + __bit_ceil(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + if (__x == 0 || __x == 1) + return 1; + auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u)); + + + + + if (!std::__is_constant_evaluated()) + { + do { if (std::__is_constant_evaluated() && !bool(__shift_exponent != __int_traits<_Tp>::__digits)) std::__glibcxx_assert_fail(); } while (false); + } + + using __promoted_type = decltype(__x << 1); + if constexpr (!is_same<__promoted_type, _Tp>::value) + { + + + + + + const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; + __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; + } + return (_Tp)1u << __shift_exponent; + } + + template + constexpr _Tp + __bit_floor(_Tp __x) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if (__x == 0) + return 0; + return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1))); + } + + template + constexpr int + __bit_width(_Tp __x) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + return _Nd - std::__countl_zero(__x); + } +# 482 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 + +} +# 77 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + template + constexpr + inline int + __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num) + { + + static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp"); +# 108 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); + } +# 152 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline void + iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) + { + + + + +# 185 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + swap(*__a, *__b); + + } +# 201 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + _ForwardIterator2 + swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + std::iter_swap(__first1, __first2); + return __first2; + } +# 230 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b) + { + + + + if (__b < __a) + return __b; + return __a; + } +# 254 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b) + { + + + + if (__a < __b) + return __b; + return __a; + } +# 278 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__b, __a)) + return __b; + return __a; + } +# 300 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__a, __b)) + return __b; + return __a; + } + + + + template + + inline _Iterator + __niter_base(_Iterator __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it; } +# 332 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + decltype(std::__niter_base(std::declval<_Ite>())) + __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, + std::random_access_iterator_tag>&) + noexcept(std::is_nothrow_copy_constructible<_Ite>::value); + + + + + + template + + inline _From + __niter_wrap(_From __from, _To __res) + { return __from + (std::__niter_base(__res) - std::__niter_base(__from)); } + + + template + + inline _Iterator + __niter_wrap(const _Iterator&, _Iterator __res) + { return __res; } + + + + + + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = *__first; + return __result; + } + }; + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = std::move(*__first); + return __result; + } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = *__first; + ++__first; + ++__result; + } + return __result; + } + + template + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to = *__from; } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = std::move(*__first); + ++__first; + ++__result; + } + return __result; + } + + template + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to = std::move(*__from); } + }; + + + template + struct __copy_move<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_m(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num = __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); + else if (_Num == 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result, __first); + return __result + _Num; + } + }; + + + + template + struct _Deque_iterator; + + struct _Bit_iterator; + + + + + + + template + struct char_traits; + + template + class istreambuf_iterator; + + template + class ostreambuf_iterator; + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(_CharT*, _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(const _CharT*, const _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + _CharT*>::__type + __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_move_a2( + istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>); + + + template + + inline _OI + __copy_move_a2(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::iterator_category _Category; + + + + + + return std::__copy_move<_IsMove, __memcpyable<_OI, _II>::__value, + _Category>::__copy_m(__first, __last, __result); + } + + template + _OI + __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + std::_Deque_iterator<_OTp, _OTp&, _OTp*> + __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_OTp, _OTp&, _OTp*>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, + std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + + inline _OI + __copy_move_a1(_II __first, _II __last, _OI __result) + { return std::__copy_move_a2<_IsMove>(__first, __last, __result); } + + template + + inline _OI + __copy_move_a(_II __first, _II __last, _OI __result) + { + return std::__niter_wrap(__result, + std::__copy_move_a1<_IsMove>(std::__niter_base(__first), + std::__niter_base(__last), + std::__niter_base(__result))); + } + + template + + _OI + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + + ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); + + template + + _OutputIterator + __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, + bool) + { + if (__n > 0) + { + while (true) + { + *__result = *__first; + ++__result; + if (--__n > 0) + ++__first; + else + break; + } + } + return __result; + } + + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, _CharT*>::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, + _Size, _CharT*, bool); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, _Size, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>, + bool); +# 639 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _OI + copy(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a<__is_move_iterator<_II>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 672 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _OI + move(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a(std::__miter_base(__first), + std::__miter_base(__last), __result); + } + + + + + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = *--__last; + return __result; + } + }; + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n = __last - __first; + for (; __n > 0; --__n) + *--__result = *--__last; + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n = __last - __first; + for (; __n > 0; --__n) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template + struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_move_b(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num = __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); + else if (_Num == 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result - 1, __first); + return __result - _Num; + } + }; + + template + + inline _BI2 + __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) + { + typedef typename iterator_traits<_BI1>::iterator_category _Category; + + + + + + return std::__copy_move_backward<_IsMove, + __memcpyable<_BI2, _BI1>::__value, + _Category>::__copy_move_b(__first, + __last, + __result); + } + + template + + inline _BI2 + __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) + { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); } + + template + _OI + __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + std::_Deque_iterator<_OTp, _OTp&, _OTp*> + __copy_move_backward_a1( + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_OTp, _OTp&, _OTp*>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, + std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __copy_move_backward_a1(_II, _II, + std::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + + inline _OI + __copy_move_backward_a(_II __first, _II __last, _OI __result) + { + return std::__niter_wrap(__result, + std::__copy_move_backward_a1<_IsMove> + (std::__niter_base(__first), std::__niter_base(__last), + std::__niter_base(__result))); + } + + template + + _OI + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_backward_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + + ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); +# 875 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _BI2 + copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + ; + + return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 910 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _BI2 + move_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + ; + + return std::__copy_move_backward_a(std::__miter_base(__first), + std::__miter_base(__last), + __result); + } + + + + + + + template + + inline typename + __gnu_cxx::__enable_if::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + for (; __first != __last; ++__first) + *__first = __value; + } + + template + + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __first != __last; ++__first) + *__first = __tmp; + } + + + template + + inline typename + __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type + __fill_a1(_Tp* __first, _Tp* __last, const _Tp& __c) + { + const _Tp __tmp = __c; +# 971 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + if (const size_t __len = __last - __first) + __builtin_memset(__first, static_cast(__tmp), __len); + } + + template + + inline void + __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first, + ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last, + const _Tp& __value) + { std::__fill_a1(__first.base(), __last.base(), __value); } + + template + void + __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const _VTp&); + + + void + __fill_a1(std::_Bit_iterator, std::_Bit_iterator, + const bool&); + + template + + inline void + __fill_a(_FIte __first, _FIte __last, const _Tp& __value) + { std::__fill_a1(__first, __last, __value); } + + template + + void + __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const _Tp&); +# 1019 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline void + fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) + { + + + + ; + + std::__fill_a(__first, __last, __value); + } + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wlong-long" + + inline constexpr int + __size_to_integer(int __n) { return __n; } + inline constexpr unsigned + __size_to_integer(unsigned __n) { return __n; } + inline constexpr long + __size_to_integer(long __n) { return __n; } + inline constexpr unsigned long + __size_to_integer(unsigned long __n) { return __n; } + inline constexpr long long + __size_to_integer(long long __n) { return __n; } + inline constexpr unsigned long long + __size_to_integer(unsigned long long __n) { return __n; } + + + __extension__ inline constexpr __int128 + __size_to_integer(__int128 __n) { return __n; } + __extension__ inline constexpr unsigned __int128 + __size_to_integer(unsigned __int128 __n) { return __n; } +# 1073 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + inline constexpr long long + __size_to_integer(float __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(double __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(long double __n) { return (long long)__n; } + + __extension__ inline constexpr long long + __size_to_integer(__float128 __n) { return (long long)__n; } + +#pragma GCC diagnostic pop + + template + + inline typename + __gnu_cxx::__enable_if::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + for (; __n > 0; --__n, (void) ++__first) + *__first = __value; + return __first; + } + + template + + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __n > 0; --__n, (void) ++__first) + *__first = __tmp; + return __first; + } + + template + + ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first, + _Size __n, const _Tp& __value, + std::input_iterator_tag); + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::output_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + return __fill_n_a1(__first, __n, __value); + } + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::input_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + return __fill_n_a1(__first, __n, __value); + } + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::random_access_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + if (__n <= 0) + return __first; + + ; + + std::__fill_a(__first, __first + __n, __value); + return __first + __n; + } +# 1175 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _OI + fill_n(_OI __first, _Size __n, const _Tp& __value) + { + + + + return std::__fill_n_a(__first, std::__size_to_integer(__n), __value, + std::__iterator_category(__first)); + } + + template + struct __equal + { + template + + static bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + for (; __first1 != __last1; ++__first1, (void) ++__first2) + if (!(*__first1 == *__first2)) + return false; + return true; + } + }; + + template<> + struct __equal + { + template + + static bool + equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) + { + if (const size_t __len = (__last1 - __first1)) + return !std::__memcmp(__first1, __first2, __len); + return true; + } + }; + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _II); + + template + bool + __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(_II, _II, + std::_Deque_iterator<_Tp, _Ref, _Ptr>); + + template + + inline bool + __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + const bool __simple = ((__is_integer<_ValueType1>::__value + || __is_pointer<_ValueType1>::__value) + && __memcmpable<_II1, _II2>::__value); + return std::__equal<__simple>::equal(__first1, __last1, __first2); + } + + template + + inline bool + __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) + { + return std::__equal_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2)); + } + + template + + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + _II2); + + template + + bool + __equal_aux(_II1, _II1, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + struct __lc_rai + { + template + + static _II1 + __newlast1(_II1, _II1 __last1, _II2, _II2) + { return __last1; } + + template + + static bool + __cnd2(_II __first, _II __last) + { return __first != __last; } + }; + + template<> + struct __lc_rai + { + template + + static _RAI1 + __newlast1(_RAI1 __first1, _RAI1 __last1, + _RAI2 __first2, _RAI2 __last2) + { + const typename iterator_traits<_RAI1>::difference_type + __diff1 = __last1 - __first1; + const typename iterator_traits<_RAI2>::difference_type + __diff2 = __last2 - __first2; + return __diff2 < __diff1 ? __first1 + __diff2 : __last1; + } + + template + static bool + __cnd2(_RAI, _RAI) + { return true; } + }; + + template + + bool + __lexicographical_compare_impl(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, + _Compare __comp) + { + typedef typename iterator_traits<_II1>::iterator_category _Category1; + typedef typename iterator_traits<_II2>::iterator_category _Category2; + typedef std::__lc_rai<_Category1, _Category2> __rai_type; + + __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); + for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); + ++__first1, (void)++__first2) + { + if (__comp(__first1, __first2)) + return true; + if (__comp(__first2, __first1)) + return false; + } + return __first1 == __last1 && __first2 != __last2; + } + + template + struct __lexicographical_compare + { + template + + static bool + __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using __gnu_cxx::__ops::__iter_less_iter; + return std::__lexicographical_compare_impl(__first1, __last1, + __first2, __last2, + __iter_less_iter()); + } + + template + + static int + __3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + while (__first1 != __last1) + { + if (__first2 == __last2) + return +1; + if (*__first1 < *__first2) + return -1; + if (*__first2 < *__first1) + return +1; + ++__first1; + ++__first2; + } + return int(__first2 == __last2) - 1; + } + }; + + template<> + struct __lexicographical_compare + { + template + + static bool + __lc(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { return __3way(__first1, __last1, __first2, __last2) < 0; } + + template + + static ptrdiff_t + __3way(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { + const size_t __len1 = __last1 - __first1; + const size_t __len2 = __last2 - __first2; + if (const size_t __len = std::min(__len1, __len2)) + if (int __result = std::__memcmp(__first1, __first2, __len)) + return __result; + return ptrdiff_t(__len1 - __len2); + } + }; + + template + + inline bool + __lexicographical_compare_aux1(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + typedef typename iterator_traits<_II2>::value_type _ValueType2; + const bool __simple = + (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value + && __is_pointer<_II1>::__value + && __is_pointer<_II2>::__value + + + + + + + + ); + + return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, + __first2, __last2); + } + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + _Tp2*, _Tp2*); + + template + bool + __lexicographical_compare_aux1(_Tp1*, _Tp1*, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + + inline bool + __lexicographical_compare_aux(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + return std::__lexicographical_compare_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2), + std::__niter_base(__last2)); + } + + template + + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + _II2, _II2); + + template + + bool + __lexicographical_compare_aux( + _II1, _II1, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + + _ForwardIterator + __lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len = std::distance(__first, __last); + + while (__len > 0) + { + _DistanceType __half = __len >> 1; + _ForwardIterator __middle = __first; + std::advance(__middle, __half); + if (__comp(__middle, __val)) + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + else + __len = __half; + } + return __first; + } +# 1527 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline _ForwardIterator + lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + + + + + ; + + return std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val()); + } + + + + template + inline constexpr _Tp + __lg(_Tp __n) + { + + return std::__bit_width(make_unsigned_t<_Tp>(__n)) - 1; +# 1563 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + } + + +# 1579 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + + + + + + + ; + + return std::__equal_aux(__first1, __last1, __first2); + } +# 1610 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return true; + } + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++17-extensions" + + + template + + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if constexpr (_RAIters::value) + { + if ((__last1 - __first1) != (__last2 - __first2)) + return false; + return std::equal(__first1, __last1, __first2); + } + else + { + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!(*__first1 == *__first2)) + return false; + return __first1 == __last1 && __first2 == __last2; + } + } + + + template + + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, + _BinaryPredicate __binary_pred) + { + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if constexpr (_RAIters::value) + { + if ((__last1 - __first1) != (__last2 - __first2)) + return false; + return std::equal(__first1, __last1, __first2, + __binary_pred); + } + else + { + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return __first1 == __last1 && __first2 == __last2; + } + } +#pragma GCC diagnostic pop +# 1701 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + + + + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2); + } +# 1734 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2, + __binary_pred); + } +# 1766 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + + + + + + + + + + ; + ; + + return std::__lexicographical_compare_aux(__first1, __last1, + __first2, __last2); + } +# 1801 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, _Compare __comp) + { + + + + ; + ; + + return std::__lexicographical_compare_impl + (__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 1916 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 1944 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2) + { + + + + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 1978 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + template + + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __first2 != __last2 + && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 2026 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2) + { + + + + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 2062 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + + + template + + inline _InputIterator + __find_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred, input_iterator_tag) + { + while (__first != __last && !__pred(__first)) + ++__first; + return __first; + } + + + template + + _RandomAccessIterator + __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Predicate __pred, random_access_iterator_tag) + { + typename iterator_traits<_RandomAccessIterator>::difference_type + __trip_count = (__last - __first) >> 2; + + for (; __trip_count > 0; --__trip_count) + { + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + } + + switch (__last - __first) + { + case 3: + if (__pred(__first)) + return __first; + ++__first; + + case 2: + if (__pred(__first)) + return __first; + ++__first; + + case 1: + if (__pred(__first)) + return __first; + ++__first; + + case 0: + default: + return __last; + } + } + + template + + inline _Iterator + __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) + { + return __find_if(__first, __last, __pred, + std::__iterator_category(__first)); + } + + template + + typename iterator_traits<_InputIterator>::difference_type + __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { + typename iterator_traits<_InputIterator>::difference_type __n = 0; + for (; __first != __last; ++__first) + if (__pred(__first)) + ++__n; + return __n; + } + + template + + _ForwardIterator + __remove_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + __first = std::__find_if(__first, __last, __pred); + if (__first == __last) + return __first; + _ForwardIterator __result = __first; + ++__first; + for (; __first != __last; ++__first) + if (!__pred(__first)) + { + *__result = std::move(*__first); + ++__result; + } + return __result; + } + + template + + _ForwardIterator1 + __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __predicate) + { + + if (__first1 == __last1 || __first2 == __last2) + return __first1; + + + _ForwardIterator2 __p1(__first2); + if (++__p1 == __last2) + return std::__find_if(__first1, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); + + + _ForwardIterator1 __current = __first1; + + for (;;) + { + __first1 = + std::__find_if(__first1, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); + + if (__first1 == __last1) + return __last1; + + _ForwardIterator2 __p = __p1; + __current = __first1; + if (++__current == __last1) + return __last1; + + while (__predicate(__current, __p)) + { + if (++__p == __last2) + return __first1; + if (++__current == __last1) + return __last1; + } + ++__first1; + } + return __first1; + } + + + template + + bool + __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _BinaryPredicate __pred) + { + + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!__pred(__first1, __first2)) + break; + + if (__first1 == __last1) + return true; + + + + _ForwardIterator2 __last2 = __first2; + std::advance(__last2, std::distance(__first1, __last1)); + for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) + { + if (__scan != std::__find_if(__first1, __scan, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) + continue; + + auto __matches + = std::__count_if(__first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); + if (0 == __matches || + std::__count_if(__scan, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) + != __matches) + return false; + } + return true; + } +# 2286 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + + ; + + return std::__is_permutation(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } + + + +# 2328 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _ForwardIterator1 + search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __predicate) + { + + + + + + + ; + ; + + return std::__search(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__predicate)); + } + + + +} +# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 1 3 +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + +# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +# 158 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + enum float_round_style + { + round_indeterminate = -1, + round_toward_zero = 0, + round_to_nearest = 1, + round_toward_infinity = 2, + round_toward_neg_infinity = 3 + }; + + + + + + + + enum float_denorm_style + { + + denorm_indeterminate = -1, + + denorm_absent = 0, + + denorm_present = 1 + }; +# 202 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + struct __numeric_limits_base + { + + + static constexpr bool is_specialized = false; + + + + + static constexpr int digits = 0; + + + static constexpr int digits10 = 0; + + + + + static constexpr int max_digits10 = 0; + + + + static constexpr bool is_signed = false; + + + static constexpr bool is_integer = false; + + + + + static constexpr bool is_exact = false; + + + + static constexpr int radix = 0; + + + + static constexpr int min_exponent = 0; + + + + static constexpr int min_exponent10 = 0; + + + + + static constexpr int max_exponent = 0; + + + + static constexpr int max_exponent10 = 0; + + + static constexpr bool has_infinity = false; + + + + static constexpr bool has_quiet_NaN = false; + + + + static constexpr bool has_signaling_NaN = false; + + + static constexpr float_denorm_style has_denorm = denorm_absent; + + + + static constexpr bool has_denorm_loss = false; + + + + static constexpr bool is_iec559 = false; + + + + + static constexpr bool is_bounded = false; +# 288 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + static constexpr bool is_modulo = false; + + + static constexpr bool traps = false; + + + static constexpr bool tinyness_before = false; + + + + + static constexpr float_round_style round_style = + round_toward_zero; + }; +# 311 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + template + struct numeric_limits : public __numeric_limits_base + { + + + static constexpr _Tp + min() noexcept { return _Tp(); } + + + static constexpr _Tp + max() noexcept { return _Tp(); } + + + + + static constexpr _Tp + lowest() noexcept { return _Tp(); } + + + + + static constexpr _Tp + epsilon() noexcept { return _Tp(); } + + + static constexpr _Tp + round_error() noexcept { return _Tp(); } + + + static constexpr _Tp + infinity() noexcept { return _Tp(); } + + + + static constexpr _Tp + quiet_NaN() noexcept { return _Tp(); } + + + + static constexpr _Tp + signaling_NaN() noexcept { return _Tp(); } + + + + + static constexpr _Tp + denorm_min() noexcept { return _Tp(); } + }; + + + + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; +# 383 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr bool + min() noexcept { return false; } + + static constexpr bool + max() noexcept { return true; } + + + static constexpr bool + lowest() noexcept { return min(); } + + static constexpr int digits = 1; + static constexpr int digits10 = 0; + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr bool + epsilon() noexcept { return false; } + + static constexpr bool + round_error() noexcept { return false; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr bool + infinity() noexcept { return false; } + + static constexpr bool + quiet_NaN() noexcept { return false; } + + static constexpr bool + signaling_NaN() noexcept { return false; } + + static constexpr bool + denorm_min() noexcept { return false; } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + + + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char + min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); } + + static constexpr char + max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); } + + + static constexpr char + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = ((char)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char + epsilon() noexcept { return 0; } + + static constexpr char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr + char infinity() noexcept { return char(); } + + static constexpr char + quiet_NaN() noexcept { return char(); } + + static constexpr char + signaling_NaN() noexcept { return char(); } + + static constexpr char + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr signed char + min() noexcept { return -0x7f - 1; } + + static constexpr signed char + max() noexcept { return 0x7f; } + + + static constexpr signed char + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr signed char + epsilon() noexcept { return 0; } + + static constexpr signed char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr signed char + infinity() noexcept { return static_cast(0); } + + static constexpr signed char + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr signed char + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr signed char + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned char + min() noexcept { return 0; } + + static constexpr unsigned char + max() noexcept { return 0x7f * 2U + 1; } + + + static constexpr unsigned char + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned char + epsilon() noexcept { return 0; } + + static constexpr unsigned char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned char + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned char + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned char + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned char + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr wchar_t + min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); } + + static constexpr wchar_t + max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); } + + + static constexpr wchar_t + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = ((wchar_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr wchar_t + epsilon() noexcept { return 0; } + + static constexpr wchar_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr wchar_t + infinity() noexcept { return wchar_t(); } + + static constexpr wchar_t + quiet_NaN() noexcept { return wchar_t(); } + + static constexpr wchar_t + signaling_NaN() noexcept { return wchar_t(); } + + static constexpr wchar_t + denorm_min() noexcept { return wchar_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; +# 796 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char16_t + min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); } + + static constexpr char16_t + max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); } + + static constexpr char16_t + lowest() noexcept { return min(); } + + static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136); + static constexpr int max_digits10 = 0; + static constexpr bool is_signed = ((char16_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char16_t + epsilon() noexcept { return 0; } + + static constexpr char16_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr char16_t + infinity() noexcept { return char16_t(); } + + static constexpr char16_t + quiet_NaN() noexcept { return char16_t(); } + + static constexpr char16_t + signaling_NaN() noexcept { return char16_t(); } + + static constexpr char16_t + denorm_min() noexcept { return char16_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char32_t + min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); } + + static constexpr char32_t + max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); } + + static constexpr char32_t + lowest() noexcept { return min(); } + + static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136); + static constexpr int max_digits10 = 0; + static constexpr bool is_signed = ((char32_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char32_t + epsilon() noexcept { return 0; } + + static constexpr char32_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr char32_t + infinity() noexcept { return char32_t(); } + + static constexpr char32_t + quiet_NaN() noexcept { return char32_t(); } + + static constexpr char32_t + signaling_NaN() noexcept { return char32_t(); } + + static constexpr char32_t + denorm_min() noexcept { return char32_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style = round_toward_zero; + }; + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr short + min() noexcept { return -0x7fff - 1; } + + static constexpr short + max() noexcept { return 0x7fff; } + + + static constexpr short + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0)); + static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr short + epsilon() noexcept { return 0; } + + static constexpr short + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr short + infinity() noexcept { return short(); } + + static constexpr short + quiet_NaN() noexcept { return short(); } + + static constexpr short + signaling_NaN() noexcept { return short(); } + + static constexpr short + denorm_min() noexcept { return short(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned short + min() noexcept { return 0; } + + static constexpr unsigned short + max() noexcept { return 0x7fff * 2U + 1; } + + + static constexpr unsigned short + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned short + epsilon() noexcept { return 0; } + + static constexpr unsigned short + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned short + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned short + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned short + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned short + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr int + min() noexcept { return -0x7fffffff - 1; } + + static constexpr int + max() noexcept { return 0x7fffffff; } + + + static constexpr int + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0)); + static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr int + epsilon() noexcept { return 0; } + + static constexpr int + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr int + infinity() noexcept { return static_cast(0); } + + static constexpr int + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr int + signaling_NaN() noexcept { return static_cast(0); } + + static constexpr int + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned int + min() noexcept { return 0; } + + static constexpr unsigned int + max() noexcept { return 0x7fffffff * 2U + 1; } + + + static constexpr unsigned int + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned int + epsilon() noexcept { return 0; } + + static constexpr unsigned int + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned int + infinity() noexcept { return static_cast(0); } + + static constexpr unsigned int + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned int + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned int + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr long + min() noexcept { return -0x7fffffffffffffffL - 1; } + + static constexpr long + max() noexcept { return 0x7fffffffffffffffL; } + + + static constexpr long + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0)); + static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr long + epsilon() noexcept { return 0; } + + static constexpr long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr long + infinity() noexcept { return static_cast(0); } + + static constexpr long + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr long + signaling_NaN() noexcept { return static_cast(0); } + + static constexpr long + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned long + min() noexcept { return 0; } + + static constexpr unsigned long + max() noexcept { return 0x7fffffffffffffffL * 2UL + 1; } + + + static constexpr unsigned long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned long + epsilon() noexcept { return 0; } + + static constexpr unsigned long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned long + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned long + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr long long + min() noexcept { return -0x7fffffffffffffffLL - 1; } + + static constexpr long long + max() noexcept { return 0x7fffffffffffffffLL; } + + + static constexpr long long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(long long) * 8 - ((long long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr long long + epsilon() noexcept { return 0; } + + static constexpr long long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr long long + infinity() noexcept { return static_cast(0); } + + static constexpr long long + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr long long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr long long + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned long long + min() noexcept { return 0; } + + static constexpr unsigned long long + max() noexcept { return 0x7fffffffffffffffLL * 2ULL + 1; } + + + static constexpr unsigned long long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned long long + epsilon() noexcept { return 0; } + + static constexpr unsigned long long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned long long + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; +# 1637 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + __extension__ template<> struct numeric_limits<__int128> { static constexpr bool is_specialized = true; static constexpr __int128 min() noexcept { return (((__int128)(-1) < 0) ? -(((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0) - 1 : (__int128)0); } static constexpr __int128 max() noexcept { return (((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0); } static constexpr int digits = 128 - 1; static constexpr int digits10 = (128 - 1) * 643L / 2136; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr __int128 epsilon() noexcept { return 0; } static constexpr __int128 round_error() noexcept { return 0; } static constexpr __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 0; static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr __int128 infinity() noexcept { return static_cast<__int128>(0); } static constexpr __int128 quiet_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 signaling_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 denorm_min() noexcept { return static_cast<__int128>(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; __extension__ template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr unsigned __int128 min() noexcept { return 0; } static constexpr unsigned __int128 max() noexcept { return (((unsigned __int128)(-1) < 0) ? (((((unsigned __int128)1 << ((128 - ((unsigned __int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(unsigned __int128)0); } static constexpr unsigned __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 0; static constexpr int digits = 128; static constexpr int digits10 = 128 * 643L / 2136; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr unsigned __int128 epsilon() noexcept { return 0; } static constexpr unsigned __int128 round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr unsigned __int128 infinity() noexcept { return static_cast(0); } static constexpr unsigned __int128 quiet_NaN() noexcept { return static_cast(0); } static constexpr unsigned __int128 signaling_NaN() noexcept { return static_cast(0); } static constexpr unsigned __int128 denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = true; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; +# 1669 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr float + min() noexcept { return 1.17549435082228750796873653722224568e-38F; } + + static constexpr float + max() noexcept { return 3.40282346638528859811704183484516925e+38F; } + + + static constexpr float + lowest() noexcept { return -3.40282346638528859811704183484516925e+38F; } + + + static constexpr int digits = 24; + static constexpr int digits10 = 6; + + static constexpr int max_digits10 + = (2 + (24) * 643L / 2136); + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr float + epsilon() noexcept { return 1.19209289550781250000000000000000000e-7F; } + + static constexpr float + round_error() noexcept { return 0.5F; } + + static constexpr int min_exponent = (-125); + static constexpr int min_exponent10 = (-37); + static constexpr int max_exponent = 128; + static constexpr int max_exponent10 = 38; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + static constexpr bool has_signaling_NaN = has_quiet_NaN; + static constexpr float_denorm_style has_denorm + = bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + = false; + + static constexpr float + infinity() noexcept { return __builtin_huge_valf(); } + + static constexpr float + quiet_NaN() noexcept { return __builtin_nanf(""); } + + static constexpr float + signaling_NaN() noexcept { return __builtin_nansf(""); } + + static constexpr float + denorm_min() noexcept { return 1.40129846432481707092372958328991613e-45F; } + + static constexpr bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before + = false; + static constexpr float_round_style round_style + = round_to_nearest; + }; + + + + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr double + min() noexcept { return double(2.22507385850720138309023271733240406e-308L); } + + static constexpr double + max() noexcept { return double(1.79769313486231570814527423731704357e+308L); } + + + static constexpr double + lowest() noexcept { return -double(1.79769313486231570814527423731704357e+308L); } + + + static constexpr int digits = 53; + static constexpr int digits10 = 15; + + static constexpr int max_digits10 + = (2 + (53) * 643L / 2136); + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr double + epsilon() noexcept { return double(2.22044604925031308084726333618164062e-16L); } + + static constexpr double + round_error() noexcept { return 0.5; } + + static constexpr int min_exponent = (-1021); + static constexpr int min_exponent10 = (-307); + static constexpr int max_exponent = 1024; + static constexpr int max_exponent10 = 308; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + static constexpr bool has_signaling_NaN = has_quiet_NaN; + static constexpr float_denorm_style has_denorm + = bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + = false; + + static constexpr double + infinity() noexcept { return __builtin_huge_val(); } + + static constexpr double + quiet_NaN() noexcept { return __builtin_nan(""); } + + static constexpr double + signaling_NaN() noexcept { return __builtin_nans(""); } + + static constexpr double + denorm_min() noexcept { return double(4.94065645841246544176568792868221372e-324L); } + + static constexpr bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before + = false; + static constexpr float_round_style round_style + = round_to_nearest; + }; + + + + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr long double + min() noexcept { return 3.36210314311209350626267781732175260e-4932L; } + + static constexpr long double + max() noexcept { return 1.18973149535723176502126385303097021e+4932L; } + + + static constexpr long double + lowest() noexcept { return -1.18973149535723176502126385303097021e+4932L; } + + + static constexpr int digits = 64; + static constexpr int digits10 = 18; + + static constexpr int max_digits10 + = (2 + (64) * 643L / 2136); + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr long double + epsilon() noexcept { return 1.08420217248550443400745280086994171e-19L; } + + static constexpr long double + round_error() noexcept { return 0.5L; } + + static constexpr int min_exponent = (-16381); + static constexpr int min_exponent10 = (-4931); + static constexpr int max_exponent = 16384; + static constexpr int max_exponent10 = 4932; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + static constexpr bool has_signaling_NaN = has_quiet_NaN; + static constexpr float_denorm_style has_denorm + = bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + = false; + + static constexpr long double + infinity() noexcept { return __builtin_huge_vall(); } + + static constexpr long double + quiet_NaN() noexcept { return __builtin_nanl(""); } + + static constexpr long double + signaling_NaN() noexcept { return __builtin_nansl(""); } + + static constexpr long double + denorm_min() noexcept { return 3.64519953188247460252840593361941982e-4951L; } + + static constexpr bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before = + false; + static constexpr float_round_style round_style = + round_to_nearest; + }; +# 1989 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +__extension__ template<> struct numeric_limits<_Float32> { static constexpr bool is_specialized = true; static constexpr _Float32 min() noexcept { return 1.17549435082228750796873653722224568e-38F32; } static constexpr _Float32 max() noexcept { return 3.40282346638528859811704183484516925e+38F32; } static constexpr _Float32 lowest() noexcept { return -3.40282346638528859811704183484516925e+38F32; } static constexpr int digits = 24; static constexpr int digits10 = 6; static constexpr int max_digits10 = (2 + (24) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr _Float32 epsilon() noexcept { return 1.19209289550781250000000000000000000e-7F32; } static constexpr _Float32 round_error() noexcept { return 0.5F32; } static constexpr int min_exponent = (-125); static constexpr int min_exponent10 = (-37); static constexpr int max_exponent = 128; static constexpr int max_exponent10 = 38; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr _Float32 infinity() noexcept { return __builtin_huge_valf32(); } static constexpr _Float32 quiet_NaN() noexcept { return __builtin_nanf32(""); } static constexpr _Float32 signaling_NaN() noexcept { return __builtin_nansf32(""); } static constexpr _Float32 denorm_min() noexcept { return 1.40129846432481707092372958328991613e-45F32; } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; + + +__extension__ template<> struct numeric_limits<_Float64> { static constexpr bool is_specialized = true; static constexpr _Float64 min() noexcept { return 2.22507385850720138309023271733240406e-308F64; } static constexpr _Float64 max() noexcept { return 1.79769313486231570814527423731704357e+308F64; } static constexpr _Float64 lowest() noexcept { return -1.79769313486231570814527423731704357e+308F64; } static constexpr int digits = 53; static constexpr int digits10 = 15; static constexpr int max_digits10 = (2 + (53) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr _Float64 epsilon() noexcept { return 2.22044604925031308084726333618164062e-16F64; } static constexpr _Float64 round_error() noexcept { return 0.5F64; } static constexpr int min_exponent = (-1021); static constexpr int min_exponent10 = (-307); static constexpr int max_exponent = 1024; static constexpr int max_exponent10 = 308; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr _Float64 infinity() noexcept { return __builtin_huge_valf64(); } static constexpr _Float64 quiet_NaN() noexcept { return __builtin_nanf64(""); } static constexpr _Float64 signaling_NaN() noexcept { return __builtin_nansf64(""); } static constexpr _Float64 denorm_min() noexcept { return 4.94065645841246544176568792868221372e-324F64; } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; + + +__extension__ template<> struct numeric_limits<_Float128> { static constexpr bool is_specialized = true; static constexpr _Float128 min() noexcept { return 3.36210314311209350626267781732175260e-4932F128; } static constexpr _Float128 max() noexcept { return 1.18973149535723176508575932662800702e+4932F128; } static constexpr _Float128 lowest() noexcept { return -1.18973149535723176508575932662800702e+4932F128; } static constexpr int digits = 113; static constexpr int digits10 = 33; static constexpr int max_digits10 = (2 + (113) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr _Float128 epsilon() noexcept { return 1.92592994438723585305597794258492732e-34F128; } static constexpr _Float128 round_error() noexcept { return 0.5F128; } static constexpr int min_exponent = (-16381); static constexpr int min_exponent10 = (-4931); static constexpr int max_exponent = 16384; static constexpr int max_exponent10 = 4932; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr _Float128 infinity() noexcept { return __builtin_huge_valf128(); } static constexpr _Float128 quiet_NaN() noexcept { return __builtin_nanf128(""); } static constexpr _Float128 signaling_NaN() noexcept { return __builtin_nansf128(""); } static constexpr _Float128 denorm_min() noexcept { return 6.47517511943802511092443895822764655e-4966F128; } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; +# 2087 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + __extension__ + template<> + struct numeric_limits<__float128> + { + static constexpr bool is_specialized = true; + + static constexpr __float128 + min() noexcept + { + + + + + return __extension__ 0x1.0p-16382Q; + + } + + static constexpr __float128 + max() noexcept + { + + + + + + + + return __extension__ 0x1.ffffffffffffffffffffffffffffp+16383Q; + + } + + static constexpr __float128 + lowest() noexcept + { return -max(); } + + static constexpr int digits = 113; + static constexpr int digits10 = 33; + + static constexpr int max_digits10 = 35; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr __float128 + epsilon() noexcept + { return double(1.9259299443872359e-34); } + + static constexpr __float128 + round_error() noexcept { return 0.5; } + + static constexpr int min_exponent = -16381; + static constexpr int min_exponent10 = -4931; + static constexpr int max_exponent = 16384; + static constexpr int max_exponent10 = 4932; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + + + static constexpr bool has_signaling_NaN = true; + + + + static constexpr float_denorm_style has_denorm + = denorm_present; + static constexpr bool has_denorm_loss = false; + + static constexpr __float128 + infinity() noexcept + { return __builtin_huge_val(); } + + static constexpr __float128 + quiet_NaN() noexcept + { return __builtin_nan(""); } + + static constexpr __float128 + signaling_NaN() noexcept + { + + return __builtin_nansq(""); + + + + + + } + + static constexpr __float128 + denorm_min() noexcept + { + + + + + return __extension__ 0x1.0p-16494Q; + + } + + static constexpr bool is_iec559 = has_signaling_NaN; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_to_nearest; +# 2218 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + }; + + + + +} +# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 1 3 +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 + namespace __detail + { + + + + template + struct __floating_point_constant + { + static const _Tp __value; + }; + + + + template + struct __numeric_constants + { + + static _Tp __pi() throw() + { return static_cast<_Tp>(3.1415926535897932384626433832795029L); } + + static _Tp __pi_2() throw() + { return static_cast<_Tp>(1.5707963267948966192313216916397514L); } + + static _Tp __pi_3() throw() + { return static_cast<_Tp>(1.0471975511965977461542144610931676L); } + + static _Tp __pi_4() throw() + { return static_cast<_Tp>(0.7853981633974483096156608458198757L); } + + static _Tp __1_pi() throw() + { return static_cast<_Tp>(0.3183098861837906715377675267450287L); } + + static _Tp __2_sqrtpi() throw() + { return static_cast<_Tp>(1.1283791670955125738961589031215452L); } + + static _Tp __sqrt2() throw() + { return static_cast<_Tp>(1.4142135623730950488016887242096981L); } + + static _Tp __sqrt3() throw() + { return static_cast<_Tp>(1.7320508075688772935274463415058723L); } + + static _Tp __sqrtpio2() throw() + { return static_cast<_Tp>(1.2533141373155002512078826424055226L); } + + static _Tp __sqrt1_2() throw() + { return static_cast<_Tp>(0.7071067811865475244008443621048490L); } + + static _Tp __lnpi() throw() + { return static_cast<_Tp>(1.1447298858494001741434273513530587L); } + + static _Tp __gamma_e() throw() + { return static_cast<_Tp>(0.5772156649015328606065120900824024L); } + + static _Tp __euler() throw() + { return static_cast<_Tp>(2.7182818284590452353602874713526625L); } + }; +# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 + template + inline bool __isnan(_Tp __x) + { return std::isnan(__x); } +# 133 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 + } + + + + + +} +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + namespace __detail + { +# 76 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __bernoulli_series(unsigned int __n) + { + + static const _Tp __num[28] = { + _Tp(1UL), -_Tp(1UL) / _Tp(2UL), + _Tp(1UL) / _Tp(6UL), _Tp(0UL), + -_Tp(1UL) / _Tp(30UL), _Tp(0UL), + _Tp(1UL) / _Tp(42UL), _Tp(0UL), + -_Tp(1UL) / _Tp(30UL), _Tp(0UL), + _Tp(5UL) / _Tp(66UL), _Tp(0UL), + -_Tp(691UL) / _Tp(2730UL), _Tp(0UL), + _Tp(7UL) / _Tp(6UL), _Tp(0UL), + -_Tp(3617UL) / _Tp(510UL), _Tp(0UL), + _Tp(43867UL) / _Tp(798UL), _Tp(0UL), + -_Tp(174611) / _Tp(330UL), _Tp(0UL), + _Tp(854513UL) / _Tp(138UL), _Tp(0UL), + -_Tp(236364091UL) / _Tp(2730UL), _Tp(0UL), + _Tp(8553103UL) / _Tp(6UL), _Tp(0UL) + }; + + if (__n == 0) + return _Tp(1); + + if (__n == 1) + return -_Tp(1) / _Tp(2); + + + if (__n % 2 == 1) + return _Tp(0); + + + if (__n < 28) + return __num[__n]; + + + _Tp __fact = _Tp(1); + if ((__n / 2) % 2 == 0) + __fact *= _Tp(-1); + for (unsigned int __k = 1; __k <= __n; ++__k) + __fact *= __k / (_Tp(2) * __numeric_constants<_Tp>::__pi()); + __fact *= _Tp(2); + + _Tp __sum = _Tp(0); + for (unsigned int __i = 1; __i < 1000; ++__i) + { + _Tp __term = std::pow(_Tp(__i), -_Tp(__n)); + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + __sum += __term; + } + + return __fact * __sum; + } +# 139 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + inline _Tp + __bernoulli(int __n) + { return __bernoulli_series<_Tp>(__n); } +# 153 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma_bernoulli(_Tp __x) + { + _Tp __lg = (__x - _Tp(0.5L)) * std::log(__x) - __x + + _Tp(0.5L) * std::log(_Tp(2) + * __numeric_constants<_Tp>::__pi()); + + const _Tp __xx = __x * __x; + _Tp __help = _Tp(1) / __x; + for ( unsigned int __i = 1; __i < 20; ++__i ) + { + const _Tp __2i = _Tp(2 * __i); + __help /= __2i * (__2i - _Tp(1)) * __xx; + __lg += __bernoulli<_Tp>(2 * __i) * __help; + } + + return __lg; + } +# 181 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma_lanczos(_Tp __x) + { + const _Tp __xm1 = __x - _Tp(1); + + static const _Tp __lanczos_cheb_7[9] = { + _Tp( 0.99999999999980993227684700473478L), + _Tp( 676.520368121885098567009190444019L), + _Tp(-1259.13921672240287047156078755283L), + _Tp( 771.3234287776530788486528258894L), + _Tp(-176.61502916214059906584551354L), + _Tp( 12.507343278686904814458936853L), + _Tp(-0.13857109526572011689554707L), + _Tp( 9.984369578019570859563e-6L), + _Tp( 1.50563273514931155834e-7L) + }; + + static const _Tp __LOGROOT2PI + = _Tp(0.9189385332046727417803297364056176L); + + _Tp __sum = __lanczos_cheb_7[0]; + for(unsigned int __k = 1; __k < 9; ++__k) + __sum += __lanczos_cheb_7[__k] / (__xm1 + __k); + + const _Tp __term1 = (__xm1 + _Tp(0.5L)) + * std::log((__xm1 + _Tp(7.5L)) + / __numeric_constants<_Tp>::__euler()); + const _Tp __term2 = __LOGROOT2PI + std::log(__sum); + const _Tp __result = __term1 + (__term2 - _Tp(7)); + + return __result; + } +# 225 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma(_Tp __x) + { + if (__x > _Tp(0.5L)) + return __log_gamma_lanczos(__x); + else + { + const _Tp __sin_fact + = std::abs(std::sin(__numeric_constants<_Tp>::__pi() * __x)); + if (__sin_fact == _Tp(0)) + std::__throw_domain_error(("Argument is nonpositive integer " "in __log_gamma") + ); + return __numeric_constants<_Tp>::__lnpi() + - std::log(__sin_fact) + - __log_gamma_lanczos(_Tp(1) - __x); + } + } +# 252 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma_sign(_Tp __x) + { + if (__x > _Tp(0)) + return _Tp(1); + else + { + const _Tp __sin_fact + = std::sin(__numeric_constants<_Tp>::__pi() * __x); + if (__sin_fact > _Tp(0)) + return (1); + else if (__sin_fact < _Tp(0)) + return -_Tp(1); + else + return _Tp(0); + } + } +# 283 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __log_bincoef(unsigned int __n, unsigned int __k) + { + + static const _Tp __max_bincoeff + = std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + _Tp __coeff = ::std::lgamma(_Tp(1 + __n)) + - ::std::lgamma(_Tp(1 + __k)) + - ::std::lgamma(_Tp(1 + __n - __k)); + + + + + + } +# 314 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __bincoef(unsigned int __n, unsigned int __k) + { + + static const _Tp __max_bincoeff + = std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + const _Tp __log_coeff = __log_bincoef<_Tp>(__n, __k); + if (__log_coeff > __max_bincoeff) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return std::exp(__log_coeff); + } +# 337 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + inline _Tp + __gamma(_Tp __x) + { return std::exp(__log_gamma(__x)); } +# 356 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __psi_series(_Tp __x) + { + _Tp __sum = -__numeric_constants<_Tp>::__gamma_e() - _Tp(1) / __x; + const unsigned int __max_iter = 100000; + for (unsigned int __k = 1; __k < __max_iter; ++__k) + { + const _Tp __term = __x / (__k * (__k + __x)); + __sum += __term; + if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon()) + break; + } + return __sum; + } +# 386 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __psi_asymp(_Tp __x) + { + _Tp __sum = std::log(__x) - _Tp(0.5L) / __x; + const _Tp __xx = __x * __x; + _Tp __xp = __xx; + const unsigned int __max_iter = 100; + for (unsigned int __k = 1; __k < __max_iter; ++__k) + { + const _Tp __term = __bernoulli<_Tp>(2 * __k) / (2 * __k * __xp); + __sum -= __term; + if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon()) + break; + __xp *= __xx; + } + return __sum; + } +# 417 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __psi(_Tp __x) + { + const int __n = static_cast(__x + 0.5L); + const _Tp __eps = _Tp(4) * std::numeric_limits<_Tp>::epsilon(); + if (__n <= 0 && std::abs(__x - _Tp(__n)) < __eps) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x < _Tp(0)) + { + const _Tp __pi = __numeric_constants<_Tp>::__pi(); + return __psi(_Tp(1) - __x) + - __pi * std::cos(__pi * __x) / std::sin(__pi * __x); + } + else if (__x > _Tp(100)) + return __psi_asymp(__x); + else + return __psi_series(__x); + } +# 446 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __psi(unsigned int __n, _Tp __x) + { + if (__x <= _Tp(0)) + std::__throw_domain_error(("Argument out of range " "in __psi") + ); + else if (__n == 0) + return __psi(__x); + else + { + const _Tp __hzeta = __hurwitz_zeta(_Tp(__n + 1), __x); + + const _Tp __ln_nfact = ::std::lgamma(_Tp(__n + 1)); + + + + _Tp __result = std::exp(__ln_nfact) * __hzeta; + if (__n % 2 == 1) + __result = -__result; + return __result; + } + } + } + + + + + + +} +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 1 3 +# 55 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 71 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + namespace __detail + { +# 98 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + void + __gamma_temme(_Tp __mu, + _Tp & __gam1, _Tp & __gam2, _Tp & __gampl, _Tp & __gammi) + { + + __gampl = _Tp(1) / ::std::tgamma(_Tp(1) + __mu); + __gammi = _Tp(1) / ::std::tgamma(_Tp(1) - __mu); + + + + + + if (std::abs(__mu) < std::numeric_limits<_Tp>::epsilon()) + __gam1 = -_Tp(__numeric_constants<_Tp>::__gamma_e()); + else + __gam1 = (__gammi - __gampl) / (_Tp(2) * __mu); + + __gam2 = (__gammi + __gampl) / (_Tp(2)); + + return; + } +# 136 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + void + __bessel_jn(_Tp __nu, _Tp __x, + _Tp & __Jnu, _Tp & __Nnu, _Tp & __Jpnu, _Tp & __Npnu) + { + if (__x == _Tp(0)) + { + if (__nu == _Tp(0)) + { + __Jnu = _Tp(1); + __Jpnu = _Tp(0); + } + else if (__nu == _Tp(1)) + { + __Jnu = _Tp(0); + __Jpnu = _Tp(0.5L); + } + else + { + __Jnu = _Tp(0); + __Jpnu = _Tp(0); + } + __Nnu = -std::numeric_limits<_Tp>::infinity(); + __Npnu = std::numeric_limits<_Tp>::infinity(); + return; + } + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + + + + const _Tp __fp_min = std::sqrt(std::numeric_limits<_Tp>::min()); + const int __max_iter = 15000; + const _Tp __x_min = _Tp(2); + + const int __nl = (__x < __x_min + ? static_cast(__nu + _Tp(0.5L)) + : std::max(0, static_cast(__nu - __x + _Tp(1.5L)))); + + const _Tp __mu = __nu - __nl; + const _Tp __mu2 = __mu * __mu; + const _Tp __xi = _Tp(1) / __x; + const _Tp __xi2 = _Tp(2) * __xi; + _Tp __w = __xi2 / __numeric_constants<_Tp>::__pi(); + int __isign = 1; + _Tp __h = __nu * __xi; + if (__h < __fp_min) + __h = __fp_min; + _Tp __b = __xi2 * __nu; + _Tp __d = _Tp(0); + _Tp __c = __h; + int __i; + for (__i = 1; __i <= __max_iter; ++__i) + { + __b += __xi2; + __d = __b - __d; + if (std::abs(__d) < __fp_min) + __d = __fp_min; + __c = __b - _Tp(1) / __c; + if (std::abs(__c) < __fp_min) + __c = __fp_min; + __d = _Tp(1) / __d; + const _Tp __del = __c * __d; + __h *= __del; + if (__d < _Tp(0)) + __isign = -__isign; + if (std::abs(__del - _Tp(1)) < __eps) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Argument x too large in __bessel_jn; " "try asymptotic expansion.") + ); + _Tp __Jnul = __isign * __fp_min; + _Tp __Jpnul = __h * __Jnul; + _Tp __Jnul1 = __Jnul; + _Tp __Jpnu1 = __Jpnul; + _Tp __fact = __nu * __xi; + for ( int __l = __nl; __l >= 1; --__l ) + { + const _Tp __Jnutemp = __fact * __Jnul + __Jpnul; + __fact -= __xi; + __Jpnul = __fact * __Jnutemp - __Jnul; + __Jnul = __Jnutemp; + } + if (__Jnul == _Tp(0)) + __Jnul = __eps; + _Tp __f= __Jpnul / __Jnul; + _Tp __Nmu, __Nnu1, __Npmu, __Jmu; + if (__x < __x_min) + { + const _Tp __x2 = __x / _Tp(2); + const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu; + _Tp __fact = (std::abs(__pimu) < __eps + ? _Tp(1) : __pimu / std::sin(__pimu)); + _Tp __d = -std::log(__x2); + _Tp __e = __mu * __d; + _Tp __fact2 = (std::abs(__e) < __eps + ? _Tp(1) : std::sinh(__e) / __e); + _Tp __gam1, __gam2, __gampl, __gammi; + __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi); + _Tp __ff = (_Tp(2) / __numeric_constants<_Tp>::__pi()) + * __fact * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d); + __e = std::exp(__e); + _Tp __p = __e / (__numeric_constants<_Tp>::__pi() * __gampl); + _Tp __q = _Tp(1) / (__e * __numeric_constants<_Tp>::__pi() * __gammi); + const _Tp __pimu2 = __pimu / _Tp(2); + _Tp __fact3 = (std::abs(__pimu2) < __eps + ? _Tp(1) : std::sin(__pimu2) / __pimu2 ); + _Tp __r = __numeric_constants<_Tp>::__pi() * __pimu2 * __fact3 * __fact3; + _Tp __c = _Tp(1); + __d = -__x2 * __x2; + _Tp __sum = __ff + __r * __q; + _Tp __sum1 = __p; + for (__i = 1; __i <= __max_iter; ++__i) + { + __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2); + __c *= __d / _Tp(__i); + __p /= _Tp(__i) - __mu; + __q /= _Tp(__i) + __mu; + const _Tp __del = __c * (__ff + __r * __q); + __sum += __del; + const _Tp __del1 = __c * __p - __i * __del; + __sum1 += __del1; + if ( std::abs(__del) < __eps * (_Tp(1) + std::abs(__sum)) ) + break; + } + if ( __i > __max_iter ) + std::__throw_runtime_error(("Bessel y series failed to converge " "in __bessel_jn.") + ); + __Nmu = -__sum; + __Nnu1 = -__sum1 * __xi2; + __Npmu = __mu * __xi * __Nmu - __Nnu1; + __Jmu = __w / (__Npmu - __f * __Nmu); + } + else + { + _Tp __a = _Tp(0.25L) - __mu2; + _Tp __q = _Tp(1); + _Tp __p = -__xi / _Tp(2); + _Tp __br = _Tp(2) * __x; + _Tp __bi = _Tp(2); + _Tp __fact = __a * __xi / (__p * __p + __q * __q); + _Tp __cr = __br + __q * __fact; + _Tp __ci = __bi + __p * __fact; + _Tp __den = __br * __br + __bi * __bi; + _Tp __dr = __br / __den; + _Tp __di = -__bi / __den; + _Tp __dlr = __cr * __dr - __ci * __di; + _Tp __dli = __cr * __di + __ci * __dr; + _Tp __temp = __p * __dlr - __q * __dli; + __q = __p * __dli + __q * __dlr; + __p = __temp; + int __i; + for (__i = 2; __i <= __max_iter; ++__i) + { + __a += _Tp(2 * (__i - 1)); + __bi += _Tp(2); + __dr = __a * __dr + __br; + __di = __a * __di + __bi; + if (std::abs(__dr) + std::abs(__di) < __fp_min) + __dr = __fp_min; + __fact = __a / (__cr * __cr + __ci * __ci); + __cr = __br + __cr * __fact; + __ci = __bi - __ci * __fact; + if (std::abs(__cr) + std::abs(__ci) < __fp_min) + __cr = __fp_min; + __den = __dr * __dr + __di * __di; + __dr /= __den; + __di /= -__den; + __dlr = __cr * __dr - __ci * __di; + __dli = __cr * __di + __ci * __dr; + __temp = __p * __dlr - __q * __dli; + __q = __p * __dli + __q * __dlr; + __p = __temp; + if (std::abs(__dlr - _Tp(1)) + std::abs(__dli) < __eps) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Lentz's method failed " "in __bessel_jn.") + ); + const _Tp __gam = (__p - __f) / __q; + __Jmu = std::sqrt(__w / ((__p - __f) * __gam + __q)); + + __Jmu = ::std::copysign(__Jmu, __Jnul); + + + + + __Nmu = __gam * __Jmu; + __Npmu = (__p + __q / __gam) * __Nmu; + __Nnu1 = __mu * __xi * __Nmu - __Npmu; + } + __fact = __Jmu / __Jnul; + __Jnu = __fact * __Jnul1; + __Jpnu = __fact * __Jpnu1; + for (__i = 1; __i <= __nl; ++__i) + { + const _Tp __Nnutemp = (__mu + __i) * __xi2 * __Nnu1 - __Nmu; + __Nmu = __Nnu1; + __Nnu1 = __Nnutemp; + } + __Nnu = __Nmu; + __Npnu = __nu * __xi * __Nmu - __Nnu1; + + return; + } +# 361 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + void + __cyl_bessel_jn_asymp(_Tp __nu, _Tp __x, _Tp & __Jnu, _Tp & __Nnu) + { + const _Tp __mu = _Tp(4) * __nu * __nu; + const _Tp __8x = _Tp(8) * __x; + + _Tp __P = _Tp(0); + _Tp __Q = _Tp(0); + + _Tp __k = _Tp(0); + _Tp __term = _Tp(1); + + int __epsP = 0; + int __epsQ = 0; + + _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + do + { + __term *= (__k == 0 + ? _Tp(1) + : -(__mu - (2 * __k - 1) * (2 * __k - 1)) / (__k * __8x)); + + __epsP = std::abs(__term) < __eps * std::abs(__P); + __P += __term; + + __k++; + + __term *= (__mu - (2 * __k - 1) * (2 * __k - 1)) / (__k * __8x); + __epsQ = std::abs(__term) < __eps * std::abs(__Q); + __Q += __term; + + if (__epsP && __epsQ && __k > (__nu / 2.)) + break; + + __k++; + } + while (__k < 1000); + + const _Tp __chi = __x - (__nu + _Tp(0.5L)) + * __numeric_constants<_Tp>::__pi_2(); + + const _Tp __c = std::cos(__chi); + const _Tp __s = std::sin(__chi); + + const _Tp __coef = std::sqrt(_Tp(2) + / (__numeric_constants<_Tp>::__pi() * __x)); + + __Jnu = __coef * (__c * __P - __s * __Q); + __Nnu = __coef * (__s * __P + __c * __Q); + + return; + } +# 444 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_bessel_ij_series(_Tp __nu, _Tp __x, _Tp __sgn, + unsigned int __max_iter) + { + if (__x == _Tp(0)) + return __nu == _Tp(0) ? _Tp(1) : _Tp(0); + + const _Tp __x2 = __x / _Tp(2); + _Tp __fact = __nu * std::log(__x2); + + __fact -= ::std::lgamma(__nu + _Tp(1)); + + + + __fact = std::exp(__fact); + const _Tp __xx4 = __sgn * __x2 * __x2; + _Tp __Jn = _Tp(1); + _Tp __term = _Tp(1); + + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + __term *= __xx4 / (_Tp(__i) * (__nu + _Tp(__i))); + __Jn += __term; + if (std::abs(__term / __Jn) < std::numeric_limits<_Tp>::epsilon()) + break; + } + + return __fact * __Jn; + } +# 490 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_bessel_j(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_j.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x * __x < _Tp(10) * (__nu + _Tp(1))) + return __cyl_bessel_ij_series(__nu, __x, -_Tp(1), 200); + else if (__x > _Tp(1000)) + { + _Tp __J_nu, __N_nu; + __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); + return __J_nu; + } + else + { + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + return __J_nu; + } + } +# 532 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_neumann_n(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_neumann_n.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x > _Tp(1000)) + { + _Tp __J_nu, __N_nu; + __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); + return __N_nu; + } + else + { + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + return __N_nu; + } + } +# 569 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + void + __sph_bessel_jn(unsigned int __n, _Tp __x, + _Tp & __j_n, _Tp & __n_n, _Tp & __jp_n, _Tp & __np_n) + { + const _Tp __nu = _Tp(__n) + _Tp(0.5L); + + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + + const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2() + / std::sqrt(__x); + + __j_n = __factor * __J_nu; + __n_n = __factor * __N_nu; + __jp_n = __factor * __Jp_nu - __j_n / (_Tp(2) * __x); + __np_n = __factor * __Np_nu - __n_n / (_Tp(2) * __x); + + return; + } +# 604 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + _Tp + __sph_bessel(unsigned int __n, _Tp __x) + { + if (__x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __sph_bessel.") + ); + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x == _Tp(0)) + { + if (__n == 0) + return _Tp(1); + else + return _Tp(0); + } + else + { + _Tp __j_n, __n_n, __jp_n, __np_n; + __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n); + return __j_n; + } + } +# 642 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + _Tp + __sph_neumann(unsigned int __n, _Tp __x) + { + if (__x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __sph_neumann.") + ); + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x == _Tp(0)) + return -std::numeric_limits<_Tp>::infinity(); + else + { + _Tp __j_n, __n_n, __jp_n, __np_n; + __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n); + return __n_n; + } + } + } + + + + + + +} +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 1 3 +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + namespace __detail + { +# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + template + _Tp + __beta_gamma(_Tp __x, _Tp __y) + { + + _Tp __bet; + + if (__x > __y) + { + __bet = ::std::tgamma(__x) + / ::std::tgamma(__x + __y); + __bet *= ::std::tgamma(__y); + } + else + { + __bet = ::std::tgamma(__y) + / ::std::tgamma(__x + __y); + __bet *= ::std::tgamma(__x); + } +# 111 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + return __bet; + } +# 127 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + template + _Tp + __beta_lgamma(_Tp __x, _Tp __y) + { + + _Tp __bet = ::std::lgamma(__x) + + ::std::lgamma(__y) + - ::std::lgamma(__x + __y); + + + + + + __bet = std::exp(__bet); + return __bet; + } +# 158 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + template + _Tp + __beta_product(_Tp __x, _Tp __y) + { + + _Tp __bet = (__x + __y) / (__x * __y); + + unsigned int __max_iter = 1000000; + for (unsigned int __k = 1; __k < __max_iter; ++__k) + { + _Tp __term = (_Tp(1) + (__x + __y) / __k) + / ((_Tp(1) + __x / __k) * (_Tp(1) + __y / __k)); + __bet *= __term; + } + + return __bet; + } +# 189 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + template + inline _Tp + __beta(_Tp __x, _Tp __y) + { + if (__isnan(__x) || __isnan(__y)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __beta_lgamma(__x, __y); + } + } + + + + + + +} +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 1 3 +# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + namespace __detail + { +# 76 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rf(_Tp __x, _Tp __y, _Tp __z) + { + const _Tp __min = std::numeric_limits<_Tp>::min(); + const _Tp __lolim = _Tp(5) * __min; + + if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0)) + std::__throw_domain_error(("Argument less than zero " "in __ellint_rf.") + ); + else if (__x + __y < __lolim || __x + __z < __lolim + || __y + __z < __lolim) + std::__throw_domain_error(("Argument too small in __ellint_rf")); + else + { + const _Tp __c0 = _Tp(1) / _Tp(4); + const _Tp __c1 = _Tp(1) / _Tp(24); + const _Tp __c2 = _Tp(1) / _Tp(10); + const _Tp __c3 = _Tp(3) / _Tp(44); + const _Tp __c4 = _Tp(1) / _Tp(14); + + _Tp __xn = __x; + _Tp __yn = __y; + _Tp __zn = __z; + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol = std::pow(__eps, _Tp(1) / _Tp(6)); + _Tp __mu; + _Tp __xndev, __yndev, __zndev; + + const unsigned int __max_iter = 100; + for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) + { + __mu = (__xn + __yn + __zn) / _Tp(3); + __xndev = 2 - (__mu + __xn) / __mu; + __yndev = 2 - (__mu + __yn) / __mu; + __zndev = 2 - (__mu + __zn) / __mu; + _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); + __epsilon = std::max(__epsilon, std::abs(__zndev)); + if (__epsilon < __errtol) + break; + const _Tp __xnroot = std::sqrt(__xn); + const _Tp __ynroot = std::sqrt(__yn); + const _Tp __znroot = std::sqrt(__zn); + const _Tp __lambda = __xnroot * (__ynroot + __znroot) + + __ynroot * __znroot; + __xn = __c0 * (__xn + __lambda); + __yn = __c0 * (__yn + __lambda); + __zn = __c0 * (__zn + __lambda); + } + + const _Tp __e2 = __xndev * __yndev - __zndev * __zndev; + const _Tp __e3 = __xndev * __yndev * __zndev; + const _Tp __s = _Tp(1) + (__c1 * __e2 - __c2 - __c3 * __e3) * __e2 + + __c4 * __e3; + + return __s / std::sqrt(__mu); + } + } +# 153 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_1_series(_Tp __k) + { + + const _Tp __kk = __k * __k; + + _Tp __term = __kk / _Tp(4); + _Tp __sum = _Tp(1) + __term; + + const unsigned int __max_iter = 1000; + for (unsigned int __i = 2; __i < __max_iter; ++__i) + { + __term *= (2 * __i - 1) * __kk / (2 * __i); + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + __sum += __term; + } + + return __numeric_constants<_Tp>::__pi_2() * __sum; + } +# 191 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_1(_Tp __k) + { + + if (__isnan(__k)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) >= _Tp(1)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __ellint_rf(_Tp(0), _Tp(1) - __k * __k, _Tp(1)); + } +# 219 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_1(_Tp __k, _Tp __phi) + { + + if (__isnan(__k) || __isnan(__phi)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __ellint_1.")); + else + { + + const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + + _Tp(0.5L)); + const _Tp __phi_red = __phi + - __n * __numeric_constants<_Tp>::__pi(); + + const _Tp __s = std::sin(__phi_red); + const _Tp __c = std::cos(__phi_red); + + const _Tp __F = __s + * __ellint_rf(__c * __c, + _Tp(1) - __k * __k * __s * __s, _Tp(1)); + + if (__n == 0) + return __F; + else + return __F + _Tp(2) * __n * __comp_ellint_1(__k); + } + } +# 266 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_2_series(_Tp __k) + { + + const _Tp __kk = __k * __k; + + _Tp __term = __kk; + _Tp __sum = __term; + + const unsigned int __max_iter = 1000; + for (unsigned int __i = 2; __i < __max_iter; ++__i) + { + const _Tp __i2m = 2 * __i - 1; + const _Tp __i2 = 2 * __i; + __term *= __i2m * __i2m * __kk / (__i2 * __i2); + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + __sum += __term / __i2m; + } + + return __numeric_constants<_Tp>::__pi_2() * (_Tp(1) - __sum); + } +# 314 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rd(_Tp __x, _Tp __y, _Tp __z) + { + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6)); + const _Tp __max = std::numeric_limits<_Tp>::max(); + const _Tp __lolim = _Tp(2) / std::pow(__max, _Tp(2) / _Tp(3)); + + if (__x < _Tp(0) || __y < _Tp(0)) + std::__throw_domain_error(("Argument less than zero " "in __ellint_rd.") + ); + else if (__x + __y < __lolim || __z < __lolim) + std::__throw_domain_error(("Argument too small " "in __ellint_rd.") + ); + else + { + const _Tp __c0 = _Tp(1) / _Tp(4); + const _Tp __c1 = _Tp(3) / _Tp(14); + const _Tp __c2 = _Tp(1) / _Tp(6); + const _Tp __c3 = _Tp(9) / _Tp(22); + const _Tp __c4 = _Tp(3) / _Tp(26); + + _Tp __xn = __x; + _Tp __yn = __y; + _Tp __zn = __z; + _Tp __sigma = _Tp(0); + _Tp __power4 = _Tp(1); + + _Tp __mu; + _Tp __xndev, __yndev, __zndev; + + const unsigned int __max_iter = 100; + for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) + { + __mu = (__xn + __yn + _Tp(3) * __zn) / _Tp(5); + __xndev = (__mu - __xn) / __mu; + __yndev = (__mu - __yn) / __mu; + __zndev = (__mu - __zn) / __mu; + _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); + __epsilon = std::max(__epsilon, std::abs(__zndev)); + if (__epsilon < __errtol) + break; + _Tp __xnroot = std::sqrt(__xn); + _Tp __ynroot = std::sqrt(__yn); + _Tp __znroot = std::sqrt(__zn); + _Tp __lambda = __xnroot * (__ynroot + __znroot) + + __ynroot * __znroot; + __sigma += __power4 / (__znroot * (__zn + __lambda)); + __power4 *= __c0; + __xn = __c0 * (__xn + __lambda); + __yn = __c0 * (__yn + __lambda); + __zn = __c0 * (__zn + __lambda); + } + + _Tp __ea = __xndev * __yndev; + _Tp __eb = __zndev * __zndev; + _Tp __ec = __ea - __eb; + _Tp __ed = __ea - _Tp(6) * __eb; + _Tp __ef = __ed + __ec + __ec; + _Tp __s1 = __ed * (-__c1 + __c3 * __ed + / _Tp(3) - _Tp(3) * __c4 * __zndev * __ef + / _Tp(2)); + _Tp __s2 = __zndev + * (__c2 * __ef + + __zndev * (-__c3 * __ec - __zndev * __c4 - __ea)); + + return _Tp(3) * __sigma + __power4 * (_Tp(1) + __s1 + __s2) + / (__mu * std::sqrt(__mu)); + } + } +# 399 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_2(_Tp __k) + { + + if (__isnan(__k)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) == 1) + return _Tp(1); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __comp_ellint_2.")); + else + { + const _Tp __kk = __k * __k; + + return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1)) + - __kk * __ellint_rd(_Tp(0), _Tp(1) - __kk, _Tp(1)) / _Tp(3); + } + } +# 433 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_2(_Tp __k, _Tp __phi) + { + + if (__isnan(__k) || __isnan(__phi)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __ellint_2.")); + else + { + + const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + + _Tp(0.5L)); + const _Tp __phi_red = __phi + - __n * __numeric_constants<_Tp>::__pi(); + + const _Tp __kk = __k * __k; + const _Tp __s = std::sin(__phi_red); + const _Tp __ss = __s * __s; + const _Tp __sss = __ss * __s; + const _Tp __c = std::cos(__phi_red); + const _Tp __cc = __c * __c; + + const _Tp __E = __s + * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1)) + - __kk * __sss + * __ellint_rd(__cc, _Tp(1) - __kk * __ss, _Tp(1)) + / _Tp(3); + + if (__n == 0) + return __E; + else + return __E + _Tp(2) * __n * __comp_ellint_2(__k); + } + } +# 492 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rc(_Tp __x, _Tp __y) + { + const _Tp __min = std::numeric_limits<_Tp>::min(); + const _Tp __lolim = _Tp(5) * __min; + + if (__x < _Tp(0) || __y < _Tp(0) || __x + __y < __lolim) + std::__throw_domain_error(("Argument less than zero " "in __ellint_rc.") + ); + else + { + const _Tp __c0 = _Tp(1) / _Tp(4); + const _Tp __c1 = _Tp(1) / _Tp(7); + const _Tp __c2 = _Tp(9) / _Tp(22); + const _Tp __c3 = _Tp(3) / _Tp(10); + const _Tp __c4 = _Tp(3) / _Tp(8); + + _Tp __xn = __x; + _Tp __yn = __y; + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol = std::pow(__eps / _Tp(30), _Tp(1) / _Tp(6)); + _Tp __mu; + _Tp __sn; + + const unsigned int __max_iter = 100; + for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) + { + __mu = (__xn + _Tp(2) * __yn) / _Tp(3); + __sn = (__yn + __mu) / __mu - _Tp(2); + if (std::abs(__sn) < __errtol) + break; + const _Tp __lambda = _Tp(2) * std::sqrt(__xn) * std::sqrt(__yn) + + __yn; + __xn = __c0 * (__xn + __lambda); + __yn = __c0 * (__yn + __lambda); + } + + _Tp __s = __sn * __sn + * (__c3 + __sn*(__c1 + __sn * (__c4 + __sn * __c2))); + + return (_Tp(1) + __s) / std::sqrt(__mu); + } + } +# 561 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rj(_Tp __x, _Tp __y, _Tp __z, _Tp __p) + { + const _Tp __min = std::numeric_limits<_Tp>::min(); + const _Tp __lolim = std::pow(_Tp(5) * __min, _Tp(1)/_Tp(3)); + + if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0)) + std::__throw_domain_error(("Argument less than zero " "in __ellint_rj.") + ); + else if (__x + __y < __lolim || __x + __z < __lolim + || __y + __z < __lolim || __p < __lolim) + std::__throw_domain_error(("Argument too small " "in __ellint_rj") + ); + else + { + const _Tp __c0 = _Tp(1) / _Tp(4); + const _Tp __c1 = _Tp(3) / _Tp(14); + const _Tp __c2 = _Tp(1) / _Tp(3); + const _Tp __c3 = _Tp(3) / _Tp(22); + const _Tp __c4 = _Tp(3) / _Tp(26); + + _Tp __xn = __x; + _Tp __yn = __y; + _Tp __zn = __z; + _Tp __pn = __p; + _Tp __sigma = _Tp(0); + _Tp __power4 = _Tp(1); + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6)); + + _Tp __mu; + _Tp __xndev, __yndev, __zndev, __pndev; + + const unsigned int __max_iter = 100; + for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) + { + __mu = (__xn + __yn + __zn + _Tp(2) * __pn) / _Tp(5); + __xndev = (__mu - __xn) / __mu; + __yndev = (__mu - __yn) / __mu; + __zndev = (__mu - __zn) / __mu; + __pndev = (__mu - __pn) / __mu; + _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); + __epsilon = std::max(__epsilon, std::abs(__zndev)); + __epsilon = std::max(__epsilon, std::abs(__pndev)); + if (__epsilon < __errtol) + break; + const _Tp __xnroot = std::sqrt(__xn); + const _Tp __ynroot = std::sqrt(__yn); + const _Tp __znroot = std::sqrt(__zn); + const _Tp __lambda = __xnroot * (__ynroot + __znroot) + + __ynroot * __znroot; + const _Tp __alpha1 = __pn * (__xnroot + __ynroot + __znroot) + + __xnroot * __ynroot * __znroot; + const _Tp __alpha2 = __alpha1 * __alpha1; + const _Tp __beta = __pn * (__pn + __lambda) + * (__pn + __lambda); + __sigma += __power4 * __ellint_rc(__alpha2, __beta); + __power4 *= __c0; + __xn = __c0 * (__xn + __lambda); + __yn = __c0 * (__yn + __lambda); + __zn = __c0 * (__zn + __lambda); + __pn = __c0 * (__pn + __lambda); + } + + _Tp __ea = __xndev * (__yndev + __zndev) + __yndev * __zndev; + _Tp __eb = __xndev * __yndev * __zndev; + _Tp __ec = __pndev * __pndev; + _Tp __e2 = __ea - _Tp(3) * __ec; + _Tp __e3 = __eb + _Tp(2) * __pndev * (__ea - __ec); + _Tp __s1 = _Tp(1) + __e2 * (-__c1 + _Tp(3) * __c3 * __e2 / _Tp(4) + - _Tp(3) * __c4 * __e3 / _Tp(2)); + _Tp __s2 = __eb * (__c2 / _Tp(2) + + __pndev * (-__c3 - __c3 + __pndev * __c4)); + _Tp __s3 = __pndev * __ea * (__c2 - __pndev * __c3) + - __c2 * __pndev * __ec; + + return _Tp(3) * __sigma + __power4 * (__s1 + __s2 + __s3) + / (__mu * std::sqrt(__mu)); + } + } +# 661 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_3(_Tp __k, _Tp __nu) + { + + if (__isnan(__k) || __isnan(__nu)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__nu == _Tp(1)) + return std::numeric_limits<_Tp>::infinity(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __comp_ellint_3.")); + else + { + const _Tp __kk = __k * __k; + + return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1)) + + __nu + * __ellint_rj(_Tp(0), _Tp(1) - __kk, _Tp(1), _Tp(1) - __nu) + / _Tp(3); + } + } +# 701 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_3(_Tp __k, _Tp __nu, _Tp __phi) + { + + if (__isnan(__k) || __isnan(__nu) || __isnan(__phi)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __ellint_3.")); + else + { + + const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + + _Tp(0.5L)); + const _Tp __phi_red = __phi + - __n * __numeric_constants<_Tp>::__pi(); + + const _Tp __kk = __k * __k; + const _Tp __s = std::sin(__phi_red); + const _Tp __ss = __s * __s; + const _Tp __sss = __ss * __s; + const _Tp __c = std::cos(__phi_red); + const _Tp __cc = __c * __c; + + const _Tp __Pi = __s + * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1)) + + __nu * __sss + * __ellint_rj(__cc, _Tp(1) - __kk * __ss, _Tp(1), + _Tp(1) - __nu * __ss) / _Tp(3); + + if (__n == 0) + return __Pi; + else + return __Pi + _Tp(2) * __n * __comp_ellint_3(__k, __nu); + } + } + } + + + + + +} +# 51 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 1 3 +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + namespace __detail + { + template _Tp __expint_E1(_Tp); +# 81 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_E1_series(_Tp __x) + { + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + _Tp __term = _Tp(1); + _Tp __esum = _Tp(0); + _Tp __osum = _Tp(0); + const unsigned int __max_iter = 1000; + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + __term *= - __x / __i; + if (std::abs(__term) < __eps) + break; + if (__term >= _Tp(0)) + __esum += __term / __i; + else + __osum += __term / __i; + } + + return - __esum - __osum + - __numeric_constants<_Tp>::__gamma_e() - std::log(__x); + } +# 118 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_E1_asymp(_Tp __x) + { + _Tp __term = _Tp(1); + _Tp __esum = _Tp(1); + _Tp __osum = _Tp(0); + const unsigned int __max_iter = 1000; + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + _Tp __prev = __term; + __term *= - __i / __x; + if (std::abs(__term) > std::abs(__prev)) + break; + if (__term >= _Tp(0)) + __esum += __term; + else + __osum += __term; + } + + return std::exp(- __x) * (__esum + __osum) / __x; + } +# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_En_series(unsigned int __n, _Tp __x) + { + const unsigned int __max_iter = 1000; + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const int __nm1 = __n - 1; + _Tp __ans = (__nm1 != 0 + ? _Tp(1) / __nm1 : -std::log(__x) + - __numeric_constants<_Tp>::__gamma_e()); + _Tp __fact = _Tp(1); + for (int __i = 1; __i <= __max_iter; ++__i) + { + __fact *= -__x / _Tp(__i); + _Tp __del; + if ( __i != __nm1 ) + __del = -__fact / _Tp(__i - __nm1); + else + { + _Tp __psi = -__numeric_constants<_Tp>::gamma_e(); + for (int __ii = 1; __ii <= __nm1; ++__ii) + __psi += _Tp(1) / _Tp(__ii); + __del = __fact * (__psi - std::log(__x)); + } + __ans += __del; + if (std::abs(__del) < __eps * std::abs(__ans)) + return __ans; + } + std::__throw_runtime_error(("Series summation failed " "in __expint_En_series.") + ); + } +# 201 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_En_cont_frac(unsigned int __n, _Tp __x) + { + const unsigned int __max_iter = 1000; + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __fp_min = std::numeric_limits<_Tp>::min(); + const int __nm1 = __n - 1; + _Tp __b = __x + _Tp(__n); + _Tp __c = _Tp(1) / __fp_min; + _Tp __d = _Tp(1) / __b; + _Tp __h = __d; + for ( unsigned int __i = 1; __i <= __max_iter; ++__i ) + { + _Tp __a = -_Tp(__i * (__nm1 + __i)); + __b += _Tp(2); + __d = _Tp(1) / (__a * __d + __b); + __c = __b + __a / __c; + const _Tp __del = __c * __d; + __h *= __del; + if (std::abs(__del - _Tp(1)) < __eps) + { + const _Tp __ans = __h * std::exp(-__x); + return __ans; + } + } + std::__throw_runtime_error(("Continued fraction failed " "in __expint_En_cont_frac.") + ); + } +# 246 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_En_recursion(unsigned int __n, _Tp __x) + { + _Tp __En; + _Tp __E1 = __expint_E1(__x); + if (__x < _Tp(__n)) + { + + __En = __E1; + for (unsigned int __j = 2; __j < __n; ++__j) + __En = (std::exp(-__x) - __x * __En) / _Tp(__j - 1); + } + else + { + + __En = _Tp(1); + const int __N = __n + 20; + _Tp __save = _Tp(0); + for (int __j = __N; __j > 0; --__j) + { + __En = (std::exp(-__x) - __j * __En) / __x; + if (__j == __n) + __save = __En; + } + _Tp __norm = __En / __E1; + __En /= __norm; + } + + return __En; + } +# 290 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_Ei_series(_Tp __x) + { + _Tp __term = _Tp(1); + _Tp __sum = _Tp(0); + const unsigned int __max_iter = 1000; + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + __term *= __x / __i; + __sum += __term / __i; + if (__term < std::numeric_limits<_Tp>::epsilon() * __sum) + break; + } + + return __numeric_constants<_Tp>::__gamma_e() + __sum + std::log(__x); + } +# 321 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_Ei_asymp(_Tp __x) + { + _Tp __term = _Tp(1); + _Tp __sum = _Tp(1); + const unsigned int __max_iter = 1000; + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + _Tp __prev = __term; + __term *= __i / __x; + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + if (__term >= __prev) + break; + __sum += __term; + } + + return std::exp(__x) * __sum / __x; + } +# 354 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_Ei(_Tp __x) + { + if (__x < _Tp(0)) + return -__expint_E1(-__x); + else if (__x < -std::log(std::numeric_limits<_Tp>::epsilon())) + return __expint_Ei_series(__x); + else + return __expint_Ei_asymp(__x); + } +# 378 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_E1(_Tp __x) + { + if (__x < _Tp(0)) + return -__expint_Ei(-__x); + else if (__x < _Tp(1)) + return __expint_E1_series(__x); + else if (__x < _Tp(100)) + return __expint_En_cont_frac(1, __x); + else + return __expint_E1_asymp(__x); + } +# 408 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_asymp(unsigned int __n, _Tp __x) + { + _Tp __term = _Tp(1); + _Tp __sum = _Tp(1); + for (unsigned int __i = 1; __i <= __n; ++__i) + { + _Tp __prev = __term; + __term *= -(__n - __i + 1) / __x; + if (std::abs(__term) > std::abs(__prev)) + break; + __sum += __term; + } + + return std::exp(-__x) * __sum / __x; + } +# 442 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_large_n(unsigned int __n, _Tp __x) + { + const _Tp __xpn = __x + __n; + const _Tp __xpn2 = __xpn * __xpn; + _Tp __term = _Tp(1); + _Tp __sum = _Tp(1); + for (unsigned int __i = 1; __i <= __n; ++__i) + { + _Tp __prev = __term; + __term *= (__n - 2 * (__i - 1) * __x) / __xpn2; + if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon()) + break; + __sum += __term; + } + + return std::exp(-__x) * __sum / __xpn; + } +# 476 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint(unsigned int __n, _Tp __x) + { + + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__n <= 1 && __x == _Tp(0)) + return std::numeric_limits<_Tp>::infinity(); + else + { + _Tp __E0 = std::exp(__x) / __x; + if (__n == 0) + return __E0; + + _Tp __E1 = __expint_E1(__x); + if (__n == 1) + return __E1; + + if (__x == _Tp(0)) + return _Tp(1) / static_cast<_Tp>(__n - 1); + + _Tp __En = __expint_En_recursion(__n, __x); + + return __En; + } + } +# 516 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + inline _Tp + __expint(_Tp __x) + { + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __expint_Ei(__x); + } + } + + + + + +} +# 52 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 1 3 +# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + namespace __detail + { +# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __conf_hyperg_series(_Tp __a, _Tp __c, _Tp __x) + { + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + _Tp __term = _Tp(1); + _Tp __Fac = _Tp(1); + const unsigned int __max_iter = 100000; + unsigned int __i; + for (__i = 0; __i < __max_iter; ++__i) + { + __term *= (__a + _Tp(__i)) * __x + / ((__c + _Tp(__i)) * _Tp(1 + __i)); + if (std::abs(__term) < __eps) + { + break; + } + __Fac += __term; + } + if (__i == __max_iter) + std::__throw_runtime_error(("Series failed to converge " "in __conf_hyperg_series.") + ); + + return __Fac; + } +# 120 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __conf_hyperg_luke(_Tp __a, _Tp __c, _Tp __xin) + { + const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L)); + const int __nmax = 20000; + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __x = -__xin; + const _Tp __x3 = __x * __x * __x; + const _Tp __t0 = __a / __c; + const _Tp __t1 = (__a + _Tp(1)) / (_Tp(2) * __c); + const _Tp __t2 = (__a + _Tp(2)) / (_Tp(2) * (__c + _Tp(1))); + _Tp __F = _Tp(1); + _Tp __prec; + + _Tp __Bnm3 = _Tp(1); + _Tp __Bnm2 = _Tp(1) + __t1 * __x; + _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x); + + _Tp __Anm3 = _Tp(1); + _Tp __Anm2 = __Bnm2 - __t0 * __x; + _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x + + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x; + + int __n = 3; + while(1) + { + _Tp __npam1 = _Tp(__n - 1) + __a; + _Tp __npcm1 = _Tp(__n - 1) + __c; + _Tp __npam2 = _Tp(__n - 2) + __a; + _Tp __npcm2 = _Tp(__n - 2) + __c; + _Tp __tnm1 = _Tp(2 * __n - 1); + _Tp __tnm3 = _Tp(2 * __n - 3); + _Tp __tnm5 = _Tp(2 * __n - 5); + _Tp __F1 = (_Tp(__n - 2) - __a) / (_Tp(2) * __tnm3 * __npcm1); + _Tp __F2 = (_Tp(__n) + __a) * __npam1 + / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1); + _Tp __F3 = -__npam2 * __npam1 * (_Tp(__n - 2) - __a) + / (_Tp(8) * __tnm3 * __tnm3 * __tnm5 + * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1); + _Tp __E = -__npam1 * (_Tp(__n - 1) - __c) + / (_Tp(2) * __tnm3 * __npcm2 * __npcm1); + + _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1 + + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3; + _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1 + + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3; + _Tp __r = __An / __Bn; + + __prec = std::abs((__F - __r) / __F); + __F = __r; + + if (__prec < __eps || __n > __nmax) + break; + + if (std::abs(__An) > __big || std::abs(__Bn) > __big) + { + __An /= __big; + __Bn /= __big; + __Anm1 /= __big; + __Bnm1 /= __big; + __Anm2 /= __big; + __Bnm2 /= __big; + __Anm3 /= __big; + __Bnm3 /= __big; + } + else if (std::abs(__An) < _Tp(1) / __big + || std::abs(__Bn) < _Tp(1) / __big) + { + __An *= __big; + __Bn *= __big; + __Anm1 *= __big; + __Bnm1 *= __big; + __Anm2 *= __big; + __Bnm2 *= __big; + __Anm3 *= __big; + __Bnm3 *= __big; + } + + ++__n; + __Bnm3 = __Bnm2; + __Bnm2 = __Bnm1; + __Bnm1 = __Bn; + __Anm3 = __Anm2; + __Anm2 = __Anm1; + __Anm1 = __An; + } + + if (__n >= __nmax) + std::__throw_runtime_error(("Iteration failed to converge " "in __conf_hyperg_luke.") + ); + + return __F; + } +# 227 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __conf_hyperg(_Tp __a, _Tp __c, _Tp __x) + { + + const _Tp __c_nint = ::std::nearbyint(__c); + + + + if (__isnan(__a) || __isnan(__c) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__c_nint == __c && __c_nint <= 0) + return std::numeric_limits<_Tp>::infinity(); + else if (__a == _Tp(0)) + return _Tp(1); + else if (__c == __a) + return std::exp(__x); + else if (__x < _Tp(0)) + return __conf_hyperg_luke(__a, __c, __x); + else + return __conf_hyperg_series(__a, __c, __x); + } +# 271 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __hyperg_series(_Tp __a, _Tp __b, _Tp __c, _Tp __x) + { + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + _Tp __term = _Tp(1); + _Tp __Fabc = _Tp(1); + const unsigned int __max_iter = 100000; + unsigned int __i; + for (__i = 0; __i < __max_iter; ++__i) + { + __term *= (__a + _Tp(__i)) * (__b + _Tp(__i)) * __x + / ((__c + _Tp(__i)) * _Tp(1 + __i)); + if (std::abs(__term) < __eps) + { + break; + } + __Fabc += __term; + } + if (__i == __max_iter) + std::__throw_runtime_error(("Series failed to converge " "in __hyperg_series.") + ); + + return __Fabc; + } + + + + + + + + template + _Tp + __hyperg_luke(_Tp __a, _Tp __b, _Tp __c, _Tp __xin) + { + const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L)); + const int __nmax = 20000; + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __x = -__xin; + const _Tp __x3 = __x * __x * __x; + const _Tp __t0 = __a * __b / __c; + const _Tp __t1 = (__a + _Tp(1)) * (__b + _Tp(1)) / (_Tp(2) * __c); + const _Tp __t2 = (__a + _Tp(2)) * (__b + _Tp(2)) + / (_Tp(2) * (__c + _Tp(1))); + + _Tp __F = _Tp(1); + + _Tp __Bnm3 = _Tp(1); + _Tp __Bnm2 = _Tp(1) + __t1 * __x; + _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x); + + _Tp __Anm3 = _Tp(1); + _Tp __Anm2 = __Bnm2 - __t0 * __x; + _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x + + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x; + + int __n = 3; + while (1) + { + const _Tp __npam1 = _Tp(__n - 1) + __a; + const _Tp __npbm1 = _Tp(__n - 1) + __b; + const _Tp __npcm1 = _Tp(__n - 1) + __c; + const _Tp __npam2 = _Tp(__n - 2) + __a; + const _Tp __npbm2 = _Tp(__n - 2) + __b; + const _Tp __npcm2 = _Tp(__n - 2) + __c; + const _Tp __tnm1 = _Tp(2 * __n - 1); + const _Tp __tnm3 = _Tp(2 * __n - 3); + const _Tp __tnm5 = _Tp(2 * __n - 5); + const _Tp __n2 = __n * __n; + const _Tp __F1 = (_Tp(3) * __n2 + (__a + __b - _Tp(6)) * __n + + _Tp(2) - __a * __b - _Tp(2) * (__a + __b)) + / (_Tp(2) * __tnm3 * __npcm1); + const _Tp __F2 = -(_Tp(3) * __n2 - (__a + __b + _Tp(6)) * __n + + _Tp(2) - __a * __b) * __npam1 * __npbm1 + / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1); + const _Tp __F3 = (__npam2 * __npam1 * __npbm2 * __npbm1 + * (_Tp(__n - 2) - __a) * (_Tp(__n - 2) - __b)) + / (_Tp(8) * __tnm3 * __tnm3 * __tnm5 + * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1); + const _Tp __E = -__npam1 * __npbm1 * (_Tp(__n - 1) - __c) + / (_Tp(2) * __tnm3 * __npcm2 * __npcm1); + + _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1 + + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3; + _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1 + + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3; + const _Tp __r = __An / __Bn; + + const _Tp __prec = std::abs((__F - __r) / __F); + __F = __r; + + if (__prec < __eps || __n > __nmax) + break; + + if (std::abs(__An) > __big || std::abs(__Bn) > __big) + { + __An /= __big; + __Bn /= __big; + __Anm1 /= __big; + __Bnm1 /= __big; + __Anm2 /= __big; + __Bnm2 /= __big; + __Anm3 /= __big; + __Bnm3 /= __big; + } + else if (std::abs(__An) < _Tp(1) / __big + || std::abs(__Bn) < _Tp(1) / __big) + { + __An *= __big; + __Bn *= __big; + __Anm1 *= __big; + __Bnm1 *= __big; + __Anm2 *= __big; + __Bnm2 *= __big; + __Anm3 *= __big; + __Bnm3 *= __big; + } + + ++__n; + __Bnm3 = __Bnm2; + __Bnm2 = __Bnm1; + __Bnm1 = __Bn; + __Anm3 = __Anm2; + __Anm2 = __Anm1; + __Anm1 = __An; + } + + if (__n >= __nmax) + std::__throw_runtime_error(("Iteration failed to converge " "in __hyperg_luke.") + ); + + return __F; + } +# 438 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __hyperg_reflect(_Tp __a, _Tp __b, _Tp __c, _Tp __x) + { + const _Tp __d = __c - __a - __b; + const int __intd = std::floor(__d + _Tp(0.5L)); + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __toler = _Tp(1000) * __eps; + const _Tp __log_max = std::log(std::numeric_limits<_Tp>::max()); + const bool __d_integer = (std::abs(__d - __intd) < __toler); + + if (__d_integer) + { + const _Tp __ln_omx = std::log(_Tp(1) - __x); + const _Tp __ad = std::abs(__d); + _Tp __F1, __F2; + + _Tp __d1, __d2; + if (__d >= _Tp(0)) + { + __d1 = __d; + __d2 = _Tp(0); + } + else + { + __d1 = _Tp(0); + __d2 = __d; + } + + const _Tp __lng_c = __log_gamma(__c); + + + if (__ad < __eps) + { + + __F1 = _Tp(0); + } + else + { + + bool __ok_d1 = true; + _Tp __lng_ad, __lng_ad1, __lng_bd1; + try + { + __lng_ad = __log_gamma(__ad); + __lng_ad1 = __log_gamma(__a + __d1); + __lng_bd1 = __log_gamma(__b + __d1); + } + catch(...) + { + __ok_d1 = false; + } + + if (__ok_d1) + { + + + + _Tp __sum1 = _Tp(1); + _Tp __term = _Tp(1); + _Tp __ln_pre1 = __lng_ad + __lng_c + __d2 * __ln_omx + - __lng_ad1 - __lng_bd1; + + + + for (int __i = 1; __i < __ad; ++__i) + { + const int __j = __i - 1; + __term *= (__a + __d2 + __j) * (__b + __d2 + __j) + / (_Tp(1) + __d2 + __j) / __i * (_Tp(1) - __x); + __sum1 += __term; + } + + if (__ln_pre1 > __log_max) + std::__throw_runtime_error(("Overflow of gamma functions" " in __hyperg_luke.") + ); + else + __F1 = std::exp(__ln_pre1) * __sum1; + } + else + { + + + __F1 = _Tp(0); + } + } + + + bool __ok_d2 = true; + _Tp __lng_ad2, __lng_bd2; + try + { + __lng_ad2 = __log_gamma(__a + __d2); + __lng_bd2 = __log_gamma(__b + __d2); + } + catch(...) + { + __ok_d2 = false; + } + + if (__ok_d2) + { + + + const int __maxiter = 2000; + const _Tp __psi_1 = -__numeric_constants<_Tp>::__gamma_e(); + const _Tp __psi_1pd = __psi(_Tp(1) + __ad); + const _Tp __psi_apd1 = __psi(__a + __d1); + const _Tp __psi_bpd1 = __psi(__b + __d1); + + _Tp __psi_term = __psi_1 + __psi_1pd - __psi_apd1 + - __psi_bpd1 - __ln_omx; + _Tp __fact = _Tp(1); + _Tp __sum2 = __psi_term; + _Tp __ln_pre2 = __lng_c + __d1 * __ln_omx + - __lng_ad2 - __lng_bd2; + + + int __j; + for (__j = 1; __j < __maxiter; ++__j) + { + + + const _Tp __term1 = _Tp(1) / _Tp(__j) + + _Tp(1) / (__ad + __j); + const _Tp __term2 = _Tp(1) / (__a + __d1 + _Tp(__j - 1)) + + _Tp(1) / (__b + __d1 + _Tp(__j - 1)); + __psi_term += __term1 - __term2; + __fact *= (__a + __d1 + _Tp(__j - 1)) + * (__b + __d1 + _Tp(__j - 1)) + / ((__ad + __j) * __j) * (_Tp(1) - __x); + const _Tp __delta = __fact * __psi_term; + __sum2 += __delta; + if (std::abs(__delta) < __eps * std::abs(__sum2)) + break; + } + if (__j == __maxiter) + std::__throw_runtime_error(("Sum F2 failed to converge " "in __hyperg_reflect") + ); + + if (__sum2 == _Tp(0)) + __F2 = _Tp(0); + else + __F2 = std::exp(__ln_pre2) * __sum2; + } + else + { + + + __F2 = _Tp(0); + } + + const _Tp __sgn_2 = (__intd % 2 == 1 ? -_Tp(1) : _Tp(1)); + const _Tp __F = __F1 + __sgn_2 * __F2; + + return __F; + } + else + { + + + + + bool __ok1 = true; + _Tp __sgn_g1ca = _Tp(0), __ln_g1ca = _Tp(0); + _Tp __sgn_g1cb = _Tp(0), __ln_g1cb = _Tp(0); + try + { + __sgn_g1ca = __log_gamma_sign(__c - __a); + __ln_g1ca = __log_gamma(__c - __a); + __sgn_g1cb = __log_gamma_sign(__c - __b); + __ln_g1cb = __log_gamma(__c - __b); + } + catch(...) + { + __ok1 = false; + } + + bool __ok2 = true; + _Tp __sgn_g2a = _Tp(0), __ln_g2a = _Tp(0); + _Tp __sgn_g2b = _Tp(0), __ln_g2b = _Tp(0); + try + { + __sgn_g2a = __log_gamma_sign(__a); + __ln_g2a = __log_gamma(__a); + __sgn_g2b = __log_gamma_sign(__b); + __ln_g2b = __log_gamma(__b); + } + catch(...) + { + __ok2 = false; + } + + const _Tp __sgn_gc = __log_gamma_sign(__c); + const _Tp __ln_gc = __log_gamma(__c); + const _Tp __sgn_gd = __log_gamma_sign(__d); + const _Tp __ln_gd = __log_gamma(__d); + const _Tp __sgn_gmd = __log_gamma_sign(-__d); + const _Tp __ln_gmd = __log_gamma(-__d); + + const _Tp __sgn1 = __sgn_gc * __sgn_gd * __sgn_g1ca * __sgn_g1cb; + const _Tp __sgn2 = __sgn_gc * __sgn_gmd * __sgn_g2a * __sgn_g2b; + + _Tp __pre1, __pre2; + if (__ok1 && __ok2) + { + _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb; + _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b + + __d * std::log(_Tp(1) - __x); + if (__ln_pre1 < __log_max && __ln_pre2 < __log_max) + { + __pre1 = std::exp(__ln_pre1); + __pre2 = std::exp(__ln_pre2); + __pre1 *= __sgn1; + __pre2 *= __sgn2; + } + else + { + std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect") + ); + } + } + else if (__ok1 && !__ok2) + { + _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb; + if (__ln_pre1 < __log_max) + { + __pre1 = std::exp(__ln_pre1); + __pre1 *= __sgn1; + __pre2 = _Tp(0); + } + else + { + std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect") + ); + } + } + else if (!__ok1 && __ok2) + { + _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b + + __d * std::log(_Tp(1) - __x); + if (__ln_pre2 < __log_max) + { + __pre1 = _Tp(0); + __pre2 = std::exp(__ln_pre2); + __pre2 *= __sgn2; + } + else + { + std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect") + ); + } + } + else + { + __pre1 = _Tp(0); + __pre2 = _Tp(0); + std::__throw_runtime_error(("Underflow of gamma functions " "in __hyperg_reflect") + ); + } + + const _Tp __F1 = __hyperg_series(__a, __b, _Tp(1) - __d, + _Tp(1) - __x); + const _Tp __F2 = __hyperg_series(__c - __a, __c - __b, _Tp(1) + __d, + _Tp(1) - __x); + + const _Tp __F = __pre1 * __F1 + __pre2 * __F2; + + return __F; + } + } +# 728 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __hyperg(_Tp __a, _Tp __b, _Tp __c, _Tp __x) + { + + const _Tp __a_nint = ::std::nearbyint(__a); + const _Tp __b_nint = ::std::nearbyint(__b); + const _Tp __c_nint = ::std::nearbyint(__c); + + + + + + const _Tp __toler = _Tp(1000) * std::numeric_limits<_Tp>::epsilon(); + if (std::abs(__x) >= _Tp(1)) + std::__throw_domain_error(("Argument outside unit circle " "in __hyperg.") + ); + else if (__isnan(__a) || __isnan(__b) + || __isnan(__c) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__c_nint == __c && __c_nint <= _Tp(0)) + return std::numeric_limits<_Tp>::infinity(); + else if (std::abs(__c - __b) < __toler || std::abs(__c - __a) < __toler) + return std::pow(_Tp(1) - __x, __c - __a - __b); + else if (__a >= _Tp(0) && __b >= _Tp(0) && __c >= _Tp(0) + && __x >= _Tp(0) && __x < _Tp(0.995L)) + return __hyperg_series(__a, __b, __c, __x); + else if (std::abs(__a) < _Tp(10) && std::abs(__b) < _Tp(10)) + { + + + if (__a < _Tp(0) && std::abs(__a - __a_nint) < __toler) + return __hyperg_series(__a_nint, __b, __c, __x); + else if (__b < _Tp(0) && std::abs(__b - __b_nint) < __toler) + return __hyperg_series(__a, __b_nint, __c, __x); + else if (__x < -_Tp(0.25L)) + return __hyperg_luke(__a, __b, __c, __x); + else if (__x < _Tp(0.5L)) + return __hyperg_series(__a, __b, __c, __x); + else + if (std::abs(__c) > _Tp(10)) + return __hyperg_series(__a, __b, __c, __x); + else + return __hyperg_reflect(__a, __b, __c, __x); + } + else + return __hyperg_luke(__a, __b, __c, __x); + } + } + + + + + + +} +# 53 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 1 3 +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 + namespace __detail + { +# 80 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 + template + _Tp + __poly_legendre_p(unsigned int __l, _Tp __x) + { + + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x == +_Tp(1)) + return +_Tp(1); + else if (__x == -_Tp(1)) + return (__l % 2 == 1 ? -_Tp(1) : +_Tp(1)); + else + { + _Tp __p_lm2 = _Tp(1); + if (__l == 0) + return __p_lm2; + + _Tp __p_lm1 = __x; + if (__l == 1) + return __p_lm1; + + _Tp __p_l = 0; + for (unsigned int __ll = 2; __ll <= __l; ++__ll) + { + + + __p_l = _Tp(2) * __x * __p_lm1 - __p_lm2 + - (__x * __p_lm1 - __p_lm2) / _Tp(__ll); + __p_lm2 = __p_lm1; + __p_lm1 = __p_l; + } + + return __p_l; + } + } +# 136 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 + template + _Tp + __assoc_legendre_p(unsigned int __l, unsigned int __m, _Tp __x, + _Tp __phase = _Tp(+1)) + { + + if (__m > __l) + return _Tp(0); + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__m == 0) + return __poly_legendre_p(__l, __x); + else + { + _Tp __p_mm = _Tp(1); + if (__m > 0) + { + + + _Tp __root = std::sqrt(_Tp(1) - __x) * std::sqrt(_Tp(1) + __x); + _Tp __fact = _Tp(1); + for (unsigned int __i = 1; __i <= __m; ++__i) + { + __p_mm *= __phase * __fact * __root; + __fact += _Tp(2); + } + } + if (__l == __m) + return __p_mm; + + _Tp __p_mp1m = _Tp(2 * __m + 1) * __x * __p_mm; + if (__l == __m + 1) + return __p_mp1m; + + _Tp __p_lm2m = __p_mm; + _Tp __P_lm1m = __p_mp1m; + _Tp __p_lm = _Tp(0); + for (unsigned int __j = __m + 2; __j <= __l; ++__j) + { + __p_lm = (_Tp(2 * __j - 1) * __x * __P_lm1m + - _Tp(__j + __m - 1) * __p_lm2m) / _Tp(__j - __m); + __p_lm2m = __P_lm1m; + __P_lm1m = __p_lm; + } + + return __p_lm; + } + } +# 214 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 + template + _Tp + __sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta) + { + if (__isnan(__theta)) + return std::numeric_limits<_Tp>::quiet_NaN(); + + const _Tp __x = std::cos(__theta); + + if (__m > __l) + return _Tp(0); + else if (__m == 0) + { + _Tp __P = __poly_legendre_p(__l, __x); + _Tp __fact = std::sqrt(_Tp(2 * __l + 1) + / (_Tp(4) * __numeric_constants<_Tp>::__pi())); + __P *= __fact; + return __P; + } + else if (__x == _Tp(1) || __x == -_Tp(1)) + { + + return _Tp(0); + } + else + { + + + + + + const _Tp __sgn = ( __m % 2 == 1 ? -_Tp(1) : _Tp(1)); + const _Tp __y_mp1m_factor = __x * std::sqrt(_Tp(2 * __m + 3)); + + const _Tp __lncirc = ::std::log1p(-__x * __x); + + + + + + const _Tp __lnpoch = ::std::lgamma(_Tp(__m + _Tp(0.5L))) + - ::std::lgamma(_Tp(__m)); + + + + + const _Tp __lnpre_val = + -_Tp(0.25L) * __numeric_constants<_Tp>::__lnpi() + + _Tp(0.5L) * (__lnpoch + __m * __lncirc); + const _Tp __sr = std::sqrt((_Tp(2) + _Tp(1) / __m) + / (_Tp(4) * __numeric_constants<_Tp>::__pi())); + _Tp __y_mm = __sgn * __sr * std::exp(__lnpre_val); + _Tp __y_mp1m = __y_mp1m_factor * __y_mm; + + if (__l == __m) + return __y_mm; + else if (__l == __m + 1) + return __y_mp1m; + else + { + _Tp __y_lm = _Tp(0); + + + for (unsigned int __ll = __m + 2; __ll <= __l; ++__ll) + { + const _Tp __rat1 = _Tp(__ll - __m) / _Tp(__ll + __m); + const _Tp __rat2 = _Tp(__ll - __m - 1) / _Tp(__ll + __m - 1); + const _Tp __fact1 = std::sqrt(__rat1 * _Tp(2 * __ll + 1) + * _Tp(2 * __ll - 1)); + const _Tp __fact2 = std::sqrt(__rat1 * __rat2 * _Tp(2 * __ll + 1) + / _Tp(2 * __ll - 3)); + __y_lm = (__x * __y_mp1m * __fact1 + - (__ll + __m - 1) * __y_mm * __fact2) / _Tp(__ll - __m); + __y_mm = __y_mp1m; + __y_mp1m = __y_lm; + } + + return __y_lm; + } + } + } + } + + + + + + +} +# 54 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 1 3 +# 51 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + namespace __detail + { +# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + template + void + __bessel_ik(_Tp __nu, _Tp __x, + _Tp & __Inu, _Tp & __Knu, _Tp & __Ipnu, _Tp & __Kpnu) + { + if (__x == _Tp(0)) + { + if (__nu == _Tp(0)) + { + __Inu = _Tp(1); + __Ipnu = _Tp(0); + } + else if (__nu == _Tp(1)) + { + __Inu = _Tp(0); + __Ipnu = _Tp(0.5L); + } + else + { + __Inu = _Tp(0); + __Ipnu = _Tp(0); + } + __Knu = std::numeric_limits<_Tp>::infinity(); + __Kpnu = -std::numeric_limits<_Tp>::infinity(); + return; + } + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __fp_min = _Tp(10) * std::numeric_limits<_Tp>::epsilon(); + const int __max_iter = 15000; + const _Tp __x_min = _Tp(2); + + const int __nl = static_cast(__nu + _Tp(0.5L)); + + const _Tp __mu = __nu - __nl; + const _Tp __mu2 = __mu * __mu; + const _Tp __xi = _Tp(1) / __x; + const _Tp __xi2 = _Tp(2) * __xi; + _Tp __h = __nu * __xi; + if ( __h < __fp_min ) + __h = __fp_min; + _Tp __b = __xi2 * __nu; + _Tp __d = _Tp(0); + _Tp __c = __h; + int __i; + for ( __i = 1; __i <= __max_iter; ++__i ) + { + __b += __xi2; + __d = _Tp(1) / (__b + __d); + __c = __b + _Tp(1) / __c; + const _Tp __del = __c * __d; + __h *= __del; + if (std::abs(__del - _Tp(1)) < __eps) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Argument x too large " "in __bessel_ik; " "try asymptotic expansion.") + + ); + _Tp __Inul = __fp_min; + _Tp __Ipnul = __h * __Inul; + _Tp __Inul1 = __Inul; + _Tp __Ipnu1 = __Ipnul; + _Tp __fact = __nu * __xi; + for (int __l = __nl; __l >= 1; --__l) + { + const _Tp __Inutemp = __fact * __Inul + __Ipnul; + __fact -= __xi; + __Ipnul = __fact * __Inutemp + __Inul; + __Inul = __Inutemp; + } + _Tp __f = __Ipnul / __Inul; + _Tp __Kmu, __Knu1; + if (__x < __x_min) + { + const _Tp __x2 = __x / _Tp(2); + const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu; + const _Tp __fact = (std::abs(__pimu) < __eps + ? _Tp(1) : __pimu / std::sin(__pimu)); + _Tp __d = -std::log(__x2); + _Tp __e = __mu * __d; + const _Tp __fact2 = (std::abs(__e) < __eps + ? _Tp(1) : std::sinh(__e) / __e); + _Tp __gam1, __gam2, __gampl, __gammi; + __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi); + _Tp __ff = __fact + * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d); + _Tp __sum = __ff; + __e = std::exp(__e); + _Tp __p = __e / (_Tp(2) * __gampl); + _Tp __q = _Tp(1) / (_Tp(2) * __e * __gammi); + _Tp __c = _Tp(1); + __d = __x2 * __x2; + _Tp __sum1 = __p; + int __i; + for (__i = 1; __i <= __max_iter; ++__i) + { + __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2); + __c *= __d / __i; + __p /= __i - __mu; + __q /= __i + __mu; + const _Tp __del = __c * __ff; + __sum += __del; + const _Tp __del1 = __c * (__p - __i * __ff); + __sum1 += __del1; + if (std::abs(__del) < __eps * std::abs(__sum)) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Bessel k series failed to converge " "in __bessel_ik.") + ); + __Kmu = __sum; + __Knu1 = __sum1 * __xi2; + } + else + { + _Tp __b = _Tp(2) * (_Tp(1) + __x); + _Tp __d = _Tp(1) / __b; + _Tp __delh = __d; + _Tp __h = __delh; + _Tp __q1 = _Tp(0); + _Tp __q2 = _Tp(1); + _Tp __a1 = _Tp(0.25L) - __mu2; + _Tp __q = __c = __a1; + _Tp __a = -__a1; + _Tp __s = _Tp(1) + __q * __delh; + int __i; + for (__i = 2; __i <= __max_iter; ++__i) + { + __a -= 2 * (__i - 1); + __c = -__a * __c / __i; + const _Tp __qnew = (__q1 - __b * __q2) / __a; + __q1 = __q2; + __q2 = __qnew; + __q += __c * __qnew; + __b += _Tp(2); + __d = _Tp(1) / (__b + __a * __d); + __delh = (__b * __d - _Tp(1)) * __delh; + __h += __delh; + const _Tp __dels = __q * __delh; + __s += __dels; + if ( std::abs(__dels / __s) < __eps ) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Steed's method failed " "in __bessel_ik.") + ); + __h = __a1 * __h; + __Kmu = std::sqrt(__numeric_constants<_Tp>::__pi() / (_Tp(2) * __x)) + * std::exp(-__x) / __s; + __Knu1 = __Kmu * (__mu + __x + _Tp(0.5L) - __h) * __xi; + } + + _Tp __Kpmu = __mu * __xi * __Kmu - __Knu1; + _Tp __Inumu = __xi / (__f * __Kmu - __Kpmu); + __Inu = __Inumu * __Inul1 / __Inul; + __Ipnu = __Inumu * __Ipnu1 / __Inul; + for ( __i = 1; __i <= __nl; ++__i ) + { + const _Tp __Knutemp = (__mu + __i) * __xi2 * __Knu1 + __Kmu; + __Kmu = __Knu1; + __Knu1 = __Knutemp; + } + __Knu = __Kmu; + __Kpnu = __nu * __xi * __Kmu - __Knu1; + + return; + } +# 267 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + template + _Tp + __cyl_bessel_i(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_i.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x * __x < _Tp(10) * (__nu + _Tp(1))) + return __cyl_bessel_ij_series(__nu, __x, +_Tp(1), 200); + else + { + _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + return __I_nu; + } + } +# 303 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + template + _Tp + __cyl_bessel_k(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_k.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + { + _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + return __K_nu; + } + } +# 337 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + template + void + __sph_bessel_ik(unsigned int __n, _Tp __x, + _Tp & __i_n, _Tp & __k_n, _Tp & __ip_n, _Tp & __kp_n) + { + const _Tp __nu = _Tp(__n) + _Tp(0.5L); + + _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + + const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2() + / std::sqrt(__x); + + __i_n = __factor * __I_nu; + __k_n = __factor * __K_nu; + __ip_n = __factor * __Ip_nu - __i_n / (_Tp(2) * __x); + __kp_n = __factor * __Kp_nu - __k_n / (_Tp(2) * __x); + + return; + } +# 373 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + template + void + __airy(_Tp __x, _Tp & __Ai, _Tp & __Bi, _Tp & __Aip, _Tp & __Bip) + { + const _Tp __absx = std::abs(__x); + const _Tp __rootx = std::sqrt(__absx); + const _Tp __z = _Tp(2) * __absx * __rootx / _Tp(3); + const _Tp _S_inf = std::numeric_limits<_Tp>::infinity(); + + if (__isnan(__x)) + __Bip = __Aip = __Bi = __Ai = std::numeric_limits<_Tp>::quiet_NaN(); + else if (__z == _S_inf) + { + __Aip = __Ai = _Tp(0); + __Bip = __Bi = _S_inf; + } + else if (__z == -_S_inf) + __Bip = __Aip = __Bi = __Ai = _Tp(0); + else if (__x > _Tp(0)) + { + _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu; + + __bessel_ik(_Tp(1) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + __Ai = __rootx * __K_nu + / (__numeric_constants<_Tp>::__sqrt3() + * __numeric_constants<_Tp>::__pi()); + __Bi = __rootx * (__K_nu / __numeric_constants<_Tp>::__pi() + + _Tp(2) * __I_nu / __numeric_constants<_Tp>::__sqrt3()); + + __bessel_ik(_Tp(2) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + __Aip = -__x * __K_nu + / (__numeric_constants<_Tp>::__sqrt3() + * __numeric_constants<_Tp>::__pi()); + __Bip = __x * (__K_nu / __numeric_constants<_Tp>::__pi() + + _Tp(2) * __I_nu + / __numeric_constants<_Tp>::__sqrt3()); + } + else if (__x < _Tp(0)) + { + _Tp __J_nu, __Jp_nu, __N_nu, __Np_nu; + + __bessel_jn(_Tp(1) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu); + __Ai = __rootx * (__J_nu + - __N_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2); + __Bi = -__rootx * (__N_nu + + __J_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2); + + __bessel_jn(_Tp(2) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu); + __Aip = __absx * (__N_nu / __numeric_constants<_Tp>::__sqrt3() + + __J_nu) / _Tp(2); + __Bip = __absx * (__J_nu / __numeric_constants<_Tp>::__sqrt3() + - __N_nu) / _Tp(2); + } + else + { + + + + __Ai = _Tp(0.35502805388781723926L); + __Bi = __Ai * __numeric_constants<_Tp>::__sqrt3(); + + + + + __Aip = -_Tp(0.25881940379280679840L); + __Bip = -__Aip * __numeric_constants<_Tp>::__sqrt3(); + } + + return; + } + } + + + + + +} +# 55 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 1 3 +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 56 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 + namespace __detail + { +# 72 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 + template + _Tp + __poly_hermite_recursion(unsigned int __n, _Tp __x) + { + + _Tp __H_0 = 1; + if (__n == 0) + return __H_0; + + + _Tp __H_1 = 2 * __x; + if (__n == 1) + return __H_1; + + + _Tp __H_n, __H_nm1, __H_nm2; + unsigned int __i; + for (__H_nm2 = __H_0, __H_nm1 = __H_1, __i = 2; __i <= __n; ++__i) + { + __H_n = 2 * (__x * __H_nm1 - (__i - 1) * __H_nm2); + __H_nm2 = __H_nm1; + __H_nm1 = __H_n; + } + + return __H_n; + } +# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 + template + inline _Tp + __poly_hermite(unsigned int __n, _Tp __x) + { + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __poly_hermite_recursion(__n, __x); + } + } + + + + + +} +# 56 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 1 3 +# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + namespace __detail + { +# 75 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre_large_n(unsigned __n, _Tpa __alpha1, _Tp __x) + { + const _Tp __a = -_Tp(__n); + const _Tp __b = _Tp(__alpha1) + _Tp(1); + const _Tp __eta = _Tp(2) * __b - _Tp(4) * __a; + const _Tp __cos2th = __x / __eta; + const _Tp __sin2th = _Tp(1) - __cos2th; + const _Tp __th = std::acos(std::sqrt(__cos2th)); + const _Tp __pre_h = __numeric_constants<_Tp>::__pi_2() + * __numeric_constants<_Tp>::__pi_2() + * __eta * __eta * __cos2th * __sin2th; + + + const _Tp __lg_b = ::std::lgamma(_Tp(__n) + __b); + const _Tp __lnfact = ::std::lgamma(_Tp(__n + 1)); + + + + + + _Tp __pre_term1 = _Tp(0.5L) * (_Tp(1) - __b) + * std::log(_Tp(0.25L) * __x * __eta); + _Tp __pre_term2 = _Tp(0.25L) * std::log(__pre_h); + _Tp __lnpre = __lg_b - __lnfact + _Tp(0.5L) * __x + + __pre_term1 - __pre_term2; + _Tp __ser_term1 = std::sin(__a * __numeric_constants<_Tp>::__pi()); + _Tp __ser_term2 = std::sin(_Tp(0.25L) * __eta + * (_Tp(2) * __th + - std::sin(_Tp(2) * __th)) + + __numeric_constants<_Tp>::__pi_4()); + _Tp __ser = __ser_term1 + __ser_term2; + + return std::exp(__lnpre) * __ser; + } +# 129 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre_hyperg(unsigned int __n, _Tpa __alpha1, _Tp __x) + { + const _Tp __b = _Tp(__alpha1) + _Tp(1); + const _Tp __mx = -__x; + const _Tp __tc_sgn = (__x < _Tp(0) ? _Tp(1) + : ((__n % 2 == 1) ? -_Tp(1) : _Tp(1))); + + _Tp __tc = _Tp(1); + const _Tp __ax = std::abs(__x); + for (unsigned int __k = 1; __k <= __n; ++__k) + __tc *= (__ax / __k); + + _Tp __term = __tc * __tc_sgn; + _Tp __sum = __term; + for (int __k = int(__n) - 1; __k >= 0; --__k) + { + __term *= ((__b + _Tp(__k)) / _Tp(int(__n) - __k)) + * _Tp(__k + 1) / __mx; + __sum += __term; + } + + return __sum; + } +# 185 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre_recursion(unsigned int __n, _Tpa __alpha1, _Tp __x) + { + + _Tp __l_0 = _Tp(1); + if (__n == 0) + return __l_0; + + + _Tp __l_1 = -__x + _Tp(1) + _Tp(__alpha1); + if (__n == 1) + return __l_1; + + + _Tp __l_n2 = __l_0; + _Tp __l_n1 = __l_1; + _Tp __l_n = _Tp(0); + for (unsigned int __nn = 2; __nn <= __n; ++__nn) + { + __l_n = (_Tp(2 * __nn - 1) + _Tp(__alpha1) - __x) + * __l_n1 / _Tp(__nn) + - (_Tp(__nn - 1) + _Tp(__alpha1)) * __l_n2 / _Tp(__nn); + __l_n2 = __l_n1; + __l_n1 = __l_n; + } + + return __l_n; + } +# 244 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre(unsigned int __n, _Tpa __alpha1, _Tp __x) + { + if (__x < _Tp(0)) + std::__throw_domain_error(("Negative argument " "in __poly_laguerre.") + ); + + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__n == 0) + return _Tp(1); + else if (__n == 1) + return _Tp(1) + _Tp(__alpha1) - __x; + else if (__x == _Tp(0)) + { + _Tp __prod = _Tp(__alpha1) + _Tp(1); + for (unsigned int __k = 2; __k <= __n; ++__k) + __prod *= (_Tp(__alpha1) + _Tp(__k)) / _Tp(__k); + return __prod; + } + else if (__n > 10000000 && _Tp(__alpha1) > -_Tp(1) + && __x < _Tp(2) * (_Tp(__alpha1) + _Tp(1)) + _Tp(4 * __n)) + return __poly_laguerre_large_n(__n, __alpha1, __x); + else if (_Tp(__alpha1) >= _Tp(0) + || (__x > _Tp(0) && _Tp(__alpha1) < -_Tp(__n + 1))) + return __poly_laguerre_recursion(__n, __alpha1, __x); + else + return __poly_laguerre_hyperg(__n, __alpha1, __x); + } +# 296 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + inline _Tp + __assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x) + { return __poly_laguerre(__n, __m, __x); } +# 316 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + inline _Tp + __laguerre(unsigned int __n, _Tp __x) + { return __poly_laguerre(__n, 0, __x); } + } + + + + + + +} +# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + namespace __detail + { +# 78 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_sum(_Tp __s) + { + + if (__s < _Tp(1)) + std::__throw_domain_error(("Bad argument in zeta sum.")); + + const unsigned int max_iter = 10000; + _Tp __zeta = _Tp(0); + for (unsigned int __k = 1; __k < max_iter; ++__k) + { + _Tp __term = std::pow(static_cast<_Tp>(__k), -__s); + if (__term < std::numeric_limits<_Tp>::epsilon()) + { + break; + } + __zeta += __term; + } + + return __zeta; + } +# 115 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_alt(_Tp __s) + { + _Tp __sgn = _Tp(1); + _Tp __zeta = _Tp(0); + for (unsigned int __i = 1; __i < 10000000; ++__i) + { + _Tp __term = __sgn / std::pow(__i, __s); + if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon()) + break; + __zeta += __term; + __sgn *= _Tp(-1); + } + __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s); + + return __zeta; + } +# 157 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_glob(_Tp __s) + { + _Tp __zeta = _Tp(0); + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + + + if (__s < _Tp(0)) + { + + if (::std::fmod(__s,_Tp(2)) == _Tp(0)) + return _Tp(0); + else + + { + _Tp __zeta = __riemann_zeta_glob(_Tp(1) - __s); + __zeta *= std::pow(_Tp(2) + * __numeric_constants<_Tp>::__pi(), __s) + * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) + + * std::exp(::std::lgamma(_Tp(1) - __s)) + + + + / __numeric_constants<_Tp>::__pi(); + return __zeta; + } + } + + _Tp __num = _Tp(0.5L); + const unsigned int __maxit = 10000; + for (unsigned int __i = 0; __i < __maxit; ++__i) + { + bool __punt = false; + _Tp __sgn = _Tp(1); + _Tp __term = _Tp(0); + for (unsigned int __j = 0; __j <= __i; ++__j) + { + + _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i)) + - ::std::lgamma(_Tp(1 + __j)) + - ::std::lgamma(_Tp(1 + __i - __j)); + + + + + + if (__bincoeff > __max_bincoeff) + { + + __punt = true; + break; + } + __bincoeff = std::exp(__bincoeff); + __term += __sgn * __bincoeff * std::pow(_Tp(1 + __j), -__s); + __sgn *= _Tp(-1); + } + if (__punt) + break; + __term *= __num; + __zeta += __term; + if (std::abs(__term/__zeta) < __eps) + break; + __num *= _Tp(0.5L); + } + + __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s); + + return __zeta; + } +# 252 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_product(_Tp __s) + { + static const _Tp __prime[] = { + _Tp(2), _Tp(3), _Tp(5), _Tp(7), _Tp(11), _Tp(13), _Tp(17), _Tp(19), + _Tp(23), _Tp(29), _Tp(31), _Tp(37), _Tp(41), _Tp(43), _Tp(47), + _Tp(53), _Tp(59), _Tp(61), _Tp(67), _Tp(71), _Tp(73), _Tp(79), + _Tp(83), _Tp(89), _Tp(97), _Tp(101), _Tp(103), _Tp(107), _Tp(109) + }; + static const unsigned int __num_primes = sizeof(__prime) / sizeof(_Tp); + + _Tp __zeta = _Tp(1); + for (unsigned int __i = 0; __i < __num_primes; ++__i) + { + const _Tp __fact = _Tp(1) - std::pow(__prime[__i], -__s); + __zeta *= __fact; + if (_Tp(1) - __fact < std::numeric_limits<_Tp>::epsilon()) + break; + } + + __zeta = _Tp(1) / __zeta; + + return __zeta; + } +# 293 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta(_Tp __s) + { + if (__isnan(__s)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__s == _Tp(1)) + return std::numeric_limits<_Tp>::infinity(); + else if (__s < -_Tp(19)) + { + _Tp __zeta = __riemann_zeta_product(_Tp(1) - __s); + __zeta *= std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s) + * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) + + * std::exp(::std::lgamma(_Tp(1) - __s)) + + + + / __numeric_constants<_Tp>::__pi(); + return __zeta; + } + else if (__s < _Tp(20)) + { + + bool __glob = true; + if (__glob) + return __riemann_zeta_glob(__s); + else + { + if (__s > _Tp(1)) + return __riemann_zeta_sum(__s); + else + { + _Tp __zeta = std::pow(_Tp(2) + * __numeric_constants<_Tp>::__pi(), __s) + * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) + + * ::std::tgamma(_Tp(1) - __s) + + + + * __riemann_zeta_sum(_Tp(1) - __s); + return __zeta; + } + } + } + else + return __riemann_zeta_product(__s); + } +# 365 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __hurwitz_zeta_glob(_Tp __a, _Tp __s) + { + _Tp __zeta = _Tp(0); + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + const unsigned int __maxit = 10000; + for (unsigned int __i = 0; __i < __maxit; ++__i) + { + bool __punt = false; + _Tp __sgn = _Tp(1); + _Tp __term = _Tp(0); + for (unsigned int __j = 0; __j <= __i; ++__j) + { + + _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i)) + - ::std::lgamma(_Tp(1 + __j)) + - ::std::lgamma(_Tp(1 + __i - __j)); + + + + + + if (__bincoeff > __max_bincoeff) + { + + __punt = true; + break; + } + __bincoeff = std::exp(__bincoeff); + __term += __sgn * __bincoeff * std::pow(_Tp(__a + __j), -__s); + __sgn *= _Tp(-1); + } + if (__punt) + break; + __term /= _Tp(__i + 1); + if (std::abs(__term / __zeta) < __eps) + break; + __zeta += __term; + } + + __zeta /= __s - _Tp(1); + + return __zeta; + } +# 430 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + inline _Tp + __hurwitz_zeta(_Tp __a, _Tp __s) + { return __hurwitz_zeta_glob(__a, __s); } + } + + + + + + +} +# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 203 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + assoc_laguerref(unsigned int __n, unsigned int __m, float __x) + { return __detail::__assoc_laguerre(__n, __m, __x); } + + + + + + + + inline long double + assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x) + { return __detail::__assoc_laguerre(__n, __m, __x); } +# 248 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__assoc_laguerre<__type>(__n, __m, __x); + } +# 264 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + assoc_legendref(unsigned int __l, unsigned int __m, float __x) + { return __detail::__assoc_legendre_p(__l, __m, __x); } + + + + + + + inline long double + assoc_legendrel(unsigned int __l, unsigned int __m, long double __x) + { return __detail::__assoc_legendre_p(__l, __m, __x); } +# 294 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__assoc_legendre_p<__type>(__l, __m, __x); + } +# 309 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + betaf(float __a, float __b) + { return __detail::__beta(__a, __b); } + + + + + + + + inline long double + betal(long double __a, long double __b) + { return __detail::__beta(__a, __b); } +# 339 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type + beta(_Tpa __a, _Tpb __b) + { + typedef typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type __type; + return __detail::__beta<__type>(__a, __b); + } +# 355 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + comp_ellint_1f(float __k) + { return __detail::__comp_ellint_1(__k); } + + + + + + + + inline long double + comp_ellint_1l(long double __k) + { return __detail::__comp_ellint_1(__k); } +# 387 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + comp_ellint_1(_Tp __k) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__comp_ellint_1<__type>(__k); + } +# 403 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + comp_ellint_2f(float __k) + { return __detail::__comp_ellint_2(__k); } + + + + + + + + inline long double + comp_ellint_2l(long double __k) + { return __detail::__comp_ellint_2(__k); } +# 434 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + comp_ellint_2(_Tp __k) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__comp_ellint_2<__type>(__k); + } +# 450 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + comp_ellint_3f(float __k, float __nu) + { return __detail::__comp_ellint_3(__k, __nu); } + + + + + + + + inline long double + comp_ellint_3l(long double __k, long double __nu) + { return __detail::__comp_ellint_3(__k, __nu); } +# 485 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type + comp_ellint_3(_Tp __k, _Tpn __nu) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type; + return __detail::__comp_ellint_3<__type>(__k, __nu); + } +# 501 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + cyl_bessel_if(float __nu, float __x) + { return __detail::__cyl_bessel_i(__nu, __x); } + + + + + + + + inline long double + cyl_bessel_il(long double __nu, long double __x) + { return __detail::__cyl_bessel_i(__nu, __x); } +# 531 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_bessel_i(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_bessel_i<__type>(__nu, __x); + } +# 547 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + cyl_bessel_jf(float __nu, float __x) + { return __detail::__cyl_bessel_j(__nu, __x); } + + + + + + + + inline long double + cyl_bessel_jl(long double __nu, long double __x) + { return __detail::__cyl_bessel_j(__nu, __x); } +# 577 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_bessel_j(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_bessel_j<__type>(__nu, __x); + } +# 593 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + cyl_bessel_kf(float __nu, float __x) + { return __detail::__cyl_bessel_k(__nu, __x); } + + + + + + + + inline long double + cyl_bessel_kl(long double __nu, long double __x) + { return __detail::__cyl_bessel_k(__nu, __x); } +# 629 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_bessel_k(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_bessel_k<__type>(__nu, __x); + } +# 645 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + cyl_neumannf(float __nu, float __x) + { return __detail::__cyl_neumann_n(__nu, __x); } + + + + + + + + inline long double + cyl_neumannl(long double __nu, long double __x) + { return __detail::__cyl_neumann_n(__nu, __x); } +# 677 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_neumann(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_neumann_n<__type>(__nu, __x); + } +# 693 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + ellint_1f(float __k, float __phi) + { return __detail::__ellint_1(__k, __phi); } + + + + + + + + inline long double + ellint_1l(long double __k, long double __phi) + { return __detail::__ellint_1(__k, __phi); } +# 725 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type + ellint_1(_Tp __k, _Tpp __phi) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type; + return __detail::__ellint_1<__type>(__k, __phi); + } +# 741 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + ellint_2f(float __k, float __phi) + { return __detail::__ellint_2(__k, __phi); } + + + + + + + + inline long double + ellint_2l(long double __k, long double __phi) + { return __detail::__ellint_2(__k, __phi); } +# 773 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type + ellint_2(_Tp __k, _Tpp __phi) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type; + return __detail::__ellint_2<__type>(__k, __phi); + } +# 789 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + ellint_3f(float __k, float __nu, float __phi) + { return __detail::__ellint_3(__k, __nu, __phi); } + + + + + + + + inline long double + ellint_3l(long double __k, long double __nu, long double __phi) + { return __detail::__ellint_3(__k, __nu, __phi); } +# 826 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type + ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi) + { + typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type; + return __detail::__ellint_3<__type>(__k, __nu, __phi); + } +# 841 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + expintf(float __x) + { return __detail::__expint(__x); } + + + + + + + + inline long double + expintl(long double __x) + { return __detail::__expint(__x); } +# 866 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + expint(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__expint<__type>(__x); + } +# 882 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + hermitef(unsigned int __n, float __x) + { return __detail::__poly_hermite(__n, __x); } + + + + + + + + inline long double + hermitel(unsigned int __n, long double __x) + { return __detail::__poly_hermite(__n, __x); } +# 914 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + hermite(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__poly_hermite<__type>(__n, __x); + } +# 930 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + laguerref(unsigned int __n, float __x) + { return __detail::__laguerre(__n, __x); } + + + + + + + + inline long double + laguerrel(unsigned int __n, long double __x) + { return __detail::__laguerre(__n, __x); } +# 958 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + laguerre(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__laguerre<__type>(__n, __x); + } +# 974 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + legendref(unsigned int __l, float __x) + { return __detail::__poly_legendre_p(__l, __x); } + + + + + + + + inline long double + legendrel(unsigned int __l, long double __x) + { return __detail::__poly_legendre_p(__l, __x); } +# 1003 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + legendre(unsigned int __l, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__poly_legendre_p<__type>(__l, __x); + } +# 1019 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + riemann_zetaf(float __s) + { return __detail::__riemann_zeta(__s); } + + + + + + + + inline long double + riemann_zetal(long double __s) + { return __detail::__riemann_zeta(__s); } +# 1054 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + riemann_zeta(_Tp __s) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__riemann_zeta<__type>(__s); + } +# 1070 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + sph_besself(unsigned int __n, float __x) + { return __detail::__sph_bessel(__n, __x); } + + + + + + + + inline long double + sph_bessell(unsigned int __n, long double __x) + { return __detail::__sph_bessel(__n, __x); } +# 1098 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + sph_bessel(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__sph_bessel<__type>(__n, __x); + } +# 1114 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + sph_legendref(unsigned int __l, unsigned int __m, float __theta) + { return __detail::__sph_legendre(__l, __m, __theta); } +# 1125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline long double + sph_legendrel(unsigned int __l, unsigned int __m, long double __theta) + { return __detail::__sph_legendre(__l, __m, __theta); } +# 1145 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__sph_legendre<__type>(__l, __m, __theta); + } +# 1161 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + sph_neumannf(unsigned int __n, float __x) + { return __detail::__sph_neumann(__n, __x); } + + + + + + + + inline long double + sph_neumannl(unsigned int __n, long double __x) + { return __detail::__sph_neumann(__n, __x); } +# 1189 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + sph_neumann(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__sph_neumann<__type>(__n, __x); + } + + + + +} + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 1216 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + airy_aif(float __x) + { + float __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Ai; + } + + + + + inline long double + airy_ail(long double __x) + { + long double __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Ai; + } + + + + + template + inline typename __gnu_cxx::__promote<_Tp>::__type + airy_ai(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + __type __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy<__type>(__x, __Ai, __Bi, __Aip, __Bip); + return __Ai; + } + + + + + inline float + airy_bif(float __x) + { + float __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Bi; + } + + + + + inline long double + airy_bil(long double __x) + { + long double __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Bi; + } + + + + + template + inline typename __gnu_cxx::__promote<_Tp>::__type + airy_bi(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + __type __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy<__type>(__x, __Ai, __Bi, __Aip, __Bip); + return __Bi; + } +# 1292 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + conf_hypergf(float __a, float __c, float __x) + { return std::__detail::__conf_hyperg(__a, __c, __x); } +# 1303 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline long double + conf_hypergl(long double __a, long double __c, long double __x) + { return std::__detail::__conf_hyperg(__a, __c, __x); } +# 1323 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type + conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x) + { + typedef typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type __type; + return std::__detail::__conf_hyperg<__type>(__a, __c, __x); + } +# 1340 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + hypergf(float __a, float __b, float __c, float __x) + { return std::__detail::__hyperg(__a, __b, __c, __x); } +# 1351 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline long double + hypergl(long double __a, long double __b, long double __c, long double __x) + { return std::__detail::__hyperg(__a, __b, __c, __x); } +# 1372 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type + hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x) + { + typedef typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp> + ::__type __type; + return std::__detail::__hyperg<__type>(__a, __b, __c, __x); + } + + + +} +# 3907 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 + + +} +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/math.h" 2 3 + +using std::abs; +using std::acos; +using std::asin; +using std::atan; +using std::atan2; +using std::cos; +using std::sin; +using std::tan; +using std::cosh; +using std::sinh; +using std::tanh; +using std::exp; +using std::frexp; +using std::ldexp; +using std::log; +using std::log10; +using std::modf; +using std::pow; +using std::sqrt; +using std::ceil; +using std::fabs; +using std::floor; +using std::fmod; + + +using std::fpclassify; +using std::isfinite; +using std::isinf; +using std::isnan; +using std::isnormal; +using std::signbit; +using std::isgreater; +using std::isgreaterequal; +using std::isless; +using std::islessequal; +using std::islessgreater; +using std::isunordered; + + + +using std::acosh; +using std::asinh; +using std::atanh; +using std::cbrt; +using std::copysign; +using std::erf; +using std::erfc; +using std::exp2; +using std::expm1; +using std::fdim; +using std::fma; +using std::fmax; +using std::fmin; +using std::hypot; +using std::ilogb; +using std::lgamma; +using std::llrint; +using std::llround; +using std::log1p; +using std::log2; +using std::logb; +using std::lrint; +using std::lround; +using std::nearbyint; +using std::nextafter; +using std::nexttoward; +using std::remainder; +using std::remquo; +using std::rint; +using std::round; +using std::scalbln; +using std::scalbn; +using std::tgamma; +using std::trunc; +# 4578 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h" 1 3 +# 4579 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +# 4582 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +# 4583 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 4653 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + +# 4653 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool signbit(float x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool signbit(double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool signbit(long double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isfinite(float x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isfinite(double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isfinite(long double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isnan(float x); + + + + +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isnan(double x); + +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isnan(long double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isinf(float x); + + + + +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isinf(double x); + +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isinf(long double x); +} +# 4832 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std +{ + template extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) T __pow_helper(T, int); + template extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) T __cmath_power(T, unsigned int); +} + +using std::abs; +using std::fabs; +using std::ceil; +using std::floor; +using std::sqrt; + +using std::pow; + +using std::log; +using std::log10; +using std::fmod; +using std::modf; +using std::exp; +using std::frexp; +using std::ldexp; +using std::asin; +using std::sin; +using std::sinh; +using std::acos; +using std::cos; +using std::cosh; +using std::atan; +using std::atan2; +using std::tan; +using std::tanh; +# 5243 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +# 5252 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int abs(long long int); +# 5272 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int abs(long int a); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float abs(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double abs(double); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float fabs(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float ceil(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float floor(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sqrt(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float pow(float, float); + + + + +template +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) +typename __gnu_cxx::__promote_2<_Tp, _Up>::__type pow(_Tp, _Up); + + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float log(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float log10(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float fmod(float, float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float modf(float, float*); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float exp(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float frexp(float, int*); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float ldexp(float, int); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float asin(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sin(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sinh(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float acos(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cos(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cosh(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float atan(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float atan2(float, float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float tan(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float tanh(float); +# 5399 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +} +# 5505 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float logb(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr int ilogb(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float scalbn(float a, int b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float scalbln(float a, long int b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float exp2(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float expm1(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float log2(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float log1p(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float acosh(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float asinh(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float atanh(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float hypot(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float cbrt(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float erf(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float erfc(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float lgamma(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float tgamma(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float copysign(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float nextafter(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float remainder(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float remquo(float a, float b, int *quo); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float round(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr long int lround(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr long long int llround(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float trunc(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float rint(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr long int lrint(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr long long int llrint(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float nearbyint(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float fdim(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float fma(float a, float b, float c); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float fmax(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float fmin(float a, float b); +} +# 5644 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float exp10(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float rsqrt(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float rcbrt(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sinpi(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cospi(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void sincospi(const float a, float *const sptr, float *const cptr); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void sincos(const float a, float *const sptr, float *const cptr); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float j0(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float j1(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float jn(const int n, const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float y0(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float y1(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float yn(const int n, const float a); + +static inline __attribute__((device)) __attribute__((cudart_builtin)) float cyl_bessel_i0(const float a); + +static inline __attribute__((device)) __attribute__((cudart_builtin)) float cyl_bessel_i1(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfinv(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfcinv(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float normcdfinv(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float normcdf(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfcx(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double copysign(const double a, const float b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double copysign(const float a, const double b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(const unsigned int a, const unsigned int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(const int a, const unsigned int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(const unsigned int a, const int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int min(const long int a, const long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(const unsigned long int a, const unsigned long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(const long int a, const unsigned long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(const unsigned long int a, const long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int min(const long long int a, const long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(const unsigned long long int a, const unsigned long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(const long long int a, const unsigned long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(const unsigned long long int a, const long long int b); +# 5785 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float min(const float a, const float b); +# 5796 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(const double a, const double b); +# 5806 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(const float a, const double b); +# 5816 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(const double a, const float b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(const unsigned int a, const unsigned int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(const int a, const unsigned int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(const unsigned int a, const int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int max(const long int a, const long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(const unsigned long int a, const unsigned long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(const long int a, const unsigned long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(const unsigned long int a, const long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int max(const long long int a, const long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(const unsigned long long int a, const unsigned long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(const long long int a, const unsigned long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(const unsigned long long int a, const long long int b); +# 5915 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float max(const float a, const float b); +# 5926 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const double a, const double b); +# 5936 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const float a, const double b); +# 5946 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const double a, const float b); +# 5958 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern "C"{ +inline __attribute__((device)) void *__nv_aligned_device_malloc(size_t size, size_t align) +{ + __attribute__((device)) void *__nv_aligned_device_malloc_impl(size_t, size_t); + return __nv_aligned_device_malloc_impl(size, align); +} +} +# 6248 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" 1 +# 77 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 78 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 79 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" 2 +# 758 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +static inline __attribute__((host)) __attribute__((device)) float exp10(const float a) +{ + return exp10f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float rsqrt(const float a) +{ + return rsqrtf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float rcbrt(const float a) +{ + return rcbrtf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float sinpi(const float a) +{ + return sinpif(a); +} + +static inline __attribute__((host)) __attribute__((device)) float cospi(const float a) +{ + return cospif(a); +} + +static inline __attribute__((host)) __attribute__((device)) void sincospi(const float a, float *const sptr, float *const cptr) +{ + sincospif(a, sptr, cptr); +} + +static inline __attribute__((host)) __attribute__((device)) void sincos(const float a, float *const sptr, float *const cptr) +{ + sincosf(a, sptr, cptr); +} + +static inline __attribute__((host)) __attribute__((device)) float j0(const float a) +{ + return j0f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float j1(const float a) +{ + return j1f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float jn(const int n, const float a) +{ + return jnf(n, a); +} + +static inline __attribute__((host)) __attribute__((device)) float y0(const float a) +{ + return y0f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float y1(const float a) +{ + return y1f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float yn(const int n, const float a) +{ + return ynf(n, a); +} + +static inline __attribute__((device)) float cyl_bessel_i0(const float a) +{ + return cyl_bessel_i0f(a); +} + +static inline __attribute__((device)) float cyl_bessel_i1(const float a) +{ + return cyl_bessel_i1f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float erfinv(const float a) +{ + return erfinvf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float erfcinv(const float a) +{ + return erfcinvf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float normcdfinv(const float a) +{ + return normcdfinvf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float normcdf(const float a) +{ + return normcdff(a); +} + +static inline __attribute__((host)) __attribute__((device)) float erfcx(const float a) +{ + return erfcxf(a); +} + +static inline __attribute__((host)) __attribute__((device)) double copysign(const double a, const float b) +{ + return copysign(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) double copysign(const float a, const double b) +{ + return copysign(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int min(const unsigned int a, const unsigned int b) +{ + return umin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int min(const int a, const unsigned int b) +{ + return umin(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int min(const unsigned int a, const int b) +{ + return umin(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) long int min(const long int a, const long int b) +{ + long int retval; + + + + + + + if (sizeof(long int) == sizeof(int)) { + + + + retval = static_cast(min(static_cast(a), static_cast(b))); + } else { + retval = static_cast(llmin(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int min(const unsigned long int a, const unsigned long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umin(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmin(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int min(const long int a, const unsigned long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umin(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmin(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int min(const unsigned long int a, const long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umin(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmin(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) long long int min(const long long int a, const long long int b) +{ + return llmin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(const unsigned long long int a, const unsigned long long int b) +{ + return ullmin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(const long long int a, const unsigned long long int b) +{ + return ullmin(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(const unsigned long long int a, const long long int b) +{ + return ullmin(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) float min(const float a, const float b) +{ + return fminf(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double min(const double a, const double b) +{ + return fmin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double min(const float a, const double b) +{ + return fmin(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) double min(const double a, const float b) +{ + return fmin(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int max(const unsigned int a, const unsigned int b) +{ + return umax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int max(const int a, const unsigned int b) +{ + return umax(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int max(const unsigned int a, const int b) +{ + return umax(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) long int max(const long int a, const long int b) +{ + long int retval; + + + + + + if (sizeof(long int) == sizeof(int)) { + + + + retval = static_cast(max(static_cast(a), static_cast(b))); + } else { + retval = static_cast(llmax(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int max(const unsigned long int a, const unsigned long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umax(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmax(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int max(const long int a, const unsigned long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umax(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmax(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int max(const unsigned long int a, const long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umax(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmax(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) long long int max(const long long int a, const long long int b) +{ + return llmax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(const unsigned long long int a, const unsigned long long int b) +{ + return ullmax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(const long long int a, const unsigned long long int b) +{ + return ullmax(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(const unsigned long long int a, const long long int b) +{ + return ullmax(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) float max(const float a, const float b) +{ + return fmaxf(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double max(const double a, const double b) +{ + return fmax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double max(const float a, const double b) +{ + return fmax(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) double max(const double a, const float b) +{ + return fmax(a, static_cast(b)); +} +# 6249 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 304 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 118 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 1 +# 81 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 82 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" 1 +# 83 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +extern "C" +{ +# 106 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __mulhi(int x, int y); +# 116 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __umulhi(unsigned int x, unsigned int y); +# 126 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __mul64hi(long long int x, long long int y); +# 136 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __umul64hi(unsigned long long int x, unsigned long long int y); +# 145 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int_as_float(int x); +# 154 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float_as_int(float x); +# 163 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint_as_float(unsigned int x); +# 172 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float_as_uint(float x); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __syncthreads(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __prof_trigger(int); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __threadfence(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __threadfence_block(void); +__attribute__((device)) __attribute__((cudart_builtin)) + +__attribute__((__noreturn__)) + + + +__attribute__((device_builtin)) void __trap(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __brkpt(); +# 196 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __saturatef(float x); +# 215 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __sad(int x, int y, unsigned int z); +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __usad(unsigned int x, unsigned int y, unsigned int z); +# 243 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __mul24(int x, int y); +# 253 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __umul24(unsigned int x, unsigned int y); +# 269 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float fdividef(float x, float y); +# 289 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdividef(float x, float y); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) double fdivide(double x, double y); +# 303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __sinf(float x) +# 303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 315 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __cosf(float x) +# 315 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 315 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __tanf(float x) +# 328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __tanhf(float x) +# 340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void __sincosf(float x, float *sptr, float *cptr) +# 353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 371 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __expf(float x) +# 371 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 371 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 385 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __exp10f(float x) +# 385 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 385 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 398 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __log2f(float x) +# 398 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 398 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __log10f(float x) +# 411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 428 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __logf(float x) +# 428 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 428 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 443 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __powf(float x, float y) +# 443 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 443 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 453 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rn(float x); +# 463 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rz(float x); +# 473 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_ru(float); +# 483 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rd(float x); +# 493 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rn(float x); +# 503 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rz(float x); +# 513 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_ru(float x); +# 523 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rd(float x); +# 532 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rn(int x); +# 541 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rz(int x); +# 550 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_ru(int x); +# 559 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rd(int x); +# 568 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rn(unsigned int x); +# 577 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rz(unsigned int x); +# 586 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_ru(unsigned int x); +# 595 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rd(unsigned int x); +# 605 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rn(float x); +# 615 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rz(float x); +# 625 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_ru(float x); +# 635 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rd(float x); +# 645 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rn(float x); +# 655 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rz(float x); +# 665 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_ru(float x); +# 675 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rd(float x); +# 684 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rn(long long int x); +# 693 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rz(long long int x); +# 702 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_ru(long long int x); +# 711 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rd(long long int x); +# 720 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rn(unsigned long long int x); +# 729 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rz(unsigned long long int x); +# 738 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_ru(unsigned long long int x); +# 747 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rd(unsigned long long int x); +# 766 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rn(float x, float y); +# 785 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rz(float x, float y); +# 804 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_ru(float x, float y); +# 823 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rd(float x, float y); +# 842 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rn(float x, float y); +# 861 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rz(float x, float y); +# 880 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_ru(float x, float y); +# 899 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rd(float x, float y); +# 917 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rn(float x, float y); +# 935 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rz(float x, float y); +# 953 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_ru(float x, float y); +# 971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rd(float x, float y); +# 1015 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rn(float x, float y, float z); +# 1059 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rz(float x, float y, float z); +# 1103 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_ru(float x, float y, float z); +# 1147 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rd(float x, float y, float z); +# 1164 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rn(float x); +# 1181 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rz(float x); +# 1198 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_ru(float x); +# 1215 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rd(float x); +# 1233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rn(float x); +# 1251 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rz(float x); +# 1269 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_ru(float x); +# 1287 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rd(float x); +# 1305 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frsqrt_rn(float x); +# 1324 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rn(float x, float y); +# 1343 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rz(float x, float y); +# 1362 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_ru(float x, float y); +# 1381 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rd(float x, float y); +# 1390 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __clz(int x); +# 1401 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __ffs(int x); +# 1410 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __popc(unsigned int x); +# 1419 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __brev(unsigned int x); +# 1428 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __clzll(long long int x); +# 1439 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __ffsll(long long int x); +# 1450 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __popcll(unsigned long long int x); +# 1459 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __brevll(unsigned long long int x); +# 1482 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __byte_perm(unsigned int x, unsigned int y, unsigned int s); +# 1494 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __hadd(int x, int y); +# 1507 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __rhadd(int x, int y); +# 1519 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __uhadd(unsigned int x, unsigned int y); +# 1532 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __urhadd(unsigned int x, unsigned int y); +# 1543 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __double2int_rz(double x); +# 1553 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __double2uint_rz(double x); +# 1563 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __double2ll_rz(double x); +# 1573 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __double2ull_rz(double x); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __pm0(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __pm1(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __pm2(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __pm3(void); +# 1603 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabs2(unsigned int a); +# 1614 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsss2(unsigned int a); +# 1625 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vadd2(unsigned int a, unsigned int b); +# 1636 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddss2 (unsigned int a, unsigned int b); +# 1646 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddus2 (unsigned int a, unsigned int b); +# 1657 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgs2(unsigned int a, unsigned int b); +# 1668 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgu2(unsigned int a, unsigned int b); +# 1679 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vhaddu2(unsigned int a, unsigned int b); +# 1690 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpeq2(unsigned int a, unsigned int b); +# 1701 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpges2(unsigned int a, unsigned int b); +# 1712 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgeu2(unsigned int a, unsigned int b); +# 1723 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgts2(unsigned int a, unsigned int b); +# 1734 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgtu2(unsigned int a, unsigned int b); +# 1745 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmples2(unsigned int a, unsigned int b); +# 1756 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpleu2(unsigned int a, unsigned int b); +# 1767 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmplts2(unsigned int a, unsigned int b); +# 1778 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpltu2(unsigned int a, unsigned int b); +# 1789 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpne2(unsigned int a, unsigned int b); +# 1800 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffu2(unsigned int a, unsigned int b); +# 1811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxs2(unsigned int a, unsigned int b); +# 1822 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxu2(unsigned int a, unsigned int b); +# 1833 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmins2(unsigned int a, unsigned int b); +# 1844 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vminu2(unsigned int a, unsigned int b); +# 1855 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vseteq2(unsigned int a, unsigned int b); +# 1866 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetges2(unsigned int a, unsigned int b); +# 1877 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgeu2(unsigned int a, unsigned int b); +# 1888 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgts2(unsigned int a, unsigned int b); +# 1899 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgtu2(unsigned int a, unsigned int b); +# 1910 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetles2(unsigned int a, unsigned int b); +# 1921 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetleu2(unsigned int a, unsigned int b); +# 1932 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetlts2(unsigned int a, unsigned int b); +# 1943 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetltu2(unsigned int a, unsigned int b); +# 1954 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetne2(unsigned int a, unsigned int b); +# 1965 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsadu2(unsigned int a, unsigned int b); +# 1976 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsub2(unsigned int a, unsigned int b); +# 1987 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubss2 (unsigned int a, unsigned int b); +# 1998 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubus2 (unsigned int a, unsigned int b); +# 2008 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vneg2(unsigned int a); +# 2018 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vnegss2(unsigned int a); +# 2029 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffs2(unsigned int a, unsigned int b); +# 2040 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsads2(unsigned int a, unsigned int b); +# 2050 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabs4(unsigned int a); +# 2061 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsss4(unsigned int a); +# 2072 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vadd4(unsigned int a, unsigned int b); +# 2083 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddss4 (unsigned int a, unsigned int b); +# 2093 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddus4 (unsigned int a, unsigned int b); +# 2104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgs4(unsigned int a, unsigned int b); +# 2115 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgu4(unsigned int a, unsigned int b); +# 2126 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vhaddu4(unsigned int a, unsigned int b); +# 2137 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpeq4(unsigned int a, unsigned int b); +# 2148 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpges4(unsigned int a, unsigned int b); +# 2159 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgeu4(unsigned int a, unsigned int b); +# 2170 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgts4(unsigned int a, unsigned int b); +# 2181 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgtu4(unsigned int a, unsigned int b); +# 2192 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmples4(unsigned int a, unsigned int b); +# 2203 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpleu4(unsigned int a, unsigned int b); +# 2214 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmplts4(unsigned int a, unsigned int b); +# 2225 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpltu4(unsigned int a, unsigned int b); +# 2236 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpne4(unsigned int a, unsigned int b); +# 2247 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffu4(unsigned int a, unsigned int b); +# 2258 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxs4(unsigned int a, unsigned int b); +# 2269 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxu4(unsigned int a, unsigned int b); +# 2280 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmins4(unsigned int a, unsigned int b); +# 2291 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vminu4(unsigned int a, unsigned int b); +# 2302 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vseteq4(unsigned int a, unsigned int b); +# 2313 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetles4(unsigned int a, unsigned int b); +# 2324 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetleu4(unsigned int a, unsigned int b); +# 2335 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetlts4(unsigned int a, unsigned int b); +# 2346 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetltu4(unsigned int a, unsigned int b); +# 2357 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetges4(unsigned int a, unsigned int b); +# 2368 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgeu4(unsigned int a, unsigned int b); +# 2379 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgts4(unsigned int a, unsigned int b); +# 2390 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgtu4(unsigned int a, unsigned int b); +# 2401 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetne4(unsigned int a, unsigned int b); +# 2412 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsadu4(unsigned int a, unsigned int b); +# 2423 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsub4(unsigned int a, unsigned int b); +# 2434 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubss4(unsigned int a, unsigned int b); +# 2445 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubus4(unsigned int a, unsigned int b); +# 2455 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vneg4(unsigned int a); +# 2465 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vnegss4(unsigned int a); +# 2476 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffs4(unsigned int a, unsigned int b); +# 2487 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsads4(unsigned int a, unsigned int b); +# 2497 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax_s32_relu(const int a, const int b); +# 2509 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax_s16x2_relu(const unsigned int a, const unsigned int b); +# 2518 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin_s32_relu(const int a, const int b); +# 2530 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin_s16x2_relu(const unsigned int a, const unsigned int b); +# 2539 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax3_s32(const int a, const int b, const int c); +# 2551 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_s16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2560 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_u32(const unsigned int a, const unsigned int b, const unsigned int c); +# 2572 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_u16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2581 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin3_s32(const int a, const int b, const int c); +# 2593 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_s16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2602 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_u32(const unsigned int a, const unsigned int b, const unsigned int c); +# 2614 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_u16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2623 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax3_s32_relu(const int a, const int b, const int c); +# 2635 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c); +# 2644 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin3_s32_relu(const int a, const int b, const int c); +# 2656 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c); +# 2665 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmax_s32(const int a, const int b, const int c); +# 2677 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_s16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2686 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_u32(const unsigned int a, const unsigned int b, const unsigned int c); +# 2698 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_u16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2707 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmin_s32(const int a, const int b, const int c); +# 2719 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_s16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2728 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_u32(const unsigned int a, const unsigned int b, const unsigned int c); +# 2740 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_u16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2750 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmax_s32_relu(const int a, const int b, const int c); +# 2762 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c); +# 2772 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmin_s32_relu(const int a, const int b, const int c); +# 2784 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c); +# 2793 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vibmax_s32(const int a, const int b, bool* const pred); +# 2802 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_u32(const unsigned int a, const unsigned int b, bool* const pred); +# 2811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vibmin_s32(const int a, const int b, bool* const pred); +# 2820 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_u32(const unsigned int a, const unsigned int b, bool* const pred); +# 2834 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_s16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo); +# 2848 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo); +# 2862 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_s16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo); +# 2876 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo); + + + + + + +} +# 2899 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" 1 +# 81 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 82 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" 2 +# 116 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +static __attribute__((host)) __attribute__((device)) short __internal_cast_u2s(unsigned short x) +{ + short res; + + (void)memcpy(&res, &x, sizeof(x)); + + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax_s32_relu(const int a, const int b){ + + + + + + + int ans = max(a, b); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax_s16x2_relu(const unsigned int a, const unsigned int b){ + unsigned int res; + + + + res = __vmaxs2(__vmaxs2(a, b), 0U); +# 178 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin_s32_relu(const int a, const int b){ + + + + + + + int ans = min(a, b); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin_s16x2_relu(const unsigned int a, const unsigned int b){ + unsigned int res; + + + + res = __vmaxs2(__vmins2(a, b), 0U); +# 232 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax3_s32(const int a, const int b, const int c){ +# 245 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return max(max(a, b), c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_s16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 262 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned int ansU_lo = (unsigned int)max(max(aS_lo, bS_lo), cS_lo); + unsigned int ansU_hi = (unsigned int)max(max(aS_hi, bS_hi), cS_hi); + + + res = (ansU_lo & 0x0000FFFFU) | (ansU_hi << 16); + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_u32(const unsigned int a, const unsigned int b, const unsigned int c){ +# 301 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return max(max(a, b), c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_u16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; + + + + + + + res = __vmaxu2(__vmaxu2(a, b), c); +# 334 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin3_s32(const int a, const int b, const int c){ +# 347 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return min(min(a, b), c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_s16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 363 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned int ansU_lo = (unsigned int)min(min(aS_lo, bS_lo), cS_lo); + unsigned int ansU_hi = (unsigned int)min(min(aS_hi, bS_hi), cS_hi); + + + res = (ansU_lo & 0x0000FFFFU) | (ansU_hi << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_u32(const unsigned int a, const unsigned int b, const unsigned int c){ +# 403 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return min(min(a, b), c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_u16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; + + + + + + + res = __vminu2(__vminu2(a, b), c); +# 436 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax3_s32_relu(const int a, const int b, const int c){ +# 449 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = max(max(a, b), c); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 467 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned ansU_lo = (unsigned)max(0, max(max(aS_lo, bS_lo), cS_lo)); + unsigned ansU_hi = (unsigned)max(0, max(max(aS_hi, bS_hi), cS_hi)); + + + res = ansU_lo | (ansU_hi << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin3_s32_relu(const int a, const int b, const int c){ +# 507 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = min(min(a, b), c); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned res; +# 525 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned ansU_lo = (unsigned)max(0, min(min(aS_lo, bS_lo), cS_lo)); + unsigned ansU_hi = (unsigned)max(0, min(min(aS_hi, bS_hi), cS_hi)); + + + res = ansU_lo | (ansU_hi << 16); + + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmax_s32(const int a, const int b, const int c){ +# 566 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return max(a + b, c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_s16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; + + + + + + + res = __vmaxs2(__vadd2(a, b), c); +# 609 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_u32(const unsigned int a, const unsigned int b, const unsigned int c){ +# 622 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return max(a + b, c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_u16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; + + + + + + + res = __vmaxu2(__vadd2(a, b), c); +# 655 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmin_s32(const int a, const int b, const int c){ +# 668 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return min(a + b, c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_s16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; + + + + + + + res = __vmins2(__vadd2(a, b), c); +# 711 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_u32(const unsigned int a, const unsigned int b, const unsigned int c){ +# 724 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return min(a + b, c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_u16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; + + + + + + + res = __vminu2(__vadd2(a, b), c); +# 757 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmax_s32_relu(const int a, const int b, const int c){ +# 770 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = max(a + b, c); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; + + + + + + + res = __vimax_s16x2_relu(__vadd2(a, b), c); +# 815 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmin_s32_relu(const int a, const int b, const int c){ +# 828 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = min(a + b, c); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; + + + + + + + res = __vimin_s16x2_relu(__vadd2(a, b), c); +# 873 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return res; +} + + + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vibmax_s32(const int a, const int b, bool* const pred){ +# 892 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = max(a, b); + + *pred = (a >= b); + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_u32(const unsigned int a, const unsigned int b, bool* const pred){ +# 913 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned int ans = max(a, b); + + *pred = (a >= b); + return ans; + +} + + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vibmin_s32(const int a, const int b, bool* const pred){ +# 935 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = min(a, b); + + *pred = (a <= b); + return ans; + +} + + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_u32(const unsigned int a, const unsigned int b, bool* const pred){ +# 957 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned int ans = min(a, b); + + *pred = (a <= b); + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_s16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 986 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + + unsigned int ansU_lo = (unsigned int)max(aS_lo, bS_lo); + unsigned int ansU_hi = (unsigned int)max(aS_hi, bS_hi); + + *pred_hi = (aS_hi >= bS_hi); + *pred_lo = (aS_lo >= bS_lo); + + + unsigned int ans = (ansU_lo & 0x0000FFFFU) | (ansU_hi << 16); + + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 1035 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + unsigned short ansU_lo = (unsigned short)max(aU_lo, bU_lo); + unsigned short ansU_hi = (unsigned short)max(aU_hi, bU_hi); + + *pred_hi = (aU_hi >= bU_hi); + *pred_lo = (aU_lo >= bU_lo); + + + unsigned int ans = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_s16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 1077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + + unsigned int ansU_lo = (unsigned int)min(aS_lo, bS_lo); + unsigned int ansU_hi = (unsigned int)min(aS_hi, bS_hi); + + *pred_hi = (aS_hi <= bS_hi); + *pred_lo = (aS_lo <= bS_lo); + + + unsigned int ans = (ansU_lo & 0x0000FFFFU) | (ansU_hi << 16); + + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 1126 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + unsigned short ansU_lo = (unsigned short)min(aU_lo, bU_lo); + unsigned short ansU_hi = (unsigned short)min(aU_hi, bU_hi); + + *pred_hi = (aU_hi <= bU_hi); + *pred_lo = (aU_lo <= bU_lo); + + + unsigned int ans = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + return ans; + +} +# 2900 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" 1 +# 89 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +static __inline__ __attribute__((device)) int atomicAdd(int *address, int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicAdd(unsigned int *address, unsigned int val) ; + +static __inline__ __attribute__((device)) int atomicSub(int *address, int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicSub(unsigned int *address, unsigned int val) ; + +static __inline__ __attribute__((device)) int atomicExch(int *address, int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicExch(unsigned int *address, unsigned int val) ; + +static __inline__ __attribute__((device)) float atomicExch(float *address, float val) ; + +static __inline__ __attribute__((device)) int atomicMin(int *address, int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicMin(unsigned int *address, unsigned int val) ; + +static __inline__ __attribute__((device)) int atomicMax(int *address, int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicMax(unsigned int *address, unsigned int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicInc(unsigned int *address, unsigned int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicDec(unsigned int *address, unsigned int val) ; + +static __inline__ __attribute__((device)) int atomicAnd(int *address, int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicAnd(unsigned int *address, unsigned int val) ; + +static __inline__ __attribute__((device)) int atomicOr(int *address, int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicOr(unsigned int *address, unsigned int val) ; + +static __inline__ __attribute__((device)) int atomicXor(int *address, int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicXor(unsigned int *address, unsigned int val) ; + +static __inline__ __attribute__((device)) int atomicCAS(int *address, int compare, int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicCAS(unsigned int *address, unsigned int compare, unsigned int val) ; +# 156 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) __attribute__((deprecated("__any""() is deprecated in favor of ""__any""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __any(int cond); +extern __attribute__((device)) __attribute__((device_builtin)) __attribute__((deprecated("__all""() is deprecated in favor of ""__all""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __all(int cond); +} +# 169 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +static __inline__ __attribute__((device)) unsigned long long int atomicAdd(unsigned long long int *address, unsigned long long int val) ; + +static __inline__ __attribute__((device)) unsigned long long int atomicExch(unsigned long long int *address, unsigned long long int val) ; + +static __inline__ __attribute__((device)) unsigned long long int atomicCAS(unsigned long long int *address, unsigned long long int compare, unsigned long long int val) ; + +static __inline__ __attribute__((device)) __attribute__((deprecated("__any""() is deprecated in favor of ""__any""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) bool any(bool cond) ; + +static __inline__ __attribute__((device)) __attribute__((deprecated("__all""() is deprecated in favor of ""__all""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) bool all(bool cond) ; +# 188 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.hpp" 1 +# 62 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.hpp" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicAdd(int *address, int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicAdd(unsigned int *address, unsigned int val); +extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicExch(int *address, int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicExch(unsigned int *address, unsigned int val); +extern __attribute__((device)) __attribute__((device_builtin)) float __fAtomicExch(float *address, float val); +extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicMin(int *address, int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicMin(unsigned int *address, unsigned int val); +extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicMax(int *address, int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicMax(unsigned int *address, unsigned int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicInc(unsigned int *address, unsigned int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicDec(unsigned int *address, unsigned int val); +extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicAnd(int *address, int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicAnd(unsigned int *address, unsigned int val); +extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicOr(int *address, int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicOr(unsigned int *address, unsigned int val); +extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicXor(int *address, int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicXor(unsigned int *address, unsigned int val); +extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicCAS(int *address, int compare, int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicCAS(unsigned int *address, unsigned int compare, unsigned int val); + + +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __ullAtomicAdd(unsigned long long int *address, unsigned long long int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __ullAtomicExch(unsigned long long int *address, unsigned long long int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __ullAtomicCAS(unsigned long long int *address, unsigned long long int compare, unsigned long long int val); +} +# 105 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.hpp" +static __inline__ __attribute__((device)) int atomicAdd(int *address, int val) +{ + return __iAtomicAdd(address, val); +} + +static __inline__ __attribute__((device)) unsigned int atomicAdd(unsigned int *address, unsigned int val) +{ + return __uAtomicAdd(address, val); +} + +static __inline__ __attribute__((device)) int atomicSub(int *address, int val) +{ + return __iAtomicAdd(address, (unsigned int)-(int)val); +} + +static __inline__ __attribute__((device)) unsigned int atomicSub(unsigned int *address, unsigned int val) +{ + return __uAtomicAdd(address, (unsigned int)-(int)val); +} + +static __inline__ __attribute__((device)) int atomicExch(int *address, int val) +{ + return __iAtomicExch(address, val); +} + +static __inline__ __attribute__((device)) unsigned int atomicExch(unsigned int *address, unsigned int val) +{ + return __uAtomicExch(address, val); +} + +static __inline__ __attribute__((device)) float atomicExch(float *address, float val) +{ + return __fAtomicExch(address, val); +} + +static __inline__ __attribute__((device)) int atomicMin(int *address, int val) +{ + return __iAtomicMin(address, val); +} + +static __inline__ __attribute__((device)) unsigned int atomicMin(unsigned int *address, unsigned int val) +{ + return __uAtomicMin(address, val); +} + +static __inline__ __attribute__((device)) int atomicMax(int *address, int val) +{ + return __iAtomicMax(address, val); +} + +static __inline__ __attribute__((device)) unsigned int atomicMax(unsigned int *address, unsigned int val) +{ + return __uAtomicMax(address, val); +} + +static __inline__ __attribute__((device)) unsigned int atomicInc(unsigned int *address, unsigned int val) +{ + return __uAtomicInc(address, val); +} + +static __inline__ __attribute__((device)) unsigned int atomicDec(unsigned int *address, unsigned int val) +{ + return __uAtomicDec(address, val); +} + +static __inline__ __attribute__((device)) int atomicAnd(int *address, int val) +{ + return __iAtomicAnd(address, val); +} + +static __inline__ __attribute__((device)) unsigned int atomicAnd(unsigned int *address, unsigned int val) +{ + return __uAtomicAnd(address, val); +} + +static __inline__ __attribute__((device)) int atomicOr(int *address, int val) +{ + return __iAtomicOr(address, val); +} + +static __inline__ __attribute__((device)) unsigned int atomicOr(unsigned int *address, unsigned int val) +{ + return __uAtomicOr(address, val); +} + +static __inline__ __attribute__((device)) int atomicXor(int *address, int val) +{ + return __iAtomicXor(address, val); +} + +static __inline__ __attribute__((device)) unsigned int atomicXor(unsigned int *address, unsigned int val) +{ + return __uAtomicXor(address, val); +} + +static __inline__ __attribute__((device)) int atomicCAS(int *address, int compare, int val) +{ + return __iAtomicCAS(address, compare, val); +} + +static __inline__ __attribute__((device)) unsigned int atomicCAS(unsigned int *address, unsigned int compare, unsigned int val) +{ + return __uAtomicCAS(address, compare, val); +} +# 224 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.hpp" +static __inline__ __attribute__((device)) unsigned long long int atomicAdd(unsigned long long int *address, unsigned long long int val) +{ + return __ullAtomicAdd(address, val); +} + +static __inline__ __attribute__((device)) unsigned long long int atomicExch(unsigned long long int *address, unsigned long long int val) +{ + return __ullAtomicExch(address, val); +} + +static __inline__ __attribute__((device)) unsigned long long int atomicCAS(unsigned long long int *address, unsigned long long int compare, unsigned long long int val) +{ + return __ullAtomicCAS(address, compare, val); +} + +static __inline__ __attribute__((device)) bool any(bool cond) +{ + return (bool)__any((int)cond); +} + +static __inline__ __attribute__((device)) bool all(bool cond) +{ + return (bool)__all((int)cond); +} +# 189 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" 2 +# 2903 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" 1 +# 83 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" 2 + + + + +extern "C" +{ +# 100 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double_as_longlong(double x); +# 109 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __longlong_as_double(long long int x); +# 266 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rn(double x, double y, double z); +# 423 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rz(double x, double y, double z); +# 580 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_ru(double x, double y, double z); +# 737 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rd(double x, double y, double z); +# 749 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rn(double x, double y); +# 761 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rz(double x, double y); +# 773 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_ru(double x, double y); +# 785 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rd(double x, double y); +# 797 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rn(double x, double y); +# 809 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rz(double x, double y); +# 821 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_ru(double x, double y); +# 833 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rd(double x, double y); +# 845 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rn(double x, double y); +# 857 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rz(double x, double y); +# 869 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_ru(double x, double y); +# 881 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rd(double x, double y); +# 890 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rn(double x); +# 899 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rz(double x); +# 908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_ru(double x); +# 917 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rd(double x); +# 926 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rn(double x); +# 935 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_ru(double x); +# 944 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rd(double x); +# 953 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rn(double x); +# 962 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_ru(double x); +# 971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rd(double x); +# 980 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rn(double x); +# 989 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_ru(double x); +# 998 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rd(double x); +# 1007 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rn(double x); +# 1016 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_ru(double x); +# 1025 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rd(double x); + + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) double __int2double_rn(int x); + + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) double __uint2double_rn(unsigned int x); +# 1050 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rn(long long int x); +# 1059 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rz(long long int x); +# 1068 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_ru(long long int x); +# 1077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rd(long long int x); +# 1086 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rn(unsigned long long int x); +# 1095 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rz(unsigned long long int x); +# 1104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_ru(unsigned long long int x); +# 1113 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rd(unsigned long long int x); +# 1122 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2hiint(double x); +# 1131 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2loint(double x); +# 1141 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __hiloint2double(int hi, int lo); +} + + + + + + + +static __inline__ __attribute__((device)) double fma(double a, double b, double c, enum cudaRoundMode mode); + + + +static __inline__ __attribute__((device)) double dmul(double a, double b, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double dadd(double a, double b, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double dsub(double a, double b, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) int double2int(double a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) unsigned int double2uint(double a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) long long int double2ll(double a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) unsigned long long int double2ull(double a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) double ll2double(long long int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double ull2double(unsigned long long int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double int2double(int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double uint2double(unsigned int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double float2double(float a, enum cudaRoundMode mode = cudaRoundNearest); + + + + + + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" 1 +# 83 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" 2 + + + + + + + +static __inline__ __attribute__((device)) double fma(double a, double b, double c, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __fma_rz(a, b, c) : + mode == cudaRoundPosInf ? __fma_ru(a, b, c) : + mode == cudaRoundMinInf ? __fma_rd(a, b, c) : + __fma_rn(a, b, c); +} + +static __inline__ __attribute__((device)) double dmul(double a, double b, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __dmul_rz(a, b) : + mode == cudaRoundPosInf ? __dmul_ru(a, b) : + mode == cudaRoundMinInf ? __dmul_rd(a, b) : + __dmul_rn(a, b); +} + +static __inline__ __attribute__((device)) double dadd(double a, double b, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __dadd_rz(a, b) : + mode == cudaRoundPosInf ? __dadd_ru(a, b) : + mode == cudaRoundMinInf ? __dadd_rd(a, b) : + __dadd_rn(a, b); +} + +static __inline__ __attribute__((device)) double dsub(double a, double b, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __dsub_rz(a, b) : + mode == cudaRoundPosInf ? __dsub_ru(a, b) : + mode == cudaRoundMinInf ? __dsub_rd(a, b) : + __dsub_rn(a, b); +} + +static __inline__ __attribute__((device)) int double2int(double a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __double2int_rn(a) : + mode == cudaRoundPosInf ? __double2int_ru(a) : + mode == cudaRoundMinInf ? __double2int_rd(a) : + __double2int_rz(a); +} + +static __inline__ __attribute__((device)) unsigned int double2uint(double a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __double2uint_rn(a) : + mode == cudaRoundPosInf ? __double2uint_ru(a) : + mode == cudaRoundMinInf ? __double2uint_rd(a) : + __double2uint_rz(a); +} + +static __inline__ __attribute__((device)) long long int double2ll(double a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __double2ll_rn(a) : + mode == cudaRoundPosInf ? __double2ll_ru(a) : + mode == cudaRoundMinInf ? __double2ll_rd(a) : + __double2ll_rz(a); +} + +static __inline__ __attribute__((device)) unsigned long long int double2ull(double a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __double2ull_rn(a) : + mode == cudaRoundPosInf ? __double2ull_ru(a) : + mode == cudaRoundMinInf ? __double2ull_rd(a) : + __double2ull_rz(a); +} + +static __inline__ __attribute__((device)) double ll2double(long long int a, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __ll2double_rz(a) : + mode == cudaRoundPosInf ? __ll2double_ru(a) : + mode == cudaRoundMinInf ? __ll2double_rd(a) : + __ll2double_rn(a); +} + +static __inline__ __attribute__((device)) double ull2double(unsigned long long int a, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __ull2double_rz(a) : + mode == cudaRoundPosInf ? __ull2double_ru(a) : + mode == cudaRoundMinInf ? __ull2double_rd(a) : + __ull2double_rn(a); +} + +static __inline__ __attribute__((device)) double int2double(int a, enum cudaRoundMode mode) +{ + return (double)a; +} + +static __inline__ __attribute__((device)) double uint2double(unsigned int a, enum cudaRoundMode mode) +{ + return (double)a; +} + +static __inline__ __attribute__((device)) double float2double(float a, enum cudaRoundMode mode) +{ + return (double)a; +} +# 1185 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" 2 +# 2904 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_atomic_functions.h" 1 +# 88 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_atomic_functions.h" +static __inline__ __attribute__((device)) float atomicAdd(float *address, float val) ; + + + + + + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_atomic_functions.hpp" 1 +# 54 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_atomic_functions.hpp" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) float __fAtomicAdd(float *address, float val); +} +# 82 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_atomic_functions.hpp" +static __inline__ __attribute__((device)) float atomicAdd(float *address, float val) +{ + return __fAtomicAdd(address, val); +} +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_atomic_functions.h" 2 +# 2905 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" 1 +# 89 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +static __inline__ __attribute__((device)) long long atomicMin(long long *address, long long val) ; + +static __inline__ __attribute__((device)) long long atomicMax(long long *address, long long val) ; + +static __inline__ __attribute__((device)) long long atomicAnd(long long *address, long long val) ; + +static __inline__ __attribute__((device)) long long atomicOr(long long *address, long long val) ; + +static __inline__ __attribute__((device)) long long atomicXor(long long *address, long long val) ; + +static __inline__ __attribute__((device)) unsigned long long atomicMin(unsigned long long *address, unsigned long long val) ; + +static __inline__ __attribute__((device)) unsigned long long atomicMax(unsigned long long *address, unsigned long long val) ; + +static __inline__ __attribute__((device)) unsigned long long atomicAnd(unsigned long long *address, unsigned long long val) ; + +static __inline__ __attribute__((device)) unsigned long long atomicOr(unsigned long long *address, unsigned long long val) ; + +static __inline__ __attribute__((device)) unsigned long long atomicXor(unsigned long long *address, unsigned long long val) ; +# 117 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.hpp" 1 +# 54 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.hpp" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) long long __illAtomicMin(long long *address, long long val); +extern __attribute__((device)) __attribute__((device_builtin)) long long __illAtomicMax(long long *address, long long val); +extern __attribute__((device)) __attribute__((device_builtin)) long long __llAtomicAnd(long long *address, long long val); +extern __attribute__((device)) __attribute__((device_builtin)) long long __llAtomicOr(long long *address, long long val); +extern __attribute__((device)) __attribute__((device_builtin)) long long __llAtomicXor(long long *address, long long val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long __ullAtomicMin(unsigned long long *address, unsigned long long val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long __ullAtomicMax(unsigned long long *address, unsigned long long val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long __ullAtomicAnd(unsigned long long *address, unsigned long long val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long __ullAtomicOr (unsigned long long *address, unsigned long long val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long __ullAtomicXor(unsigned long long *address, unsigned long long val); +} +# 94 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.hpp" +static __inline__ __attribute__((device)) long long atomicMin(long long *address, long long val) +{ + return __illAtomicMin(address, val); +} + +static __inline__ __attribute__((device)) long long atomicMax(long long *address, long long val) +{ + return __illAtomicMax(address, val); +} + +static __inline__ __attribute__((device)) long long atomicAnd(long long *address, long long val) +{ + return __llAtomicAnd(address, val); +} + +static __inline__ __attribute__((device)) long long atomicOr(long long *address, long long val) +{ + return __llAtomicOr(address, val); +} + +static __inline__ __attribute__((device)) long long atomicXor(long long *address, long long val) +{ + return __llAtomicXor(address, val); +} + +static __inline__ __attribute__((device)) unsigned long long atomicMin(unsigned long long *address, unsigned long long val) +{ + return __ullAtomicMin(address, val); +} + +static __inline__ __attribute__((device)) unsigned long long atomicMax(unsigned long long *address, unsigned long long val) +{ + return __ullAtomicMax(address, val); +} + +static __inline__ __attribute__((device)) unsigned long long atomicAnd(unsigned long long *address, unsigned long long val) +{ + return __ullAtomicAnd(address, val); +} + +static __inline__ __attribute__((device)) unsigned long long atomicOr(unsigned long long *address, unsigned long long val) +{ + return __ullAtomicOr(address, val); +} + +static __inline__ __attribute__((device)) unsigned long long atomicXor(unsigned long long *address, unsigned long long val) +{ + return __ullAtomicXor(address, val); +} +# 118 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" 2 +# 2906 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_35_atomic_functions.h" 1 +# 56 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_35_atomic_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" 1 +# 57 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_35_atomic_functions.h" 2 +# 2907 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" 1 +# 325 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.hpp" 1 +# 61 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.hpp" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) double __dAtomicAdd(double *address, double val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicAdd_block(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicAdd_system(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicAdd_block(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicAdd_system(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicAdd_block(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicAdd_system(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +float __fAtomicAdd_block(float *address, float val); + +extern __attribute__((device)) __attribute__((device_builtin)) +float __fAtomicAdd_system(float *address, float val); + +extern __attribute__((device)) __attribute__((device_builtin)) +double __dAtomicAdd_block(double *address, double val); + +extern __attribute__((device)) __attribute__((device_builtin)) +double __dAtomicAdd_system(double *address, double val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicExch_block(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicExch_system(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicExch_block(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicExch_system(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicExch_block(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicExch_system(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +float __fAtomicExch_block(float *address, float val); + +extern __attribute__((device)) __attribute__((device_builtin)) +float __fAtomicExch_system(float *address, float val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicMin_block(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicMin_system(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +long long __illAtomicMin_block(long long *address, long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +long long __illAtomicMin_system(long long *address, long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicMin_block(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicMin_system(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicMin_block(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicMin_system(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicMax_block(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicMax_system(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +long long __illAtomicMax_block(long long *address, long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +long long __illAtomicMax_system(long long *address, long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicMax_block(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicMax_system(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicMax_block(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicMax_system(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicInc_block(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicInc_system(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicDec_block(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicDec_system(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicCAS_block(int *address, int compare, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicCAS_system(int *address, int compare, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicCAS_block(unsigned int *address, unsigned int compare, + unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicCAS_system(unsigned int *address, unsigned int compare, + unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicCAS_block(unsigned long long int *address, + unsigned long long int compare, + unsigned long long int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicCAS_system(unsigned long long int *address, + unsigned long long int compare, + unsigned long long int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicAnd_block(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicAnd_system(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +long long __llAtomicAnd_block(long long *address, long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +long long __llAtomicAnd_system(long long *address, long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicAnd_block(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicAnd_system(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicAnd_block(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicAnd_system(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicOr_block(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicOr_system(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +long long __llAtomicOr_block(long long *address, long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +long long __llAtomicOr_system(long long *address, long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicOr_block(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicOr_system(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicOr_block(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicOr_system(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicXor_block(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicXor_system(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +long long __llAtomicXor_block(long long *address, long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +long long __llAtomicXor_system(long long *address, long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicXor_block(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicXor_system(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicXor_block(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicXor_system(unsigned long long *address, unsigned long long val); +} +# 326 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" 2 +# 2908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" 1 +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) void __threadfence_system(void); +# 119 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rn(double x, double y); +# 139 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rz(double x, double y); +# 159 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_ru(double x, double y); +# 179 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rd(double x, double y); +# 194 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rn(double x); +# 209 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rz(double x); +# 224 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_ru(double x); +# 239 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rd(double x); +# 254 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rn(double x); +# 269 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rz(double x); +# 284 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_ru(double x); +# 299 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rd(double x); +extern __attribute__((device)) __attribute__((device_builtin)) __attribute__((deprecated("__ballot""() is deprecated in favor of ""__ballot""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __ballot(int); +extern __attribute__((device)) __attribute__((device_builtin)) int __syncthreads_count(int); +extern __attribute__((device)) __attribute__((device_builtin)) int __syncthreads_and(int); +extern __attribute__((device)) __attribute__((device_builtin)) int __syncthreads_or(int); +extern __attribute__((device)) __attribute__((device_builtin)) long long int clock64(void); +# 314 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rn(float x, float y, float z); +# 323 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rd(float x, float y, float z); +# 332 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_ru(float x, float y, float z); +# 341 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rz(float x, float y, float z); +# 354 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double_as_longlong(double x); +# 363 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __longlong_as_double(long long int x); +# 407 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rn(double x, double y, double z); +# 451 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rz(double x, double y, double z); +# 495 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_ru(double x, double y, double z); +# 539 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rd(double x, double y, double z); +# 558 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rn(double x, double y); +# 577 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rz(double x, double y); +# 596 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_ru(double x, double y); +# 615 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rd(double x, double y); +# 634 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rn(double x, double y); +# 653 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rz(double x, double y); +# 672 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_ru(double x, double y); +# 691 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rd(double x, double y); +# 709 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rn(double x, double y); +# 727 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rz(double x, double y); +# 745 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_ru(double x, double y); +# 763 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rd(double x, double y); +# 772 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rn(double x); +# 781 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rz(double x); +# 790 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_ru(double x); +# 799 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rd(double x); +# 809 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rn(double x); +# 819 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_ru(double x); +# 829 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rd(double x); +# 839 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rn(double x); +# 849 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_ru(double x); +# 859 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rd(double x); +# 869 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rn(double x); +# 879 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_ru(double x); +# 889 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rd(double x); +# 899 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rn(double x); +# 909 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_ru(double x); +# 919 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rd(double x); + + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) double __int2double_rn(int x); + + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) double __uint2double_rn(unsigned int x); +# 944 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rn(long long int x); +# 953 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rz(long long int x); +# 962 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_ru(long long int x); +# 971 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rd(long long int x); +# 980 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rn(unsigned long long int x); +# 989 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rz(unsigned long long int x); +# 998 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_ru(unsigned long long int x); +# 1007 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rd(unsigned long long int x); +# 1016 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2hiint(double x); +# 1025 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2loint(double x); +# 1035 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __hiloint2double(int hi, int lo); + + +} + + + + + + +static __inline__ __attribute__((device)) __attribute__((deprecated("__ballot""() is deprecated in favor of ""__ballot""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int ballot(bool pred) ; + +static __inline__ __attribute__((device)) int syncthreads_count(bool pred) ; + +static __inline__ __attribute__((device)) bool syncthreads_and(bool pred) ; + +static __inline__ __attribute__((device)) bool syncthreads_or(bool pred) ; + + + + +static __inline__ __attribute__((device)) unsigned int __isGlobal(const void *ptr) ; +static __inline__ __attribute__((device)) unsigned int __isShared(const void *ptr) ; +static __inline__ __attribute__((device)) unsigned int __isConstant(const void *ptr) ; +static __inline__ __attribute__((device)) unsigned int __isLocal(const void *ptr) ; + + + +static __inline__ __attribute__((device)) size_t __cvta_generic_to_global(const void *ptr) ; +static __inline__ __attribute__((device)) size_t __cvta_generic_to_shared(const void *ptr) ; +static __inline__ __attribute__((device)) size_t __cvta_generic_to_constant(const void *ptr) ; +static __inline__ __attribute__((device)) size_t __cvta_generic_to_local(const void *ptr) ; + + + + +static __inline__ __attribute__((device)) void * __cvta_global_to_generic(size_t rawbits) ; +static __inline__ __attribute__((device)) void * __cvta_shared_to_generic(size_t rawbits) ; +static __inline__ __attribute__((device)) void * __cvta_constant_to_generic(size_t rawbits) ; +static __inline__ __attribute__((device)) void * __cvta_local_to_generic(size_t rawbits) ; +# 1140 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +static __inline__ __attribute__((host)) __attribute__((device)) unsigned short __nv_bswap16(unsigned short in); +static __inline__ __attribute__((host)) __attribute__((device)) unsigned int __nv_bswap32(unsigned int in); +static __inline__ __attribute__((host)) __attribute__((device)) unsigned long long __nv_bswap64(unsigned long long in); +# 1152 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.hpp" 1 +# 77 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.hpp" +static __inline__ __attribute__((device)) unsigned int ballot(bool pred) +{ + return __ballot((int)pred); +} + +static __inline__ __attribute__((device)) int syncthreads_count(bool pred) +{ + return __syncthreads_count((int)pred); +} + +static __inline__ __attribute__((device)) bool syncthreads_and(bool pred) +{ + return (bool)__syncthreads_and((int)pred); +} + +static __inline__ __attribute__((device)) bool syncthreads_or(bool pred) +{ + return (bool)__syncthreads_or((int)pred); +} + + +extern "C" { + __attribute__((device)) unsigned __nv_isGlobal_impl(const void *); + __attribute__((device)) unsigned __nv_isShared_impl(const void *); + __attribute__((device)) unsigned __nv_isConstant_impl(const void *); + __attribute__((device)) unsigned __nv_isLocal_impl(const void *); + __attribute__((device)) unsigned __nv_isGridConstant_impl(const void *); +} + +static __inline__ __attribute__((device)) unsigned int __isGlobal(const void *ptr) +{ + return __nv_isGlobal_impl(ptr); +} + +static __inline__ __attribute__((device)) unsigned int __isShared(const void *ptr) +{ + return __nv_isShared_impl(ptr); +} + +static __inline__ __attribute__((device)) unsigned int __isConstant(const void *ptr) +{ + return __nv_isConstant_impl(ptr); +} + +static __inline__ __attribute__((device)) unsigned int __isLocal(const void *ptr) +{ + return __nv_isLocal_impl(ptr); +} +# 133 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.hpp" +extern "C" { + __attribute__((device)) size_t __nv_cvta_generic_to_global_impl(const void *); + __attribute__((device)) size_t __nv_cvta_generic_to_shared_impl(const void *); + __attribute__((device)) size_t __nv_cvta_generic_to_constant_impl(const void *); + __attribute__((device)) size_t __nv_cvta_generic_to_local_impl(const void *); + __attribute__((device)) void * __nv_cvta_global_to_generic_impl(size_t); + __attribute__((device)) void * __nv_cvta_shared_to_generic_impl(size_t); + __attribute__((device)) void * __nv_cvta_constant_to_generic_impl(size_t); + __attribute__((device)) void * __nv_cvta_local_to_generic_impl(size_t); +} + +static __inline__ __attribute__((device)) size_t __cvta_generic_to_global(const void *p) +{ + return __nv_cvta_generic_to_global_impl(p); +} + +static __inline__ __attribute__((device)) size_t __cvta_generic_to_shared(const void *p) +{ + return __nv_cvta_generic_to_shared_impl(p); +} + +static __inline__ __attribute__((device)) size_t __cvta_generic_to_constant(const void *p) +{ + return __nv_cvta_generic_to_constant_impl(p); +} + +static __inline__ __attribute__((device)) size_t __cvta_generic_to_local(const void *p) +{ + return __nv_cvta_generic_to_local_impl(p); +} + +static __inline__ __attribute__((device)) void * __cvta_global_to_generic(size_t rawbits) +{ + return __nv_cvta_global_to_generic_impl(rawbits); +} + +static __inline__ __attribute__((device)) void * __cvta_shared_to_generic(size_t rawbits) +{ + return __nv_cvta_shared_to_generic_impl(rawbits); +} + +static __inline__ __attribute__((device)) void * __cvta_constant_to_generic(size_t rawbits) +{ + return __nv_cvta_constant_to_generic_impl(rawbits); +} + +static __inline__ __attribute__((device)) void * __cvta_local_to_generic(size_t rawbits) +{ + return __nv_cvta_local_to_generic_impl(rawbits); +} +# 217 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.hpp" +extern "C" { + __attribute__((device)) unsigned short __nv_bswap16_impl(unsigned short); + __attribute__((device)) unsigned int __nv_bswap32_impl(unsigned int); + __attribute__((device)) unsigned long long __nv_bswap64_impl(unsigned long long); +} + +static __inline__ __attribute__((host)) __attribute__((device)) unsigned short __nv_bswap16(unsigned short in) { + return __nv_bswap16_impl(in); +} + +static __inline__ __attribute__((host)) __attribute__((device)) unsigned int __nv_bswap32(unsigned int in) { + return __nv_bswap32_impl(in); +} + +static __inline__ __attribute__((host)) __attribute__((device)) unsigned long long __nv_bswap64(unsigned long long in) { + return __nv_bswap64_impl(in); +} +# 1153 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" 2 +# 2909 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" 1 +# 123 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +static __attribute__((device)) __inline__ unsigned __fns(unsigned mask, unsigned base, int offset) ; +static __attribute__((device)) __inline__ void __barrier_sync(unsigned id) ; +static __attribute__((device)) __inline__ void __barrier_sync_count(unsigned id, unsigned cnt) ; +static __attribute__((device)) __inline__ void __syncwarp(unsigned mask=0xFFFFFFFF) ; +static __attribute__((device)) __inline__ int __all_sync(unsigned mask, int pred) ; +static __attribute__((device)) __inline__ int __any_sync(unsigned mask, int pred) ; +static __attribute__((device)) __inline__ int __uni_sync(unsigned mask, int pred) ; +static __attribute__((device)) __inline__ unsigned __ballot_sync(unsigned mask, int pred) ; +static __attribute__((device)) __inline__ unsigned __activemask() ; +# 140 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __shfl(int var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __shfl(unsigned int var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __shfl_up(int var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __shfl_up(unsigned int var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __shfl_down(int var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __shfl_down(unsigned int var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __shfl_xor(int var, int laneMask, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __shfl_xor(unsigned int var, int laneMask, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) float __shfl(float var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) float __shfl_up(float var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) float __shfl_down(float var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) float __shfl_xor(float var, int laneMask, int width=32) ; + + +static __attribute__((device)) __inline__ int __shfl_sync(unsigned mask, int var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ unsigned int __shfl_sync(unsigned mask, unsigned int var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ int __shfl_up_sync(unsigned mask, int var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ unsigned int __shfl_up_sync(unsigned mask, unsigned int var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ int __shfl_down_sync(unsigned mask, int var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ unsigned int __shfl_down_sync(unsigned mask, unsigned int var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ int __shfl_xor_sync(unsigned mask, int var, int laneMask, int width=32) ; +static __attribute__((device)) __inline__ unsigned int __shfl_xor_sync(unsigned mask, unsigned int var, int laneMask, int width=32) ; +static __attribute__((device)) __inline__ float __shfl_sync(unsigned mask, float var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ float __shfl_up_sync(unsigned mask, float var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ float __shfl_down_sync(unsigned mask, float var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ float __shfl_xor_sync(unsigned mask, float var, int laneMask, int width=32) ; + + + +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long long __shfl(unsigned long long var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long long __shfl(long long var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long long __shfl_up(long long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long long __shfl_up(unsigned long long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long long __shfl_down(long long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long long __shfl_down(unsigned long long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long long __shfl_xor(long long var, int laneMask, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long long __shfl_xor(unsigned long long var, int laneMask, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) double __shfl(double var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) double __shfl_up(double var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) double __shfl_down(double var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) double __shfl_xor(double var, int laneMask, int width=32) ; + + +static __attribute__((device)) __inline__ long long __shfl_sync(unsigned mask, long long var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ unsigned long long __shfl_sync(unsigned mask, unsigned long long var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ long long __shfl_up_sync(unsigned mask, long long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ unsigned long long __shfl_up_sync(unsigned mask, unsigned long long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ long long __shfl_down_sync(unsigned mask, long long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ unsigned long long __shfl_down_sync(unsigned mask, unsigned long long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ long long __shfl_xor_sync(unsigned mask, long long var, int laneMask, int width=32) ; +static __attribute__((device)) __inline__ unsigned long long __shfl_xor_sync(unsigned mask, unsigned long long var, int laneMask, int width=32) ; +static __attribute__((device)) __inline__ double __shfl_sync(unsigned mask, double var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ double __shfl_up_sync(unsigned mask, double var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ double __shfl_down_sync(unsigned mask, double var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ double __shfl_xor_sync(unsigned mask, double var, int laneMask, int width=32) ; + + + +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long __shfl(long var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long __shfl(unsigned long var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long __shfl_up(long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long __shfl_up(unsigned long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long __shfl_down(long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long __shfl_down(unsigned long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long __shfl_xor(long var, int laneMask, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long __shfl_xor(unsigned long var, int laneMask, int width=32) ; + + +static __attribute__((device)) __inline__ long __shfl_sync(unsigned mask, long var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ unsigned long __shfl_sync(unsigned mask, unsigned long var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ long __shfl_up_sync(unsigned mask, long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ unsigned long __shfl_up_sync(unsigned mask, unsigned long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ long __shfl_down_sync(unsigned mask, long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ unsigned long __shfl_down_sync(unsigned mask, unsigned long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ long __shfl_xor_sync(unsigned mask, long var, int laneMask, int width=32) ; +static __attribute__((device)) __inline__ unsigned long __shfl_xor_sync(unsigned mask, unsigned long var, int laneMask, int width=32) ; +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.hpp" 1 +# 73 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.hpp" +extern "C" +{ +} +# 89 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.hpp" +static __attribute__((device)) __inline__ +unsigned __fns(unsigned mask, unsigned base, int offset) { + extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __nvvm_fns(unsigned int mask, unsigned int base, int offset); + return __nvvm_fns(mask, base, offset); +} + +static __attribute__((device)) __inline__ +void __barrier_sync(unsigned id) { + extern __attribute__((device)) __attribute__((device_builtin)) void __nvvm_barrier_sync(unsigned id); + return __nvvm_barrier_sync(id); +} + +static __attribute__((device)) __inline__ +void __barrier_sync_count(unsigned id, unsigned cnt) { + extern __attribute__((device)) __attribute__((device_builtin)) void __nvvm_barrier_sync_cnt(unsigned id, unsigned cnt); + return __nvvm_barrier_sync_cnt(id, cnt); +} + +static __attribute__((device)) __inline__ +void __syncwarp(unsigned mask) { + extern __attribute__((device)) __attribute__((device_builtin)) void __nvvm_bar_warp_sync(unsigned mask); + return __nvvm_bar_warp_sync(mask); +} + +static __attribute__((device)) __inline__ +int __all_sync(unsigned mask, int pred) { + extern __attribute__((device)) __attribute__((device_builtin)) int __nvvm_vote_all_sync(unsigned int mask, int pred); + return __nvvm_vote_all_sync(mask, pred); +} + +static __attribute__((device)) __inline__ +int __any_sync(unsigned mask, int pred) { + extern __attribute__((device)) __attribute__((device_builtin)) int __nvvm_vote_any_sync(unsigned int mask, int pred); + return __nvvm_vote_any_sync(mask, pred); +} + +static __attribute__((device)) __inline__ +int __uni_sync(unsigned mask, int pred) { + extern __attribute__((device)) __attribute__((device_builtin)) int __nvvm_vote_uni_sync(unsigned int mask, int pred); + return __nvvm_vote_uni_sync(mask, pred); +} + +static __attribute__((device)) __inline__ +unsigned __ballot_sync(unsigned mask, int pred) { + extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __nvvm_vote_ballot_sync(unsigned int mask, int pred); + return __nvvm_vote_ballot_sync(mask, pred); +} + +static __attribute__((device)) __inline__ +unsigned __activemask() { + unsigned ret; + asm volatile ("activemask.b32 %0;" : "=r"(ret)); + return ret; +} + + + + +static __attribute__((device)) __inline__ int __shfl(int var, int srcLane, int width) { + int ret; + int c = ((32 -width) << 8) | 0x1f; + asm volatile ("shfl.idx.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(var), "r"(srcLane), "r"(c)); + return ret; +} + +static __attribute__((device)) __inline__ unsigned int __shfl(unsigned int var, int srcLane, int width) { + return (unsigned int) __shfl((int)var, srcLane, width); +} + +static __attribute__((device)) __inline__ int __shfl_up(int var, unsigned int delta, int width) { + int ret; + int c = (32 -width) << 8; + asm volatile ("shfl.up.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(var), "r"(delta), "r"(c)); + return ret; +} + +static __attribute__((device)) __inline__ unsigned int __shfl_up(unsigned int var, unsigned int delta, int width) { + return (unsigned int) __shfl_up((int)var, delta, width); +} + +static __attribute__((device)) __inline__ int __shfl_down(int var, unsigned int delta, int width) { + int ret; + int c = ((32 -width) << 8) | 0x1f; + asm volatile ("shfl.down.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(var), "r"(delta), "r"(c)); + return ret; +} + +static __attribute__((device)) __inline__ unsigned int __shfl_down(unsigned int var, unsigned int delta, int width) { + return (unsigned int) __shfl_down((int)var, delta, width); +} + +static __attribute__((device)) __inline__ int __shfl_xor(int var, int laneMask, int width) { + int ret; + int c = ((32 -width) << 8) | 0x1f; + asm volatile ("shfl.bfly.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(var), "r"(laneMask), "r"(c)); + return ret; +} + +static __attribute__((device)) __inline__ unsigned int __shfl_xor(unsigned int var, int laneMask, int width) { + return (unsigned int) __shfl_xor((int)var, laneMask, width); +} + +static __attribute__((device)) __inline__ float __shfl(float var, int srcLane, int width) { + float ret; + int c; + c = ((32 -width) << 8) | 0x1f; + asm volatile ("shfl.idx.b32 %0, %1, %2, %3;" : "=f"(ret) : "f"(var), "r"(srcLane), "r"(c)); + return ret; +} + +static __attribute__((device)) __inline__ float __shfl_up(float var, unsigned int delta, int width) { + float ret; + int c; + c = (32 -width) << 8; + asm volatile ("shfl.up.b32 %0, %1, %2, %3;" : "=f"(ret) : "f"(var), "r"(delta), "r"(c)); + return ret; +} + +static __attribute__((device)) __inline__ float __shfl_down(float var, unsigned int delta, int width) { + float ret; + int c; + c = ((32 -width) << 8) | 0x1f; + asm volatile ("shfl.down.b32 %0, %1, %2, %3;" : "=f"(ret) : "f"(var), "r"(delta), "r"(c)); + return ret; +} + +static __attribute__((device)) __inline__ float __shfl_xor(float var, int laneMask, int width) { + float ret; + int c; + c = ((32 -width) << 8) | 0x1f; + asm volatile ("shfl.bfly.b32 %0, %1, %2, %3;" : "=f"(ret) : "f"(var), "r"(laneMask), "r"(c)); + return ret; +} + + + +static __attribute__((device)) __inline__ long long __shfl(long long var, int srcLane, int width) { + int lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(var)); + hi = __shfl(hi, srcLane, width); + lo = __shfl(lo, srcLane, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=l"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ unsigned long long __shfl(unsigned long long var, int srcLane, int width) { + return (unsigned long long) __shfl((long long) var, srcLane, width); +} + +static __attribute__((device)) __inline__ long long __shfl_up(long long var, unsigned int delta, int width) { + int lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(var)); + hi = __shfl_up(hi, delta, width); + lo = __shfl_up(lo, delta, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=l"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ unsigned long long __shfl_up(unsigned long long var, unsigned int delta, int width) { + return (unsigned long long) __shfl_up((long long) var, delta, width); +} + +static __attribute__((device)) __inline__ long long __shfl_down(long long var, unsigned int delta, int width) { + int lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(var)); + hi = __shfl_down(hi, delta, width); + lo = __shfl_down(lo, delta, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=l"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ unsigned long long __shfl_down(unsigned long long var, unsigned int delta, int width) { + return (unsigned long long) __shfl_down((long long) var, delta, width); +} + +static __attribute__((device)) __inline__ long long __shfl_xor(long long var, int laneMask, int width) { + int lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(var)); + hi = __shfl_xor(hi, laneMask, width); + lo = __shfl_xor(lo, laneMask, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=l"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ unsigned long long __shfl_xor(unsigned long long var, int laneMask, int width) { + return (unsigned long long) __shfl_xor((long long) var, laneMask, width); +} + +static __attribute__((device)) __inline__ double __shfl(double var, int srcLane, int width) { + unsigned lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "d"(var)); + hi = __shfl(hi, srcLane, width); + lo = __shfl(lo, srcLane, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=d"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ double __shfl_up(double var, unsigned int delta, int width) { + unsigned lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "d"(var)); + hi = __shfl_up(hi, delta, width); + lo = __shfl_up(lo, delta, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=d"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ double __shfl_down(double var, unsigned int delta, int width) { + unsigned lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "d"(var)); + hi = __shfl_down(hi, delta, width); + lo = __shfl_down(lo, delta, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=d"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ double __shfl_xor(double var, int laneMask, int width) { + unsigned lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "d"(var)); + hi = __shfl_xor(hi, laneMask, width); + lo = __shfl_xor(lo, laneMask, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=d"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ long __shfl(long var, int srcLane, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl((long long) var, srcLane, width) : + __shfl((int) var, srcLane, width); +} + +static __attribute__((device)) __inline__ unsigned long __shfl(unsigned long var, int srcLane, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl((unsigned long long) var, srcLane, width) : + __shfl((unsigned int) var, srcLane, width); +} + +static __attribute__((device)) __inline__ long __shfl_up(long var, unsigned int delta, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_up((long long) var, delta, width) : + __shfl_up((int) var, delta, width); +} + +static __attribute__((device)) __inline__ unsigned long __shfl_up(unsigned long var, unsigned int delta, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_up((unsigned long long) var, delta, width) : + __shfl_up((unsigned int) var, delta, width); +} + +static __attribute__((device)) __inline__ long __shfl_down(long var, unsigned int delta, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_down((long long) var, delta, width) : + __shfl_down((int) var, delta, width); +} + +static __attribute__((device)) __inline__ unsigned long __shfl_down(unsigned long var, unsigned int delta, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_down((unsigned long long) var, delta, width) : + __shfl_down((unsigned int) var, delta, width); +} + +static __attribute__((device)) __inline__ long __shfl_xor(long var, int laneMask, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_xor((long long) var, laneMask, width) : + __shfl_xor((int) var, laneMask, width); +} + +static __attribute__((device)) __inline__ unsigned long __shfl_xor(unsigned long var, int laneMask, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_xor((unsigned long long) var, laneMask, width) : + __shfl_xor((unsigned int) var, laneMask, width); +} +# 369 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.hpp" +static __attribute__((device)) __inline__ int __shfl_sync(unsigned mask, int var, int srcLane, int width) { + extern __attribute__((device)) __attribute__((device_builtin)) unsigned __nvvm_shfl_idx_sync(unsigned mask, unsigned a, unsigned b, unsigned c); + int ret; + int c = ((32 -width) << 8) | 0x1f; + ret = __nvvm_shfl_idx_sync(mask, var, srcLane, c); + return ret; +} + +static __attribute__((device)) __inline__ unsigned int __shfl_sync(unsigned mask, unsigned int var, int srcLane, int width) { + return (unsigned int) __shfl_sync(mask, (int)var, srcLane, width); +} + +static __attribute__((device)) __inline__ int __shfl_up_sync(unsigned mask, int var, unsigned int delta, int width) { + extern __attribute__((device)) __attribute__((device_builtin)) unsigned __nvvm_shfl_up_sync(unsigned mask, unsigned a, unsigned b, unsigned c); + int ret; + int c = (32 -width) << 8; + ret = __nvvm_shfl_up_sync(mask, var, delta, c); + return ret; +} + +static __attribute__((device)) __inline__ unsigned int __shfl_up_sync(unsigned mask, unsigned int var, unsigned int delta, int width) { + return (unsigned int) __shfl_up_sync(mask, (int)var, delta, width); +} + +static __attribute__((device)) __inline__ int __shfl_down_sync(unsigned mask, int var, unsigned int delta, int width) { + extern __attribute__((device)) __attribute__((device_builtin)) unsigned __nvvm_shfl_down_sync(unsigned mask, unsigned a, unsigned b, unsigned c); + int ret; + int c = ((32 -width) << 8) | 0x1f; + ret = __nvvm_shfl_down_sync(mask, var, delta, c); + return ret; +} + +static __attribute__((device)) __inline__ unsigned int __shfl_down_sync(unsigned mask, unsigned int var, unsigned int delta, int width) { + return (unsigned int) __shfl_down_sync(mask, (int)var, delta, width); +} + +static __attribute__((device)) __inline__ int __shfl_xor_sync(unsigned mask, int var, int laneMask, int width) { + extern __attribute__((device)) __attribute__((device_builtin)) unsigned __nvvm_shfl_bfly_sync(unsigned mask, unsigned a, unsigned b, unsigned c); + int ret; + int c = ((32 -width) << 8) | 0x1f; + ret = __nvvm_shfl_bfly_sync(mask, var, laneMask, c); + return ret; +} + +static __attribute__((device)) __inline__ unsigned int __shfl_xor_sync(unsigned mask, unsigned int var, int laneMask, int width) { + return (unsigned int) __shfl_xor_sync(mask, (int)var, laneMask, width); +} + +static __attribute__((device)) __inline__ float __shfl_sync(unsigned mask, float var, int srcLane, int width) { + extern __attribute__((device)) __attribute__((device_builtin)) unsigned __nvvm_shfl_idx_sync(unsigned mask, unsigned a, unsigned b, unsigned c); + int ret; + int c; + c = ((32 -width) << 8) | 0x1f; + ret = __nvvm_shfl_idx_sync(mask, __float_as_int(var), srcLane, c); + return __int_as_float(ret); +} + +static __attribute__((device)) __inline__ float __shfl_up_sync(unsigned mask, float var, unsigned int delta, int width) { + extern __attribute__((device)) __attribute__((device_builtin)) unsigned __nvvm_shfl_up_sync(unsigned mask, unsigned a, unsigned b, unsigned c); + int ret; + int c; + c = (32 -width) << 8; + ret = __nvvm_shfl_up_sync(mask, __float_as_int(var), delta, c); + return __int_as_float(ret); +} + +static __attribute__((device)) __inline__ float __shfl_down_sync(unsigned mask, float var, unsigned int delta, int width) { + extern __attribute__((device)) __attribute__((device_builtin)) unsigned __nvvm_shfl_down_sync(unsigned mask, unsigned a, unsigned b, unsigned c); + int ret; + int c; + c = ((32 -width) << 8) | 0x1f; + ret = __nvvm_shfl_down_sync(mask, __float_as_int(var), delta, c); + return __int_as_float(ret); +} + +static __attribute__((device)) __inline__ float __shfl_xor_sync(unsigned mask, float var, int laneMask, int width) { + extern __attribute__((device)) __attribute__((device_builtin)) unsigned __nvvm_shfl_bfly_sync(unsigned mask, unsigned a, unsigned b, unsigned c); + int ret; + int c; + c = ((32 -width) << 8) | 0x1f; + ret = __nvvm_shfl_bfly_sync(mask, __float_as_int(var), laneMask, c); + return __int_as_float(ret); +} + + +static __attribute__((device)) __inline__ long long __shfl_sync(unsigned mask, long long var, int srcLane, int width) { + int lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(var)); + hi = __shfl_sync(mask, hi, srcLane, width); + lo = __shfl_sync(mask, lo, srcLane, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=l"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ unsigned long long __shfl_sync(unsigned mask, unsigned long long var, int srcLane, int width) { + return (unsigned long long) __shfl_sync(mask, (long long) var, srcLane, width); +} + +static __attribute__((device)) __inline__ long long __shfl_up_sync(unsigned mask, long long var, unsigned int delta, int width) { + int lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(var)); + hi = __shfl_up_sync(mask, hi, delta, width); + lo = __shfl_up_sync(mask, lo, delta, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=l"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ unsigned long long __shfl_up_sync(unsigned mask, unsigned long long var, unsigned int delta, int width) { + return (unsigned long long) __shfl_up_sync(mask, (long long) var, delta, width); +} + +static __attribute__((device)) __inline__ long long __shfl_down_sync(unsigned mask, long long var, unsigned int delta, int width) { + int lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(var)); + hi = __shfl_down_sync(mask, hi, delta, width); + lo = __shfl_down_sync(mask, lo, delta, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=l"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ unsigned long long __shfl_down_sync(unsigned mask, unsigned long long var, unsigned int delta, int width) { + return (unsigned long long) __shfl_down_sync(mask, (long long) var, delta, width); +} + +static __attribute__((device)) __inline__ long long __shfl_xor_sync(unsigned mask, long long var, int laneMask, int width) { + int lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(var)); + hi = __shfl_xor_sync(mask, hi, laneMask, width); + lo = __shfl_xor_sync(mask, lo, laneMask, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=l"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ unsigned long long __shfl_xor_sync(unsigned mask, unsigned long long var, int laneMask, int width) { + return (unsigned long long) __shfl_xor_sync(mask, (long long) var, laneMask, width); +} + +static __attribute__((device)) __inline__ double __shfl_sync(unsigned mask, double var, int srcLane, int width) { + unsigned lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "d"(var)); + hi = __shfl_sync(mask, hi, srcLane, width); + lo = __shfl_sync(mask, lo, srcLane, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=d"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ double __shfl_up_sync(unsigned mask, double var, unsigned int delta, int width) { + unsigned lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "d"(var)); + hi = __shfl_up_sync(mask, hi, delta, width); + lo = __shfl_up_sync(mask, lo, delta, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=d"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ double __shfl_down_sync(unsigned mask, double var, unsigned int delta, int width) { + unsigned lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "d"(var)); + hi = __shfl_down_sync(mask, hi, delta, width); + lo = __shfl_down_sync(mask, lo, delta, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=d"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ double __shfl_xor_sync(unsigned mask, double var, int laneMask, int width) { + unsigned lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "d"(var)); + hi = __shfl_xor_sync(mask, hi, laneMask, width); + lo = __shfl_xor_sync(mask, lo, laneMask, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=d"(var) : "r"(lo), "r"(hi)); + return var; +} + + + +static __attribute__((device)) __inline__ long __shfl_sync(unsigned mask, long var, int srcLane, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_sync(mask, (long long) var, srcLane, width) : + __shfl_sync(mask, (int) var, srcLane, width); +} + +static __attribute__((device)) __inline__ unsigned long __shfl_sync(unsigned mask, unsigned long var, int srcLane, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_sync(mask, (unsigned long long) var, srcLane, width) : + __shfl_sync(mask, (unsigned int) var, srcLane, width); +} + +static __attribute__((device)) __inline__ long __shfl_up_sync(unsigned mask, long var, unsigned int delta, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_up_sync(mask, (long long) var, delta, width) : + __shfl_up_sync(mask, (int) var, delta, width); +} + +static __attribute__((device)) __inline__ unsigned long __shfl_up_sync(unsigned mask, unsigned long var, unsigned int delta, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_up_sync(mask, (unsigned long long) var, delta, width) : + __shfl_up_sync(mask, (unsigned int) var, delta, width); +} + +static __attribute__((device)) __inline__ long __shfl_down_sync(unsigned mask, long var, unsigned int delta, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_down_sync(mask, (long long) var, delta, width) : + __shfl_down_sync(mask, (int) var, delta, width); +} + +static __attribute__((device)) __inline__ unsigned long __shfl_down_sync(unsigned mask, unsigned long var, unsigned int delta, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_down_sync(mask, (unsigned long long) var, delta, width) : + __shfl_down_sync(mask, (unsigned int) var, delta, width); +} + +static __attribute__((device)) __inline__ long __shfl_xor_sync(unsigned mask, long var, int laneMask, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_xor_sync(mask, (long long) var, laneMask, width) : + __shfl_xor_sync(mask, (int) var, laneMask, width); +} + +static __attribute__((device)) __inline__ unsigned long __shfl_xor_sync(unsigned mask, unsigned long var, int laneMask, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_xor_sync(mask, (unsigned long long) var, laneMask, width) : + __shfl_xor_sync(mask, (unsigned int) var, laneMask, width); +} +# 234 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" 2 +# 2910 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" 1 +# 91 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ long __ldg(const long *ptr) ; +static __attribute__((device)) __inline__ unsigned long __ldg(const unsigned long *ptr) ; + +static __attribute__((device)) __inline__ char __ldg(const char *ptr) ; +static __attribute__((device)) __inline__ signed char __ldg(const signed char *ptr) ; +static __attribute__((device)) __inline__ short __ldg(const short *ptr) ; +static __attribute__((device)) __inline__ int __ldg(const int *ptr) ; +static __attribute__((device)) __inline__ long long __ldg(const long long *ptr) ; +static __attribute__((device)) __inline__ char2 __ldg(const char2 *ptr) ; +static __attribute__((device)) __inline__ char4 __ldg(const char4 *ptr) ; +static __attribute__((device)) __inline__ short2 __ldg(const short2 *ptr) ; +static __attribute__((device)) __inline__ short4 __ldg(const short4 *ptr) ; +static __attribute__((device)) __inline__ int2 __ldg(const int2 *ptr) ; +static __attribute__((device)) __inline__ int4 __ldg(const int4 *ptr) ; +static __attribute__((device)) __inline__ longlong2 __ldg(const longlong2 *ptr) ; + +static __attribute__((device)) __inline__ unsigned char __ldg(const unsigned char *ptr) ; +static __attribute__((device)) __inline__ unsigned short __ldg(const unsigned short *ptr) ; +static __attribute__((device)) __inline__ unsigned int __ldg(const unsigned int *ptr) ; +static __attribute__((device)) __inline__ unsigned long long __ldg(const unsigned long long *ptr) ; +static __attribute__((device)) __inline__ uchar2 __ldg(const uchar2 *ptr) ; +static __attribute__((device)) __inline__ uchar4 __ldg(const uchar4 *ptr) ; +static __attribute__((device)) __inline__ ushort2 __ldg(const ushort2 *ptr) ; +static __attribute__((device)) __inline__ ushort4 __ldg(const ushort4 *ptr) ; +static __attribute__((device)) __inline__ uint2 __ldg(const uint2 *ptr) ; +static __attribute__((device)) __inline__ uint4 __ldg(const uint4 *ptr) ; +static __attribute__((device)) __inline__ ulonglong2 __ldg(const ulonglong2 *ptr) ; + +static __attribute__((device)) __inline__ float __ldg(const float *ptr) ; +static __attribute__((device)) __inline__ double __ldg(const double *ptr) ; +static __attribute__((device)) __inline__ float2 __ldg(const float2 *ptr) ; +static __attribute__((device)) __inline__ float4 __ldg(const float4 *ptr) ; +static __attribute__((device)) __inline__ double2 __ldg(const double2 *ptr) ; + + + + +static __attribute__((device)) __inline__ long __ldcg(const long *ptr) ; +static __attribute__((device)) __inline__ unsigned long __ldcg(const unsigned long *ptr) ; + +static __attribute__((device)) __inline__ char __ldcg(const char *ptr) ; +static __attribute__((device)) __inline__ signed char __ldcg(const signed char *ptr) ; +static __attribute__((device)) __inline__ short __ldcg(const short *ptr) ; +static __attribute__((device)) __inline__ int __ldcg(const int *ptr) ; +static __attribute__((device)) __inline__ long long __ldcg(const long long *ptr) ; +static __attribute__((device)) __inline__ char2 __ldcg(const char2 *ptr) ; +static __attribute__((device)) __inline__ char4 __ldcg(const char4 *ptr) ; +static __attribute__((device)) __inline__ short2 __ldcg(const short2 *ptr) ; +static __attribute__((device)) __inline__ short4 __ldcg(const short4 *ptr) ; +static __attribute__((device)) __inline__ int2 __ldcg(const int2 *ptr) ; +static __attribute__((device)) __inline__ int4 __ldcg(const int4 *ptr) ; +static __attribute__((device)) __inline__ longlong2 __ldcg(const longlong2 *ptr) ; + +static __attribute__((device)) __inline__ unsigned char __ldcg(const unsigned char *ptr) ; +static __attribute__((device)) __inline__ unsigned short __ldcg(const unsigned short *ptr) ; +static __attribute__((device)) __inline__ unsigned int __ldcg(const unsigned int *ptr) ; +static __attribute__((device)) __inline__ unsigned long long __ldcg(const unsigned long long *ptr) ; +static __attribute__((device)) __inline__ uchar2 __ldcg(const uchar2 *ptr) ; +static __attribute__((device)) __inline__ uchar4 __ldcg(const uchar4 *ptr) ; +static __attribute__((device)) __inline__ ushort2 __ldcg(const ushort2 *ptr) ; +static __attribute__((device)) __inline__ ushort4 __ldcg(const ushort4 *ptr) ; +static __attribute__((device)) __inline__ uint2 __ldcg(const uint2 *ptr) ; +static __attribute__((device)) __inline__ uint4 __ldcg(const uint4 *ptr) ; +static __attribute__((device)) __inline__ ulonglong2 __ldcg(const ulonglong2 *ptr) ; + +static __attribute__((device)) __inline__ float __ldcg(const float *ptr) ; +static __attribute__((device)) __inline__ double __ldcg(const double *ptr) ; +static __attribute__((device)) __inline__ float2 __ldcg(const float2 *ptr) ; +static __attribute__((device)) __inline__ float4 __ldcg(const float4 *ptr) ; +static __attribute__((device)) __inline__ double2 __ldcg(const double2 *ptr) ; + + + +static __attribute__((device)) __inline__ long __ldca(const long *ptr) ; +static __attribute__((device)) __inline__ unsigned long __ldca(const unsigned long *ptr) ; + +static __attribute__((device)) __inline__ char __ldca(const char *ptr) ; +static __attribute__((device)) __inline__ signed char __ldca(const signed char *ptr) ; +static __attribute__((device)) __inline__ short __ldca(const short *ptr) ; +static __attribute__((device)) __inline__ int __ldca(const int *ptr) ; +static __attribute__((device)) __inline__ long long __ldca(const long long *ptr) ; +static __attribute__((device)) __inline__ char2 __ldca(const char2 *ptr) ; +static __attribute__((device)) __inline__ char4 __ldca(const char4 *ptr) ; +static __attribute__((device)) __inline__ short2 __ldca(const short2 *ptr) ; +static __attribute__((device)) __inline__ short4 __ldca(const short4 *ptr) ; +static __attribute__((device)) __inline__ int2 __ldca(const int2 *ptr) ; +static __attribute__((device)) __inline__ int4 __ldca(const int4 *ptr) ; +static __attribute__((device)) __inline__ longlong2 __ldca(const longlong2 *ptr) ; + +static __attribute__((device)) __inline__ unsigned char __ldca(const unsigned char *ptr) ; +static __attribute__((device)) __inline__ unsigned short __ldca(const unsigned short *ptr) ; +static __attribute__((device)) __inline__ unsigned int __ldca(const unsigned int *ptr) ; +static __attribute__((device)) __inline__ unsigned long long __ldca(const unsigned long long *ptr) ; +static __attribute__((device)) __inline__ uchar2 __ldca(const uchar2 *ptr) ; +static __attribute__((device)) __inline__ uchar4 __ldca(const uchar4 *ptr) ; +static __attribute__((device)) __inline__ ushort2 __ldca(const ushort2 *ptr) ; +static __attribute__((device)) __inline__ ushort4 __ldca(const ushort4 *ptr) ; +static __attribute__((device)) __inline__ uint2 __ldca(const uint2 *ptr) ; +static __attribute__((device)) __inline__ uint4 __ldca(const uint4 *ptr) ; +static __attribute__((device)) __inline__ ulonglong2 __ldca(const ulonglong2 *ptr) ; + +static __attribute__((device)) __inline__ float __ldca(const float *ptr) ; +static __attribute__((device)) __inline__ double __ldca(const double *ptr) ; +static __attribute__((device)) __inline__ float2 __ldca(const float2 *ptr) ; +static __attribute__((device)) __inline__ float4 __ldca(const float4 *ptr) ; +static __attribute__((device)) __inline__ double2 __ldca(const double2 *ptr) ; + + + +static __attribute__((device)) __inline__ long __ldcs(const long *ptr) ; +static __attribute__((device)) __inline__ unsigned long __ldcs(const unsigned long *ptr) ; + +static __attribute__((device)) __inline__ char __ldcs(const char *ptr) ; +static __attribute__((device)) __inline__ signed char __ldcs(const signed char *ptr) ; +static __attribute__((device)) __inline__ short __ldcs(const short *ptr) ; +static __attribute__((device)) __inline__ int __ldcs(const int *ptr) ; +static __attribute__((device)) __inline__ long long __ldcs(const long long *ptr) ; +static __attribute__((device)) __inline__ char2 __ldcs(const char2 *ptr) ; +static __attribute__((device)) __inline__ char4 __ldcs(const char4 *ptr) ; +static __attribute__((device)) __inline__ short2 __ldcs(const short2 *ptr) ; +static __attribute__((device)) __inline__ short4 __ldcs(const short4 *ptr) ; +static __attribute__((device)) __inline__ int2 __ldcs(const int2 *ptr) ; +static __attribute__((device)) __inline__ int4 __ldcs(const int4 *ptr) ; +static __attribute__((device)) __inline__ longlong2 __ldcs(const longlong2 *ptr) ; + +static __attribute__((device)) __inline__ unsigned char __ldcs(const unsigned char *ptr) ; +static __attribute__((device)) __inline__ unsigned short __ldcs(const unsigned short *ptr) ; +static __attribute__((device)) __inline__ unsigned int __ldcs(const unsigned int *ptr) ; +static __attribute__((device)) __inline__ unsigned long long __ldcs(const unsigned long long *ptr) ; +static __attribute__((device)) __inline__ uchar2 __ldcs(const uchar2 *ptr) ; +static __attribute__((device)) __inline__ uchar4 __ldcs(const uchar4 *ptr) ; +static __attribute__((device)) __inline__ ushort2 __ldcs(const ushort2 *ptr) ; +static __attribute__((device)) __inline__ ushort4 __ldcs(const ushort4 *ptr) ; +static __attribute__((device)) __inline__ uint2 __ldcs(const uint2 *ptr) ; +static __attribute__((device)) __inline__ uint4 __ldcs(const uint4 *ptr) ; +static __attribute__((device)) __inline__ ulonglong2 __ldcs(const ulonglong2 *ptr) ; + +static __attribute__((device)) __inline__ float __ldcs(const float *ptr) ; +static __attribute__((device)) __inline__ double __ldcs(const double *ptr) ; +static __attribute__((device)) __inline__ float2 __ldcs(const float2 *ptr) ; +static __attribute__((device)) __inline__ float4 __ldcs(const float4 *ptr) ; +static __attribute__((device)) __inline__ double2 __ldcs(const double2 *ptr) ; + + + +static __attribute__((device)) __inline__ long __ldlu(const long *ptr) ; +static __attribute__((device)) __inline__ unsigned long __ldlu(const unsigned long *ptr) ; + +static __attribute__((device)) __inline__ char __ldlu(const char *ptr) ; +static __attribute__((device)) __inline__ signed char __ldlu(const signed char *ptr) ; +static __attribute__((device)) __inline__ short __ldlu(const short *ptr) ; +static __attribute__((device)) __inline__ int __ldlu(const int *ptr) ; +static __attribute__((device)) __inline__ long long __ldlu(const long long *ptr) ; +static __attribute__((device)) __inline__ char2 __ldlu(const char2 *ptr) ; +static __attribute__((device)) __inline__ char4 __ldlu(const char4 *ptr) ; +static __attribute__((device)) __inline__ short2 __ldlu(const short2 *ptr) ; +static __attribute__((device)) __inline__ short4 __ldlu(const short4 *ptr) ; +static __attribute__((device)) __inline__ int2 __ldlu(const int2 *ptr) ; +static __attribute__((device)) __inline__ int4 __ldlu(const int4 *ptr) ; +static __attribute__((device)) __inline__ longlong2 __ldlu(const longlong2 *ptr) ; + +static __attribute__((device)) __inline__ unsigned char __ldlu(const unsigned char *ptr) ; +static __attribute__((device)) __inline__ unsigned short __ldlu(const unsigned short *ptr) ; +static __attribute__((device)) __inline__ unsigned int __ldlu(const unsigned int *ptr) ; +static __attribute__((device)) __inline__ unsigned long long __ldlu(const unsigned long long *ptr) ; +static __attribute__((device)) __inline__ uchar2 __ldlu(const uchar2 *ptr) ; +static __attribute__((device)) __inline__ uchar4 __ldlu(const uchar4 *ptr) ; +static __attribute__((device)) __inline__ ushort2 __ldlu(const ushort2 *ptr) ; +static __attribute__((device)) __inline__ ushort4 __ldlu(const ushort4 *ptr) ; +static __attribute__((device)) __inline__ uint2 __ldlu(const uint2 *ptr) ; +static __attribute__((device)) __inline__ uint4 __ldlu(const uint4 *ptr) ; +static __attribute__((device)) __inline__ ulonglong2 __ldlu(const ulonglong2 *ptr) ; + +static __attribute__((device)) __inline__ float __ldlu(const float *ptr) ; +static __attribute__((device)) __inline__ double __ldlu(const double *ptr) ; +static __attribute__((device)) __inline__ float2 __ldlu(const float2 *ptr) ; +static __attribute__((device)) __inline__ float4 __ldlu(const float4 *ptr) ; +static __attribute__((device)) __inline__ double2 __ldlu(const double2 *ptr) ; + + + +static __attribute__((device)) __inline__ long __ldcv(const long *ptr) ; +static __attribute__((device)) __inline__ unsigned long __ldcv(const unsigned long *ptr) ; + +static __attribute__((device)) __inline__ char __ldcv(const char *ptr) ; +static __attribute__((device)) __inline__ signed char __ldcv(const signed char *ptr) ; +static __attribute__((device)) __inline__ short __ldcv(const short *ptr) ; +static __attribute__((device)) __inline__ int __ldcv(const int *ptr) ; +static __attribute__((device)) __inline__ long long __ldcv(const long long *ptr) ; +static __attribute__((device)) __inline__ char2 __ldcv(const char2 *ptr) ; +static __attribute__((device)) __inline__ char4 __ldcv(const char4 *ptr) ; +static __attribute__((device)) __inline__ short2 __ldcv(const short2 *ptr) ; +static __attribute__((device)) __inline__ short4 __ldcv(const short4 *ptr) ; +static __attribute__((device)) __inline__ int2 __ldcv(const int2 *ptr) ; +static __attribute__((device)) __inline__ int4 __ldcv(const int4 *ptr) ; +static __attribute__((device)) __inline__ longlong2 __ldcv(const longlong2 *ptr) ; + +static __attribute__((device)) __inline__ unsigned char __ldcv(const unsigned char *ptr) ; +static __attribute__((device)) __inline__ unsigned short __ldcv(const unsigned short *ptr) ; +static __attribute__((device)) __inline__ unsigned int __ldcv(const unsigned int *ptr) ; +static __attribute__((device)) __inline__ unsigned long long __ldcv(const unsigned long long *ptr) ; +static __attribute__((device)) __inline__ uchar2 __ldcv(const uchar2 *ptr) ; +static __attribute__((device)) __inline__ uchar4 __ldcv(const uchar4 *ptr) ; +static __attribute__((device)) __inline__ ushort2 __ldcv(const ushort2 *ptr) ; +static __attribute__((device)) __inline__ ushort4 __ldcv(const ushort4 *ptr) ; +static __attribute__((device)) __inline__ uint2 __ldcv(const uint2 *ptr) ; +static __attribute__((device)) __inline__ uint4 __ldcv(const uint4 *ptr) ; +static __attribute__((device)) __inline__ ulonglong2 __ldcv(const ulonglong2 *ptr) ; + +static __attribute__((device)) __inline__ float __ldcv(const float *ptr) ; +static __attribute__((device)) __inline__ double __ldcv(const double *ptr) ; +static __attribute__((device)) __inline__ float2 __ldcv(const float2 *ptr) ; +static __attribute__((device)) __inline__ float4 __ldcv(const float4 *ptr) ; +static __attribute__((device)) __inline__ double2 __ldcv(const double2 *ptr) ; + + + +static __attribute__((device)) __inline__ void __stwb(long *ptr, long value) ; +static __attribute__((device)) __inline__ void __stwb(unsigned long *ptr, unsigned long value) ; + +static __attribute__((device)) __inline__ void __stwb(char *ptr, char value) ; +static __attribute__((device)) __inline__ void __stwb(signed char *ptr, signed char value) ; +static __attribute__((device)) __inline__ void __stwb(short *ptr, short value) ; +static __attribute__((device)) __inline__ void __stwb(int *ptr, int value) ; +static __attribute__((device)) __inline__ void __stwb(long long *ptr, long long value) ; +static __attribute__((device)) __inline__ void __stwb(char2 *ptr, char2 value) ; +static __attribute__((device)) __inline__ void __stwb(char4 *ptr, char4 value) ; +static __attribute__((device)) __inline__ void __stwb(short2 *ptr, short2 value) ; +static __attribute__((device)) __inline__ void __stwb(short4 *ptr, short4 value) ; +static __attribute__((device)) __inline__ void __stwb(int2 *ptr, int2 value) ; +static __attribute__((device)) __inline__ void __stwb(int4 *ptr, int4 value) ; +static __attribute__((device)) __inline__ void __stwb(longlong2 *ptr, longlong2 value) ; + +static __attribute__((device)) __inline__ void __stwb(unsigned char *ptr, unsigned char value) ; +static __attribute__((device)) __inline__ void __stwb(unsigned short *ptr, unsigned short value) ; +static __attribute__((device)) __inline__ void __stwb(unsigned int *ptr, unsigned int value) ; +static __attribute__((device)) __inline__ void __stwb(unsigned long long *ptr, unsigned long long value) ; +static __attribute__((device)) __inline__ void __stwb(uchar2 *ptr, uchar2 value) ; +static __attribute__((device)) __inline__ void __stwb(uchar4 *ptr, uchar4 value) ; +static __attribute__((device)) __inline__ void __stwb(ushort2 *ptr, ushort2 value) ; +static __attribute__((device)) __inline__ void __stwb(ushort4 *ptr, ushort4 value) ; +static __attribute__((device)) __inline__ void __stwb(uint2 *ptr, uint2 value) ; +static __attribute__((device)) __inline__ void __stwb(uint4 *ptr, uint4 value) ; +static __attribute__((device)) __inline__ void __stwb(ulonglong2 *ptr, ulonglong2 value) ; + +static __attribute__((device)) __inline__ void __stwb(float *ptr, float value) ; +static __attribute__((device)) __inline__ void __stwb(double *ptr, double value) ; +static __attribute__((device)) __inline__ void __stwb(float2 *ptr, float2 value) ; +static __attribute__((device)) __inline__ void __stwb(float4 *ptr, float4 value) ; +static __attribute__((device)) __inline__ void __stwb(double2 *ptr, double2 value) ; + + + +static __attribute__((device)) __inline__ void __stcg(long *ptr, long value) ; +static __attribute__((device)) __inline__ void __stcg(unsigned long *ptr, unsigned long value) ; + +static __attribute__((device)) __inline__ void __stcg(char *ptr, char value) ; +static __attribute__((device)) __inline__ void __stcg(signed char *ptr, signed char value) ; +static __attribute__((device)) __inline__ void __stcg(short *ptr, short value) ; +static __attribute__((device)) __inline__ void __stcg(int *ptr, int value) ; +static __attribute__((device)) __inline__ void __stcg(long long *ptr, long long value) ; +static __attribute__((device)) __inline__ void __stcg(char2 *ptr, char2 value) ; +static __attribute__((device)) __inline__ void __stcg(char4 *ptr, char4 value) ; +static __attribute__((device)) __inline__ void __stcg(short2 *ptr, short2 value) ; +static __attribute__((device)) __inline__ void __stcg(short4 *ptr, short4 value) ; +static __attribute__((device)) __inline__ void __stcg(int2 *ptr, int2 value) ; +static __attribute__((device)) __inline__ void __stcg(int4 *ptr, int4 value) ; +static __attribute__((device)) __inline__ void __stcg(longlong2 *ptr, longlong2 value) ; + +static __attribute__((device)) __inline__ void __stcg(unsigned char *ptr, unsigned char value) ; +static __attribute__((device)) __inline__ void __stcg(unsigned short *ptr, unsigned short value) ; +static __attribute__((device)) __inline__ void __stcg(unsigned int *ptr, unsigned int value) ; +static __attribute__((device)) __inline__ void __stcg(unsigned long long *ptr, unsigned long long value) ; +static __attribute__((device)) __inline__ void __stcg(uchar2 *ptr, uchar2 value) ; +static __attribute__((device)) __inline__ void __stcg(uchar4 *ptr, uchar4 value) ; +static __attribute__((device)) __inline__ void __stcg(ushort2 *ptr, ushort2 value) ; +static __attribute__((device)) __inline__ void __stcg(ushort4 *ptr, ushort4 value) ; +static __attribute__((device)) __inline__ void __stcg(uint2 *ptr, uint2 value) ; +static __attribute__((device)) __inline__ void __stcg(uint4 *ptr, uint4 value) ; +static __attribute__((device)) __inline__ void __stcg(ulonglong2 *ptr, ulonglong2 value) ; + +static __attribute__((device)) __inline__ void __stcg(float *ptr, float value) ; +static __attribute__((device)) __inline__ void __stcg(double *ptr, double value) ; +static __attribute__((device)) __inline__ void __stcg(float2 *ptr, float2 value) ; +static __attribute__((device)) __inline__ void __stcg(float4 *ptr, float4 value) ; +static __attribute__((device)) __inline__ void __stcg(double2 *ptr, double2 value) ; + + + +static __attribute__((device)) __inline__ void __stcs(long *ptr, long value) ; +static __attribute__((device)) __inline__ void __stcs(unsigned long *ptr, unsigned long value) ; + +static __attribute__((device)) __inline__ void __stcs(char *ptr, char value) ; +static __attribute__((device)) __inline__ void __stcs(signed char *ptr, signed char value) ; +static __attribute__((device)) __inline__ void __stcs(short *ptr, short value) ; +static __attribute__((device)) __inline__ void __stcs(int *ptr, int value) ; +static __attribute__((device)) __inline__ void __stcs(long long *ptr, long long value) ; +static __attribute__((device)) __inline__ void __stcs(char2 *ptr, char2 value) ; +static __attribute__((device)) __inline__ void __stcs(char4 *ptr, char4 value) ; +static __attribute__((device)) __inline__ void __stcs(short2 *ptr, short2 value) ; +static __attribute__((device)) __inline__ void __stcs(short4 *ptr, short4 value) ; +static __attribute__((device)) __inline__ void __stcs(int2 *ptr, int2 value) ; +static __attribute__((device)) __inline__ void __stcs(int4 *ptr, int4 value) ; +static __attribute__((device)) __inline__ void __stcs(longlong2 *ptr, longlong2 value) ; + +static __attribute__((device)) __inline__ void __stcs(unsigned char *ptr, unsigned char value) ; +static __attribute__((device)) __inline__ void __stcs(unsigned short *ptr, unsigned short value) ; +static __attribute__((device)) __inline__ void __stcs(unsigned int *ptr, unsigned int value) ; +static __attribute__((device)) __inline__ void __stcs(unsigned long long *ptr, unsigned long long value) ; +static __attribute__((device)) __inline__ void __stcs(uchar2 *ptr, uchar2 value) ; +static __attribute__((device)) __inline__ void __stcs(uchar4 *ptr, uchar4 value) ; +static __attribute__((device)) __inline__ void __stcs(ushort2 *ptr, ushort2 value) ; +static __attribute__((device)) __inline__ void __stcs(ushort4 *ptr, ushort4 value) ; +static __attribute__((device)) __inline__ void __stcs(uint2 *ptr, uint2 value) ; +static __attribute__((device)) __inline__ void __stcs(uint4 *ptr, uint4 value) ; +static __attribute__((device)) __inline__ void __stcs(ulonglong2 *ptr, ulonglong2 value) ; + +static __attribute__((device)) __inline__ void __stcs(float *ptr, float value) ; +static __attribute__((device)) __inline__ void __stcs(double *ptr, double value) ; +static __attribute__((device)) __inline__ void __stcs(float2 *ptr, float2 value) ; +static __attribute__((device)) __inline__ void __stcs(float4 *ptr, float4 value) ; +static __attribute__((device)) __inline__ void __stcs(double2 *ptr, double2 value) ; + + + +static __attribute__((device)) __inline__ void __stwt(long *ptr, long value) ; +static __attribute__((device)) __inline__ void __stwt(unsigned long *ptr, unsigned long value) ; + +static __attribute__((device)) __inline__ void __stwt(char *ptr, char value) ; +static __attribute__((device)) __inline__ void __stwt(signed char *ptr, signed char value) ; +static __attribute__((device)) __inline__ void __stwt(short *ptr, short value) ; +static __attribute__((device)) __inline__ void __stwt(int *ptr, int value) ; +static __attribute__((device)) __inline__ void __stwt(long long *ptr, long long value) ; +static __attribute__((device)) __inline__ void __stwt(char2 *ptr, char2 value) ; +static __attribute__((device)) __inline__ void __stwt(char4 *ptr, char4 value) ; +static __attribute__((device)) __inline__ void __stwt(short2 *ptr, short2 value) ; +static __attribute__((device)) __inline__ void __stwt(short4 *ptr, short4 value) ; +static __attribute__((device)) __inline__ void __stwt(int2 *ptr, int2 value) ; +static __attribute__((device)) __inline__ void __stwt(int4 *ptr, int4 value) ; +static __attribute__((device)) __inline__ void __stwt(longlong2 *ptr, longlong2 value) ; + +static __attribute__((device)) __inline__ void __stwt(unsigned char *ptr, unsigned char value) ; +static __attribute__((device)) __inline__ void __stwt(unsigned short *ptr, unsigned short value) ; +static __attribute__((device)) __inline__ void __stwt(unsigned int *ptr, unsigned int value) ; +static __attribute__((device)) __inline__ void __stwt(unsigned long long *ptr, unsigned long long value) ; +static __attribute__((device)) __inline__ void __stwt(uchar2 *ptr, uchar2 value) ; +static __attribute__((device)) __inline__ void __stwt(uchar4 *ptr, uchar4 value) ; +static __attribute__((device)) __inline__ void __stwt(ushort2 *ptr, ushort2 value) ; +static __attribute__((device)) __inline__ void __stwt(ushort4 *ptr, ushort4 value) ; +static __attribute__((device)) __inline__ void __stwt(uint2 *ptr, uint2 value) ; +static __attribute__((device)) __inline__ void __stwt(uint4 *ptr, uint4 value) ; +static __attribute__((device)) __inline__ void __stwt(ulonglong2 *ptr, ulonglong2 value) ; + +static __attribute__((device)) __inline__ void __stwt(float *ptr, float value) ; +static __attribute__((device)) __inline__ void __stwt(double *ptr, double value) ; +static __attribute__((device)) __inline__ void __stwt(float2 *ptr, float2 value) ; +static __attribute__((device)) __inline__ void __stwt(float4 *ptr, float4 value) ; +static __attribute__((device)) __inline__ void __stwt(double2 *ptr, double2 value) ; +# 465 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_l(unsigned int lo, unsigned int hi, unsigned int shift) ; +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_lc(unsigned int lo, unsigned int hi, unsigned int shift) ; +# 490 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_r(unsigned int lo, unsigned int hi, unsigned int shift) ; +# 502 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_rc(unsigned int lo, unsigned int hi, unsigned int shift) ; +# 512 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.hpp" 1 +# 73 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.hpp" +extern "C" +{ + + +} +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.hpp" +static __attribute__((device)) __inline__ long __ldg(const long *ptr) { unsigned long ret; asm volatile ("ld.global.nc.s64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return (long)ret; } +static __attribute__((device)) __inline__ unsigned long __ldg(const unsigned long *ptr) { unsigned long ret; asm volatile ("ld.global.nc.u64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return ret; } + + + + + + +static __attribute__((device)) __inline__ char __ldg(const char *ptr) { unsigned int ret; asm volatile ("ld.global.nc.s8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (char)ret; } +static __attribute__((device)) __inline__ signed char __ldg(const signed char *ptr) { unsigned int ret; asm volatile ("ld.global.nc.s8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (signed char)ret; } +static __attribute__((device)) __inline__ short __ldg(const short *ptr) { unsigned short ret; asm volatile ("ld.global.nc.s16 %0, [%1];" : "=h"(ret) : "l" (ptr)); return (short)ret; } +static __attribute__((device)) __inline__ int __ldg(const int *ptr) { unsigned int ret; asm volatile ("ld.global.nc.s32 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (int)ret; } +static __attribute__((device)) __inline__ long long __ldg(const long long *ptr) { unsigned long long ret; asm volatile ("ld.global.nc.s64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return (long long)ret; } +static __attribute__((device)) __inline__ char2 __ldg(const char2 *ptr) { char2 ret; int2 tmp; asm volatile ("ld.global.nc.v2.s8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr)); ret.x = (char)tmp.x; ret.y = (char)tmp.y; return ret; } +static __attribute__((device)) __inline__ char4 __ldg(const char4 *ptr) { char4 ret; int4 tmp; asm volatile ("ld.global.nc.v4.s8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr)); ret.x = (char)tmp.x; ret.y = (char)tmp.y; ret.z = (char)tmp.z; ret.w = (char)tmp.w; return ret; } +static __attribute__((device)) __inline__ short2 __ldg(const short2 *ptr) { short2 ret; asm volatile ("ld.global.nc.v2.s16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ short4 __ldg(const short4 *ptr) { short4 ret; asm volatile ("ld.global.nc.v4.s16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ int2 __ldg(const int2 *ptr) { int2 ret; asm volatile ("ld.global.nc.v2.s32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ int4 __ldg(const int4 *ptr) { int4 ret; asm volatile ("ld.global.nc.v4.s32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ longlong2 __ldg(const longlong2 *ptr) { longlong2 ret; asm volatile ("ld.global.nc.v2.s64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr)); return ret; } + +static __attribute__((device)) __inline__ unsigned char __ldg(const unsigned char *ptr) { unsigned int ret; asm volatile ("ld.global.nc.u8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (unsigned char)ret; } +static __attribute__((device)) __inline__ unsigned short __ldg(const unsigned short *ptr) { unsigned short ret; asm volatile ("ld.global.nc.u16 %0, [%1];" : "=h"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ unsigned int __ldg(const unsigned int *ptr) { unsigned int ret; asm volatile ("ld.global.nc.u32 %0, [%1];" : "=r"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ unsigned long long __ldg(const unsigned long long *ptr) { unsigned long long ret; asm volatile ("ld.global.nc.u64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uchar2 __ldg(const uchar2 *ptr) { uchar2 ret; uint2 tmp; asm volatile ("ld.global.nc.v2.u8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr)); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; return ret; } +static __attribute__((device)) __inline__ uchar4 __ldg(const uchar4 *ptr) { uchar4 ret; uint4 tmp; asm volatile ("ld.global.nc.v4.u8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr)); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; ret.z = (unsigned char)tmp.z; ret.w = (unsigned char)tmp.w; return ret; } +static __attribute__((device)) __inline__ ushort2 __ldg(const ushort2 *ptr) { ushort2 ret; asm volatile ("ld.global.nc.v2.u16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ ushort4 __ldg(const ushort4 *ptr) { ushort4 ret; asm volatile ("ld.global.nc.v4.u16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uint2 __ldg(const uint2 *ptr) { uint2 ret; asm volatile ("ld.global.nc.v2.u32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uint4 __ldg(const uint4 *ptr) { uint4 ret; asm volatile ("ld.global.nc.v4.u32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ ulonglong2 __ldg(const ulonglong2 *ptr) { ulonglong2 ret; asm volatile ("ld.global.nc.v2.u64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr)); return ret; } + +static __attribute__((device)) __inline__ float __ldg(const float *ptr) { float ret; asm volatile ("ld.global.nc.f32 %0, [%1];" : "=f"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ double __ldg(const double *ptr) { double ret; asm volatile ("ld.global.nc.f64 %0, [%1];" : "=d"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ float2 __ldg(const float2 *ptr) { float2 ret; asm volatile ("ld.global.nc.v2.f32 {%0,%1}, [%2];" : "=f"(ret.x), "=f"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ float4 __ldg(const float4 *ptr) { float4 ret; asm volatile ("ld.global.nc.v4.f32 {%0,%1,%2,%3}, [%4];" : "=f"(ret.x), "=f"(ret.y), "=f"(ret.z), "=f"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ double2 __ldg(const double2 *ptr) { double2 ret; asm volatile ("ld.global.nc.v2.f64 {%0,%1}, [%2];" : "=d"(ret.x), "=d"(ret.y) : "l" (ptr)); return ret; } +# 147 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.hpp" +static __attribute__((device)) __inline__ long __ldcg(const long *ptr) { unsigned long ret; asm volatile ("ld.global.cg.s64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return (long)ret; } +static __attribute__((device)) __inline__ unsigned long __ldcg(const unsigned long *ptr) { unsigned long ret; asm volatile ("ld.global.cg.u64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return ret; } + + + + + + +static __attribute__((device)) __inline__ char __ldcg(const char *ptr) { unsigned int ret; asm volatile ("ld.global.cg.s8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (char)ret; } +static __attribute__((device)) __inline__ signed char __ldcg(const signed char *ptr) { unsigned int ret; asm volatile ("ld.global.cg.s8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (signed char)ret; } +static __attribute__((device)) __inline__ short __ldcg(const short *ptr) { unsigned short ret; asm volatile ("ld.global.cg.s16 %0, [%1];" : "=h"(ret) : "l" (ptr)); return (short)ret; } +static __attribute__((device)) __inline__ int __ldcg(const int *ptr) { unsigned int ret; asm volatile ("ld.global.cg.s32 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (int)ret; } +static __attribute__((device)) __inline__ long long __ldcg(const long long *ptr) { unsigned long long ret; asm volatile ("ld.global.cg.s64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return (long long)ret; } +static __attribute__((device)) __inline__ char2 __ldcg(const char2 *ptr) { char2 ret; int2 tmp; asm volatile ("ld.global.cg.v2.s8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr)); ret.x = (char)tmp.x; ret.y = (char)tmp.y; return ret; } +static __attribute__((device)) __inline__ char4 __ldcg(const char4 *ptr) { char4 ret; int4 tmp; asm volatile ("ld.global.cg.v4.s8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr)); ret.x = (char)tmp.x; ret.y = (char)tmp.y; ret.z = (char)tmp.z; ret.w = (char)tmp.w; return ret; } +static __attribute__((device)) __inline__ short2 __ldcg(const short2 *ptr) { short2 ret; asm volatile ("ld.global.cg.v2.s16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ short4 __ldcg(const short4 *ptr) { short4 ret; asm volatile ("ld.global.cg.v4.s16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ int2 __ldcg(const int2 *ptr) { int2 ret; asm volatile ("ld.global.cg.v2.s32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ int4 __ldcg(const int4 *ptr) { int4 ret; asm volatile ("ld.global.cg.v4.s32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ longlong2 __ldcg(const longlong2 *ptr) { longlong2 ret; asm volatile ("ld.global.cg.v2.s64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr)); return ret; } + +static __attribute__((device)) __inline__ unsigned char __ldcg(const unsigned char *ptr) { unsigned int ret; asm volatile ("ld.global.cg.u8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (unsigned char)ret; } +static __attribute__((device)) __inline__ unsigned short __ldcg(const unsigned short *ptr) { unsigned short ret; asm volatile ("ld.global.cg.u16 %0, [%1];" : "=h"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ unsigned int __ldcg(const unsigned int *ptr) { unsigned int ret; asm volatile ("ld.global.cg.u32 %0, [%1];" : "=r"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ unsigned long long __ldcg(const unsigned long long *ptr) { unsigned long long ret; asm volatile ("ld.global.cg.u64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uchar2 __ldcg(const uchar2 *ptr) { uchar2 ret; uint2 tmp; asm volatile ("ld.global.cg.v2.u8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr)); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; return ret; } +static __attribute__((device)) __inline__ uchar4 __ldcg(const uchar4 *ptr) { uchar4 ret; uint4 tmp; asm volatile ("ld.global.cg.v4.u8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr)); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; ret.z = (unsigned char)tmp.z; ret.w = (unsigned char)tmp.w; return ret; } +static __attribute__((device)) __inline__ ushort2 __ldcg(const ushort2 *ptr) { ushort2 ret; asm volatile ("ld.global.cg.v2.u16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ ushort4 __ldcg(const ushort4 *ptr) { ushort4 ret; asm volatile ("ld.global.cg.v4.u16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uint2 __ldcg(const uint2 *ptr) { uint2 ret; asm volatile ("ld.global.cg.v2.u32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uint4 __ldcg(const uint4 *ptr) { uint4 ret; asm volatile ("ld.global.cg.v4.u32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ ulonglong2 __ldcg(const ulonglong2 *ptr) { ulonglong2 ret; asm volatile ("ld.global.cg.v2.u64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr)); return ret; } + +static __attribute__((device)) __inline__ float __ldcg(const float *ptr) { float ret; asm volatile ("ld.global.cg.f32 %0, [%1];" : "=f"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ double __ldcg(const double *ptr) { double ret; asm volatile ("ld.global.cg.f64 %0, [%1];" : "=d"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ float2 __ldcg(const float2 *ptr) { float2 ret; asm volatile ("ld.global.cg.v2.f32 {%0,%1}, [%2];" : "=f"(ret.x), "=f"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ float4 __ldcg(const float4 *ptr) { float4 ret; asm volatile ("ld.global.cg.v4.f32 {%0,%1,%2,%3}, [%4];" : "=f"(ret.x), "=f"(ret.y), "=f"(ret.z), "=f"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ double2 __ldcg(const double2 *ptr) { double2 ret; asm volatile ("ld.global.cg.v2.f64 {%0,%1}, [%2];" : "=d"(ret.x), "=d"(ret.y) : "l" (ptr)); return ret; } + + + + + + + +static __attribute__((device)) __inline__ long __ldca(const long *ptr) { unsigned long ret; asm volatile ("ld.global.ca.s64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return (long)ret; } +static __attribute__((device)) __inline__ unsigned long __ldca(const unsigned long *ptr) { unsigned long ret; asm volatile ("ld.global.ca.u64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return ret; } + + + + + + +static __attribute__((device)) __inline__ char __ldca(const char *ptr) { unsigned int ret; asm volatile ("ld.global.ca.s8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (char)ret; } +static __attribute__((device)) __inline__ signed char __ldca(const signed char *ptr) { unsigned int ret; asm volatile ("ld.global.ca.s8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (signed char)ret; } +static __attribute__((device)) __inline__ short __ldca(const short *ptr) { unsigned short ret; asm volatile ("ld.global.ca.s16 %0, [%1];" : "=h"(ret) : "l" (ptr)); return (short)ret; } +static __attribute__((device)) __inline__ int __ldca(const int *ptr) { unsigned int ret; asm volatile ("ld.global.ca.s32 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (int)ret; } +static __attribute__((device)) __inline__ long long __ldca(const long long *ptr) { unsigned long long ret; asm volatile ("ld.global.ca.s64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return (long long)ret; } +static __attribute__((device)) __inline__ char2 __ldca(const char2 *ptr) { char2 ret; int2 tmp; asm volatile ("ld.global.ca.v2.s8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr)); ret.x = (char)tmp.x; ret.y = (char)tmp.y; return ret; } +static __attribute__((device)) __inline__ char4 __ldca(const char4 *ptr) { char4 ret; int4 tmp; asm volatile ("ld.global.ca.v4.s8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr)); ret.x = (char)tmp.x; ret.y = (char)tmp.y; ret.z = (char)tmp.z; ret.w = (char)tmp.w; return ret; } +static __attribute__((device)) __inline__ short2 __ldca(const short2 *ptr) { short2 ret; asm volatile ("ld.global.ca.v2.s16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ short4 __ldca(const short4 *ptr) { short4 ret; asm volatile ("ld.global.ca.v4.s16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ int2 __ldca(const int2 *ptr) { int2 ret; asm volatile ("ld.global.ca.v2.s32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ int4 __ldca(const int4 *ptr) { int4 ret; asm volatile ("ld.global.ca.v4.s32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ longlong2 __ldca(const longlong2 *ptr) { longlong2 ret; asm volatile ("ld.global.ca.v2.s64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr)); return ret; } + +static __attribute__((device)) __inline__ unsigned char __ldca(const unsigned char *ptr) { unsigned int ret; asm volatile ("ld.global.ca.u8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (unsigned char)ret; } +static __attribute__((device)) __inline__ unsigned short __ldca(const unsigned short *ptr) { unsigned short ret; asm volatile ("ld.global.ca.u16 %0, [%1];" : "=h"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ unsigned int __ldca(const unsigned int *ptr) { unsigned int ret; asm volatile ("ld.global.ca.u32 %0, [%1];" : "=r"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ unsigned long long __ldca(const unsigned long long *ptr) { unsigned long long ret; asm volatile ("ld.global.ca.u64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uchar2 __ldca(const uchar2 *ptr) { uchar2 ret; uint2 tmp; asm volatile ("ld.global.ca.v2.u8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr)); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; return ret; } +static __attribute__((device)) __inline__ uchar4 __ldca(const uchar4 *ptr) { uchar4 ret; uint4 tmp; asm volatile ("ld.global.ca.v4.u8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr)); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; ret.z = (unsigned char)tmp.z; ret.w = (unsigned char)tmp.w; return ret; } +static __attribute__((device)) __inline__ ushort2 __ldca(const ushort2 *ptr) { ushort2 ret; asm volatile ("ld.global.ca.v2.u16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ ushort4 __ldca(const ushort4 *ptr) { ushort4 ret; asm volatile ("ld.global.ca.v4.u16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uint2 __ldca(const uint2 *ptr) { uint2 ret; asm volatile ("ld.global.ca.v2.u32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uint4 __ldca(const uint4 *ptr) { uint4 ret; asm volatile ("ld.global.ca.v4.u32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ ulonglong2 __ldca(const ulonglong2 *ptr) { ulonglong2 ret; asm volatile ("ld.global.ca.v2.u64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr)); return ret; } + +static __attribute__((device)) __inline__ float __ldca(const float *ptr) { float ret; asm volatile ("ld.global.ca.f32 %0, [%1];" : "=f"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ double __ldca(const double *ptr) { double ret; asm volatile ("ld.global.ca.f64 %0, [%1];" : "=d"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ float2 __ldca(const float2 *ptr) { float2 ret; asm volatile ("ld.global.ca.v2.f32 {%0,%1}, [%2];" : "=f"(ret.x), "=f"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ float4 __ldca(const float4 *ptr) { float4 ret; asm volatile ("ld.global.ca.v4.f32 {%0,%1,%2,%3}, [%4];" : "=f"(ret.x), "=f"(ret.y), "=f"(ret.z), "=f"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ double2 __ldca(const double2 *ptr) { double2 ret; asm volatile ("ld.global.ca.v2.f64 {%0,%1}, [%2];" : "=d"(ret.x), "=d"(ret.y) : "l" (ptr)); return ret; } + + + + + + + +static __attribute__((device)) __inline__ long __ldcs(const long *ptr) { unsigned long ret; asm volatile ("ld.global.cs.s64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return (long)ret; } +static __attribute__((device)) __inline__ unsigned long __ldcs(const unsigned long *ptr) { unsigned long ret; asm volatile ("ld.global.cs.u64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return ret; } + + + + + + +static __attribute__((device)) __inline__ char __ldcs(const char *ptr) { unsigned int ret; asm volatile ("ld.global.cs.s8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (char)ret; } +static __attribute__((device)) __inline__ signed char __ldcs(const signed char *ptr) { unsigned int ret; asm volatile ("ld.global.cs.s8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (signed char)ret; } +static __attribute__((device)) __inline__ short __ldcs(const short *ptr) { unsigned short ret; asm volatile ("ld.global.cs.s16 %0, [%1];" : "=h"(ret) : "l" (ptr)); return (short)ret; } +static __attribute__((device)) __inline__ int __ldcs(const int *ptr) { unsigned int ret; asm volatile ("ld.global.cs.s32 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (int)ret; } +static __attribute__((device)) __inline__ long long __ldcs(const long long *ptr) { unsigned long long ret; asm volatile ("ld.global.cs.s64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return (long long)ret; } +static __attribute__((device)) __inline__ char2 __ldcs(const char2 *ptr) { char2 ret; int2 tmp; asm volatile ("ld.global.cs.v2.s8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr)); ret.x = (char)tmp.x; ret.y = (char)tmp.y; return ret; } +static __attribute__((device)) __inline__ char4 __ldcs(const char4 *ptr) { char4 ret; int4 tmp; asm volatile ("ld.global.cs.v4.s8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr)); ret.x = (char)tmp.x; ret.y = (char)tmp.y; ret.z = (char)tmp.z; ret.w = (char)tmp.w; return ret; } +static __attribute__((device)) __inline__ short2 __ldcs(const short2 *ptr) { short2 ret; asm volatile ("ld.global.cs.v2.s16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ short4 __ldcs(const short4 *ptr) { short4 ret; asm volatile ("ld.global.cs.v4.s16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ int2 __ldcs(const int2 *ptr) { int2 ret; asm volatile ("ld.global.cs.v2.s32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ int4 __ldcs(const int4 *ptr) { int4 ret; asm volatile ("ld.global.cs.v4.s32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ longlong2 __ldcs(const longlong2 *ptr) { longlong2 ret; asm volatile ("ld.global.cs.v2.s64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr)); return ret; } + +static __attribute__((device)) __inline__ unsigned char __ldcs(const unsigned char *ptr) { unsigned int ret; asm volatile ("ld.global.cs.u8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (unsigned char)ret; } +static __attribute__((device)) __inline__ unsigned short __ldcs(const unsigned short *ptr) { unsigned short ret; asm volatile ("ld.global.cs.u16 %0, [%1];" : "=h"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ unsigned int __ldcs(const unsigned int *ptr) { unsigned int ret; asm volatile ("ld.global.cs.u32 %0, [%1];" : "=r"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ unsigned long long __ldcs(const unsigned long long *ptr) { unsigned long long ret; asm volatile ("ld.global.cs.u64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uchar2 __ldcs(const uchar2 *ptr) { uchar2 ret; uint2 tmp; asm volatile ("ld.global.cs.v2.u8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr)); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; return ret; } +static __attribute__((device)) __inline__ uchar4 __ldcs(const uchar4 *ptr) { uchar4 ret; uint4 tmp; asm volatile ("ld.global.cs.v4.u8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr)); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; ret.z = (unsigned char)tmp.z; ret.w = (unsigned char)tmp.w; return ret; } +static __attribute__((device)) __inline__ ushort2 __ldcs(const ushort2 *ptr) { ushort2 ret; asm volatile ("ld.global.cs.v2.u16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ ushort4 __ldcs(const ushort4 *ptr) { ushort4 ret; asm volatile ("ld.global.cs.v4.u16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uint2 __ldcs(const uint2 *ptr) { uint2 ret; asm volatile ("ld.global.cs.v2.u32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uint4 __ldcs(const uint4 *ptr) { uint4 ret; asm volatile ("ld.global.cs.v4.u32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ ulonglong2 __ldcs(const ulonglong2 *ptr) { ulonglong2 ret; asm volatile ("ld.global.cs.v2.u64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr)); return ret; } + +static __attribute__((device)) __inline__ float __ldcs(const float *ptr) { float ret; asm volatile ("ld.global.cs.f32 %0, [%1];" : "=f"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ double __ldcs(const double *ptr) { double ret; asm volatile ("ld.global.cs.f64 %0, [%1];" : "=d"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ float2 __ldcs(const float2 *ptr) { float2 ret; asm volatile ("ld.global.cs.v2.f32 {%0,%1}, [%2];" : "=f"(ret.x), "=f"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ float4 __ldcs(const float4 *ptr) { float4 ret; asm volatile ("ld.global.cs.v4.f32 {%0,%1,%2,%3}, [%4];" : "=f"(ret.x), "=f"(ret.y), "=f"(ret.z), "=f"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ double2 __ldcs(const double2 *ptr) { double2 ret; asm volatile ("ld.global.cs.v2.f64 {%0,%1}, [%2];" : "=d"(ret.x), "=d"(ret.y) : "l" (ptr)); return ret; } + + + + + + + +static __attribute__((device)) __inline__ long __ldlu(const long *ptr) { unsigned long ret; asm ("ld.global.lu.s64 %0, [%1];" : "=l"(ret) : "l" (ptr) : "memory"); return (long)ret; } +static __attribute__((device)) __inline__ unsigned long __ldlu(const unsigned long *ptr) { unsigned long ret; asm ("ld.global.lu.u64 %0, [%1];" : "=l"(ret) : "l" (ptr) : "memory"); return ret; } + + + + + + +static __attribute__((device)) __inline__ char __ldlu(const char *ptr) { unsigned int ret; asm ("ld.global.lu.s8 %0, [%1];" : "=r"(ret) : "l" (ptr) : "memory"); return (char)ret; } +static __attribute__((device)) __inline__ signed char __ldlu(const signed char *ptr) { unsigned int ret; asm ("ld.global.lu.s8 %0, [%1];" : "=r"(ret) : "l" (ptr) : "memory"); return (signed char)ret; } +static __attribute__((device)) __inline__ short __ldlu(const short *ptr) { unsigned short ret; asm ("ld.global.lu.s16 %0, [%1];" : "=h"(ret) : "l" (ptr) : "memory"); return (short)ret; } +static __attribute__((device)) __inline__ int __ldlu(const int *ptr) { unsigned int ret; asm ("ld.global.lu.s32 %0, [%1];" : "=r"(ret) : "l" (ptr) : "memory"); return (int)ret; } +static __attribute__((device)) __inline__ long long __ldlu(const long long *ptr) { unsigned long long ret; asm ("ld.global.lu.s64 %0, [%1];" : "=l"(ret) : "l" (ptr) : "memory"); return (long long)ret; } +static __attribute__((device)) __inline__ char2 __ldlu(const char2 *ptr) { char2 ret; int2 tmp; asm ("ld.global.lu.v2.s8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr) : "memory"); ret.x = (char)tmp.x; ret.y = (char)tmp.y; return ret; } +static __attribute__((device)) __inline__ char4 __ldlu(const char4 *ptr) { char4 ret; int4 tmp; asm ("ld.global.lu.v4.s8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr) : "memory"); ret.x = (char)tmp.x; ret.y = (char)tmp.y; ret.z = (char)tmp.z; ret.w = (char)tmp.w; return ret; } +static __attribute__((device)) __inline__ short2 __ldlu(const short2 *ptr) { short2 ret; asm ("ld.global.lu.v2.s16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ short4 __ldlu(const short4 *ptr) { short4 ret; asm ("ld.global.lu.v4.s16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ int2 __ldlu(const int2 *ptr) { int2 ret; asm ("ld.global.lu.v2.s32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ int4 __ldlu(const int4 *ptr) { int4 ret; asm ("ld.global.lu.v4.s32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ longlong2 __ldlu(const longlong2 *ptr) { longlong2 ret; asm ("ld.global.lu.v2.s64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr) : "memory"); return ret; } + +static __attribute__((device)) __inline__ unsigned char __ldlu(const unsigned char *ptr) { unsigned int ret; asm ("ld.global.lu.u8 %0, [%1];" : "=r"(ret) : "l" (ptr) : "memory"); return (unsigned char)ret; } +static __attribute__((device)) __inline__ unsigned short __ldlu(const unsigned short *ptr) { unsigned short ret; asm ("ld.global.lu.u16 %0, [%1];" : "=h"(ret) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ unsigned int __ldlu(const unsigned int *ptr) { unsigned int ret; asm ("ld.global.lu.u32 %0, [%1];" : "=r"(ret) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ unsigned long long __ldlu(const unsigned long long *ptr) { unsigned long long ret; asm ("ld.global.lu.u64 %0, [%1];" : "=l"(ret) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ uchar2 __ldlu(const uchar2 *ptr) { uchar2 ret; uint2 tmp; asm ("ld.global.lu.v2.u8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr) : "memory"); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; return ret; } +static __attribute__((device)) __inline__ uchar4 __ldlu(const uchar4 *ptr) { uchar4 ret; uint4 tmp; asm ("ld.global.lu.v4.u8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr) : "memory"); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; ret.z = (unsigned char)tmp.z; ret.w = (unsigned char)tmp.w; return ret; } +static __attribute__((device)) __inline__ ushort2 __ldlu(const ushort2 *ptr) { ushort2 ret; asm ("ld.global.lu.v2.u16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ ushort4 __ldlu(const ushort4 *ptr) { ushort4 ret; asm ("ld.global.lu.v4.u16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ uint2 __ldlu(const uint2 *ptr) { uint2 ret; asm ("ld.global.lu.v2.u32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ uint4 __ldlu(const uint4 *ptr) { uint4 ret; asm ("ld.global.lu.v4.u32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ ulonglong2 __ldlu(const ulonglong2 *ptr) { ulonglong2 ret; asm ("ld.global.lu.v2.u64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr) : "memory"); return ret; } + +static __attribute__((device)) __inline__ float __ldlu(const float *ptr) { float ret; asm ("ld.global.lu.f32 %0, [%1];" : "=f"(ret) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ double __ldlu(const double *ptr) { double ret; asm ("ld.global.lu.f64 %0, [%1];" : "=d"(ret) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ float2 __ldlu(const float2 *ptr) { float2 ret; asm ("ld.global.lu.v2.f32 {%0,%1}, [%2];" : "=f"(ret.x), "=f"(ret.y) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ float4 __ldlu(const float4 *ptr) { float4 ret; asm ("ld.global.lu.v4.f32 {%0,%1,%2,%3}, [%4];" : "=f"(ret.x), "=f"(ret.y), "=f"(ret.z), "=f"(ret.w) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ double2 __ldlu(const double2 *ptr) { double2 ret; asm ("ld.global.lu.v2.f64 {%0,%1}, [%2];" : "=d"(ret.x), "=d"(ret.y) : "l" (ptr) : "memory"); return ret; } + + + + + + + +static __attribute__((device)) __inline__ long __ldcv(const long *ptr) { unsigned long ret; asm ("ld.global.cv.s64 %0, [%1];" : "=l"(ret) : "l" (ptr) : "memory"); return (long)ret; } +static __attribute__((device)) __inline__ unsigned long __ldcv(const unsigned long *ptr) { unsigned long ret; asm ("ld.global.cv.u64 %0, [%1];" : "=l"(ret) : "l" (ptr) : "memory"); return ret; } + + + + + + +static __attribute__((device)) __inline__ char __ldcv(const char *ptr) { unsigned int ret; asm ("ld.global.cv.s8 %0, [%1];" : "=r"(ret) : "l" (ptr) : "memory"); return (char)ret; } +static __attribute__((device)) __inline__ signed char __ldcv(const signed char *ptr) { unsigned int ret; asm ("ld.global.cv.s8 %0, [%1];" : "=r"(ret) : "l" (ptr) : "memory"); return (signed char)ret; } +static __attribute__((device)) __inline__ short __ldcv(const short *ptr) { unsigned short ret; asm ("ld.global.cv.s16 %0, [%1];" : "=h"(ret) : "l" (ptr) : "memory"); return (short)ret; } +static __attribute__((device)) __inline__ int __ldcv(const int *ptr) { unsigned int ret; asm ("ld.global.cv.s32 %0, [%1];" : "=r"(ret) : "l" (ptr) : "memory"); return (int)ret; } +static __attribute__((device)) __inline__ long long __ldcv(const long long *ptr) { unsigned long long ret; asm ("ld.global.cv.s64 %0, [%1];" : "=l"(ret) : "l" (ptr) : "memory"); return (long long)ret; } +static __attribute__((device)) __inline__ char2 __ldcv(const char2 *ptr) { char2 ret; int2 tmp; asm ("ld.global.cv.v2.s8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr) : "memory"); ret.x = (char)tmp.x; ret.y = (char)tmp.y; return ret; } +static __attribute__((device)) __inline__ char4 __ldcv(const char4 *ptr) { char4 ret; int4 tmp; asm ("ld.global.cv.v4.s8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr) : "memory"); ret.x = (char)tmp.x; ret.y = (char)tmp.y; ret.z = (char)tmp.z; ret.w = (char)tmp.w; return ret; } +static __attribute__((device)) __inline__ short2 __ldcv(const short2 *ptr) { short2 ret; asm ("ld.global.cv.v2.s16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ short4 __ldcv(const short4 *ptr) { short4 ret; asm ("ld.global.cv.v4.s16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ int2 __ldcv(const int2 *ptr) { int2 ret; asm ("ld.global.cv.v2.s32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ int4 __ldcv(const int4 *ptr) { int4 ret; asm ("ld.global.cv.v4.s32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ longlong2 __ldcv(const longlong2 *ptr) { longlong2 ret; asm ("ld.global.cv.v2.s64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr) : "memory"); return ret; } + +static __attribute__((device)) __inline__ unsigned char __ldcv(const unsigned char *ptr) { unsigned int ret; asm ("ld.global.cv.u8 %0, [%1];" : "=r"(ret) : "l" (ptr) : "memory"); return (unsigned char)ret; } +static __attribute__((device)) __inline__ unsigned short __ldcv(const unsigned short *ptr) { unsigned short ret; asm ("ld.global.cv.u16 %0, [%1];" : "=h"(ret) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ unsigned int __ldcv(const unsigned int *ptr) { unsigned int ret; asm ("ld.global.cv.u32 %0, [%1];" : "=r"(ret) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ unsigned long long __ldcv(const unsigned long long *ptr) { unsigned long long ret; asm ("ld.global.cv.u64 %0, [%1];" : "=l"(ret) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ uchar2 __ldcv(const uchar2 *ptr) { uchar2 ret; uint2 tmp; asm ("ld.global.cv.v2.u8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr) : "memory"); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; return ret; } +static __attribute__((device)) __inline__ uchar4 __ldcv(const uchar4 *ptr) { uchar4 ret; uint4 tmp; asm ("ld.global.cv.v4.u8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr) : "memory"); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; ret.z = (unsigned char)tmp.z; ret.w = (unsigned char)tmp.w; return ret; } +static __attribute__((device)) __inline__ ushort2 __ldcv(const ushort2 *ptr) { ushort2 ret; asm ("ld.global.cv.v2.u16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ ushort4 __ldcv(const ushort4 *ptr) { ushort4 ret; asm ("ld.global.cv.v4.u16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ uint2 __ldcv(const uint2 *ptr) { uint2 ret; asm ("ld.global.cv.v2.u32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ uint4 __ldcv(const uint4 *ptr) { uint4 ret; asm ("ld.global.cv.v4.u32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ ulonglong2 __ldcv(const ulonglong2 *ptr) { ulonglong2 ret; asm ("ld.global.cv.v2.u64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr) : "memory"); return ret; } + +static __attribute__((device)) __inline__ float __ldcv(const float *ptr) { float ret; asm ("ld.global.cv.f32 %0, [%1];" : "=f"(ret) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ double __ldcv(const double *ptr) { double ret; asm ("ld.global.cv.f64 %0, [%1];" : "=d"(ret) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ float2 __ldcv(const float2 *ptr) { float2 ret; asm ("ld.global.cv.v2.f32 {%0,%1}, [%2];" : "=f"(ret.x), "=f"(ret.y) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ float4 __ldcv(const float4 *ptr) { float4 ret; asm ("ld.global.cv.v4.f32 {%0,%1,%2,%3}, [%4];" : "=f"(ret.x), "=f"(ret.y), "=f"(ret.z), "=f"(ret.w) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ double2 __ldcv(const double2 *ptr) { double2 ret; asm ("ld.global.cv.v2.f64 {%0,%1}, [%2];" : "=d"(ret.x), "=d"(ret.y) : "l" (ptr) : "memory"); return ret; } + + + + + + + +static __attribute__((device)) __inline__ void __stwb(long *ptr, long value) { asm ("st.global.wb.s64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(unsigned long *ptr, unsigned long value) { asm ("st.global.wb.u64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } + + + + + + +static __attribute__((device)) __inline__ void __stwb(char *ptr, char value) { asm ("st.global.wb.s8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(signed char *ptr, signed char value) { asm ("st.global.wb.s8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(short *ptr, short value) { asm ("st.global.wb.s16 [%0], %1;" :: "l" (ptr), "h"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(int *ptr, int value) { asm ("st.global.wb.s32 [%0], %1;" :: "l" (ptr), "r"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(long long *ptr, long long value) { asm ("st.global.wb.s64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(char2 *ptr, char2 value) { const int x = value.x, y = value.y; asm ("st.global.wb.v2.s8 [%0], {%1,%2};" :: "l" (ptr), "r"(x), "r"(y) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(char4 *ptr, char4 value) { const int x = value.x, y = value.y, z = value.z, w = value.w; asm ("st.global.wb.v4.s8 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(x), "r"(y), "r"(z), "r"(w) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(short2 *ptr, short2 value) { asm ("st.global.wb.v2.s16 [%0], {%1,%2};" :: "l" (ptr), "h"(value.x), "h"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(short4 *ptr, short4 value) { asm ("st.global.wb.v4.s16 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "h"(value.x), "h"(value.y), "h"(value.z), "h"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(int2 *ptr, int2 value) { asm ("st.global.wb.v2.s32 [%0], {%1,%2};" :: "l" (ptr), "r"(value.x), "r"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(int4 *ptr, int4 value) { asm ("st.global.wb.v4.s32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(value.x), "r"(value.y), "r"(value.z), "r"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(longlong2 *ptr, longlong2 value) { asm ("st.global.wb.v2.s64 [%0], {%1,%2};" :: "l" (ptr), "l"(value.x), "l"(value.y) : "memory"); } + +static __attribute__((device)) __inline__ void __stwb(unsigned char *ptr, unsigned char value) { asm ("st.global.wb.u8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(unsigned short *ptr, unsigned short value) { asm ("st.global.wb.u16 [%0], %1;" :: "l" (ptr), "h"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(unsigned int *ptr, unsigned int value) { asm ("st.global.wb.u32 [%0], %1;" :: "l" (ptr), "r"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(unsigned long long *ptr, unsigned long long value) { asm ("st.global.wb.u64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(uchar2 *ptr, uchar2 value) { const int x = value.x, y = value.y; asm ("st.global.wb.v2.u8 [%0], {%1,%2};" :: "l" (ptr), "r"(x), "r"(y) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(uchar4 *ptr, uchar4 value) { const int x = value.x, y = value.y, z = value.z, w = value.w; asm ("st.global.wb.v4.u8 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(x), "r"(y), "r"(z), "r"(w) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(ushort2 *ptr, ushort2 value) { asm ("st.global.wb.v2.u16 [%0], {%1,%2};" :: "l" (ptr), "h"(value.x), "h"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(ushort4 *ptr, ushort4 value) { asm ("st.global.wb.v4.u16 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "h"(value.x), "h"(value.y), "h"(value.z), "h"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(uint2 *ptr, uint2 value) { asm ("st.global.wb.v2.u32 [%0], {%1,%2};" :: "l" (ptr), "r"(value.x), "r"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(uint4 *ptr, uint4 value) { asm ("st.global.wb.v4.u32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(value.x), "r"(value.y), "r"(value.z), "r"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(ulonglong2 *ptr, ulonglong2 value) { asm ("st.global.wb.v2.u64 [%0], {%1,%2};" :: "l" (ptr), "l"(value.x), "l"(value.y) : "memory"); } + +static __attribute__((device)) __inline__ void __stwb(float *ptr, float value) { asm ("st.global.wb.f32 [%0], %1;" :: "l" (ptr), "f"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(double *ptr, double value) { asm ("st.global.wb.f64 [%0], %1;" :: "l" (ptr), "d"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(float2 *ptr, float2 value) { asm ("st.global.wb.v2.f32 [%0], {%1,%2};" :: "l" (ptr), "f"(value.x), "f"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(float4 *ptr, float4 value) { asm ("st.global.wb.v4.f32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "f"(value.x), "f"(value.y), "f"(value.z), "f"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(double2 *ptr, double2 value) { asm ("st.global.wb.v2.f64 [%0], {%1,%2};" :: "l" (ptr), "d"(value.x), "d"(value.y) : "memory"); } + + + + + + + +static __attribute__((device)) __inline__ void __stcg(long *ptr, long value) { asm ("st.global.cg.s64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(unsigned long *ptr, unsigned long value) { asm ("st.global.cg.u64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } + + + + + + +static __attribute__((device)) __inline__ void __stcg(char *ptr, char value) { asm ("st.global.cg.s8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(signed char *ptr, signed char value) { asm ("st.global.cg.s8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(short *ptr, short value) { asm ("st.global.cg.s16 [%0], %1;" :: "l" (ptr), "h"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(int *ptr, int value) { asm ("st.global.cg.s32 [%0], %1;" :: "l" (ptr), "r"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(long long *ptr, long long value) { asm ("st.global.cg.s64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(char2 *ptr, char2 value) { const int x = value.x, y = value.y; asm ("st.global.cg.v2.s8 [%0], {%1,%2};" :: "l" (ptr), "r"(x), "r"(y) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(char4 *ptr, char4 value) { const int x = value.x, y = value.y, z = value.z, w = value.w; asm ("st.global.cg.v4.s8 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(x), "r"(y), "r"(z), "r"(w) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(short2 *ptr, short2 value) { asm ("st.global.cg.v2.s16 [%0], {%1,%2};" :: "l" (ptr), "h"(value.x), "h"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(short4 *ptr, short4 value) { asm ("st.global.cg.v4.s16 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "h"(value.x), "h"(value.y), "h"(value.z), "h"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(int2 *ptr, int2 value) { asm ("st.global.cg.v2.s32 [%0], {%1,%2};" :: "l" (ptr), "r"(value.x), "r"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(int4 *ptr, int4 value) { asm ("st.global.cg.v4.s32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(value.x), "r"(value.y), "r"(value.z), "r"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(longlong2 *ptr, longlong2 value) { asm ("st.global.cg.v2.s64 [%0], {%1,%2};" :: "l" (ptr), "l"(value.x), "l"(value.y) : "memory"); } + +static __attribute__((device)) __inline__ void __stcg(unsigned char *ptr, unsigned char value) { asm ("st.global.cg.u8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(unsigned short *ptr, unsigned short value) { asm ("st.global.cg.u16 [%0], %1;" :: "l" (ptr), "h"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(unsigned int *ptr, unsigned int value) { asm ("st.global.cg.u32 [%0], %1;" :: "l" (ptr), "r"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(unsigned long long *ptr, unsigned long long value) { asm ("st.global.cg.u64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(uchar2 *ptr, uchar2 value) { const int x = value.x, y = value.y; asm ("st.global.cg.v2.u8 [%0], {%1,%2};" :: "l" (ptr), "r"(x), "r"(y) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(uchar4 *ptr, uchar4 value) { const int x = value.x, y = value.y, z = value.z, w = value.w; asm ("st.global.cg.v4.u8 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(x), "r"(y), "r"(z), "r"(w) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(ushort2 *ptr, ushort2 value) { asm ("st.global.cg.v2.u16 [%0], {%1,%2};" :: "l" (ptr), "h"(value.x), "h"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(ushort4 *ptr, ushort4 value) { asm ("st.global.cg.v4.u16 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "h"(value.x), "h"(value.y), "h"(value.z), "h"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(uint2 *ptr, uint2 value) { asm ("st.global.cg.v2.u32 [%0], {%1,%2};" :: "l" (ptr), "r"(value.x), "r"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(uint4 *ptr, uint4 value) { asm ("st.global.cg.v4.u32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(value.x), "r"(value.y), "r"(value.z), "r"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(ulonglong2 *ptr, ulonglong2 value) { asm ("st.global.cg.v2.u64 [%0], {%1,%2};" :: "l" (ptr), "l"(value.x), "l"(value.y) : "memory"); } + +static __attribute__((device)) __inline__ void __stcg(float *ptr, float value) { asm ("st.global.cg.f32 [%0], %1;" :: "l" (ptr), "f"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(double *ptr, double value) { asm ("st.global.cg.f64 [%0], %1;" :: "l" (ptr), "d"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(float2 *ptr, float2 value) { asm ("st.global.cg.v2.f32 [%0], {%1,%2};" :: "l" (ptr), "f"(value.x), "f"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(float4 *ptr, float4 value) { asm ("st.global.cg.v4.f32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "f"(value.x), "f"(value.y), "f"(value.z), "f"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(double2 *ptr, double2 value) { asm ("st.global.cg.v2.f64 [%0], {%1,%2};" :: "l" (ptr), "d"(value.x), "d"(value.y) : "memory"); } + + + + + + + +static __attribute__((device)) __inline__ void __stcs(long *ptr, long value) { asm ("st.global.cs.s64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(unsigned long *ptr, unsigned long value) { asm ("st.global.cs.u64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } + + + + + + +static __attribute__((device)) __inline__ void __stcs(char *ptr, char value) { asm ("st.global.cs.s8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(signed char *ptr, signed char value) { asm ("st.global.cs.s8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(short *ptr, short value) { asm ("st.global.cs.s16 [%0], %1;" :: "l" (ptr), "h"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(int *ptr, int value) { asm ("st.global.cs.s32 [%0], %1;" :: "l" (ptr), "r"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(long long *ptr, long long value) { asm ("st.global.cs.s64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(char2 *ptr, char2 value) { const int x = value.x, y = value.y; asm ("st.global.cs.v2.s8 [%0], {%1,%2};" :: "l" (ptr), "r"(x), "r"(y) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(char4 *ptr, char4 value) { const int x = value.x, y = value.y, z = value.z, w = value.w; asm ("st.global.cs.v4.s8 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(x), "r"(y), "r"(z), "r"(w) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(short2 *ptr, short2 value) { asm ("st.global.cs.v2.s16 [%0], {%1,%2};" :: "l" (ptr), "h"(value.x), "h"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(short4 *ptr, short4 value) { asm ("st.global.cs.v4.s16 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "h"(value.x), "h"(value.y), "h"(value.z), "h"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(int2 *ptr, int2 value) { asm ("st.global.cs.v2.s32 [%0], {%1,%2};" :: "l" (ptr), "r"(value.x), "r"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(int4 *ptr, int4 value) { asm ("st.global.cs.v4.s32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(value.x), "r"(value.y), "r"(value.z), "r"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(longlong2 *ptr, longlong2 value) { asm ("st.global.cs.v2.s64 [%0], {%1,%2};" :: "l" (ptr), "l"(value.x), "l"(value.y) : "memory"); } + +static __attribute__((device)) __inline__ void __stcs(unsigned char *ptr, unsigned char value) { asm ("st.global.cs.u8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(unsigned short *ptr, unsigned short value) { asm ("st.global.cs.u16 [%0], %1;" :: "l" (ptr), "h"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(unsigned int *ptr, unsigned int value) { asm ("st.global.cs.u32 [%0], %1;" :: "l" (ptr), "r"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(unsigned long long *ptr, unsigned long long value) { asm ("st.global.cs.u64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(uchar2 *ptr, uchar2 value) { const int x = value.x, y = value.y; asm ("st.global.cs.v2.u8 [%0], {%1,%2};" :: "l" (ptr), "r"(x), "r"(y) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(uchar4 *ptr, uchar4 value) { const int x = value.x, y = value.y, z = value.z, w = value.w; asm ("st.global.cs.v4.u8 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(x), "r"(y), "r"(z), "r"(w) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(ushort2 *ptr, ushort2 value) { asm ("st.global.cs.v2.u16 [%0], {%1,%2};" :: "l" (ptr), "h"(value.x), "h"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(ushort4 *ptr, ushort4 value) { asm ("st.global.cs.v4.u16 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "h"(value.x), "h"(value.y), "h"(value.z), "h"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(uint2 *ptr, uint2 value) { asm ("st.global.cs.v2.u32 [%0], {%1,%2};" :: "l" (ptr), "r"(value.x), "r"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(uint4 *ptr, uint4 value) { asm ("st.global.cs.v4.u32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(value.x), "r"(value.y), "r"(value.z), "r"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(ulonglong2 *ptr, ulonglong2 value) { asm ("st.global.cs.v2.u64 [%0], {%1,%2};" :: "l" (ptr), "l"(value.x), "l"(value.y) : "memory"); } + +static __attribute__((device)) __inline__ void __stcs(float *ptr, float value) { asm ("st.global.cs.f32 [%0], %1;" :: "l" (ptr), "f"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(double *ptr, double value) { asm ("st.global.cs.f64 [%0], %1;" :: "l" (ptr), "d"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(float2 *ptr, float2 value) { asm ("st.global.cs.v2.f32 [%0], {%1,%2};" :: "l" (ptr), "f"(value.x), "f"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(float4 *ptr, float4 value) { asm ("st.global.cs.v4.f32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "f"(value.x), "f"(value.y), "f"(value.z), "f"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(double2 *ptr, double2 value) { asm ("st.global.cs.v2.f64 [%0], {%1,%2};" :: "l" (ptr), "d"(value.x), "d"(value.y) : "memory"); } + + + + + + + +static __attribute__((device)) __inline__ void __stwt(long *ptr, long value) { asm ("st.global.wt.s64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(unsigned long *ptr, unsigned long value) { asm ("st.global.wt.u64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } + + + + + + +static __attribute__((device)) __inline__ void __stwt(char *ptr, char value) { asm ("st.global.wt.s8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(signed char *ptr, signed char value) { asm ("st.global.wt.s8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(short *ptr, short value) { asm ("st.global.wt.s16 [%0], %1;" :: "l" (ptr), "h"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(int *ptr, int value) { asm ("st.global.wt.s32 [%0], %1;" :: "l" (ptr), "r"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(long long *ptr, long long value) { asm ("st.global.wt.s64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(char2 *ptr, char2 value) { const int x = value.x, y = value.y; asm ("st.global.wt.v2.s8 [%0], {%1,%2};" :: "l" (ptr), "r"(x), "r"(y) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(char4 *ptr, char4 value) { const int x = value.x, y = value.y, z = value.z, w = value.w; asm ("st.global.wt.v4.s8 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(x), "r"(y), "r"(z), "r"(w) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(short2 *ptr, short2 value) { asm ("st.global.wt.v2.s16 [%0], {%1,%2};" :: "l" (ptr), "h"(value.x), "h"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(short4 *ptr, short4 value) { asm ("st.global.wt.v4.s16 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "h"(value.x), "h"(value.y), "h"(value.z), "h"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(int2 *ptr, int2 value) { asm ("st.global.wt.v2.s32 [%0], {%1,%2};" :: "l" (ptr), "r"(value.x), "r"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(int4 *ptr, int4 value) { asm ("st.global.wt.v4.s32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(value.x), "r"(value.y), "r"(value.z), "r"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(longlong2 *ptr, longlong2 value) { asm ("st.global.wt.v2.s64 [%0], {%1,%2};" :: "l" (ptr), "l"(value.x), "l"(value.y) : "memory"); } + +static __attribute__((device)) __inline__ void __stwt(unsigned char *ptr, unsigned char value) { asm ("st.global.wt.u8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(unsigned short *ptr, unsigned short value) { asm ("st.global.wt.u16 [%0], %1;" :: "l" (ptr), "h"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(unsigned int *ptr, unsigned int value) { asm ("st.global.wt.u32 [%0], %1;" :: "l" (ptr), "r"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(unsigned long long *ptr, unsigned long long value) { asm ("st.global.wt.u64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(uchar2 *ptr, uchar2 value) { const int x = value.x, y = value.y; asm ("st.global.wt.v2.u8 [%0], {%1,%2};" :: "l" (ptr), "r"(x), "r"(y) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(uchar4 *ptr, uchar4 value) { const int x = value.x, y = value.y, z = value.z, w = value.w; asm ("st.global.wt.v4.u8 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(x), "r"(y), "r"(z), "r"(w) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(ushort2 *ptr, ushort2 value) { asm ("st.global.wt.v2.u16 [%0], {%1,%2};" :: "l" (ptr), "h"(value.x), "h"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(ushort4 *ptr, ushort4 value) { asm ("st.global.wt.v4.u16 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "h"(value.x), "h"(value.y), "h"(value.z), "h"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(uint2 *ptr, uint2 value) { asm ("st.global.wt.v2.u32 [%0], {%1,%2};" :: "l" (ptr), "r"(value.x), "r"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(uint4 *ptr, uint4 value) { asm ("st.global.wt.v4.u32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(value.x), "r"(value.y), "r"(value.z), "r"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(ulonglong2 *ptr, ulonglong2 value) { asm ("st.global.wt.v2.u64 [%0], {%1,%2};" :: "l" (ptr), "l"(value.x), "l"(value.y) : "memory"); } + +static __attribute__((device)) __inline__ void __stwt(float *ptr, float value) { asm ("st.global.wt.f32 [%0], %1;" :: "l" (ptr), "f"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(double *ptr, double value) { asm ("st.global.wt.f64 [%0], %1;" :: "l" (ptr), "d"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(float2 *ptr, float2 value) { asm ("st.global.wt.v2.f32 [%0], {%1,%2};" :: "l" (ptr), "f"(value.x), "f"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(float4 *ptr, float4 value) { asm ("st.global.wt.v4.f32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "f"(value.x), "f"(value.y), "f"(value.z), "f"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(double2 *ptr, double2 value) { asm ("st.global.wt.v2.f64 [%0], {%1,%2};" :: "l" (ptr), "d"(value.x), "d"(value.y) : "memory"); } +# 553 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.hpp" +static __attribute__((device)) __inline__ unsigned int __funnelshift_l(unsigned int lo, unsigned int hi, unsigned int shift) +{ + unsigned int ret; + asm volatile ("shf.l.wrap.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(lo), "r"(hi), "r"(shift)); + return ret; +} +static __attribute__((device)) __inline__ unsigned int __funnelshift_lc(unsigned int lo, unsigned int hi, unsigned int shift) +{ + unsigned int ret; + asm volatile ("shf.l.clamp.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(lo), "r"(hi), "r"(shift)); + return ret; +} + + +static __attribute__((device)) __inline__ unsigned int __funnelshift_r(unsigned int lo, unsigned int hi, unsigned int shift) +{ + unsigned int ret; + asm volatile ("shf.r.wrap.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(lo), "r"(hi), "r"(shift)); + return ret; +} +static __attribute__((device)) __inline__ unsigned int __funnelshift_rc(unsigned int lo, unsigned int hi, unsigned int shift) +{ + unsigned int ret; + asm volatile ("shf.r.clamp.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(lo), "r"(hi), "r"(shift)); + return ret; +} +# 513 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" 2 +# 2911 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_35_intrinsics.h" 1 +# 2912 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" 1 +# 235 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.hpp" 1 +# 236 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" 2 +# 2913 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" 1 +# 128 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.hpp" 1 +# 129 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" 2 +# 2914 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" 1 +# 156 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.hpp" 1 +# 157 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" 2 +# 2915 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" 1 +# 273 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.hpp" 1 +# 274 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" 2 +# 2916 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" 1 +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.hpp" 1 +# 245 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" 2 +# 2917 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" 1 +# 65 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template struct __nv_itex_trait { }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1Dfetch(T *ptr, cudaTextureObject_t obj, int x) +{ + __nv_tex_surf_handler("__itex1Dfetch", ptr, obj, x); +} + +template +static __attribute__((device)) T tex1Dfetch(cudaTextureObject_t texObject, int x) +{ + T ret; + tex1Dfetch(&ret, texObject, x); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1D(T *ptr, cudaTextureObject_t obj, float x) +{ + __nv_tex_surf_handler("__itex1D", ptr, obj, x); +} + + +template +static __attribute__((device)) T tex1D(cudaTextureObject_t texObject, float x) +{ + T ret; + tex1D(&ret, texObject, x); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2D(T *ptr, cudaTextureObject_t obj, float x, float y) +{ + __nv_tex_surf_handler("__itex2D", ptr, obj, x, y); +} + +template +static __attribute__((device)) T tex2D(cudaTextureObject_t texObject, float x, float y) +{ + T ret; + tex2D(&ret, texObject, x, y); + return ret; +} +# 173 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template +static __attribute__((device)) typename __nv_itex_trait::type tex3D(T *ptr, cudaTextureObject_t obj, float x, float y, float z) +{ + __nv_tex_surf_handler("__itex3D", ptr, obj, x, y, z); +} + +template +static __attribute__((device)) T tex3D(cudaTextureObject_t texObject, float x, float y, float z) +{ + T ret; + tex3D(&ret, texObject, x, y, z); + return ret; +} +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DLayered(T *ptr, cudaTextureObject_t obj, float x, int layer) +{ + __nv_tex_surf_handler("__itex1DLayered", ptr, obj, x, layer); +} + +template +static __attribute__((device)) T tex1DLayered(cudaTextureObject_t texObject, float x, int layer) +{ + T ret; + tex1DLayered(&ret, texObject, x, layer); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayered(T *ptr, cudaTextureObject_t obj, float x, float y, int layer) +{ + __nv_tex_surf_handler("__itex2DLayered", ptr, obj, x, y, layer); +} + +template +static __attribute__((device)) T tex2DLayered(cudaTextureObject_t texObject, float x, float y, int layer) +{ + T ret; + tex2DLayered(&ret, texObject, x, y, layer); + return ret; +} +# 254 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemap(T *ptr, cudaTextureObject_t obj, float x, float y, float z) +{ + __nv_tex_surf_handler("__itexCubemap", ptr, obj, x, y, z); +} + + +template +static __attribute__((device)) T texCubemap(cudaTextureObject_t texObject, float x, float y, float z) +{ + T ret; + texCubemap(&ret, texObject, x, y, z); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapLayered(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer) +{ + __nv_tex_surf_handler("__itexCubemapLayered", ptr, obj, x, y, z, layer); +} + +template +static __attribute__((device)) T texCubemapLayered(cudaTextureObject_t texObject, float x, float y, float z, int layer) +{ + T ret; + texCubemapLayered(&ret, texObject, x, y, z, layer); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2Dgather(T *ptr, cudaTextureObject_t obj, float x, float y, int comp = 0) +{ + __nv_tex_surf_handler("__itex2Dgather", ptr, obj, x, y, comp); +} + +template +static __attribute__((device)) T tex2Dgather(cudaTextureObject_t to, float x, float y, int comp = 0) +{ + T ret; + tex2Dgather(&ret, to, x, y, comp); + return ret; +} +# 317 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DLod(T *ptr, cudaTextureObject_t obj, float x, float level) +{ + __nv_tex_surf_handler("__itex1DLod", ptr, obj, x, level); +} + +template +static __attribute__((device)) T tex1DLod(cudaTextureObject_t texObject, float x, float level) +{ + T ret; + tex1DLod(&ret, texObject, x, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float level) +{ + __nv_tex_surf_handler("__itex2DLod", ptr, obj, x, y, level); +} + +template +static __attribute__((device)) T tex2DLod(cudaTextureObject_t texObject, float x, float y, float level) +{ + T ret; + tex2DLod(&ret, texObject, x, y, level); + return ret; +} +# 367 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template +static __attribute__((device)) typename __nv_itex_trait::type tex3DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level) +{ + __nv_tex_surf_handler("__itex3DLod", ptr, obj, x, y, z, level); +} + +template +static __attribute__((device)) T tex3DLod(cudaTextureObject_t texObject, float x, float y, float z, float level) +{ + T ret; + tex3DLod(&ret, texObject, x, y, z, level); + return ret; +} +# 401 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, int layer, float level) +{ + __nv_tex_surf_handler("__itex1DLayeredLod", ptr, obj, x, layer, level); +} + +template +static __attribute__((device)) T tex1DLayeredLod(cudaTextureObject_t texObject, float x, int layer, float level) +{ + T ret; + tex1DLayeredLod(&ret, texObject, x, layer, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, float level) +{ + __nv_tex_surf_handler("__itex2DLayeredLod", ptr, obj, x, y, layer, level); +} + +template +static __attribute__((device)) T tex2DLayeredLod(cudaTextureObject_t texObject, float x, float y, int layer, float level) +{ + T ret; + tex2DLayeredLod(&ret, texObject, x, y, layer, level); + return ret; +} +# 448 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level) +{ + __nv_tex_surf_handler("__itexCubemapLod", ptr, obj, x, y, z, level); +} + +template +static __attribute__((device)) T texCubemapLod(cudaTextureObject_t texObject, float x, float y, float z, float level) +{ + T ret; + texCubemapLod(&ret, texObject, x, y, z, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + __nv_tex_surf_handler("__itexCubemapGrad_v2", ptr, obj, x, y, z, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T texCubemapGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + T ret; + texCubemapGrad(&ret, texObject, x, y, z, dPdx, dPdy); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer, float level) +{ + __nv_tex_surf_handler("__itexCubemapLayeredLod", ptr, obj, x, y, z, layer, level); +} + +template +static __attribute__((device)) T texCubemapLayeredLod(cudaTextureObject_t texObject, float x, float y, float z, int layer, float level) +{ + T ret; + texCubemapLayeredLod(&ret, texObject, x, y, z, layer, level); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DGrad(T *ptr, cudaTextureObject_t obj, float x, float dPdx, float dPdy) +{ + __nv_tex_surf_handler("__itex1DGrad", ptr, obj, x, dPdx, dPdy); +} + +template +static __attribute__((device)) T tex1DGrad(cudaTextureObject_t texObject, float x, float dPdx, float dPdy) +{ + T ret; + tex1DGrad(&ret, texObject, x, dPdx, dPdy); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float2 dPdx, float2 dPdy) +{ + __nv_tex_surf_handler("__itex2DGrad_v2", ptr, obj, x, y, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T tex2DGrad(cudaTextureObject_t texObject, float x, float y, float2 dPdx, float2 dPdy) +{ + T ret; + tex2DGrad(&ret, texObject, x, y, dPdx, dPdy); + return ret; +} +# 539 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template +static __attribute__((device)) typename __nv_itex_trait::type tex3DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + __nv_tex_surf_handler("__itex3DGrad_v2", ptr, obj, x, y, z, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T tex3DGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + T ret; + tex3DGrad(&ret, texObject, x, y, z, dPdx, dPdy); + return ret; +} +# 573 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DLayeredGrad(T *ptr, cudaTextureObject_t obj, float x, int layer, float dPdx, float dPdy) +{ + __nv_tex_surf_handler("__itex1DLayeredGrad", ptr, obj, x, layer, dPdx, dPdy); +} + +template +static __attribute__((device)) T tex1DLayeredGrad(cudaTextureObject_t texObject, float x, int layer, float dPdx, float dPdy) +{ + T ret; + tex1DLayeredGrad(&ret, texObject, x, layer, dPdx, dPdy); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayeredGrad(T * ptr, cudaTextureObject_t obj, float x, float y, int layer, float2 dPdx, float2 dPdy) +{ + __nv_tex_surf_handler("__itex2DLayeredGrad_v2", ptr, obj, x, y, layer, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T tex2DLayeredGrad(cudaTextureObject_t texObject, float x, float y, int layer, float2 dPdx, float2 dPdy) +{ + T ret; + tex2DLayeredGrad(&ret, texObject, x, y, layer, dPdx, dPdy); + return ret; +} +# 621 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapLayeredGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer, float4 dPdx, float4 dPdy) +{ + __nv_tex_surf_handler("__itexCubemapLayeredGrad_v2", ptr, obj, x, y, z, layer, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T texCubemapLayeredGrad(cudaTextureObject_t texObject, float x, float y, float z, int layer, float4 dPdx, float4 dPdy) +{ + T ret; + texCubemapLayeredGrad(&ret, texObject, x, y, z, layer, dPdx, dPdy); + return ret; +} +# 2919 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" 1 +# 58 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template struct __nv_isurf_trait { }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; + +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; + +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; + + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf1Dread(T *ptr, cudaSurfaceObject_t obj, int x, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf1Dread", ptr, obj, x, mode); +} + +template +static __attribute__((device)) T surf1Dread(cudaSurfaceObject_t surfObject, int x, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf1Dread(&ret, surfObject, x, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf2Dread(T *ptr, cudaSurfaceObject_t obj, int x, int y, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf2Dread", ptr, obj, x, y, mode); +} + +template +static __attribute__((device)) T surf2Dread(cudaSurfaceObject_t surfObject, int x, int y, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf2Dread(&ret, surfObject, x, y, boundaryMode); + return ret; +} + + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf3Dread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int z, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf3Dread", ptr, obj, x, y, z, mode); +} + +template +static __attribute__((device)) T surf3Dread(cudaSurfaceObject_t surfObject, int x, int y, int z, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf3Dread(&ret, surfObject, x, y, z, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf1DLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf1DLayeredread", ptr, obj, x, layer, mode); +} + +template +static __attribute__((device)) T surf1DLayeredread(cudaSurfaceObject_t surfObject, int x, int layer, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf1DLayeredread(&ret, surfObject, x, layer, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf2DLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf2DLayeredread", ptr, obj, x, y, layer, mode); +} + +template +static __attribute__((device)) T surf2DLayeredread(cudaSurfaceObject_t surfObject, int x, int y, int layer, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf2DLayeredread(&ret, surfObject, x, y, layer, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surfCubemapread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int face, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurfCubemapread", ptr, obj, x, y, face, mode); +} + +template +static __attribute__((device)) T surfCubemapread(cudaSurfaceObject_t surfObject, int x, int y, int face, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surfCubemapread(&ret, surfObject, x, y, face, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surfCubemapLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int layerface, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurfCubemapLayeredread", ptr, obj, x, y, layerface, mode); +} + +template +static __attribute__((device)) T surfCubemapLayeredread(cudaSurfaceObject_t surfObject, int x, int y, int layerface, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surfCubemapLayeredread(&ret, surfObject, x, y, layerface, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf1Dwrite(T val, cudaSurfaceObject_t obj, int x, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf1Dwrite_v2", &val, obj, x, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf2Dwrite(T val, cudaSurfaceObject_t obj, int x, int y, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf2Dwrite_v2", &val, obj, x, y, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf3Dwrite(T val, cudaSurfaceObject_t obj, int x, int y, int z, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf3Dwrite_v2", &val, obj, x, y, z, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf1DLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf1DLayeredwrite_v2", &val, obj, x, layer, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf2DLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int y, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf2DLayeredwrite_v2", &val, obj, x, y, layer, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surfCubemapwrite(T val, cudaSurfaceObject_t obj, int x, int y, int face, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurfCubemapwrite_v2", &val, obj, x, y, face, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surfCubemapLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int y, int layerface, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurfCubemapLayeredwrite_v2", &val, obj, x, y, layerface, mode); +} +# 2920 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/cudacc_ext.h" 1 +# 2922 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 + + +extern "C" __attribute__((host)) __attribute__((device)) unsigned __cudaPushCallConfiguration(dim3 gridDim, + dim3 blockDim, + size_t sharedMem = 0, + struct CUstream_st *stream = 0); +# 2969 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +enum { + __NV_ATOMIC_RELAXED, + __NV_ATOMIC_CONSUME, + __NV_ATOMIC_ACQUIRE, + __NV_ATOMIC_RELEASE, + __NV_ATOMIC_ACQ_REL, + __NV_ATOMIC_SEQ_CST +}; + +enum { + __NV_THREAD_SCOPE_THREAD, + __NV_THREAD_SCOPE_BLOCK, + __NV_THREAD_SCOPE_CLUSTER, + __NV_THREAD_SCOPE_DEVICE, + __NV_THREAD_SCOPE_SYSTEM +}; +# 119 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/device_launch_parameters.h" 1 +# 68 "/opt/cuda/bin/../targets/x86_64-linux/include/device_launch_parameters.h" +extern "C" { + + +uint3 __attribute__((device_builtin)) extern const threadIdx; +uint3 __attribute__((device_builtin)) extern const blockIdx; +dim3 __attribute__((device_builtin)) extern const blockDim; +dim3 __attribute__((device_builtin)) extern const gridDim; +int __attribute__((device_builtin)) extern const warpSize; + + + + +} +# 120 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 148 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 1 3 +# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 + +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 1 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 + +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + namespace rel_ops + { +# 86 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 + template + inline bool + operator!=(const _Tp& __x, const _Tp& __y) + { return !(__x == __y); } +# 99 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 + template + inline bool + operator>(const _Tp& __x, const _Tp& __y) + { return __y < __x; } +# 112 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 + template + inline bool + operator<=(const _Tp& __x, const _Tp& __y) + { return !(__y < __x); } +# 125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 + template + inline bool + operator>=(const _Tp& __x, const _Tp& __y) + { return !(__x < __y); } + } + + +} +# 69 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 2 3 + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/initializer_list" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/initializer_list" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/initializer_list" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + template + class initializer_list + { + public: + typedef _E value_type; + typedef const _E& reference; + typedef const _E& const_reference; + typedef size_t size_type; + typedef const _E* iterator; + typedef const _E* const_iterator; + + private: + iterator _M_array; + size_type _M_len; + + + constexpr initializer_list(const_iterator __a, size_type __l) + : _M_array(__a), _M_len(__l) { } + + public: + constexpr initializer_list() noexcept + : _M_array(0), _M_len(0) { } + + + constexpr size_type + size() const noexcept { return _M_len; } + + + constexpr const_iterator + begin() const noexcept { return _M_array; } + + + constexpr const_iterator + end() const noexcept { return begin() + size(); } + }; + + + + + + + + template + constexpr const _Tp* + begin(initializer_list<_Tp> __ils) noexcept + { return __ils.begin(); } + + + + + + + + template + constexpr const _Tp* + end(initializer_list<_Tp> __ils) noexcept + { return __ils.end(); } +} +# 74 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 2 3 +# 96 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 97 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template + + inline _Tp + exchange(_Tp& __obj, _Up&& __new_val) + noexcept(__and_, + is_nothrow_assignable<_Tp&, _Up>>::value) + { return std::__exchange(__obj, std::forward<_Up>(__new_val)); } + + + + template + [[nodiscard]] + constexpr add_const_t<_Tp>& + as_const(_Tp& __t) noexcept + { return __t; } + + template + void as_const(const _Tp&&) = delete; +# 230 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 + +} +# 149 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" + +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchKernel( + T *func, + dim3 gridDim, + dim3 blockDim, + void **args, + size_t sharedMem = 0, + cudaStream_t stream = 0 +) +{ + return ::cudaLaunchKernel((const void *)func, gridDim, blockDim, args, sharedMem, stream); +} +# 279 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchKernelEx( + const cudaLaunchConfig_t *config, + void (*kernel)(ExpTypes...), + ActTypes &&... args +) +{ + return [&](ExpTypes... coercedArgs){ + void *pArgs[] = { &coercedArgs... }; + return ::cudaLaunchKernelExC(config, (const void *)kernel, pArgs); + }(std::forward(args)...); +} +# 348 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchKernelEx( + const cudaLaunchConfig_t *config, + const cudaKernel_t kernel, + ActTypes &&... args +) +{ + void *pArgs[] = { &args... }; + return ::cudaLaunchKernelExC(config, (const void *)kernel, pArgs); +} +# 410 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchCooperativeKernel( + T *func, + dim3 gridDim, + dim3 blockDim, + void **args, + size_t sharedMem = 0, + cudaStream_t stream = 0 +) +{ + return ::cudaLaunchCooperativeKernel((const void *)func, gridDim, blockDim, args, sharedMem, stream); +} +# 454 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaEventCreate( + cudaEvent_t *event, + unsigned int flags +) +{ + return ::cudaEventCreateWithFlags(event, flags); +} +# 498 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaGraphInstantiate( + cudaGraphExec_t *pGraphExec, + cudaGraph_t graph, + cudaGraphNode_t *pErrorNode, + char *pLogBuffer, + size_t bufferSize +) +{ + (void)pErrorNode; + (void)pLogBuffer; + (void)bufferSize; + return ::cudaGraphInstantiate(pGraphExec, graph, 0); +} +# 569 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaMallocHost( + void **ptr, + size_t size, + unsigned int flags +) +{ + return ::cudaHostAlloc(ptr, size, flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaHostAlloc( + T **ptr, + size_t size, + unsigned int flags +) +{ + return ::cudaHostAlloc((void**)(void*)ptr, size, flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaHostGetDevicePointer( + T **pDevice, + void *pHost, + unsigned int flags +) +{ + return ::cudaHostGetDevicePointer((void**)(void*)pDevice, pHost, flags); +} +# 698 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocManaged( + T **devPtr, + size_t size, + unsigned int flags = 0x01 +) +{ + return ::cudaMallocManaged((void**)(void*)devPtr, size, flags); +} +# 716 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +cudaError_t cudaMemAdvise( + T *devPtr, + size_t count, + enum cudaMemoryAdvise advice, + struct cudaMemLocation location +) +{ + return ::cudaMemAdvise_v2((const void *)devPtr, count, advice, location); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMemPrefetchAsync( + T *devPtr, + size_t count, + struct cudaMemLocation location, + unsigned int flags, + cudaStream_t stream = 0 +) +{ + return ::cudaMemPrefetchAsync_v2((const void *)devPtr, count, location, flags, stream); +} +# 819 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaStreamAttachMemAsync( + cudaStream_t stream, + T *devPtr, + size_t length = 0, + unsigned int flags = 0x04 +) +{ + return ::cudaStreamAttachMemAsync(stream, (void*)devPtr, length, flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMalloc( + T **devPtr, + size_t size +) +{ + return ::cudaMalloc((void**)(void*)devPtr, size); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocHost( + T **ptr, + size_t size, + unsigned int flags = 0 +) +{ + return cudaMallocHost((void**)(void*)ptr, size, flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocPitch( + T **devPtr, + size_t *pitch, + size_t width, + size_t height +) +{ + return ::cudaMallocPitch((void**)(void*)devPtr, pitch, width, height); +} +# 869 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaMallocAsync( + void **ptr, + size_t size, + cudaMemPool_t memPool, + cudaStream_t stream +) +{ + return ::cudaMallocFromPoolAsync(ptr, size, memPool, stream); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocAsync( + T **ptr, + size_t size, + cudaMemPool_t memPool, + cudaStream_t stream +) +{ + return ::cudaMallocFromPoolAsync((void**)(void*)ptr, size, memPool, stream); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocAsync( + T **ptr, + size_t size, + cudaStream_t stream +) +{ + return ::cudaMallocAsync((void**)(void*)ptr, size, stream); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocFromPoolAsync( + T **ptr, + size_t size, + cudaMemPool_t memPool, + cudaStream_t stream +) +{ + return ::cudaMallocFromPoolAsync((void**)(void*)ptr, size, memPool, stream); +} +# 919 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyBatchAsync( + T **dsts, U **srcs, size_t *sizes, size_t count, struct cudaMemcpyAttributes *attrs, + size_t *attrsIdxs, size_t numAttrs, size_t *failIdx, cudaStream_t hStream +) +{ + return ::cudaMemcpyBatchAsync((void **)dsts, (void **)srcs, sizes, count, attrs, attrsIdxs, numAttrs, failIdx, hStream); +} +# 938 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyBatchAsync( + T **dsts, U **srcs, size_t *sizes, size_t count, struct cudaMemcpyAttributes attr, size_t *failIdx, cudaStream_t hStream +) +{ + size_t attrsIdxs = 0; + return ::cudaMemcpyBatchAsync((void **)dsts, (void **)srcs, sizes, count, &attr, &attrsIdxs, 1, failIdx, hStream); +} +# 984 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyToSymbol( + const T &symbol, + const void *src, + size_t count, + size_t offset = 0, + enum cudaMemcpyKind kind = cudaMemcpyHostToDevice +) +{ + return ::cudaMemcpyToSymbol((const void*)&symbol, src, count, offset, kind); +} +# 1038 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyToSymbolAsync( + const T &symbol, + const void *src, + size_t count, + size_t offset = 0, + enum cudaMemcpyKind kind = cudaMemcpyHostToDevice, + cudaStream_t stream = 0 +) +{ + return ::cudaMemcpyToSymbolAsync((const void*)&symbol, src, count, offset, kind, stream); +} +# 1086 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyFromSymbol( + void *dst, + const T &symbol, + size_t count, + size_t offset = 0, + enum cudaMemcpyKind kind = cudaMemcpyDeviceToHost +) +{ + return ::cudaMemcpyFromSymbol(dst, (const void*)&symbol, count, offset, kind); +} +# 1140 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyFromSymbolAsync( + void *dst, + const T &symbol, + size_t count, + size_t offset = 0, + enum cudaMemcpyKind kind = cudaMemcpyDeviceToHost, + cudaStream_t stream = 0 +) +{ + return ::cudaMemcpyFromSymbolAsync(dst, (const void*)&symbol, count, offset, kind, stream); +} +# 1209 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphAddMemcpyNodeToSymbol( + cudaGraphNode_t *pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t *pDependencies, + size_t numDependencies, + const T &symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphAddMemcpyNodeToSymbol(pGraphNode, graph, pDependencies, numDependencies, (const void*)&symbol, src, count, offset, kind); +} +# 1280 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphAddMemcpyNodeFromSymbol( + cudaGraphNode_t* pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t* pDependencies, + size_t numDependencies, + void* dst, + const T &symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphAddMemcpyNodeFromSymbol(pGraphNode, graph, pDependencies, numDependencies, dst, (const void*)&symbol, count, offset, kind); +} +# 1331 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParamsToSymbol( + cudaGraphNode_t node, + const T &symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphMemcpyNodeSetParamsToSymbol(node, (const void*)&symbol, src, count, offset, kind); +} +# 1379 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParamsFromSymbol( + cudaGraphNode_t node, + void* dst, + const T &symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphMemcpyNodeSetParamsFromSymbol(node, dst, (const void*)&symbol, count, offset, kind); +} +# 1437 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParamsToSymbol( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + const T &symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphExecMemcpyNodeSetParamsToSymbol(hGraphExec, node, (const void*)&symbol, src, count, offset, kind); +} +# 1496 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParamsFromSymbol( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + void* dst, + const T &symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphExecMemcpyNodeSetParamsFromSymbol(hGraphExec, node, dst, (const void*)&symbol, count, offset, kind); +} + + +static __inline__ __attribute__((host)) cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphNode_t *hErrorNode_out, enum cudaGraphExecUpdateResult *updateResult_out) +{ + cudaGraphExecUpdateResultInfo resultInfo; + cudaError_t status = cudaGraphExecUpdate(hGraphExec, hGraph, &resultInfo); + if (hErrorNode_out) { + *hErrorNode_out = resultInfo.errorNode; + } + if (updateResult_out) { + *updateResult_out = resultInfo.result; + } + return status; +} +# 1549 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaUserObjectCreate( + cudaUserObject_t *object_out, + T *objectToWrap, + unsigned int initialRefcount, + unsigned int flags) +{ + return ::cudaUserObjectCreate( + object_out, + objectToWrap, + [](void *vpObj) { delete reinterpret_cast(vpObj); }, + initialRefcount, + flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaUserObjectCreate( + cudaUserObject_t *object_out, + T *objectToWrap, + unsigned int initialRefcount, + cudaUserObjectFlags flags) +{ + return cudaUserObjectCreate(object_out, objectToWrap, initialRefcount, (unsigned int)flags); +} +# 1599 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetSymbolAddress( + void **devPtr, + const T &symbol +) +{ + return ::cudaGetSymbolAddress(devPtr, (const void*)&symbol); +} +# 1631 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetSymbolSize( + size_t *size, + const T &symbol +) +{ + return ::cudaGetSymbolSize(size, (const void*)&symbol); +} +# 1683 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncSetCacheConfig( + T *func, + enum cudaFuncCache cacheConfig +) +{ + return ::cudaFuncSetCacheConfig((const void*)func, cacheConfig); +} + +template +static __inline__ +__attribute__((deprecated)) +__attribute__((host)) cudaError_t cudaFuncSetSharedMemConfig( + T *func, + enum cudaSharedMemConfig config +) +{ + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + + return ::cudaFuncSetSharedMemConfig((const void*)func, config); + +#pragma GCC diagnostic pop + +} +# 1743 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor( + int *numBlocks, + T func, + int blockSize, + size_t dynamicSMemSize) +{ + return ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, (const void*)func, blockSize, dynamicSMemSize, 0x00); +} +# 1796 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags( + int *numBlocks, + T func, + int blockSize, + size_t dynamicSMemSize, + unsigned int flags) +{ + return ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, (const void*)func, blockSize, dynamicSMemSize, flags); +} + + + + +class __cudaOccupancyB2DHelper { + size_t n; +public: + inline __attribute__((host)) __attribute__((device)) __cudaOccupancyB2DHelper(size_t n_) : n(n_) {} + inline __attribute__((host)) __attribute__((device)) size_t operator()(int) + { + return n; + } +}; +# 1866 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) __attribute__((device)) cudaError_t cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags( + int *minGridSize, + int *blockSize, + T func, + UnaryFunction blockSizeToDynamicSMemSize, + int blockSizeLimit = 0, + unsigned int flags = 0) +{ + cudaError_t status; + + + int device; + struct cudaFuncAttributes attr; + + + int maxThreadsPerMultiProcessor; + int warpSize; + int devMaxThreadsPerBlock; + int multiProcessorCount; + int funcMaxThreadsPerBlock; + int occupancyLimit; + int granularity; + + + int maxBlockSize = 0; + int numBlocks = 0; + int maxOccupancy = 0; + + + int blockSizeToTryAligned; + int blockSizeToTry; + int blockSizeLimitAligned; + int occupancyInBlocks; + int occupancyInThreads; + size_t dynamicSMemSize; + + + + + + if (!minGridSize || !blockSize || !func) { + return cudaErrorInvalidValue; + } + + + + + + status = ::cudaGetDevice(&device); + if (status != cudaSuccess) { + return status; + } + + status = cudaDeviceGetAttribute( + &maxThreadsPerMultiProcessor, + cudaDevAttrMaxThreadsPerMultiProcessor, + device); + if (status != cudaSuccess) { + return status; + } + + status = cudaDeviceGetAttribute( + &warpSize, + cudaDevAttrWarpSize, + device); + if (status != cudaSuccess) { + return status; + } + + status = cudaDeviceGetAttribute( + &devMaxThreadsPerBlock, + cudaDevAttrMaxThreadsPerBlock, + device); + if (status != cudaSuccess) { + return status; + } + + status = cudaDeviceGetAttribute( + &multiProcessorCount, + cudaDevAttrMultiProcessorCount, + device); + if (status != cudaSuccess) { + return status; + } + + status = cudaFuncGetAttributes(&attr, func); + if (status != cudaSuccess) { + return status; + } + + funcMaxThreadsPerBlock = attr.maxThreadsPerBlock; + + + + + + occupancyLimit = maxThreadsPerMultiProcessor; + granularity = warpSize; + + if (blockSizeLimit == 0) { + blockSizeLimit = devMaxThreadsPerBlock; + } + + if (devMaxThreadsPerBlock < blockSizeLimit) { + blockSizeLimit = devMaxThreadsPerBlock; + } + + if (funcMaxThreadsPerBlock < blockSizeLimit) { + blockSizeLimit = funcMaxThreadsPerBlock; + } + + blockSizeLimitAligned = ((blockSizeLimit + (granularity - 1)) / granularity) * granularity; + + for (blockSizeToTryAligned = blockSizeLimitAligned; blockSizeToTryAligned > 0; blockSizeToTryAligned -= granularity) { + + + + if (blockSizeLimit < blockSizeToTryAligned) { + blockSizeToTry = blockSizeLimit; + } else { + blockSizeToTry = blockSizeToTryAligned; + } + + dynamicSMemSize = blockSizeToDynamicSMemSize(blockSizeToTry); + + status = cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags( + &occupancyInBlocks, + func, + blockSizeToTry, + dynamicSMemSize, + flags); + + if (status != cudaSuccess) { + return status; + } + + occupancyInThreads = blockSizeToTry * occupancyInBlocks; + + if (occupancyInThreads > maxOccupancy) { + maxBlockSize = blockSizeToTry; + numBlocks = occupancyInBlocks; + maxOccupancy = occupancyInThreads; + } + + + + if (occupancyLimit == maxOccupancy) { + break; + } + } + + + + + + + + *minGridSize = numBlocks * multiProcessorCount; + *blockSize = maxBlockSize; + + return status; +} +# 2062 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) __attribute__((device)) cudaError_t cudaOccupancyMaxPotentialBlockSizeVariableSMem( + int *minGridSize, + int *blockSize, + T func, + UnaryFunction blockSizeToDynamicSMemSize, + int blockSizeLimit = 0) +{ + return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, blockSizeToDynamicSMemSize, blockSizeLimit, 0x00); +} +# 2108 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) __attribute__((device)) cudaError_t cudaOccupancyMaxPotentialBlockSize( + int *minGridSize, + int *blockSize, + T func, + size_t dynamicSMemSize = 0, + int blockSizeLimit = 0) +{ + return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, __cudaOccupancyB2DHelper(dynamicSMemSize), blockSizeLimit, 0x00); +} +# 2147 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock( + size_t *dynamicSmemSize, + T *func, + int numBlocks, + int blockSize) +{ + return ::cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, (const void*)func, numBlocks, blockSize); +} +# 2206 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) __attribute__((device)) cudaError_t cudaOccupancyMaxPotentialBlockSizeWithFlags( + int *minGridSize, + int *blockSize, + T func, + size_t dynamicSMemSize = 0, + int blockSizeLimit = 0, + unsigned int flags = 0) +{ + return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, __cudaOccupancyB2DHelper(dynamicSMemSize), blockSizeLimit, flags); +} +# 2251 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxPotentialClusterSize( + int *clusterSize, + T *func, + const cudaLaunchConfig_t *config) +{ + return ::cudaOccupancyMaxPotentialClusterSize(clusterSize, (const void*)func, config); +} +# 2295 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxActiveClusters( + int *numClusters, + T *func, + const cudaLaunchConfig_t *config) +{ + return ::cudaOccupancyMaxActiveClusters(numClusters, (const void*)func, config); +} +# 2336 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncGetAttributes( + struct cudaFuncAttributes *attr, + T *entry +) +{ + return ::cudaFuncGetAttributes(attr, (const void*)entry); +} +# 2402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncSetAttribute( + T *func, + enum cudaFuncAttribute attr, + int value +) +{ + return ::cudaFuncSetAttribute((const void*)func, attr, value); +} +# 2435 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncGetName( + const char **name, + T *func +) +{ + return ::cudaFuncGetName(name, (const void *)func); +} +# 2458 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetKernel( + cudaKernel_t *kernelPtr, + T *func +) +{ + return ::cudaGetKernel(kernelPtr, (const void *)func); +} +# 2496 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLibraryGetGlobal(T **dptr, size_t *bytes, cudaLibrary_t library, const char *name) +{ + return ::cudaLibraryGetGlobal((void**)(void*)dptr, bytes, library, name); +} +# 2530 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLibraryGetManaged(T **dptr, size_t *bytes, cudaLibrary_t library, const char *name) +{ + return ::cudaLibraryGetManaged((void**)(void*)dptr, bytes, library, name); +} +# 2560 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLibraryGetUnifiedFunction(T **fptr, cudaLibrary_t library, const char *symbol) +{ + return ::cudaLibraryGetUnifiedFunction((void**)(void*)fptr, library, symbol); +} +# 2576 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +#pragma GCC diagnostic pop +# 0 "" 2 +# 1 "CMakeCUDACompilerId.cu" +# 477 "CMakeCUDACompilerId.cu" +char const* info_compiler = "INFO" ":" "compiler[" "NVIDIA" "]"; + +char const* info_simulate = "INFO" ":" "simulate[" "GNU" "]"; +# 790 "CMakeCUDACompilerId.cu" +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + ('0' + (((12) / 10000000)%10)), ('0' + (((12) / 1000000)%10)), ('0' + (((12) / 100000)%10)), ('0' + (((12) / 10000)%10)), ('0' + (((12) / 1000)%10)), ('0' + (((12) / 100)%10)), ('0' + (((12) / 10)%10)), ('0' + ((12) % 10)), + + '.', ('0' + (((8) / 10000000)%10)), ('0' + (((8) / 1000000)%10)), ('0' + (((8) / 100000)%10)), ('0' + (((8) / 10000)%10)), ('0' + (((8) / 1000)%10)), ('0' + (((8) / 100)%10)), ('0' + (((8) / 10)%10)), ('0' + ((8) % 10)), + + '.', ('0' + (((93) / 10000000)%10)), ('0' + (((93) / 1000000)%10)), ('0' + (((93) / 100000)%10)), ('0' + (((93) / 10000)%10)), ('0' + (((93) / 1000)%10)), ('0' + (((93) / 100)%10)), ('0' + (((93) / 10)%10)), ('0' + ((93) % 10)), + + + + + + ']','\0'}; +# 819 "CMakeCUDACompilerId.cu" +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + ('0' + (((14) / 10000000)%10)), ('0' + (((14) / 1000000)%10)), ('0' + (((14) / 100000)%10)), ('0' + (((14) / 10000)%10)), ('0' + (((14) / 1000)%10)), ('0' + (((14) / 100)%10)), ('0' + (((14) / 10)%10)), ('0' + ((14) % 10)), + + '.', ('0' + (((2) / 10000000)%10)), ('0' + (((2) / 1000000)%10)), ('0' + (((2) / 100000)%10)), ('0' + (((2) / 10000)%10)), ('0' + (((2) / 1000)%10)), ('0' + (((2) / 100)%10)), ('0' + (((2) / 10)%10)), ('0' + ((2) % 10)), + + + + + + + + ']','\0'}; + + + + + + +char const* info_platform = "INFO" ":" "platform[" "Linux" "]"; +char const* info_arch = "INFO" ":" "arch[" "]"; + + + + +char const* info_host_compiler = "INFO" ":" "host_compiler[" "GNU" "]"; + + + + +char const info_host_compiler_version[] = { + 'I', 'N', 'F', 'O', ':','h','o','s','t','_', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + ('0' + (((14) / 10000000)%10)), ('0' + (((14) / 1000000)%10)), ('0' + (((14) / 100000)%10)), ('0' + (((14) / 10000)%10)), ('0' + (((14) / 1000)%10)), ('0' + (((14) / 100)%10)), ('0' + (((14) / 10)%10)), ('0' + ((14) % 10)), + + '.', ('0' + (((2) / 10000000)%10)), ('0' + (((2) / 1000000)%10)), ('0' + (((2) / 100000)%10)), ('0' + (((2) / 10000)%10)), ('0' + (((2) / 1000)%10)), ('0' + (((2) / 100)%10)), ('0' + (((2) / 10)%10)), ('0' + ((2) % 10)), + + '.', ('0' + (((1) / 10000000)%10)), ('0' + (((1) / 1000000)%10)), ('0' + (((1) / 100000)%10)), ('0' + (((1) / 10000)%10)), ('0' + (((1) / 1000)%10)), ('0' + (((1) / 100)%10)), ('0' + (((1) / 10)%10)), ('0' + ((1) % 10)), + + + + + + ']','\0'}; +# 882 "CMakeCUDACompilerId.cu" +const char* info_language_standard_default = "INFO" ":" "standard_default[" + + + + + + + + "17" + + + + + + + +"]"; + +const char* info_language_extensions_default = "INFO" ":" "extensions_default[" + + + "ON" + + + +"]"; + + + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; + + require += info_version[argc]; + + + require += info_simulate[argc]; + + + require += info_simulate_version[argc]; + + + require += info_host_compiler[argc]; + + + require += info_host_compiler_version[argc]; + + require += info_language_standard_default[argc]; + require += info_language_extensions_default[argc]; + (void)argv; + return require; +} diff --git a/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp4.ii b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp4.ii new file mode 100644 index 0000000..1a04387 --- /dev/null +++ b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp4.ii @@ -0,0 +1,34363 @@ +# 0 "CMakeCUDACompilerId.cu" +# 0 "" +# 0 "" +# 1 "/usr/include/stdc-predef.h" 1 3 4 +# 0 "" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 1 +# 61 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +#pragma GCC diagnostic push + + +#pragma GCC diagnostic ignored "-Wunused-function" +# 82 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_config.h" 1 +# 216 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_config.h" +# 1 "/usr/include/features.h" 1 3 4 +# 415 "/usr/include/features.h" 3 4 +# 1 "/usr/include/features-time64.h" 1 3 4 +# 20 "/usr/include/features-time64.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 21 "/usr/include/features-time64.h" 2 3 4 +# 1 "/usr/include/bits/timesize.h" 1 3 4 +# 19 "/usr/include/bits/timesize.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/bits/timesize.h" 2 3 4 +# 22 "/usr/include/features-time64.h" 2 3 4 +# 416 "/usr/include/features.h" 2 3 4 +# 524 "/usr/include/features.h" 3 4 +# 1 "/usr/include/sys/cdefs.h" 1 3 4 +# 730 "/usr/include/sys/cdefs.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 731 "/usr/include/sys/cdefs.h" 2 3 4 +# 1 "/usr/include/bits/long-double.h" 1 3 4 +# 732 "/usr/include/sys/cdefs.h" 2 3 4 +# 525 "/usr/include/features.h" 2 3 4 +# 548 "/usr/include/features.h" 3 4 +# 1 "/usr/include/gnu/stubs.h" 1 3 4 +# 10 "/usr/include/gnu/stubs.h" 3 4 +# 1 "/usr/include/gnu/stubs-64.h" 1 3 4 +# 11 "/usr/include/gnu/stubs.h" 2 3 4 +# 549 "/usr/include/features.h" 2 3 4 +# 217 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_config.h" 2 +# 83 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + + + + + + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 56 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" 1 +# 59 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 64 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" +# 1 "/usr/include/ctype.h" 1 3 4 +# 26 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/bits/types.h" 1 3 4 +# 27 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/bits/types.h" 2 3 4 +# 1 "/usr/include/bits/timesize.h" 1 3 4 +# 19 "/usr/include/bits/timesize.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/bits/timesize.h" 2 3 4 +# 29 "/usr/include/bits/types.h" 2 3 4 + + + +# 31 "/usr/include/bits/types.h" 3 4 +typedef unsigned char __u_char; +typedef unsigned short int __u_short; +typedef unsigned int __u_int; +typedef unsigned long int __u_long; + + +typedef signed char __int8_t; +typedef unsigned char __uint8_t; +typedef signed short int __int16_t; +typedef unsigned short int __uint16_t; +typedef signed int __int32_t; +typedef unsigned int __uint32_t; + +typedef signed long int __int64_t; +typedef unsigned long int __uint64_t; + + + + + + +typedef __int8_t __int_least8_t; +typedef __uint8_t __uint_least8_t; +typedef __int16_t __int_least16_t; +typedef __uint16_t __uint_least16_t; +typedef __int32_t __int_least32_t; +typedef __uint32_t __uint_least32_t; +typedef __int64_t __int_least64_t; +typedef __uint64_t __uint_least64_t; + + + +typedef long int __quad_t; +typedef unsigned long int __u_quad_t; + + + + + + + +typedef long int __intmax_t; +typedef unsigned long int __uintmax_t; +# 141 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/typesizes.h" 1 3 4 +# 142 "/usr/include/bits/types.h" 2 3 4 +# 1 "/usr/include/bits/time64.h" 1 3 4 +# 143 "/usr/include/bits/types.h" 2 3 4 + + +typedef unsigned long int __dev_t; +typedef unsigned int __uid_t; +typedef unsigned int __gid_t; +typedef unsigned long int __ino_t; +typedef unsigned long int __ino64_t; +typedef unsigned int __mode_t; +typedef unsigned long int __nlink_t; +typedef long int __off_t; +typedef long int __off64_t; +typedef int __pid_t; +typedef struct { int __val[2]; } __fsid_t; +typedef long int __clock_t; +typedef unsigned long int __rlim_t; +typedef unsigned long int __rlim64_t; +typedef unsigned int __id_t; +typedef long int __time_t; +typedef unsigned int __useconds_t; +typedef long int __suseconds_t; +typedef long int __suseconds64_t; + +typedef int __daddr_t; +typedef int __key_t; + + +typedef int __clockid_t; + + +typedef void * __timer_t; + + +typedef long int __blksize_t; + + + + +typedef long int __blkcnt_t; +typedef long int __blkcnt64_t; + + +typedef unsigned long int __fsblkcnt_t; +typedef unsigned long int __fsblkcnt64_t; + + +typedef unsigned long int __fsfilcnt_t; +typedef unsigned long int __fsfilcnt64_t; + + +typedef long int __fsword_t; + +typedef long int __ssize_t; + + +typedef long int __syscall_slong_t; + +typedef unsigned long int __syscall_ulong_t; + + + +typedef __off64_t __loff_t; +typedef char *__caddr_t; + + +typedef long int __intptr_t; + + +typedef unsigned int __socklen_t; + + + + +typedef int __sig_atomic_t; +# 27 "/usr/include/ctype.h" 2 3 4 + +extern "C" { +# 39 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/bits/endian.h" 1 3 4 +# 35 "/usr/include/bits/endian.h" 3 4 +# 1 "/usr/include/bits/endianness.h" 1 3 4 +# 36 "/usr/include/bits/endian.h" 2 3 4 +# 40 "/usr/include/ctype.h" 2 3 4 + + + + + + +enum +{ + _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), + _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), + _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), + _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), + _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), + _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), + _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), + _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), + _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), + _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), + _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), + _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8)) +}; +# 79 "/usr/include/ctype.h" 3 4 +extern const unsigned short int **__ctype_b_loc (void) + noexcept (true) __attribute__ ((__const__)); +extern const __int32_t **__ctype_tolower_loc (void) + noexcept (true) __attribute__ ((__const__)); +extern const __int32_t **__ctype_toupper_loc (void) + noexcept (true) __attribute__ ((__const__)); +# 108 "/usr/include/ctype.h" 3 4 +extern int isalnum (int) noexcept (true); +extern int isalpha (int) noexcept (true); +extern int iscntrl (int) noexcept (true); +extern int isdigit (int) noexcept (true); +extern int islower (int) noexcept (true); +extern int isgraph (int) noexcept (true); +extern int isprint (int) noexcept (true); +extern int ispunct (int) noexcept (true); +extern int isspace (int) noexcept (true); +extern int isupper (int) noexcept (true); +extern int isxdigit (int) noexcept (true); + + + +extern int tolower (int __c) noexcept (true); + + +extern int toupper (int __c) noexcept (true); + + + + +extern int isblank (int) noexcept (true); + + + + +extern int isctype (int __c, int __mask) noexcept (true); + + + + + + +extern int isascii (int __c) noexcept (true); + + + +extern int toascii (int __c) noexcept (true); + + + +extern int _toupper (int) noexcept (true); +extern int _tolower (int) noexcept (true); +# 237 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/bits/types/locale_t.h" 1 3 4 +# 22 "/usr/include/bits/types/locale_t.h" 3 4 +# 1 "/usr/include/bits/types/__locale_t.h" 1 3 4 +# 27 "/usr/include/bits/types/__locale_t.h" 3 4 +struct __locale_struct +{ + + struct __locale_data *__locales[13]; + + + const unsigned short int *__ctype_b; + const int *__ctype_tolower; + const int *__ctype_toupper; + + + const char *__names[13]; +}; + +typedef struct __locale_struct *__locale_t; +# 23 "/usr/include/bits/types/locale_t.h" 2 3 4 + +typedef __locale_t locale_t; +# 238 "/usr/include/ctype.h" 2 3 4 +# 251 "/usr/include/ctype.h" 3 4 +extern int isalnum_l (int, locale_t) noexcept (true); +extern int isalpha_l (int, locale_t) noexcept (true); +extern int iscntrl_l (int, locale_t) noexcept (true); +extern int isdigit_l (int, locale_t) noexcept (true); +extern int islower_l (int, locale_t) noexcept (true); +extern int isgraph_l (int, locale_t) noexcept (true); +extern int isprint_l (int, locale_t) noexcept (true); +extern int ispunct_l (int, locale_t) noexcept (true); +extern int isspace_l (int, locale_t) noexcept (true); +extern int isupper_l (int, locale_t) noexcept (true); +extern int isxdigit_l (int, locale_t) noexcept (true); + +extern int isblank_l (int, locale_t) noexcept (true); + + + +extern int __tolower_l (int __c, locale_t __l) noexcept (true); +extern int tolower_l (int __c, locale_t __l) noexcept (true); + + +extern int __toupper_l (int __c, locale_t __l) noexcept (true); +extern int toupper_l (int __c, locale_t __l) noexcept (true); +# 327 "/usr/include/ctype.h" 3 4 +} +# 65 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 2 +# 60 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" 2 +# 68 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" + +# 68 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" +enum __attribute__((device_builtin)) cudaRoundMode +{ + cudaRoundNearest, + cudaRoundZero, + cudaRoundPosInf, + cudaRoundMinInf +}; +# 57 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 1 +# 59 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 60 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" 1 +# 65 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 66 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" 2 +# 104 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +struct __attribute__((device_builtin)) char1 +{ + signed char x; +}; + +struct __attribute__((device_builtin)) uchar1 +{ + unsigned char x; +}; + + +struct __attribute__((device_builtin)) __attribute__((aligned(2))) char2 +{ + signed char x, y; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(2))) uchar2 +{ + unsigned char x, y; +}; + +struct __attribute__((device_builtin)) char3 +{ + signed char x, y, z; +}; + +struct __attribute__((device_builtin)) uchar3 +{ + unsigned char x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(4))) char4 +{ + signed char x, y, z, w; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(4))) uchar4 +{ + unsigned char x, y, z, w; +}; + +struct __attribute__((device_builtin)) short1 +{ + short x; +}; + +struct __attribute__((device_builtin)) ushort1 +{ + unsigned short x; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(4))) short2 +{ + short x, y; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(4))) ushort2 +{ + unsigned short x, y; +}; + +struct __attribute__((device_builtin)) short3 +{ + short x, y, z; +}; + +struct __attribute__((device_builtin)) ushort3 +{ + unsigned short x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(8))) short4 { short x; short y; short z; short w; }; +struct __attribute__((device_builtin)) __attribute__((aligned(8))) ushort4 { unsigned short x; unsigned short y; unsigned short z; unsigned short w; }; + +struct __attribute__((device_builtin)) int1 +{ + int x; +}; + +struct __attribute__((device_builtin)) uint1 +{ + unsigned int x; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(8))) int2 { int x; int y; }; +struct __attribute__((device_builtin)) __attribute__((aligned(8))) uint2 { unsigned int x; unsigned int y; }; + +struct __attribute__((device_builtin)) int3 +{ + int x, y, z; +}; + +struct __attribute__((device_builtin)) uint3 +{ + unsigned int x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) int4 +{ + int x, y, z, w; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) uint4 +{ + unsigned int x, y, z, w; +}; + +struct __attribute__((device_builtin)) long1 +{ + long int x; +}; + +struct __attribute__((device_builtin)) ulong1 +{ + unsigned long x; +}; + + + + + + +struct __attribute__((device_builtin)) __attribute__((aligned(2*sizeof(long int)))) long2 +{ + long int x, y; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(2*sizeof(unsigned long int)))) ulong2 +{ + unsigned long int x, y; +}; + + + +struct __attribute__((device_builtin)) long3 +{ + long int x, y, z; +}; + +struct __attribute__((device_builtin)) ulong3 +{ + unsigned long int x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) long4 +{ + long int x, y, z, w; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) ulong4 +{ + unsigned long int x, y, z, w; +}; + +struct __attribute__((device_builtin)) float1 +{ + float x; +}; +# 280 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +struct __attribute__((device_builtin)) __attribute__((aligned(8))) float2 { float x; float y; }; + + + + +struct __attribute__((device_builtin)) float3 +{ + float x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) float4 +{ + float x, y, z, w; +}; + +struct __attribute__((device_builtin)) longlong1 +{ + long long int x; +}; + +struct __attribute__((device_builtin)) ulonglong1 +{ + unsigned long long int x; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) longlong2 +{ + long long int x, y; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) ulonglong2 +{ + unsigned long long int x, y; +}; + +struct __attribute__((device_builtin)) longlong3 +{ + long long int x, y, z; +}; + +struct __attribute__((device_builtin)) ulonglong3 +{ + unsigned long long int x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) longlong4 +{ + long long int x, y, z ,w; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) ulonglong4 +{ + unsigned long long int x, y, z, w; +}; + +struct __attribute__((device_builtin)) double1 +{ + double x; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) double2 +{ + double x, y; +}; + +struct __attribute__((device_builtin)) double3 +{ + double x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) double4 +{ + double x, y, z, w; +}; +# 367 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +typedef __attribute__((device_builtin)) struct char1 char1; +typedef __attribute__((device_builtin)) struct uchar1 uchar1; +typedef __attribute__((device_builtin)) struct char2 char2; +typedef __attribute__((device_builtin)) struct uchar2 uchar2; +typedef __attribute__((device_builtin)) struct char3 char3; +typedef __attribute__((device_builtin)) struct uchar3 uchar3; +typedef __attribute__((device_builtin)) struct char4 char4; +typedef __attribute__((device_builtin)) struct uchar4 uchar4; +typedef __attribute__((device_builtin)) struct short1 short1; +typedef __attribute__((device_builtin)) struct ushort1 ushort1; +typedef __attribute__((device_builtin)) struct short2 short2; +typedef __attribute__((device_builtin)) struct ushort2 ushort2; +typedef __attribute__((device_builtin)) struct short3 short3; +typedef __attribute__((device_builtin)) struct ushort3 ushort3; +typedef __attribute__((device_builtin)) struct short4 short4; +typedef __attribute__((device_builtin)) struct ushort4 ushort4; +typedef __attribute__((device_builtin)) struct int1 int1; +typedef __attribute__((device_builtin)) struct uint1 uint1; +typedef __attribute__((device_builtin)) struct int2 int2; +typedef __attribute__((device_builtin)) struct uint2 uint2; +typedef __attribute__((device_builtin)) struct int3 int3; +typedef __attribute__((device_builtin)) struct uint3 uint3; +typedef __attribute__((device_builtin)) struct int4 int4; +typedef __attribute__((device_builtin)) struct uint4 uint4; +typedef __attribute__((device_builtin)) struct long1 long1; +typedef __attribute__((device_builtin)) struct ulong1 ulong1; +typedef __attribute__((device_builtin)) struct long2 long2; +typedef __attribute__((device_builtin)) struct ulong2 ulong2; +typedef __attribute__((device_builtin)) struct long3 long3; +typedef __attribute__((device_builtin)) struct ulong3 ulong3; +typedef __attribute__((device_builtin)) struct long4 long4; +typedef __attribute__((device_builtin)) struct ulong4 ulong4; +typedef __attribute__((device_builtin)) struct float1 float1; +typedef __attribute__((device_builtin)) struct float2 float2; +typedef __attribute__((device_builtin)) struct float3 float3; +typedef __attribute__((device_builtin)) struct float4 float4; +typedef __attribute__((device_builtin)) struct longlong1 longlong1; +typedef __attribute__((device_builtin)) struct ulonglong1 ulonglong1; +typedef __attribute__((device_builtin)) struct longlong2 longlong2; +typedef __attribute__((device_builtin)) struct ulonglong2 ulonglong2; +typedef __attribute__((device_builtin)) struct longlong3 longlong3; +typedef __attribute__((device_builtin)) struct ulonglong3 ulonglong3; +typedef __attribute__((device_builtin)) struct longlong4 longlong4; +typedef __attribute__((device_builtin)) struct ulonglong4 ulonglong4; +typedef __attribute__((device_builtin)) struct double1 double1; +typedef __attribute__((device_builtin)) struct double2 double2; +typedef __attribute__((device_builtin)) struct double3 double3; +typedef __attribute__((device_builtin)) struct double4 double4; +# 426 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +struct __attribute__((device_builtin)) dim3 +{ + unsigned int x, y, z; + + + __attribute__((host)) __attribute__((device)) constexpr dim3(unsigned int vx = 1, unsigned int vy = 1, unsigned int vz = 1) : x(vx), y(vy), z(vz) {} + __attribute__((host)) __attribute__((device)) constexpr dim3(uint3 v) : x(v.x), y(v.y), z(v.z) {} + __attribute__((host)) __attribute__((device)) constexpr operator uint3(void) const { return uint3{x, y, z}; } + + + + + + +}; + +typedef __attribute__((device_builtin)) struct dim3 dim3; +# 62 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 2 +# 83 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 1 3 4 +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/syslimits.h" 1 3 4 + + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 1 3 4 +# 210 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 3 4 +# 1 "/usr/include/limits.h" 1 3 4 +# 26 "/usr/include/limits.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/limits.h" 2 3 4 +# 195 "/usr/include/limits.h" 3 4 +# 1 "/usr/include/bits/posix1_lim.h" 1 3 4 +# 27 "/usr/include/bits/posix1_lim.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/bits/posix1_lim.h" 2 3 4 +# 161 "/usr/include/bits/posix1_lim.h" 3 4 +# 1 "/usr/include/bits/local_lim.h" 1 3 4 +# 38 "/usr/include/bits/local_lim.h" 3 4 +# 1 "/usr/include/linux/limits.h" 1 3 4 +# 39 "/usr/include/bits/local_lim.h" 2 3 4 +# 81 "/usr/include/bits/local_lim.h" 3 4 +# 1 "/usr/include/bits/pthread_stack_min-dynamic.h" 1 3 4 +# 23 "/usr/include/bits/pthread_stack_min-dynamic.h" 3 4 + +# 23 "/usr/include/bits/pthread_stack_min-dynamic.h" 3 4 +extern "C" { +extern long int __sysconf (int __name) noexcept (true); +} +# 82 "/usr/include/bits/local_lim.h" 2 3 4 +# 162 "/usr/include/bits/posix1_lim.h" 2 3 4 +# 196 "/usr/include/limits.h" 2 3 4 + + + +# 1 "/usr/include/bits/posix2_lim.h" 1 3 4 +# 200 "/usr/include/limits.h" 2 3 4 + + + +# 1 "/usr/include/bits/xopen_lim.h" 1 3 4 +# 64 "/usr/include/bits/xopen_lim.h" 3 4 +# 1 "/usr/include/bits/uio_lim.h" 1 3 4 +# 65 "/usr/include/bits/xopen_lim.h" 2 3 4 +# 204 "/usr/include/limits.h" 2 3 4 +# 211 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 2 3 4 +# 8 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/syslimits.h" 2 3 4 +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 2 3 4 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 2 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 145 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 4 +typedef long int ptrdiff_t; +# 214 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 4 +typedef long unsigned int size_t; +# 425 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 4 +typedef struct { + long long __max_align_ll __attribute__((__aligned__(__alignof__(long long)))); + long double __max_align_ld __attribute__((__aligned__(__alignof__(long double)))); +# 436 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 4 +} max_align_t; + + + + + + + typedef decltype(nullptr) nullptr_t; +# 85 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 2 +# 205 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + +# 205 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +enum __attribute__((device_builtin)) cudaError +{ + + + + + + cudaSuccess = 0, + + + + + + cudaErrorInvalidValue = 1, + + + + + + cudaErrorMemoryAllocation = 2, + + + + + + cudaErrorInitializationError = 3, + + + + + + + cudaErrorCudartUnloading = 4, + + + + + + + cudaErrorProfilerDisabled = 5, + + + + + + + + cudaErrorProfilerNotInitialized = 6, + + + + + + + cudaErrorProfilerAlreadyStarted = 7, + + + + + + + cudaErrorProfilerAlreadyStopped = 8, + + + + + + + + cudaErrorInvalidConfiguration = 9, + + + + + + cudaErrorInvalidPitchValue = 12, + + + + + + cudaErrorInvalidSymbol = 13, + + + + + + + + cudaErrorInvalidHostPointer = 16, + + + + + + + + cudaErrorInvalidDevicePointer = 17, + + + + + cudaErrorInvalidTexture = 18, + + + + + + cudaErrorInvalidTextureBinding = 19, + + + + + + + cudaErrorInvalidChannelDescriptor = 20, + + + + + + cudaErrorInvalidMemcpyDirection = 21, +# 336 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorAddressOfConstant = 22, +# 345 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorTextureFetchFailed = 23, +# 354 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorTextureNotBound = 24, +# 363 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSynchronizationError = 25, + + + + + cudaErrorInvalidFilterSetting = 26, + + + + + + cudaErrorInvalidNormSetting = 27, + + + + + + + + cudaErrorMixedDeviceExecution = 28, + + + + + + + + cudaErrorNotYetImplemented = 31, +# 399 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorMemoryValueTooLarge = 32, + + + + + + cudaErrorStubLibrary = 34, + + + + + + + cudaErrorInsufficientDriver = 35, + + + + + + + cudaErrorCallRequiresNewerDriver = 36, + + + + + + cudaErrorInvalidSurface = 37, + + + + + + cudaErrorDuplicateVariableName = 43, + + + + + + cudaErrorDuplicateTextureName = 44, + + + + + + cudaErrorDuplicateSurfaceName = 45, +# 453 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorDevicesUnavailable = 46, +# 466 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorIncompatibleDriverContext = 49, + + + + + + cudaErrorMissingConfiguration = 52, +# 481 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorPriorLaunchFailure = 53, + + + + + + cudaErrorLaunchMaxDepthExceeded = 65, + + + + + + + + cudaErrorLaunchFileScopedTex = 66, + + + + + + + + cudaErrorLaunchFileScopedSurf = 67, +# 519 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSyncDepthExceeded = 68, +# 531 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorLaunchPendingCountExceeded = 69, + + + + + + cudaErrorInvalidDeviceFunction = 98, + + + + + + cudaErrorNoDevice = 100, + + + + + + + cudaErrorInvalidDevice = 101, + + + + + cudaErrorDeviceNotLicensed = 102, +# 564 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSoftwareValidityNotEstablished = 103, + + + + + cudaErrorStartupFailure = 127, + + + + + cudaErrorInvalidKernelImage = 200, +# 584 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorDeviceUninitialized = 201, + + + + + cudaErrorMapBufferObjectFailed = 205, + + + + + cudaErrorUnmapBufferObjectFailed = 206, + + + + + + cudaErrorArrayIsMapped = 207, + + + + + cudaErrorAlreadyMapped = 208, + + + + + + + + cudaErrorNoKernelImageForDevice = 209, + + + + + cudaErrorAlreadyAcquired = 210, + + + + + cudaErrorNotMapped = 211, + + + + + + cudaErrorNotMappedAsArray = 212, + + + + + + cudaErrorNotMappedAsPointer = 213, + + + + + + cudaErrorECCUncorrectable = 214, + + + + + + cudaErrorUnsupportedLimit = 215, + + + + + + cudaErrorDeviceAlreadyInUse = 216, + + + + + + cudaErrorPeerAccessUnsupported = 217, + + + + + + cudaErrorInvalidPtx = 218, + + + + + cudaErrorInvalidGraphicsContext = 219, + + + + + + cudaErrorNvlinkUncorrectable = 220, + + + + + + + cudaErrorJitCompilerNotFound = 221, + + + + + + + cudaErrorUnsupportedPtxVersion = 222, + + + + + + + cudaErrorJitCompilationDisabled = 223, + + + + + cudaErrorUnsupportedExecAffinity = 224, + + + + + + cudaErrorUnsupportedDevSideSync = 225, +# 719 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorContained = 226, + + + + + cudaErrorInvalidSource = 300, + + + + + cudaErrorFileNotFound = 301, + + + + + cudaErrorSharedObjectSymbolNotFound = 302, + + + + + cudaErrorSharedObjectInitFailed = 303, + + + + + cudaErrorOperatingSystem = 304, + + + + + + + cudaErrorInvalidResourceHandle = 400, + + + + + + cudaErrorIllegalState = 401, + + + + + + + + cudaErrorLossyQuery = 402, + + + + + + + cudaErrorSymbolNotFound = 500, + + + + + + + + cudaErrorNotReady = 600, + + + + + + + + cudaErrorIllegalAddress = 700, +# 797 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorLaunchOutOfResources = 701, +# 808 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorLaunchTimeout = 702, + + + + + + cudaErrorLaunchIncompatibleTexturing = 703, + + + + + + + cudaErrorPeerAccessAlreadyEnabled = 704, + + + + + + + cudaErrorPeerAccessNotEnabled = 705, +# 841 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSetOnActiveProcess = 708, + + + + + + + cudaErrorContextIsDestroyed = 709, + + + + + + + cudaErrorAssert = 710, + + + + + + + cudaErrorTooManyPeers = 711, + + + + + + cudaErrorHostMemoryAlreadyRegistered = 712, + + + + + + cudaErrorHostMemoryNotRegistered = 713, +# 883 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorHardwareStackError = 714, + + + + + + + + cudaErrorIllegalInstruction = 715, +# 900 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorMisalignedAddress = 716, +# 911 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorInvalidAddressSpace = 717, + + + + + + + + cudaErrorInvalidPc = 718, +# 930 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorLaunchFailure = 719, +# 939 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorCooperativeLaunchTooLarge = 720, + + + + + + + + cudaErrorTensorMemoryLeak = 721, + + + + + cudaErrorNotPermitted = 800, + + + + + + cudaErrorNotSupported = 801, +# 967 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSystemNotReady = 802, + + + + + + + cudaErrorSystemDriverMismatch = 803, +# 983 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorCompatNotSupportedOnDevice = 804, + + + + + cudaErrorMpsConnectionFailed = 805, + + + + + cudaErrorMpsRpcFailure = 806, + + + + + + cudaErrorMpsServerNotReady = 807, + + + + + cudaErrorMpsMaxClientsReached = 808, + + + + + cudaErrorMpsMaxConnectionsReached = 809, + + + + + cudaErrorMpsClientTerminated = 810, + + + + + cudaErrorCdpNotSupported = 811, + + + + + cudaErrorCdpVersionMismatch = 812, + + + + + cudaErrorStreamCaptureUnsupported = 900, + + + + + + cudaErrorStreamCaptureInvalidated = 901, + + + + + + cudaErrorStreamCaptureMerge = 902, + + + + + cudaErrorStreamCaptureUnmatched = 903, + + + + + + cudaErrorStreamCaptureUnjoined = 904, + + + + + + + cudaErrorStreamCaptureIsolation = 905, + + + + + + cudaErrorStreamCaptureImplicit = 906, + + + + + + cudaErrorCapturedEvent = 907, + + + + + + + cudaErrorStreamCaptureWrongThread = 908, + + + + + cudaErrorTimeout = 909, + + + + + + cudaErrorGraphExecUpdateFailure = 910, +# 1099 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorExternalDevice = 911, + + + + + + cudaErrorInvalidClusterSize = 912, + + + + + + cudaErrorFunctionNotLoaded = 913, + + + + + + cudaErrorInvalidResourceType = 914, + + + + + + cudaErrorInvalidResourceConfiguration = 915, + + + + + cudaErrorUnknown = 999 + + + + + + + + , cudaErrorApiFailureBase = 10000 +}; + + + + +enum __attribute__((device_builtin)) cudaChannelFormatKind +{ + cudaChannelFormatKindSigned = 0, + cudaChannelFormatKindUnsigned = 1, + cudaChannelFormatKindFloat = 2, + cudaChannelFormatKindNone = 3, + cudaChannelFormatKindNV12 = 4, + cudaChannelFormatKindUnsignedNormalized8X1 = 5, + cudaChannelFormatKindUnsignedNormalized8X2 = 6, + cudaChannelFormatKindUnsignedNormalized8X4 = 7, + cudaChannelFormatKindUnsignedNormalized16X1 = 8, + cudaChannelFormatKindUnsignedNormalized16X2 = 9, + cudaChannelFormatKindUnsignedNormalized16X4 = 10, + cudaChannelFormatKindSignedNormalized8X1 = 11, + cudaChannelFormatKindSignedNormalized8X2 = 12, + cudaChannelFormatKindSignedNormalized8X4 = 13, + cudaChannelFormatKindSignedNormalized16X1 = 14, + cudaChannelFormatKindSignedNormalized16X2 = 15, + cudaChannelFormatKindSignedNormalized16X4 = 16, + cudaChannelFormatKindUnsignedBlockCompressed1 = 17, + cudaChannelFormatKindUnsignedBlockCompressed1SRGB = 18, + cudaChannelFormatKindUnsignedBlockCompressed2 = 19, + cudaChannelFormatKindUnsignedBlockCompressed2SRGB = 20, + cudaChannelFormatKindUnsignedBlockCompressed3 = 21, + cudaChannelFormatKindUnsignedBlockCompressed3SRGB = 22, + cudaChannelFormatKindUnsignedBlockCompressed4 = 23, + cudaChannelFormatKindSignedBlockCompressed4 = 24, + cudaChannelFormatKindUnsignedBlockCompressed5 = 25, + cudaChannelFormatKindSignedBlockCompressed5 = 26, + cudaChannelFormatKindUnsignedBlockCompressed6H = 27, + cudaChannelFormatKindSignedBlockCompressed6H = 28, + cudaChannelFormatKindUnsignedBlockCompressed7 = 29, + cudaChannelFormatKindUnsignedBlockCompressed7SRGB = 30, + cudaChannelFormatKindUnsignedNormalized1010102 = 31 + +}; + + + + +struct __attribute__((device_builtin)) cudaChannelFormatDesc +{ + int x; + int y; + int z; + int w; + enum cudaChannelFormatKind f; +}; + + + + +typedef struct cudaArray *cudaArray_t; + + + + +typedef const struct cudaArray *cudaArray_const_t; + +struct cudaArray; + + + + +typedef struct cudaMipmappedArray *cudaMipmappedArray_t; + + + + +typedef const struct cudaMipmappedArray *cudaMipmappedArray_const_t; + +struct cudaMipmappedArray; +# 1223 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct __attribute__((device_builtin)) cudaArraySparseProperties { + struct { + unsigned int width; + unsigned int height; + unsigned int depth; + } tileExtent; + unsigned int miptailFirstLevel; + unsigned long long miptailSize; + unsigned int flags; + unsigned int reserved[4]; +}; + + + + +struct __attribute__((device_builtin)) cudaArrayMemoryRequirements { + size_t size; + size_t alignment; + unsigned int reserved[4]; +}; + + + + +enum __attribute__((device_builtin)) cudaMemoryType +{ + cudaMemoryTypeUnregistered = 0, + cudaMemoryTypeHost = 1, + cudaMemoryTypeDevice = 2, + cudaMemoryTypeManaged = 3 +}; + + + + +enum __attribute__((device_builtin)) cudaMemcpyKind +{ + cudaMemcpyHostToHost = 0, + cudaMemcpyHostToDevice = 1, + cudaMemcpyDeviceToHost = 2, + cudaMemcpyDeviceToDevice = 3, + cudaMemcpyDefault = 4 +}; + + + + + + +struct __attribute__((device_builtin)) cudaPitchedPtr +{ + void *ptr; + size_t pitch; + size_t xsize; + size_t ysize; +}; + + + + + + +struct __attribute__((device_builtin)) cudaExtent +{ + size_t width; + size_t height; + size_t depth; +}; + + + + + + +struct __attribute__((device_builtin)) cudaPos +{ + size_t x; + size_t y; + size_t z; +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpy3DParms +{ + cudaArray_t srcArray; + struct cudaPos srcPos; + struct cudaPitchedPtr srcPtr; + + cudaArray_t dstArray; + struct cudaPos dstPos; + struct cudaPitchedPtr dstPtr; + + struct cudaExtent extent; + enum cudaMemcpyKind kind; +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpyNodeParams { + int flags; + int reserved[3]; + struct cudaMemcpy3DParms copyParams; +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpy3DPeerParms +{ + cudaArray_t srcArray; + struct cudaPos srcPos; + struct cudaPitchedPtr srcPtr; + int srcDevice; + + cudaArray_t dstArray; + struct cudaPos dstPos; + struct cudaPitchedPtr dstPtr; + int dstDevice; + + struct cudaExtent extent; +}; + + + + +struct __attribute__((device_builtin)) cudaMemsetParams { + void *dst; + size_t pitch; + unsigned int value; + unsigned int elementSize; + size_t width; + size_t height; +}; + + + + +struct __attribute__((device_builtin)) cudaMemsetParamsV2 { + void *dst; + size_t pitch; + unsigned int value; + unsigned int elementSize; + size_t width; + size_t height; +}; + + + + +enum __attribute__((device_builtin)) cudaAccessProperty { + cudaAccessPropertyNormal = 0, + cudaAccessPropertyStreaming = 1, + cudaAccessPropertyPersisting = 2 +}; +# 1392 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct __attribute__((device_builtin)) cudaAccessPolicyWindow { + void *base_ptr; + size_t num_bytes; + float hitRatio; + enum cudaAccessProperty hitProp; + enum cudaAccessProperty missProp; +}; +# 1410 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef void ( *cudaHostFn_t)(void *userData); + + + + +struct __attribute__((device_builtin)) cudaHostNodeParams { + cudaHostFn_t fn; + void* userData; +}; + + + + +struct __attribute__((device_builtin)) cudaHostNodeParamsV2 { + cudaHostFn_t fn; + void* userData; +}; + + + + +enum __attribute__((device_builtin)) cudaStreamCaptureStatus { + cudaStreamCaptureStatusNone = 0, + cudaStreamCaptureStatusActive = 1, + cudaStreamCaptureStatusInvalidated = 2 + +}; + + + + + +enum __attribute__((device_builtin)) cudaStreamCaptureMode { + cudaStreamCaptureModeGlobal = 0, + cudaStreamCaptureModeThreadLocal = 1, + cudaStreamCaptureModeRelaxed = 2 +}; + +enum __attribute__((device_builtin)) cudaSynchronizationPolicy { + cudaSyncPolicyAuto = 1, + cudaSyncPolicySpin = 2, + cudaSyncPolicyYield = 3, + cudaSyncPolicyBlockingSync = 4 +}; + + + + +enum __attribute__((device_builtin)) cudaClusterSchedulingPolicy { + cudaClusterSchedulingPolicyDefault = 0, + cudaClusterSchedulingPolicySpread = 1, + cudaClusterSchedulingPolicyLoadBalancing = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaStreamUpdateCaptureDependenciesFlags { + cudaStreamAddCaptureDependencies = 0x0, + cudaStreamSetCaptureDependencies = 0x1 +}; + + + + +enum __attribute__((device_builtin)) cudaUserObjectFlags { + cudaUserObjectNoDestructorSync = 0x1 +}; + + + + +enum __attribute__((device_builtin)) cudaUserObjectRetainFlags { + cudaGraphUserObjectMove = 0x1 +}; + + + + +struct cudaGraphicsResource; + + + + +enum __attribute__((device_builtin)) cudaGraphicsRegisterFlags +{ + cudaGraphicsRegisterFlagsNone = 0, + cudaGraphicsRegisterFlagsReadOnly = 1, + cudaGraphicsRegisterFlagsWriteDiscard = 2, + cudaGraphicsRegisterFlagsSurfaceLoadStore = 4, + cudaGraphicsRegisterFlagsTextureGather = 8 +}; + + + + +enum __attribute__((device_builtin)) cudaGraphicsMapFlags +{ + cudaGraphicsMapFlagsNone = 0, + cudaGraphicsMapFlagsReadOnly = 1, + cudaGraphicsMapFlagsWriteDiscard = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaGraphicsCubeFace +{ + cudaGraphicsCubeFacePositiveX = 0x00, + cudaGraphicsCubeFaceNegativeX = 0x01, + cudaGraphicsCubeFacePositiveY = 0x02, + cudaGraphicsCubeFaceNegativeY = 0x03, + cudaGraphicsCubeFacePositiveZ = 0x04, + cudaGraphicsCubeFaceNegativeZ = 0x05 +}; + + + + +enum __attribute__((device_builtin)) cudaResourceType +{ + cudaResourceTypeArray = 0x00, + cudaResourceTypeMipmappedArray = 0x01, + cudaResourceTypeLinear = 0x02, + cudaResourceTypePitch2D = 0x03 +}; + + + + +enum __attribute__((device_builtin)) cudaResourceViewFormat +{ + cudaResViewFormatNone = 0x00, + cudaResViewFormatUnsignedChar1 = 0x01, + cudaResViewFormatUnsignedChar2 = 0x02, + cudaResViewFormatUnsignedChar4 = 0x03, + cudaResViewFormatSignedChar1 = 0x04, + cudaResViewFormatSignedChar2 = 0x05, + cudaResViewFormatSignedChar4 = 0x06, + cudaResViewFormatUnsignedShort1 = 0x07, + cudaResViewFormatUnsignedShort2 = 0x08, + cudaResViewFormatUnsignedShort4 = 0x09, + cudaResViewFormatSignedShort1 = 0x0a, + cudaResViewFormatSignedShort2 = 0x0b, + cudaResViewFormatSignedShort4 = 0x0c, + cudaResViewFormatUnsignedInt1 = 0x0d, + cudaResViewFormatUnsignedInt2 = 0x0e, + cudaResViewFormatUnsignedInt4 = 0x0f, + cudaResViewFormatSignedInt1 = 0x10, + cudaResViewFormatSignedInt2 = 0x11, + cudaResViewFormatSignedInt4 = 0x12, + cudaResViewFormatHalf1 = 0x13, + cudaResViewFormatHalf2 = 0x14, + cudaResViewFormatHalf4 = 0x15, + cudaResViewFormatFloat1 = 0x16, + cudaResViewFormatFloat2 = 0x17, + cudaResViewFormatFloat4 = 0x18, + cudaResViewFormatUnsignedBlockCompressed1 = 0x19, + cudaResViewFormatUnsignedBlockCompressed2 = 0x1a, + cudaResViewFormatUnsignedBlockCompressed3 = 0x1b, + cudaResViewFormatUnsignedBlockCompressed4 = 0x1c, + cudaResViewFormatSignedBlockCompressed4 = 0x1d, + cudaResViewFormatUnsignedBlockCompressed5 = 0x1e, + cudaResViewFormatSignedBlockCompressed5 = 0x1f, + cudaResViewFormatUnsignedBlockCompressed6H = 0x20, + cudaResViewFormatSignedBlockCompressed6H = 0x21, + cudaResViewFormatUnsignedBlockCompressed7 = 0x22 +}; + + + + +struct __attribute__((device_builtin)) cudaResourceDesc { + enum cudaResourceType resType; + + union { + struct { + cudaArray_t array; + } array; + struct { + cudaMipmappedArray_t mipmap; + } mipmap; + struct { + void *devPtr; + struct cudaChannelFormatDesc desc; + size_t sizeInBytes; + } linear; + struct { + void *devPtr; + struct cudaChannelFormatDesc desc; + size_t width; + size_t height; + size_t pitchInBytes; + } pitch2D; + } res; +}; + + + + +struct __attribute__((device_builtin)) cudaResourceViewDesc +{ + enum cudaResourceViewFormat format; + size_t width; + size_t height; + size_t depth; + unsigned int firstMipmapLevel; + unsigned int lastMipmapLevel; + unsigned int firstLayer; + unsigned int lastLayer; +}; + + + + +struct __attribute__((device_builtin)) cudaPointerAttributes +{ + + + + + enum cudaMemoryType type; +# 1642 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + int device; + + + + + + void *devicePointer; +# 1657 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + void *hostPointer; +}; + + + + +struct __attribute__((device_builtin)) cudaFuncAttributes +{ + + + + + + size_t sharedSizeBytes; + + + + + + size_t constSizeBytes; + + + + + size_t localSizeBytes; + + + + + + + int maxThreadsPerBlock; + + + + + int numRegs; + + + + + + + int ptxVersion; + + + + + + + int binaryVersion; + + + + + + int cacheModeCA; + + + + + + + int maxDynamicSharedSizeBytes; +# 1729 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + int preferredShmemCarveout; + + + + + + int clusterDimMustBeSet; +# 1746 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + int requiredClusterWidth; + int requiredClusterHeight; + int requiredClusterDepth; + + + + + + int clusterSchedulingPolicyPreference; +# 1776 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + int nonPortableClusterSizeAllowed; + + + + + int reserved[16]; +}; + + + + +enum __attribute__((device_builtin)) cudaFuncAttribute +{ + cudaFuncAttributeMaxDynamicSharedMemorySize = 8, + cudaFuncAttributePreferredSharedMemoryCarveout = 9, + cudaFuncAttributeClusterDimMustBeSet = 10, + cudaFuncAttributeRequiredClusterWidth = 11, + cudaFuncAttributeRequiredClusterHeight = 12, + cudaFuncAttributeRequiredClusterDepth = 13, + cudaFuncAttributeNonPortableClusterSizeAllowed = 14, + cudaFuncAttributeClusterSchedulingPolicyPreference = 15, + cudaFuncAttributeMax +}; + + + + +enum __attribute__((device_builtin)) cudaFuncCache +{ + cudaFuncCachePreferNone = 0, + cudaFuncCachePreferShared = 1, + cudaFuncCachePreferL1 = 2, + cudaFuncCachePreferEqual = 3 +}; + + + + + +enum __attribute__((device_builtin)) cudaSharedMemConfig +{ + cudaSharedMemBankSizeDefault = 0, + cudaSharedMemBankSizeFourByte = 1, + cudaSharedMemBankSizeEightByte = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaSharedCarveout { + cudaSharedmemCarveoutDefault = -1, + cudaSharedmemCarveoutMaxShared = 100, + cudaSharedmemCarveoutMaxL1 = 0 +}; + + + + +enum __attribute__((device_builtin)) cudaComputeMode +{ + cudaComputeModeDefault = 0, + cudaComputeModeExclusive = 1, + cudaComputeModeProhibited = 2, + cudaComputeModeExclusiveProcess = 3 +}; + + + + +enum __attribute__((device_builtin)) cudaLimit +{ + cudaLimitStackSize = 0x00, + cudaLimitPrintfFifoSize = 0x01, + cudaLimitMallocHeapSize = 0x02, + cudaLimitDevRuntimeSyncDepth = 0x03, + cudaLimitDevRuntimePendingLaunchCount = 0x04, + cudaLimitMaxL2FetchGranularity = 0x05, + cudaLimitPersistingL2CacheSize = 0x06 +}; + + + + +enum __attribute__((device_builtin)) cudaMemoryAdvise +{ + cudaMemAdviseSetReadMostly = 1, + cudaMemAdviseUnsetReadMostly = 2, + cudaMemAdviseSetPreferredLocation = 3, + cudaMemAdviseUnsetPreferredLocation = 4, + cudaMemAdviseSetAccessedBy = 5, + cudaMemAdviseUnsetAccessedBy = 6 +}; + + + + +enum __attribute__((device_builtin)) cudaMemRangeAttribute +{ + cudaMemRangeAttributeReadMostly = 1, + cudaMemRangeAttributePreferredLocation = 2, + cudaMemRangeAttributeAccessedBy = 3, + cudaMemRangeAttributeLastPrefetchLocation = 4 + , cudaMemRangeAttributePreferredLocationType = 5 + , cudaMemRangeAttributePreferredLocationId = 6 + , cudaMemRangeAttributeLastPrefetchLocationType = 7 + , cudaMemRangeAttributeLastPrefetchLocationId = 8 +}; + + + + +enum __attribute__((device_builtin)) cudaFlushGPUDirectRDMAWritesOptions { + cudaFlushGPUDirectRDMAWritesOptionHost = 1<<0, + cudaFlushGPUDirectRDMAWritesOptionMemOps = 1<<1 +}; + + + + +enum __attribute__((device_builtin)) cudaGPUDirectRDMAWritesOrdering { + cudaGPUDirectRDMAWritesOrderingNone = 0, + cudaGPUDirectRDMAWritesOrderingOwner = 100, + cudaGPUDirectRDMAWritesOrderingAllDevices = 200 +}; + + + + +enum __attribute__((device_builtin)) cudaFlushGPUDirectRDMAWritesScope { + cudaFlushGPUDirectRDMAWritesToOwner = 100, + cudaFlushGPUDirectRDMAWritesToAllDevices = 200 +}; + + + + +enum __attribute__((device_builtin)) cudaFlushGPUDirectRDMAWritesTarget { + cudaFlushGPUDirectRDMAWritesTargetCurrentDevice +}; + + + + + +enum __attribute__((device_builtin)) cudaDeviceAttr +{ + cudaDevAttrMaxThreadsPerBlock = 1, + cudaDevAttrMaxBlockDimX = 2, + cudaDevAttrMaxBlockDimY = 3, + cudaDevAttrMaxBlockDimZ = 4, + cudaDevAttrMaxGridDimX = 5, + cudaDevAttrMaxGridDimY = 6, + cudaDevAttrMaxGridDimZ = 7, + cudaDevAttrMaxSharedMemoryPerBlock = 8, + cudaDevAttrTotalConstantMemory = 9, + cudaDevAttrWarpSize = 10, + cudaDevAttrMaxPitch = 11, + cudaDevAttrMaxRegistersPerBlock = 12, + cudaDevAttrClockRate = 13, + cudaDevAttrTextureAlignment = 14, + cudaDevAttrGpuOverlap = 15, + cudaDevAttrMultiProcessorCount = 16, + cudaDevAttrKernelExecTimeout = 17, + cudaDevAttrIntegrated = 18, + cudaDevAttrCanMapHostMemory = 19, + cudaDevAttrComputeMode = 20, + cudaDevAttrMaxTexture1DWidth = 21, + cudaDevAttrMaxTexture2DWidth = 22, + cudaDevAttrMaxTexture2DHeight = 23, + cudaDevAttrMaxTexture3DWidth = 24, + cudaDevAttrMaxTexture3DHeight = 25, + cudaDevAttrMaxTexture3DDepth = 26, + cudaDevAttrMaxTexture2DLayeredWidth = 27, + cudaDevAttrMaxTexture2DLayeredHeight = 28, + cudaDevAttrMaxTexture2DLayeredLayers = 29, + cudaDevAttrSurfaceAlignment = 30, + cudaDevAttrConcurrentKernels = 31, + cudaDevAttrEccEnabled = 32, + cudaDevAttrPciBusId = 33, + cudaDevAttrPciDeviceId = 34, + cudaDevAttrTccDriver = 35, + cudaDevAttrMemoryClockRate = 36, + cudaDevAttrGlobalMemoryBusWidth = 37, + cudaDevAttrL2CacheSize = 38, + cudaDevAttrMaxThreadsPerMultiProcessor = 39, + cudaDevAttrAsyncEngineCount = 40, + cudaDevAttrUnifiedAddressing = 41, + cudaDevAttrMaxTexture1DLayeredWidth = 42, + cudaDevAttrMaxTexture1DLayeredLayers = 43, + cudaDevAttrMaxTexture2DGatherWidth = 45, + cudaDevAttrMaxTexture2DGatherHeight = 46, + cudaDevAttrMaxTexture3DWidthAlt = 47, + cudaDevAttrMaxTexture3DHeightAlt = 48, + cudaDevAttrMaxTexture3DDepthAlt = 49, + cudaDevAttrPciDomainId = 50, + cudaDevAttrTexturePitchAlignment = 51, + cudaDevAttrMaxTextureCubemapWidth = 52, + cudaDevAttrMaxTextureCubemapLayeredWidth = 53, + cudaDevAttrMaxTextureCubemapLayeredLayers = 54, + cudaDevAttrMaxSurface1DWidth = 55, + cudaDevAttrMaxSurface2DWidth = 56, + cudaDevAttrMaxSurface2DHeight = 57, + cudaDevAttrMaxSurface3DWidth = 58, + cudaDevAttrMaxSurface3DHeight = 59, + cudaDevAttrMaxSurface3DDepth = 60, + cudaDevAttrMaxSurface1DLayeredWidth = 61, + cudaDevAttrMaxSurface1DLayeredLayers = 62, + cudaDevAttrMaxSurface2DLayeredWidth = 63, + cudaDevAttrMaxSurface2DLayeredHeight = 64, + cudaDevAttrMaxSurface2DLayeredLayers = 65, + cudaDevAttrMaxSurfaceCubemapWidth = 66, + cudaDevAttrMaxSurfaceCubemapLayeredWidth = 67, + cudaDevAttrMaxSurfaceCubemapLayeredLayers = 68, + cudaDevAttrMaxTexture1DLinearWidth = 69, + cudaDevAttrMaxTexture2DLinearWidth = 70, + cudaDevAttrMaxTexture2DLinearHeight = 71, + cudaDevAttrMaxTexture2DLinearPitch = 72, + cudaDevAttrMaxTexture2DMipmappedWidth = 73, + cudaDevAttrMaxTexture2DMipmappedHeight = 74, + cudaDevAttrComputeCapabilityMajor = 75, + cudaDevAttrComputeCapabilityMinor = 76, + cudaDevAttrMaxTexture1DMipmappedWidth = 77, + cudaDevAttrStreamPrioritiesSupported = 78, + cudaDevAttrGlobalL1CacheSupported = 79, + cudaDevAttrLocalL1CacheSupported = 80, + cudaDevAttrMaxSharedMemoryPerMultiprocessor = 81, + cudaDevAttrMaxRegistersPerMultiprocessor = 82, + cudaDevAttrManagedMemory = 83, + cudaDevAttrIsMultiGpuBoard = 84, + cudaDevAttrMultiGpuBoardGroupID = 85, + cudaDevAttrHostNativeAtomicSupported = 86, + cudaDevAttrSingleToDoublePrecisionPerfRatio = 87, + cudaDevAttrPageableMemoryAccess = 88, + cudaDevAttrConcurrentManagedAccess = 89, + cudaDevAttrComputePreemptionSupported = 90, + cudaDevAttrCanUseHostPointerForRegisteredMem = 91, + cudaDevAttrReserved92 = 92, + cudaDevAttrReserved93 = 93, + cudaDevAttrReserved94 = 94, + cudaDevAttrCooperativeLaunch = 95, + cudaDevAttrCooperativeMultiDeviceLaunch = 96, + cudaDevAttrMaxSharedMemoryPerBlockOptin = 97, + cudaDevAttrCanFlushRemoteWrites = 98, + cudaDevAttrHostRegisterSupported = 99, + cudaDevAttrPageableMemoryAccessUsesHostPageTables = 100, + cudaDevAttrDirectManagedMemAccessFromHost = 101, + cudaDevAttrMaxBlocksPerMultiprocessor = 106, + cudaDevAttrMaxPersistingL2CacheSize = 108, + cudaDevAttrMaxAccessPolicyWindowSize = 109, + cudaDevAttrReservedSharedMemoryPerBlock = 111, + cudaDevAttrSparseCudaArraySupported = 112, + cudaDevAttrHostRegisterReadOnlySupported = 113, + cudaDevAttrTimelineSemaphoreInteropSupported = 114, + cudaDevAttrMaxTimelineSemaphoreInteropSupported = 114, + cudaDevAttrMemoryPoolsSupported = 115, + cudaDevAttrGPUDirectRDMASupported = 116, + cudaDevAttrGPUDirectRDMAFlushWritesOptions = 117, + cudaDevAttrGPUDirectRDMAWritesOrdering = 118, + cudaDevAttrMemoryPoolSupportedHandleTypes = 119, + cudaDevAttrClusterLaunch = 120, + cudaDevAttrDeferredMappingCudaArraySupported = 121, + cudaDevAttrReserved122 = 122, + cudaDevAttrReserved123 = 123, + cudaDevAttrReserved124 = 124, + cudaDevAttrIpcEventSupport = 125, + cudaDevAttrMemSyncDomainCount = 126, + cudaDevAttrReserved127 = 127, + cudaDevAttrReserved128 = 128, + cudaDevAttrReserved129 = 129, + cudaDevAttrNumaConfig = 130, + cudaDevAttrNumaId = 131, + cudaDevAttrReserved132 = 132, + cudaDevAttrMpsEnabled = 133, + cudaDevAttrHostNumaId = 134, + cudaDevAttrD3D12CigSupported = 135, + cudaDevAttrGpuPciDeviceId = 139, + cudaDevAttrGpuPciSubsystemId = 140, + cudaDevAttrHostNumaMultinodeIpcSupported = 143, + cudaDevAttrMax +}; + + + + +enum __attribute__((device_builtin)) cudaMemPoolAttr +{ +# 2070 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaMemPoolReuseFollowEventDependencies = 0x1, + + + + + + + cudaMemPoolReuseAllowOpportunistic = 0x2, + + + + + + + + cudaMemPoolReuseAllowInternalDependencies = 0x3, +# 2096 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaMemPoolAttrReleaseThreshold = 0x4, + + + + + + cudaMemPoolAttrReservedMemCurrent = 0x5, + + + + + + + cudaMemPoolAttrReservedMemHigh = 0x6, + + + + + + cudaMemPoolAttrUsedMemCurrent = 0x7, + + + + + + + cudaMemPoolAttrUsedMemHigh = 0x8 +}; + + + + +enum __attribute__((device_builtin)) cudaMemLocationType { + cudaMemLocationTypeInvalid = 0, + cudaMemLocationTypeDevice = 1 + , cudaMemLocationTypeHost = 2 + , cudaMemLocationTypeHostNuma = 3 + , cudaMemLocationTypeHostNumaCurrent = 4 +}; + + + + + + + +struct __attribute__((device_builtin)) cudaMemLocation { + enum cudaMemLocationType type; + int id; +}; + + + + +enum __attribute__((device_builtin)) cudaMemAccessFlags { + cudaMemAccessFlagsProtNone = 0, + cudaMemAccessFlagsProtRead = 1, + cudaMemAccessFlagsProtReadWrite = 3 +}; + + + + +struct __attribute__((device_builtin)) cudaMemAccessDesc { + struct cudaMemLocation location; + enum cudaMemAccessFlags flags; +}; + + + + +enum __attribute__((device_builtin)) cudaMemAllocationType { + cudaMemAllocationTypeInvalid = 0x0, + + + + cudaMemAllocationTypePinned = 0x1, + cudaMemAllocationTypeMax = 0x7FFFFFFF +}; + + + + +enum __attribute__((device_builtin)) cudaMemAllocationHandleType { + cudaMemHandleTypeNone = 0x0, + cudaMemHandleTypePosixFileDescriptor = 0x1, + cudaMemHandleTypeWin32 = 0x2, + cudaMemHandleTypeWin32Kmt = 0x4, + cudaMemHandleTypeFabric = 0x8 +}; +# 2196 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct __attribute__((device_builtin)) cudaMemPoolProps { + enum cudaMemAllocationType allocType; + enum cudaMemAllocationHandleType handleTypes; + struct cudaMemLocation location; + + + + + + + void *win32SecurityAttributes; + size_t maxSize; + unsigned short usage; + unsigned char reserved[54]; +}; + + + + +struct __attribute__((device_builtin)) cudaMemPoolPtrExportData { + unsigned char reserved[64]; +}; + + + + +struct __attribute__((device_builtin)) cudaMemAllocNodeParams { + + + + + struct cudaMemPoolProps poolProps; + const struct cudaMemAccessDesc *accessDescs; + size_t accessDescCount; + size_t bytesize; + void *dptr; +}; + + + + +struct __attribute__((device_builtin)) cudaMemAllocNodeParamsV2 { + + + + + struct cudaMemPoolProps poolProps; + const struct cudaMemAccessDesc *accessDescs; + size_t accessDescCount; + size_t bytesize; + void *dptr; +}; + + + + +struct __attribute__((device_builtin)) cudaMemFreeNodeParams { + void *dptr; +}; + + + + +enum __attribute__((device_builtin)) cudaGraphMemAttributeType { + + + + + cudaGraphMemAttrUsedMemCurrent = 0x0, + + + + + + + cudaGraphMemAttrUsedMemHigh = 0x1, + + + + + + + cudaGraphMemAttrReservedMemCurrent = 0x2, + + + + + + + cudaGraphMemAttrReservedMemHigh = 0x3 +}; + + + + +enum __attribute__((device_builtin)) cudaMemcpyFlags { + cudaMemcpyFlagDefault = 0x0, + + + + + cudaMemcpyFlagPreferOverlapWithCompute = 0x1 +}; + +enum __attribute__((device_builtin)) cudaMemcpySrcAccessOrder { + + + + cudaMemcpySrcAccessOrderInvalid = 0x0, + + + + + cudaMemcpySrcAccessOrderStream = 0x1, +# 2320 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaMemcpySrcAccessOrderDuringApiCall = 0x2, +# 2329 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaMemcpySrcAccessOrderAny = 0x3, + + cudaMemcpySrcAccessOrderMax = 0x7FFFFFFF +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpyAttributes { + enum cudaMemcpySrcAccessOrder srcAccessOrder; + struct cudaMemLocation srcLocHint; + struct cudaMemLocation dstLocHint; + unsigned int flags; +}; + + + + +enum __attribute__((device_builtin)) cudaMemcpy3DOperandType { + cudaMemcpyOperandTypePointer = 0x1, + cudaMemcpyOperandTypeArray = 0x2, + cudaMemcpyOperandTypeMax = 0x7FFFFFFF +}; + + + + +struct __attribute__((device_builtin)) cudaOffset3D { + size_t x; + size_t y; + size_t z; +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpy3DOperand { + enum cudaMemcpy3DOperandType type; + union { + + + + struct { + void *ptr; + size_t rowLength; + size_t layerHeight; + struct cudaMemLocation locHint; + } ptr; + + + + + struct { + cudaArray_t array; + struct cudaOffset3D offset; + } array; + } op; +}; + +struct __attribute__((device_builtin)) cudaMemcpy3DBatchOp { + struct cudaMemcpy3DOperand src; + struct cudaMemcpy3DOperand dst; + struct cudaExtent extent; + enum cudaMemcpySrcAccessOrder srcAccessOrder; + unsigned int flags; +}; + + + + + +enum __attribute__((device_builtin)) cudaDeviceP2PAttr { + cudaDevP2PAttrPerformanceRank = 1, + cudaDevP2PAttrAccessSupported = 2, + cudaDevP2PAttrNativeAtomicSupported = 3, + cudaDevP2PAttrCudaArrayAccessSupported = 4 +}; + + + + + + +struct __attribute__((device_builtin)) CUuuid_st { + char bytes[16]; +}; +typedef __attribute__((device_builtin)) struct CUuuid_st CUuuid; + +typedef __attribute__((device_builtin)) struct CUuuid_st cudaUUID_t; + + + + +struct __attribute__((device_builtin)) cudaDeviceProp +{ + char name[256]; + cudaUUID_t uuid; + char luid[8]; + unsigned int luidDeviceNodeMask; + size_t totalGlobalMem; + size_t sharedMemPerBlock; + int regsPerBlock; + int warpSize; + size_t memPitch; + int maxThreadsPerBlock; + int maxThreadsDim[3]; + int maxGridSize[3]; + int clockRate; + size_t totalConstMem; + int major; + int minor; + size_t textureAlignment; + size_t texturePitchAlignment; + int deviceOverlap; + int multiProcessorCount; + int kernelExecTimeoutEnabled; + int integrated; + int canMapHostMemory; + int computeMode; + int maxTexture1D; + int maxTexture1DMipmap; + int maxTexture1DLinear; + int maxTexture2D[2]; + int maxTexture2DMipmap[2]; + int maxTexture2DLinear[3]; + int maxTexture2DGather[2]; + int maxTexture3D[3]; + int maxTexture3DAlt[3]; + int maxTextureCubemap; + int maxTexture1DLayered[2]; + int maxTexture2DLayered[3]; + int maxTextureCubemapLayered[2]; + int maxSurface1D; + int maxSurface2D[2]; + int maxSurface3D[3]; + int maxSurface1DLayered[2]; + int maxSurface2DLayered[3]; + int maxSurfaceCubemap; + int maxSurfaceCubemapLayered[2]; + size_t surfaceAlignment; + int concurrentKernels; + int ECCEnabled; + int pciBusID; + int pciDeviceID; + int pciDomainID; + int tccDriver; + int asyncEngineCount; + int unifiedAddressing; + int memoryClockRate; + int memoryBusWidth; + int l2CacheSize; + int persistingL2CacheMaxSize; + int maxThreadsPerMultiProcessor; + int streamPrioritiesSupported; + int globalL1CacheSupported; + int localL1CacheSupported; + size_t sharedMemPerMultiprocessor; + int regsPerMultiprocessor; + int managedMemory; + int isMultiGpuBoard; + int multiGpuBoardGroupID; + int hostNativeAtomicSupported; + int singleToDoublePrecisionPerfRatio; + int pageableMemoryAccess; + int concurrentManagedAccess; + int computePreemptionSupported; + int canUseHostPointerForRegisteredMem; + int cooperativeLaunch; + int cooperativeMultiDeviceLaunch; + size_t sharedMemPerBlockOptin; + int pageableMemoryAccessUsesHostPageTables; + int directManagedMemAccessFromHost; + int maxBlocksPerMultiProcessor; + int accessPolicyMaxWindowSize; + size_t reservedSharedMemPerBlock; + int hostRegisterSupported; + int sparseCudaArraySupported; + int hostRegisterReadOnlySupported; + int timelineSemaphoreInteropSupported; + int memoryPoolsSupported; + int gpuDirectRDMASupported; + unsigned int gpuDirectRDMAFlushWritesOptions; + int gpuDirectRDMAWritesOrdering; + unsigned int memoryPoolSupportedHandleTypes; + int deferredMappingCudaArraySupported; + int ipcEventSupported; + int clusterLaunch; + int unifiedFunctionPointers; + int reserved[63]; +}; +# 2528 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef __attribute__((device_builtin)) struct __attribute__((device_builtin)) cudaIpcEventHandle_st +{ + char reserved[64]; +}cudaIpcEventHandle_t; + + + + +typedef __attribute__((device_builtin)) struct __attribute__((device_builtin)) cudaIpcMemHandle_st +{ + char reserved[64]; +}cudaIpcMemHandle_t; + + + + +typedef __attribute__((device_builtin)) struct __attribute__((device_builtin)) cudaMemFabricHandle_st +{ + char reserved[64]; +}cudaMemFabricHandle_t; + + + + +enum __attribute__((device_builtin)) cudaExternalMemoryHandleType { + + + + cudaExternalMemoryHandleTypeOpaqueFd = 1, + + + + cudaExternalMemoryHandleTypeOpaqueWin32 = 2, + + + + cudaExternalMemoryHandleTypeOpaqueWin32Kmt = 3, + + + + cudaExternalMemoryHandleTypeD3D12Heap = 4, + + + + cudaExternalMemoryHandleTypeD3D12Resource = 5, + + + + cudaExternalMemoryHandleTypeD3D11Resource = 6, + + + + cudaExternalMemoryHandleTypeD3D11ResourceKmt = 7, + + + + cudaExternalMemoryHandleTypeNvSciBuf = 8 +}; +# 2627 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct __attribute__((device_builtin)) cudaExternalMemoryHandleDesc { + + + + enum cudaExternalMemoryHandleType type; + union { + + + + + + int fd; +# 2654 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + + + + void *handle; + + + + + const void *name; + } win32; + + + + + const void *nvSciBufObject; + } handle; + + + + unsigned long long size; + + + + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalMemoryBufferDesc { + + + + unsigned long long offset; + + + + unsigned long long size; + + + + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalMemoryMipmappedArrayDesc { + + + + + unsigned long long offset; + + + + struct cudaChannelFormatDesc formatDesc; + + + + struct cudaExtent extent; + + + + + unsigned int flags; + + + + unsigned int numLevels; +}; + + + + +enum __attribute__((device_builtin)) cudaExternalSemaphoreHandleType { + + + + cudaExternalSemaphoreHandleTypeOpaqueFd = 1, + + + + cudaExternalSemaphoreHandleTypeOpaqueWin32 = 2, + + + + cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3, + + + + cudaExternalSemaphoreHandleTypeD3D12Fence = 4, + + + + cudaExternalSemaphoreHandleTypeD3D11Fence = 5, + + + + cudaExternalSemaphoreHandleTypeNvSciSync = 6, + + + + cudaExternalSemaphoreHandleTypeKeyedMutex = 7, + + + + cudaExternalSemaphoreHandleTypeKeyedMutexKmt = 8, + + + + cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9, + + + + cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10 +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreHandleDesc { + + + + enum cudaExternalSemaphoreHandleType type; + union { + + + + + + + int fd; +# 2804 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + + + + void *handle; + + + + + const void *name; + } win32; + + + + const void* nvSciSyncObj; + } handle; + + + + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalParams_v1 { + struct { + + + + struct { + + + + unsigned long long value; + } fence; + union { + + + + + void *fence; + unsigned long long reserved; + } nvSciSync; + + + + struct { + + + + unsigned long long key; + } keyedMutex; + } params; +# 2868 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitParams_v1 { + struct { + + + + struct { + + + + unsigned long long value; + } fence; + union { + + + + + void *fence; + unsigned long long reserved; + } nvSciSync; + + + + struct { + + + + unsigned long long key; + + + + unsigned int timeoutMs; + } keyedMutex; + } params; +# 2917 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalParams{ + struct { + + + + struct { + + + + unsigned long long value; + } fence; + union { + + + + + void *fence; + unsigned long long reserved; + } nvSciSync; + + + + struct { + + + + unsigned long long key; + } keyedMutex; + unsigned int reserved[12]; + } params; +# 2963 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned int flags; + unsigned int reserved[16]; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitParams { + struct { + + + + struct { + + + + unsigned long long value; + } fence; + union { + + + + + void *fence; + unsigned long long reserved; + } nvSciSync; + + + + struct { + + + + unsigned long long key; + + + + unsigned int timeoutMs; + } keyedMutex; + unsigned int reserved[10]; + } params; +# 3014 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned int flags; + unsigned int reserved[16]; +}; +# 3027 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef __attribute__((device_builtin)) enum cudaError cudaError_t; + + + + +typedef __attribute__((device_builtin)) struct CUstream_st *cudaStream_t; + + + + +typedef __attribute__((device_builtin)) struct CUevent_st *cudaEvent_t; + + + + +typedef __attribute__((device_builtin)) struct cudaGraphicsResource *cudaGraphicsResource_t; + + + + +typedef __attribute__((device_builtin)) struct CUexternalMemory_st *cudaExternalMemory_t; + + + + +typedef __attribute__((device_builtin)) struct CUexternalSemaphore_st *cudaExternalSemaphore_t; + + + + +typedef __attribute__((device_builtin)) struct CUgraph_st *cudaGraph_t; + + + + +typedef __attribute__((device_builtin)) struct CUgraphNode_st *cudaGraphNode_t; + + + + +typedef __attribute__((device_builtin)) struct CUuserObject_st *cudaUserObject_t; + + + + +typedef __attribute__((device_builtin)) unsigned long long cudaGraphConditionalHandle; + + + + +typedef __attribute__((device_builtin)) struct CUfunc_st *cudaFunction_t; + + + + +typedef __attribute__((device_builtin)) struct CUkern_st *cudaKernel_t; + + + + +enum __attribute__((device_builtin)) cudaJitOption +{ + + + + + + cudaJitMaxRegisters = 0, +# 3108 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitThreadsPerBlock = 1, + + + + + + + + cudaJitWallTime = 2, +# 3125 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitInfoLogBuffer = 3, +# 3134 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitInfoLogBufferSizeBytes = 4, +# 3143 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitErrorLogBuffer = 5, +# 3152 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitErrorLogBufferSizeBytes = 6, + + + + + + + + cudaJitOptimizationLevel = 7, + + + + + + + + cudaJitFallbackStrategy = 10, + + + + + + + + cudaJitGenerateDebugInfo = 11, + + + + + + + cudaJitLogVerbose = 12, + + + + + + + cudaJitGenerateLineInfo = 13, + + + + + + + + cudaJitCacheMode = 14, + + + + + + + cudaJitPositionIndependentCode = 30, +# 3218 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitMinCtaPerSm = 31, +# 3231 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitMaxThreadsPerBlock = 32, +# 3241 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitOverrideDirectiveValues = 33, +}; + + + + + +enum __attribute__((device_builtin)) cudaLibraryOption +{ + cudaLibraryHostUniversalFunctionAndDataTable = 0, +# 3261 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaLibraryBinaryIsPreserved = 1, +}; + +struct __attribute__((device_builtin)) cudalibraryHostUniversalFunctionAndDataTable +{ + void *functionTable; + size_t functionWindowSize; + void *dataTable; + size_t dataWindowSize; +}; + + + + +enum __attribute__((device_builtin)) cudaJit_CacheMode +{ + cudaJitCacheOptionNone = 0, + cudaJitCacheOptionCG, + cudaJitCacheOptionCA +}; + + + + +enum __attribute__((device_builtin)) cudaJit_Fallback +{ + cudaPreferPtx = 0, + + cudaPreferBinary +}; + + + + +typedef __attribute__((device_builtin)) struct CUlib_st *cudaLibrary_t; + + + + +typedef __attribute__((device_builtin)) struct CUmemPoolHandle_st *cudaMemPool_t; + + + + +enum __attribute__((device_builtin)) cudaCGScope { + cudaCGScopeInvalid = 0, + cudaCGScopeGrid = 1, + cudaCGScopeMultiGrid = 2 +}; + + + + +struct __attribute__((device_builtin)) cudaLaunchParams +{ + void *func; + dim3 gridDim; + dim3 blockDim; + void **args; + size_t sharedMem; + cudaStream_t stream; +}; + + + + +struct __attribute__((device_builtin)) cudaKernelNodeParams { + void* func; + dim3 gridDim; + dim3 blockDim; + unsigned int sharedMemBytes; + void **kernelParams; + void **extra; +}; + + + + +struct __attribute__((device_builtin)) cudaKernelNodeParamsV2 { + void* func; + + dim3 gridDim; + dim3 blockDim; + + + + + + unsigned int sharedMemBytes; + void **kernelParams; + void **extra; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalNodeParams { + cudaExternalSemaphore_t* extSemArray; + const struct cudaExternalSemaphoreSignalParams* paramsArray; + unsigned int numExtSems; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalNodeParamsV2 { + cudaExternalSemaphore_t* extSemArray; + const struct cudaExternalSemaphoreSignalParams* paramsArray; + unsigned int numExtSems; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitNodeParams { + cudaExternalSemaphore_t* extSemArray; + const struct cudaExternalSemaphoreWaitParams* paramsArray; + unsigned int numExtSems; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitNodeParamsV2 { + cudaExternalSemaphore_t* extSemArray; + const struct cudaExternalSemaphoreWaitParams* paramsArray; + unsigned int numExtSems; +}; + +enum __attribute__((device_builtin)) cudaGraphConditionalHandleFlags { + cudaGraphCondAssignDefault = 1 +}; + + + + +enum __attribute__((device_builtin)) cudaGraphConditionalNodeType { + cudaGraphCondTypeIf = 0, + cudaGraphCondTypeWhile = 1, + cudaGraphCondTypeSwitch = 2, +}; + + + + +struct __attribute__((device_builtin)) cudaConditionalNodeParams { + cudaGraphConditionalHandle handle; + + + enum cudaGraphConditionalNodeType type; + unsigned int size; + + cudaGraph_t *phGraph_out; +# 3432 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +}; + + + + +enum __attribute__((device_builtin)) cudaGraphNodeType { + cudaGraphNodeTypeKernel = 0x00, + cudaGraphNodeTypeMemcpy = 0x01, + cudaGraphNodeTypeMemset = 0x02, + cudaGraphNodeTypeHost = 0x03, + cudaGraphNodeTypeGraph = 0x04, + cudaGraphNodeTypeEmpty = 0x05, + cudaGraphNodeTypeWaitEvent = 0x06, + cudaGraphNodeTypeEventRecord = 0x07, + cudaGraphNodeTypeExtSemaphoreSignal = 0x08, + cudaGraphNodeTypeExtSemaphoreWait = 0x09, + cudaGraphNodeTypeMemAlloc = 0x0a, + cudaGraphNodeTypeMemFree = 0x0b, + cudaGraphNodeTypeConditional = 0x0d, +# 3467 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaGraphNodeTypeCount +}; + + + + +struct __attribute__((device_builtin)) cudaChildGraphNodeParams { + cudaGraph_t graph; + +}; + + + + +struct __attribute__((device_builtin)) cudaEventRecordNodeParams { + cudaEvent_t event; +}; + + + + +struct __attribute__((device_builtin)) cudaEventWaitNodeParams { + cudaEvent_t event; +}; + + + + +struct __attribute__((device_builtin)) cudaGraphNodeParams { + enum cudaGraphNodeType type; + int reserved0[3]; + + union { + long long reserved1[29]; + struct cudaKernelNodeParamsV2 kernel; + struct cudaMemcpyNodeParams memcpy; + struct cudaMemsetParamsV2 memset; + struct cudaHostNodeParamsV2 host; + struct cudaChildGraphNodeParams graph; + struct cudaEventWaitNodeParams eventWait; + struct cudaEventRecordNodeParams eventRecord; + struct cudaExternalSemaphoreSignalNodeParamsV2 extSemSignal; + struct cudaExternalSemaphoreWaitNodeParamsV2 extSemWait; + struct cudaMemAllocNodeParamsV2 alloc; + struct cudaMemFreeNodeParams free; + struct cudaConditionalNodeParams conditional; + }; + + long long reserved2; +}; + + + + +typedef __attribute__((device_builtin)) enum cudaGraphDependencyType_enum { + cudaGraphDependencyTypeDefault = 0, + cudaGraphDependencyTypeProgrammatic = 1 + + + + +} cudaGraphDependencyType; + + + + + + +typedef __attribute__((device_builtin)) struct cudaGraphEdgeData_st { + unsigned char from_port; +# 3546 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned char to_port; + + + + + + + unsigned char type; + + + unsigned char reserved[5]; + +} cudaGraphEdgeData; +# 3579 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef struct CUgraphExec_st* cudaGraphExec_t; + + + + +enum __attribute__((device_builtin)) cudaGraphExecUpdateResult { + cudaGraphExecUpdateSuccess = 0x0, + cudaGraphExecUpdateError = 0x1, + cudaGraphExecUpdateErrorTopologyChanged = 0x2, + cudaGraphExecUpdateErrorNodeTypeChanged = 0x3, + cudaGraphExecUpdateErrorFunctionChanged = 0x4, + cudaGraphExecUpdateErrorParametersChanged = 0x5, + cudaGraphExecUpdateErrorNotSupported = 0x6, + cudaGraphExecUpdateErrorUnsupportedFunctionChange = 0x7, + cudaGraphExecUpdateErrorAttributesChanged = 0x8 +}; + + + + +typedef __attribute__((device_builtin)) enum cudaGraphInstantiateResult { + cudaGraphInstantiateSuccess = 0, + cudaGraphInstantiateError = 1, + cudaGraphInstantiateInvalidStructure = 2, + cudaGraphInstantiateNodeOperationNotSupported = 3, + cudaGraphInstantiateMultipleDevicesNotSupported = 4, + cudaGraphInstantiateConditionalHandleUnused = 5 +} cudaGraphInstantiateResult; + + + + +typedef __attribute__((device_builtin)) struct cudaGraphInstantiateParams_st +{ + unsigned long long flags; + cudaStream_t uploadStream; + cudaGraphNode_t errNode_out; + cudaGraphInstantiateResult result_out; +} cudaGraphInstantiateParams; + + + + +typedef __attribute__((device_builtin)) struct cudaGraphExecUpdateResultInfo_st { + + + + enum cudaGraphExecUpdateResult result; + + + + + + + cudaGraphNode_t errorNode; + + + + + cudaGraphNode_t errorFromNode; +} cudaGraphExecUpdateResultInfo; + + + + +typedef struct CUgraphDeviceUpdatableNode_st* cudaGraphDeviceNode_t; + + + + +enum __attribute__((device_builtin)) cudaGraphKernelNodeField +{ + cudaGraphKernelNodeFieldInvalid = 0, + cudaGraphKernelNodeFieldGridDim, + cudaGraphKernelNodeFieldParam, + cudaGraphKernelNodeFieldEnabled +}; + + + + +struct __attribute__((device_builtin)) cudaGraphKernelNodeUpdate { + cudaGraphDeviceNode_t node; + enum cudaGraphKernelNodeField field; + union { + + dim3 gridDim; + + + + + struct { + const void *pValue; + size_t offset; + size_t size; + } param; + unsigned int isEnabled; + } updateData; +}; + + + + + +enum __attribute__((device_builtin)) cudaGetDriverEntryPointFlags { + cudaEnableDefault = 0x0, + cudaEnableLegacyStream = 0x1, + cudaEnablePerThreadDefaultStream = 0x2 +}; + + + + +enum __attribute__((device_builtin)) cudaDriverEntryPointQueryResult { + cudaDriverEntryPointSuccess = 0, + cudaDriverEntryPointSymbolNotFound = 1, + cudaDriverEntryPointVersionNotSufficent = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaGraphDebugDotFlags { + cudaGraphDebugDotFlagsVerbose = 1<<0, + cudaGraphDebugDotFlagsKernelNodeParams = 1<<2, + cudaGraphDebugDotFlagsMemcpyNodeParams = 1<<3, + cudaGraphDebugDotFlagsMemsetNodeParams = 1<<4, + cudaGraphDebugDotFlagsHostNodeParams = 1<<5, + cudaGraphDebugDotFlagsEventNodeParams = 1<<6, + cudaGraphDebugDotFlagsExtSemasSignalNodeParams = 1<<7, + cudaGraphDebugDotFlagsExtSemasWaitNodeParams = 1<<8, + cudaGraphDebugDotFlagsKernelNodeAttributes = 1<<9, + cudaGraphDebugDotFlagsHandles = 1<<10, + cudaGraphDebugDotFlagsConditionalNodeParams = 1<<15, +}; + + + + +enum __attribute__((device_builtin)) cudaGraphInstantiateFlags { + cudaGraphInstantiateFlagAutoFreeOnLaunch = 1 + , cudaGraphInstantiateFlagUpload = 2 + + + , cudaGraphInstantiateFlagDeviceLaunch = 4 + + + , cudaGraphInstantiateFlagUseNodePriority = 8 + +}; +# 3746 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef __attribute__((device_builtin)) enum cudaLaunchMemSyncDomain { + cudaLaunchMemSyncDomainDefault = 0, + cudaLaunchMemSyncDomainRemote = 1 +} cudaLaunchMemSyncDomain; +# 3762 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef __attribute__((device_builtin)) struct cudaLaunchMemSyncDomainMap_st { + unsigned char default_; + unsigned char remote; +} cudaLaunchMemSyncDomainMap; + + + + +typedef __attribute__((device_builtin)) enum cudaLaunchAttributeID { + cudaLaunchAttributeIgnore = 0 + , cudaLaunchAttributeAccessPolicyWindow = 1 + + , cudaLaunchAttributeCooperative = 2 + + , cudaLaunchAttributeSynchronizationPolicy = 3 + , cudaLaunchAttributeClusterDimension = 4 + + , cudaLaunchAttributeClusterSchedulingPolicyPreference = 5 + + , cudaLaunchAttributeProgrammaticStreamSerialization = 6 +# 3792 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributeProgrammaticEvent = 7 +# 3818 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributePriority = 8 + + , cudaLaunchAttributeMemSyncDomainMap = 9 + + , cudaLaunchAttributeMemSyncDomain = 10 + + , cudaLaunchAttributePreferredClusterDimension = 11 +# 3860 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributeLaunchCompletionEvent = 12 +# 3882 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributeDeviceUpdatableKernelNode = 13 +# 3910 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributePreferredSharedMemoryCarveout = 14 + + + + + + +} cudaLaunchAttributeID; + + + + +typedef __attribute__((device_builtin)) union cudaLaunchAttributeValue { + char pad[64]; + struct cudaAccessPolicyWindow accessPolicyWindow; + int cooperative; + + enum cudaSynchronizationPolicy syncPolicy; +# 3941 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + unsigned int x; + unsigned int y; + unsigned int z; + } clusterDim; + enum cudaClusterSchedulingPolicy clusterSchedulingPolicyPreference; + + + int programmaticStreamSerializationAllowed; +# 3960 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + cudaEvent_t event; + int flags; + int triggerAtBlockStart; + } programmaticEvent; + int priority; + cudaLaunchMemSyncDomainMap memSyncDomainMap; + + + cudaLaunchMemSyncDomain memSyncDomain; +# 3984 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + unsigned int x; + unsigned int y; + unsigned int z; + } preferredClusterDim; +# 3997 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + cudaEvent_t event; + int flags; + } launchCompletionEvent; + + + + + + + + struct { + int deviceUpdatable; + cudaGraphDeviceNode_t devNode; + } deviceUpdatableKernelNode; + unsigned int sharedMemCarveout; +} cudaLaunchAttributeValue; + + + + +typedef __attribute__((device_builtin)) struct cudaLaunchAttribute_st { + cudaLaunchAttributeID id; + char pad[8 - sizeof(cudaLaunchAttributeID)]; + cudaLaunchAttributeValue val; +} cudaLaunchAttribute; + + + + +typedef __attribute__((device_builtin)) struct cudaLaunchConfig_st { + dim3 gridDim; + dim3 blockDim; + size_t dynamicSmemBytes; + cudaStream_t stream; + cudaLaunchAttribute *attrs; + unsigned int numAttrs; +} cudaLaunchConfig_t; +# 4061 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +enum __attribute__((device_builtin)) cudaDeviceNumaConfig { + cudaDeviceNumaConfigNone = 0, + cudaDeviceNumaConfigNumaNode, +}; + + + + +typedef struct cudaAsyncCallbackEntry* cudaAsyncCallbackHandle_t; + +struct cudaAsyncCallbackEntry; + + + + +typedef __attribute__((device_builtin)) enum cudaAsyncNotificationType_enum { + cudaAsyncNotificationTypeOverBudget = 0x1 +} cudaAsyncNotificationType; + + + + +typedef __attribute__((device_builtin)) struct cudaAsyncNotificationInfo +{ + cudaAsyncNotificationType type; + union { + struct { + unsigned long long bytesOverBudget; + } overBudget; + } info; +} cudaAsyncNotificationInfo_t; + +typedef void (*cudaAsyncCallback)(cudaAsyncNotificationInfo_t*, void*, cudaAsyncCallbackHandle_t); +# 60 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_types.h" 1 +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_types.h" +enum __attribute__((device_builtin)) cudaSurfaceBoundaryMode +{ + cudaBoundaryModeZero = 0, + cudaBoundaryModeClamp = 1, + cudaBoundaryModeTrap = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaSurfaceFormatMode +{ + cudaFormatModeForced = 0, + cudaFormatModeAuto = 1 +}; + + + + +typedef __attribute__((device_builtin)) unsigned long long cudaSurfaceObject_t; +# 63 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_types.h" 1 +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_types.h" +enum __attribute__((device_builtin)) cudaTextureAddressMode +{ + cudaAddressModeWrap = 0, + cudaAddressModeClamp = 1, + cudaAddressModeMirror = 2, + cudaAddressModeBorder = 3 +}; + + + + +enum __attribute__((device_builtin)) cudaTextureFilterMode +{ + cudaFilterModePoint = 0, + cudaFilterModeLinear = 1 +}; + + + + +enum __attribute__((device_builtin)) cudaTextureReadMode +{ + cudaReadModeElementType = 0, + cudaReadModeNormalizedFloat = 1 +}; + + + + +struct __attribute__((device_builtin)) cudaTextureDesc +{ + + + + enum cudaTextureAddressMode addressMode[3]; + + + + enum cudaTextureFilterMode filterMode; + + + + enum cudaTextureReadMode readMode; + + + + int sRGB; + + + + float borderColor[4]; + + + + int normalizedCoords; + + + + unsigned int maxAnisotropy; + + + + enum cudaTextureFilterMode mipmapFilterMode; + + + + float mipmapLevelBias; + + + + float minMipmapLevelClamp; + + + + float maxMipmapLevelClamp; + + + + int disableTrilinearOptimization; + + + + int seamlessCubemap; +}; + + + + +typedef __attribute__((device_builtin)) unsigned long long cudaTextureObject_t; +# 64 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 2 +# 91 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/library_types.h" 1 +# 57 "/opt/cuda/bin/../targets/x86_64-linux/include/library_types.h" +typedef enum cudaDataType_t +{ + CUDA_R_16F = 2, + CUDA_C_16F = 6, + CUDA_R_16BF = 14, + CUDA_C_16BF = 15, + CUDA_R_32F = 0, + CUDA_C_32F = 4, + CUDA_R_64F = 1, + CUDA_C_64F = 5, + CUDA_R_4I = 16, + CUDA_C_4I = 17, + CUDA_R_4U = 18, + CUDA_C_4U = 19, + CUDA_R_8I = 3, + CUDA_C_8I = 7, + CUDA_R_8U = 8, + CUDA_C_8U = 9, + CUDA_R_16I = 20, + CUDA_C_16I = 21, + CUDA_R_16U = 22, + CUDA_C_16U = 23, + CUDA_R_32I = 10, + CUDA_C_32I = 11, + CUDA_R_32U = 12, + CUDA_C_32U = 13, + CUDA_R_64I = 24, + CUDA_C_64I = 25, + CUDA_R_64U = 26, + CUDA_C_64U = 27, + CUDA_R_8F_E4M3 = 28, + CUDA_R_8F_UE4M3 = CUDA_R_8F_E4M3, + CUDA_R_8F_E5M2 = 29, + CUDA_R_8F_UE8M0 = 30, + CUDA_R_6F_E2M3 = 31, + CUDA_R_6F_E3M2 = 32, + CUDA_R_4F_E2M1 = 33, +} cudaDataType; + + +typedef enum libraryPropertyType_t +{ + MAJOR_VERSION, + MINOR_VERSION, + PATCH_LEVEL +} libraryPropertyType; +# 92 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" 1 +# 61 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 1 +# 148 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 149 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 151 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" 1 +# 54 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h" 1 3 +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 308 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 + +# 308 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + typedef long unsigned int size_t; + typedef long int ptrdiff_t; + + + typedef decltype(nullptr) nullptr_t; + + +#pragma GCC visibility push(default) + + + extern "C++" __attribute__ ((__noreturn__, __always_inline__)) + inline void __terminate() noexcept + { + void terminate() noexcept __attribute__ ((__noreturn__,__cold__)); + terminate(); + } +#pragma GCC visibility pop +} +# 341 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +namespace __gnu_cxx +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +# 534 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ +#pragma GCC visibility push(default) + + + + + __attribute__((__always_inline__)) + constexpr inline bool + __is_constant_evaluated() noexcept + { + + + + + + return __builtin_is_constant_evaluated(); + + + + } +#pragma GCC visibility pop +} +# 573 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ +#pragma GCC visibility push(default) + + extern "C++" __attribute__ ((__noreturn__)) + void + __glibcxx_assert_fail + (const char* __file, int __line, const char* __function, + const char* __condition) + noexcept; +#pragma GCC visibility pop +} +# 604 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + __attribute__((__always_inline__,__visibility__("default"))) + inline void + __glibcxx_assert_fail() + { } +} +# 683 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3 +# 684 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3 +# 687 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 828 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace __gnu_cxx +{ + typedef __decltype(0.0bf16) __bfloat16_t; +} +# 890 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/pstl/pstl_config.h" 1 3 +# 891 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 2 3 +# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +# 1 "/usr/include/stdlib.h" 1 3 4 +# 26 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/stdlib.h" 2 3 4 + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 33 "/usr/include/stdlib.h" 2 3 4 + +extern "C" { + + + + + +# 1 "/usr/include/bits/waitflags.h" 1 3 4 +# 41 "/usr/include/stdlib.h" 2 3 4 +# 1 "/usr/include/bits/waitstatus.h" 1 3 4 +# 42 "/usr/include/stdlib.h" 2 3 4 +# 56 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/floatn.h" 1 3 4 +# 131 "/usr/include/bits/floatn.h" 3 4 +# 1 "/usr/include/bits/floatn-common.h" 1 3 4 +# 24 "/usr/include/bits/floatn-common.h" 3 4 +# 1 "/usr/include/bits/long-double.h" 1 3 4 +# 25 "/usr/include/bits/floatn-common.h" 2 3 4 +# 132 "/usr/include/bits/floatn.h" 2 3 4 +# 57 "/usr/include/stdlib.h" 2 3 4 + + +typedef struct + { + int quot; + int rem; + } div_t; + + + +typedef struct + { + long int quot; + long int rem; + } ldiv_t; + + + + + +__extension__ typedef struct + { + long long int quot; + long long int rem; + } lldiv_t; +# 98 "/usr/include/stdlib.h" 3 4 +extern size_t __ctype_get_mb_cur_max (void) noexcept (true) ; + + + +extern double atof (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern int atoi (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern long int atol (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +__extension__ extern long long int atoll (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +extern double strtod (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern float strtof (const char *__restrict __nptr, + char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern long double strtold (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 141 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float64 strtof64 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float128 strtof128 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float32x strtof32x (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float64x strtof64x (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 177 "/usr/include/stdlib.h" 3 4 +extern long int strtol (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern unsigned long int strtoul (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern long int strtol (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtol") + + + __attribute__ ((__nonnull__ (1))); +extern unsigned long int strtoul (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoul") + + + + __attribute__ ((__nonnull__ (1))); + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") + + + __attribute__ ((__nonnull__ (1))); +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") + + + + __attribute__ ((__nonnull__ (1))); + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") + + + __attribute__ ((__nonnull__ (1))); +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") + + + + __attribute__ ((__nonnull__ (1))); +# 278 "/usr/include/stdlib.h" 3 4 +extern int strfromd (char *__dest, size_t __size, const char *__format, + double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfromf (char *__dest, size_t __size, const char *__format, + float __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfroml (char *__dest, size_t __size, const char *__format, + long double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 298 "/usr/include/stdlib.h" 3 4 +extern int strfromf32 (char *__dest, size_t __size, const char * __format, + _Float32 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64 (char *__dest, size_t __size, const char * __format, + _Float64 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf128 (char *__dest, size_t __size, const char * __format, + _Float128 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf32x (char *__dest, size_t __size, const char * __format, + _Float32x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64x (char *__dest, size_t __size, const char * __format, + _Float64x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 340 "/usr/include/stdlib.h" 3 4 +extern long int strtol_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +extern unsigned long int strtoul_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + + + + + +extern long int strtol_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtol_l") + + + + __attribute__ ((__nonnull__ (1, 4))); +extern unsigned long int strtoul_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoul_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoll_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoull_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +# 415 "/usr/include/stdlib.h" 3 4 +extern double strtod_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern float strtof_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern long double strtold_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 436 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64 strtof64_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float128 strtof128_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float32x strtof32x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64x strtof64x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 505 "/usr/include/stdlib.h" 3 4 +extern char *l64a (long int __n) noexcept (true) ; + + +extern long int a64l (const char *__s) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + + +# 1 "/usr/include/sys/types.h" 1 3 4 +# 27 "/usr/include/sys/types.h" 3 4 +extern "C" { + + + + + +typedef __u_char u_char; +typedef __u_short u_short; +typedef __u_int u_int; +typedef __u_long u_long; +typedef __quad_t quad_t; +typedef __u_quad_t u_quad_t; +typedef __fsid_t fsid_t; + + +typedef __loff_t loff_t; + + + + +typedef __ino_t ino_t; + + + + + + +typedef __ino64_t ino64_t; + + + + +typedef __dev_t dev_t; + + + + +typedef __gid_t gid_t; + + + + +typedef __mode_t mode_t; + + + + +typedef __nlink_t nlink_t; + + + + +typedef __uid_t uid_t; + + + + + +typedef __off_t off_t; + + + + + + +typedef __off64_t off64_t; + + + + +typedef __pid_t pid_t; + + + + + +typedef __id_t id_t; + + + + +typedef __ssize_t ssize_t; + + + + + +typedef __daddr_t daddr_t; +typedef __caddr_t caddr_t; + + + + + +typedef __key_t key_t; + + + + +# 1 "/usr/include/bits/types/clock_t.h" 1 3 4 + + + + + + +typedef __clock_t clock_t; +# 127 "/usr/include/sys/types.h" 2 3 4 + +# 1 "/usr/include/bits/types/clockid_t.h" 1 3 4 + + + + + + +typedef __clockid_t clockid_t; +# 129 "/usr/include/sys/types.h" 2 3 4 +# 1 "/usr/include/bits/types/time_t.h" 1 3 4 +# 10 "/usr/include/bits/types/time_t.h" 3 4 +typedef __time_t time_t; +# 130 "/usr/include/sys/types.h" 2 3 4 +# 1 "/usr/include/bits/types/timer_t.h" 1 3 4 + + + + + + +typedef __timer_t timer_t; +# 131 "/usr/include/sys/types.h" 2 3 4 + + + +typedef __useconds_t useconds_t; + + + +typedef __suseconds_t suseconds_t; + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 145 "/usr/include/sys/types.h" 2 3 4 + + + +typedef unsigned long int ulong; +typedef unsigned short int ushort; +typedef unsigned int uint; + + + + +# 1 "/usr/include/bits/stdint-intn.h" 1 3 4 +# 24 "/usr/include/bits/stdint-intn.h" 3 4 +typedef __int8_t int8_t; +typedef __int16_t int16_t; +typedef __int32_t int32_t; +typedef __int64_t int64_t; +# 156 "/usr/include/sys/types.h" 2 3 4 + + +typedef __uint8_t u_int8_t; +typedef __uint16_t u_int16_t; +typedef __uint32_t u_int32_t; +typedef __uint64_t u_int64_t; + + +typedef int register_t __attribute__ ((__mode__ (__word__))); +# 176 "/usr/include/sys/types.h" 3 4 +# 1 "/usr/include/endian.h" 1 3 4 +# 35 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/bits/byteswap.h" 1 3 4 +# 33 "/usr/include/bits/byteswap.h" 3 4 +static __inline __uint16_t +__bswap_16 (__uint16_t __bsx) +{ + + return __builtin_bswap16 (__bsx); + + + +} + + + + + + +static __inline __uint32_t +__bswap_32 (__uint32_t __bsx) +{ + + return __builtin_bswap32 (__bsx); + + + +} +# 69 "/usr/include/bits/byteswap.h" 3 4 +__extension__ static __inline __uint64_t +__bswap_64 (__uint64_t __bsx) +{ + + return __builtin_bswap64 (__bsx); + + + +} +# 36 "/usr/include/endian.h" 2 3 4 +# 1 "/usr/include/bits/uintn-identity.h" 1 3 4 +# 32 "/usr/include/bits/uintn-identity.h" 3 4 +static __inline __uint16_t +__uint16_identity (__uint16_t __x) +{ + return __x; +} + +static __inline __uint32_t +__uint32_identity (__uint32_t __x) +{ + return __x; +} + +static __inline __uint64_t +__uint64_identity (__uint64_t __x) +{ + return __x; +} +# 37 "/usr/include/endian.h" 2 3 4 +# 177 "/usr/include/sys/types.h" 2 3 4 + + +# 1 "/usr/include/sys/select.h" 1 3 4 +# 30 "/usr/include/sys/select.h" 3 4 +# 1 "/usr/include/bits/select.h" 1 3 4 +# 31 "/usr/include/sys/select.h" 2 3 4 + + +# 1 "/usr/include/bits/types/sigset_t.h" 1 3 4 + + + +# 1 "/usr/include/bits/types/__sigset_t.h" 1 3 4 + + + + +typedef struct +{ + unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; +} __sigset_t; +# 5 "/usr/include/bits/types/sigset_t.h" 2 3 4 + + +typedef __sigset_t sigset_t; +# 34 "/usr/include/sys/select.h" 2 3 4 + + + +# 1 "/usr/include/bits/types/struct_timeval.h" 1 3 4 + + + + + + + +struct timeval +{ + + + + + __time_t tv_sec; + __suseconds_t tv_usec; + +}; +# 38 "/usr/include/sys/select.h" 2 3 4 + +# 1 "/usr/include/bits/types/struct_timespec.h" 1 3 4 +# 11 "/usr/include/bits/types/struct_timespec.h" 3 4 +struct timespec +{ + + + + __time_t tv_sec; + + + + + __syscall_slong_t tv_nsec; +# 31 "/usr/include/bits/types/struct_timespec.h" 3 4 +}; +# 40 "/usr/include/sys/select.h" 2 3 4 +# 49 "/usr/include/sys/select.h" 3 4 +typedef long int __fd_mask; +# 59 "/usr/include/sys/select.h" 3 4 +typedef struct + { + + + + __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; + + + + + + } fd_set; + + + + + + +typedef __fd_mask fd_mask; +# 91 "/usr/include/sys/select.h" 3 4 +extern "C" { +# 102 "/usr/include/sys/select.h" 3 4 +extern int select (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + struct timeval *__restrict __timeout); +# 127 "/usr/include/sys/select.h" 3 4 +extern int pselect (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + const struct timespec *__restrict __timeout, + const __sigset_t *__restrict __sigmask); +# 153 "/usr/include/sys/select.h" 3 4 +} +# 180 "/usr/include/sys/types.h" 2 3 4 + + + + + +typedef __blksize_t blksize_t; + + + + + + +typedef __blkcnt_t blkcnt_t; + + + +typedef __fsblkcnt_t fsblkcnt_t; + + + +typedef __fsfilcnt_t fsfilcnt_t; +# 219 "/usr/include/sys/types.h" 3 4 +typedef __blkcnt64_t blkcnt64_t; +typedef __fsblkcnt64_t fsblkcnt64_t; +typedef __fsfilcnt64_t fsfilcnt64_t; + + + + + +# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4 +# 23 "/usr/include/bits/pthreadtypes.h" 3 4 +# 1 "/usr/include/bits/thread-shared-types.h" 1 3 4 +# 44 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/pthreadtypes-arch.h" 1 3 4 +# 21 "/usr/include/bits/pthreadtypes-arch.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 22 "/usr/include/bits/pthreadtypes-arch.h" 2 3 4 +# 45 "/usr/include/bits/thread-shared-types.h" 2 3 4 + +# 1 "/usr/include/bits/atomic_wide_counter.h" 1 3 4 +# 25 "/usr/include/bits/atomic_wide_counter.h" 3 4 +typedef union +{ + __extension__ unsigned long long int __value64; + struct + { + unsigned int __low; + unsigned int __high; + } __value32; +} __atomic_wide_counter; +# 47 "/usr/include/bits/thread-shared-types.h" 2 3 4 + + + + +typedef struct __pthread_internal_list +{ + struct __pthread_internal_list *__prev; + struct __pthread_internal_list *__next; +} __pthread_list_t; + +typedef struct __pthread_internal_slist +{ + struct __pthread_internal_slist *__next; +} __pthread_slist_t; +# 76 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/struct_mutex.h" 1 3 4 +# 22 "/usr/include/bits/struct_mutex.h" 3 4 +struct __pthread_mutex_s +{ + int __lock; + unsigned int __count; + int __owner; + + unsigned int __nusers; + + + + int __kind; + + short __spins; + short __elision; + __pthread_list_t __list; +# 53 "/usr/include/bits/struct_mutex.h" 3 4 +}; +# 77 "/usr/include/bits/thread-shared-types.h" 2 3 4 +# 89 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/struct_rwlock.h" 1 3 4 +# 23 "/usr/include/bits/struct_rwlock.h" 3 4 +struct __pthread_rwlock_arch_t +{ + unsigned int __readers; + unsigned int __writers; + unsigned int __wrphase_futex; + unsigned int __writers_futex; + unsigned int __pad3; + unsigned int __pad4; + + int __cur_writer; + int __shared; + signed char __rwelision; + + + + + unsigned char __pad1[7]; + + + unsigned long int __pad2; + + + unsigned int __flags; +# 55 "/usr/include/bits/struct_rwlock.h" 3 4 +}; +# 90 "/usr/include/bits/thread-shared-types.h" 2 3 4 + + + + +struct __pthread_cond_s +{ + __atomic_wide_counter __wseq; + __atomic_wide_counter __g1_start; + unsigned int __g_size[2] ; + unsigned int __g1_orig_size; + unsigned int __wrefs; + unsigned int __g_signals[2]; + unsigned int __unused_initialized_1; + unsigned int __unused_initialized_2; +}; + +typedef unsigned int __tss_t; +typedef unsigned long int __thrd_t; + +typedef struct +{ + int __data ; +} __once_flag; +# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4 + + + +typedef unsigned long int pthread_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_mutexattr_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_condattr_t; + + + +typedef unsigned int pthread_key_t; + + + +typedef int pthread_once_t; + + +union pthread_attr_t +{ + char __size[56]; + long int __align; +}; + +typedef union pthread_attr_t pthread_attr_t; + + + + +typedef union +{ + struct __pthread_mutex_s __data; + char __size[40]; + long int __align; +} pthread_mutex_t; + + +typedef union +{ + struct __pthread_cond_s __data; + char __size[48]; + __extension__ long long int __align; +} pthread_cond_t; + + + + + +typedef union +{ + struct __pthread_rwlock_arch_t __data; + char __size[56]; + long int __align; +} pthread_rwlock_t; + +typedef union +{ + char __size[8]; + long int __align; +} pthread_rwlockattr_t; + + + + + +typedef volatile int pthread_spinlock_t; + + + + +typedef union +{ + char __size[32]; + long int __align; +} pthread_barrier_t; + +typedef union +{ + char __size[4]; + int __align; +} pthread_barrierattr_t; +# 228 "/usr/include/sys/types.h" 2 3 4 + + +} +# 515 "/usr/include/stdlib.h" 2 3 4 + + + + + + +extern long int random (void) noexcept (true); + + +extern void srandom (unsigned int __seed) noexcept (true); + + + + + +extern char *initstate (unsigned int __seed, char *__statebuf, + size_t __statelen) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern char *setstate (char *__statebuf) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + + +struct random_data + { + int32_t *fptr; + int32_t *rptr; + int32_t *state; + int rand_type; + int rand_deg; + int rand_sep; + int32_t *end_ptr; + }; + +extern int random_r (struct random_data *__restrict __buf, + int32_t *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern int srandom_r (unsigned int __seed, struct random_data *__buf) + noexcept (true) __attribute__ ((__nonnull__ (2))); + +extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, + size_t __statelen, + struct random_data *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (2, 4))); + +extern int setstate_r (char *__restrict __statebuf, + struct random_data *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern int rand (void) noexcept (true); + +extern void srand (unsigned int __seed) noexcept (true); + + + +extern int rand_r (unsigned int *__seed) noexcept (true); + + + + + + + +extern double drand48 (void) noexcept (true); +extern double erand48 (unsigned short int __xsubi[3]) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int lrand48 (void) noexcept (true); +extern long int nrand48 (unsigned short int __xsubi[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int mrand48 (void) noexcept (true); +extern long int jrand48 (unsigned short int __xsubi[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void srand48 (long int __seedval) noexcept (true); +extern unsigned short int *seed48 (unsigned short int __seed16v[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); +extern void lcong48 (unsigned short int __param[7]) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +struct drand48_data + { + unsigned short int __x[3]; + unsigned short int __old_x[3]; + unsigned short int __c; + unsigned short int __init; + __extension__ unsigned long long int __a; + + }; + + +extern int drand48_r (struct drand48_data *__restrict __buffer, + double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int erand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int lrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int nrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int mrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int jrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int srand48_r (long int __seedval, struct drand48_data *__buffer) + noexcept (true) __attribute__ ((__nonnull__ (2))); + +extern int seed48_r (unsigned short int __seed16v[3], + struct drand48_data *__buffer) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern int lcong48_r (unsigned short int __param[7], + struct drand48_data *__buffer) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern __uint32_t arc4random (void) + noexcept (true) ; + + +extern void arc4random_buf (void *__buf, size_t __size) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern __uint32_t arc4random_uniform (__uint32_t __upper_bound) + noexcept (true) ; + + + + +extern void *malloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) + __attribute__ ((__alloc_size__ (1))) ; + +extern void *calloc (size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) ; + + + + + + +extern void *realloc (void *__ptr, size_t __size) + noexcept (true) __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2))); + + +extern void free (void *__ptr) noexcept (true); + + + + + + + +extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__warn_unused_result__)) + __attribute__ ((__alloc_size__ (2, 3))) + __attribute__ ((__malloc__ (__builtin_free, 1))); + + +extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__malloc__ (reallocarray, 1))); + + + +# 1 "/usr/include/alloca.h" 1 3 4 +# 24 "/usr/include/alloca.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 25 "/usr/include/alloca.h" 2 3 4 + +extern "C" { + + + + + +extern void *alloca (size_t __size) noexcept (true); + + + + + +} +# 707 "/usr/include/stdlib.h" 2 3 4 + + + + + +extern void *valloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) + __attribute__ ((__alloc_size__ (1))) ; + + + + +extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) + noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + +extern void *aligned_alloc (size_t __alignment, size_t __size) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_align__ (1))) + __attribute__ ((__alloc_size__ (2))) ; + + + +extern void abort (void) noexcept (true) __attribute__ ((__noreturn__)) __attribute__ ((__cold__)); + + + +extern int atexit (void (*__func) (void)) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern "C++" int at_quick_exit (void (*__func) (void)) + noexcept (true) __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1))); +# 749 "/usr/include/stdlib.h" 3 4 +extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern void exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + + +extern void quick_exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + + +extern void _Exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + +extern char *getenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + +extern char *secure_getenv (const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + + + +extern int putenv (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern int setenv (const char *__name, const char *__value, int __replace) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + +extern int unsetenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern int clearenv (void) noexcept (true); +# 814 "/usr/include/stdlib.h" 3 4 +extern char *mktemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))); +# 827 "/usr/include/stdlib.h" 3 4 +extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 837 "/usr/include/stdlib.h" 3 4 +extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 849 "/usr/include/stdlib.h" 3 4 +extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; +# 859 "/usr/include/stdlib.h" 3 4 +extern int mkstemps64 (char *__template, int __suffixlen) + __attribute__ ((__nonnull__ (1))) ; +# 870 "/usr/include/stdlib.h" 3 4 +extern char *mkdtemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))) ; +# 881 "/usr/include/stdlib.h" 3 4 +extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 891 "/usr/include/stdlib.h" 3 4 +extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 901 "/usr/include/stdlib.h" 3 4 +extern int mkostemps (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 913 "/usr/include/stdlib.h" 3 4 +extern int mkostemps64 (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 923 "/usr/include/stdlib.h" 3 4 +extern int system (const char *__command) ; + + + + + +extern char *canonicalize_file_name (const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__malloc__)) + __attribute__ ((__malloc__ (__builtin_free, 1))) ; +# 940 "/usr/include/stdlib.h" 3 4 +extern char *realpath (const char *__restrict __name, + char *__restrict __resolved) noexcept (true) ; + + + + + + +typedef int (*__compar_fn_t) (const void *, const void *); + + +typedef __compar_fn_t comparison_fn_t; + + + +typedef int (*__compar_d_fn_t) (const void *, const void *, void *); + + + + +extern void *bsearch (const void *__key, const void *__base, + size_t __nmemb, size_t __size, __compar_fn_t __compar) + __attribute__ ((__nonnull__ (1, 2, 5))) ; + + + + + + + +extern void qsort (void *__base, size_t __nmemb, size_t __size, + __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4))); + +extern void qsort_r (void *__base, size_t __nmemb, size_t __size, + __compar_d_fn_t __compar, void *__arg) + __attribute__ ((__nonnull__ (1, 4))); + + + + +extern int abs (int __x) noexcept (true) __attribute__ ((__const__)) ; +extern long int labs (long int __x) noexcept (true) __attribute__ ((__const__)) ; + + +__extension__ extern long long int llabs (long long int __x) + noexcept (true) __attribute__ ((__const__)) ; + + + + + + +extern div_t div (int __numer, int __denom) + noexcept (true) __attribute__ ((__const__)) ; +extern ldiv_t ldiv (long int __numer, long int __denom) + noexcept (true) __attribute__ ((__const__)) ; + + +__extension__ extern lldiv_t lldiv (long long int __numer, + long long int __denom) + noexcept (true) __attribute__ ((__const__)) ; +# 1012 "/usr/include/stdlib.h" 3 4 +extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *gcvt (double __value, int __ndigit, char *__buf) + noexcept (true) __attribute__ ((__nonnull__ (3))) ; + + + + +extern char *qecvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qfcvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qgcvt (long double __value, int __ndigit, char *__buf) + noexcept (true) __attribute__ ((__nonnull__ (3))) ; + + + + +extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); +extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); + +extern int qecvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); +extern int qfcvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); + + + + + +extern int mblen (const char *__s, size_t __n) noexcept (true); + + +extern int mbtowc (wchar_t *__restrict __pwc, + const char *__restrict __s, size_t __n) noexcept (true); + + +extern int wctomb (char *__s, wchar_t __wchar) noexcept (true); + + + +extern size_t mbstowcs (wchar_t *__restrict __pwcs, + const char *__restrict __s, size_t __n) noexcept (true) + __attribute__ ((__access__ (__read_only__, 2))); + +extern size_t wcstombs (char *__restrict __s, + const wchar_t *__restrict __pwcs, size_t __n) + noexcept (true) + __attribute__ ((__access__ (__write_only__, 1, 3))) + __attribute__ ((__access__ (__read_only__, 2))); + + + + + + +extern int rpmatch (const char *__response) noexcept (true) __attribute__ ((__nonnull__ (1))) ; +# 1099 "/usr/include/stdlib.h" 3 4 +extern int getsubopt (char **__restrict __optionp, + char *const *__restrict __tokens, + char **__restrict __valuep) + noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))) ; + + + + + + + +extern int posix_openpt (int __oflag) ; + + + + + + + +extern int grantpt (int __fd) noexcept (true); + + + +extern int unlockpt (int __fd) noexcept (true); + + + + +extern char *ptsname (int __fd) noexcept (true) ; + + + + + + +extern int ptsname_r (int __fd, char *__buf, size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3))); + + +extern int getpt (void); + + + + + + +extern int getloadavg (double __loadavg[], int __nelem) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 1155 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/stdlib-float.h" 1 3 4 +# 1156 "/usr/include/stdlib.h" 2 3 4 +# 1167 "/usr/include/stdlib.h" 3 4 +} +# 80 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 2 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 +# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::abs; + + + inline long + abs(long __i) { return __builtin_labs(__i); } + + + + inline long long + abs(long long __x) { return __builtin_llabs (__x); } +# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 + inline constexpr double + abs(double __x) + { return __builtin_fabs(__x); } + + inline constexpr float + abs(float __x) + { return __builtin_fabsf(__x); } + + inline constexpr long double + abs(long double __x) + { return __builtin_fabsl(__x); } + + + + __extension__ inline constexpr __int128 + abs(__int128 __x) { return __x >= 0 ? __x : -__x; } +# 135 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 + __extension__ inline constexpr + __float128 + abs(__float128 __x) + { + + + + return __builtin_fabsf128(__x); + + + + + } + + + +} +} +# 82 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 2 3 +# 125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::div_t; + using ::ldiv_t; + + using ::abort; + + using ::aligned_alloc; + + using ::atexit; + + + using ::at_quick_exit; + + + using ::atof; + using ::atoi; + using ::atol; + using ::bsearch; + using ::calloc; + using ::div; + using ::exit; + using ::free; + using ::getenv; + using ::labs; + using ::ldiv; + using ::malloc; + + using ::mblen; + using ::mbstowcs; + using ::mbtowc; + + using ::qsort; + + + using ::quick_exit; + + + using ::rand; + using ::realloc; + using ::srand; + using ::strtod; + using ::strtol; + using ::strtoul; + using ::system; + + using ::wcstombs; + using ::wctomb; + + + + inline ldiv_t + div(long __i, long __j) noexcept { return ldiv(__i, __j); } + + + + +} +# 199 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + using ::lldiv_t; + + + + + + using ::_Exit; + + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wlong-long" + using ::llabs; + + inline lldiv_t + div(long long __n, long long __d) + { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; } + + using ::lldiv; +#pragma GCC diagnostic pop +# 234 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 + using ::atoll; + using ::strtoll; + using ::strtoull; + + using ::strtof; + using ::strtold; + + +} + +namespace std +{ + + using ::__gnu_cxx::lldiv_t; + + using ::__gnu_cxx::_Exit; + + using ::__gnu_cxx::llabs; + using ::__gnu_cxx::div; + using ::__gnu_cxx::lldiv; + + using ::__gnu_cxx::atoll; + using ::__gnu_cxx::strtof; + using ::__gnu_cxx::strtoll; + using ::__gnu_cxx::strtoull; + using ::__gnu_cxx::strtold; +} +# 278 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +} +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h" 2 3 + +using std::abort; +using std::atexit; +using std::exit; + + + using std::at_quick_exit; + + + using std::quick_exit; + + + using std::_Exit; + + + + +using std::div_t; +using std::ldiv_t; + +using std::abs; +using std::atof; +using std::atoi; +using std::atol; +using std::bsearch; +using std::calloc; +using std::div; +using std::free; +using std::getenv; +using std::labs; +using std::ldiv; +using std::malloc; + +using std::mblen; +using std::mbstowcs; +using std::mbtowc; + +using std::qsort; +using std::rand; +using std::realloc; +using std::srand; +using std::strtod; +using std::strtol; +using std::strtoul; +using std::system; + +using std::wcstombs; +using std::wctomb; +# 55 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" 2 +# 173 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 174 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" 2 +# 184 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" + +# 184 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern "C" +{ + + + + + +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaDeviceSynchronizeDeprecationAvoidance(void); +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2DeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2DeviceGetLimit(size_t *pValue, enum cudaLimit limit); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2DeviceGetCacheConfig(enum cudaFuncCache *pCacheConfig); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2DeviceGetSharedMemConfig(enum cudaSharedMemConfig *pConfig); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2GetLastError(void); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2PeekAtLastError(void); +extern __attribute__((device)) __attribute__((cudart_builtin)) const char* __cudaCDP2GetErrorString(cudaError_t error); +extern __attribute__((device)) __attribute__((cudart_builtin)) const char* __cudaCDP2GetErrorName(cudaError_t error); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2GetDeviceCount(int *count); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2GetDevice(int *device); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2StreamCreateWithFlags(cudaStream_t *pStream, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2StreamDestroy(cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2StreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2StreamWaitEvent_ptsz(cudaStream_t stream, cudaEvent_t event, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventCreateWithFlags(cudaEvent_t *event, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventRecord(cudaEvent_t event, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventRecord_ptsz(cudaEvent_t event, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventRecordWithFlags_ptsz(cudaEvent_t event, cudaStream_t stream, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventDestroy(cudaEvent_t event); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2FuncGetAttributes(struct cudaFuncAttributes *attr, const void *func); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Free(void *devPtr); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Malloc(void **devPtr, size_t size); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2MemcpyAsync(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2MemcpyAsync_ptsz(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memcpy2DAsync(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memcpy2DAsync_ptsz(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memcpy3DAsync(const struct cudaMemcpy3DParms *p, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memcpy3DAsync_ptsz(const struct cudaMemcpy3DParms *p, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2MemsetAsync(void *devPtr, int value, size_t count, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2MemsetAsync_ptsz(void *devPtr, int value, size_t count, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memset2DAsync(void *devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memset2DAsync_ptsz(void *devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memset3DAsync(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memset3DAsync_ptsz(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2RuntimeGetVersion(int *runtimeVersion); +extern __attribute__((device)) __attribute__((cudart_builtin)) void * __cudaCDP2GetParameterBuffer(size_t alignment, size_t size); +extern __attribute__((device)) __attribute__((cudart_builtin)) void * __cudaCDP2GetParameterBufferV2(void *func, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2LaunchDevice_ptsz(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2LaunchDeviceV2_ptsz(void *parameterBuffer, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2LaunchDevice(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2LaunchDeviceV2(void *parameterBuffer, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func, int blockSize, size_t dynamicSmemSize); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *func, int blockSize, size_t dynamicSmemSize, unsigned int flags); + + +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream); +# 311 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static inline __attribute__((device)) __attribute__((cudart_builtin)) cudaGraphExec_t cudaGetCurrentGraphExec(void) +{ + unsigned long long current_graph_exec; + asm ("mov.u64 %0, %%current_graph_exec;" : "=l"(current_graph_exec)); + return (cudaGraphExec_t)current_graph_exec; +} +# 346 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetParam(cudaGraphDeviceNode_t node, size_t offset, const void *value , size_t size); +# 374 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetEnabled(cudaGraphDeviceNode_t node, bool enable); +# 401 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetGridDim(cudaGraphDeviceNode_t node, dim3 gridDim); +# 430 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeUpdatesApply(const cudaGraphKernelNodeUpdate *updates, size_t updateCount); +# 448 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static inline __attribute__((device)) __attribute__((cudart_builtin)) void cudaTriggerProgrammaticLaunchCompletion(void) +{ + asm volatile("griddepcontrol.launch_dependents;":::); +} +# 464 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static inline __attribute__((device)) __attribute__((cudart_builtin)) void cudaGridDependencySynchronize(void) +{ + asm volatile("griddepcontrol.wait;":::"memory"); +} +# 479 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) void cudaGraphSetConditional(cudaGraphConditionalHandle handle, unsigned int value); + + +extern __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long cudaCGGetIntrinsicHandle(enum cudaCGScope scope); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaCGSynchronize(unsigned long long handle, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaCGSynchronizeGrid(unsigned long long handle, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaCGGetSize(unsigned int *numThreads, unsigned int *numGrids, unsigned long long handle); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaCGGetRank(unsigned int *threadRank, unsigned int *gridRank, unsigned long long handle); +# 714 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) void * cudaGetParameterBuffer(size_t alignment, size_t size) +{ + return __cudaCDP2GetParameterBuffer(alignment, size); +} + + + + + + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) void * cudaGetParameterBufferV2(void *func, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize) +{ + return __cudaCDP2GetParameterBufferV2(func, gridDimension, blockDimension, sharedMemSize); +} + + + + + + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDevice_ptsz(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream) +{ + return __cudaCDP2LaunchDevice_ptsz(func, parameterBuffer, gridDimension, blockDimension, sharedMemSize, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDeviceV2_ptsz(void *parameterBuffer, cudaStream_t stream) +{ + return __cudaCDP2LaunchDeviceV2_ptsz(parameterBuffer, stream); +} +# 800 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" + static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDevice(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream) + { + return __cudaCDP2LaunchDevice(func, parameterBuffer, gridDimension, blockDimension, sharedMemSize, stream); + } + + static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDeviceV2(void *parameterBuffer, cudaStream_t stream) + { + return __cudaCDP2LaunchDeviceV2(parameterBuffer, stream); + } +# 862 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +} + + + + + +template static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMalloc(T **devPtr, size_t size); +template static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetAttributes(struct cudaFuncAttributes *attr, T *entry); +template static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, T func, int blockSize, size_t dynamicSmemSize); +template static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, T func, int blockSize, size_t dynamicSmemSize, unsigned int flags); +# 901 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +template +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetParam(cudaGraphDeviceNode_t node, size_t offset, const T &value) +{ + return cudaGraphKernelNodeSetParam(node, offset, &value, sizeof(T)); +} +# 154 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 2 +# 287 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern "C" { +# 334 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceReset(void); +# 356 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceSynchronize(void); +# 442 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetLimit(enum cudaLimit limit, size_t value); +# 478 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetLimit(size_t *pValue, enum cudaLimit limit); +# 501 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t *maxWidthInElements, const struct cudaChannelFormatDesc *fmtDesc, int device); +# 535 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetCacheConfig(enum cudaFuncCache *pCacheConfig); +# 572 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority); +# 616 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetCacheConfig(enum cudaFuncCache cacheConfig); +# 643 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetByPCIBusId(int *device, const char *pciBusId); +# 673 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetPCIBusId(char *pciBusId, int len, int device); +# 724 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t *handle, cudaEvent_t event); +# 768 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcOpenEventHandle(cudaEvent_t *event, cudaIpcEventHandle_t handle); +# 813 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t *handle, void *devPtr); +# 880 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcOpenMemHandle(void **devPtr, cudaIpcMemHandle_t handle, unsigned int flags); +# 919 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcCloseMemHandle(void *devPtr); +# 951 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(enum cudaFlushGPUDirectRDMAWritesTarget target, enum cudaFlushGPUDirectRDMAWritesScope scope); +# 989 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback); +# 1012 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback); +# 1059 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetSharedMemConfig(enum cudaSharedMemConfig *pConfig); +# 1105 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaDeviceSetSharedMemConfig(enum cudaSharedMemConfig config); +# 1146 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadExit(void); +# 1172 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSynchronize(void); +# 1221 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSetLimit(enum cudaLimit limit, size_t value); +# 1254 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadGetLimit(size_t *pValue, enum cudaLimit limit); +# 1290 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadGetCacheConfig(enum cudaFuncCache *pCacheConfig); +# 1337 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSetCacheConfig(enum cudaFuncCache cacheConfig); +# 1402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetLastError(void); +# 1453 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaPeekAtLastError(void); +# 1469 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) const char* cudaGetErrorName(cudaError_t error); +# 1485 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) const char* cudaGetErrorString(cudaError_t error); +# 1514 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceCount(int *count); +# 1818 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceProperties_v2(struct cudaDeviceProp *prop, int device); +# 2024 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device); +# 2042 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t *memPool, int device); +# 2066 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool); +# 2086 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetMemPool(cudaMemPool_t *memPool, int device); +# 2148 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetNvSciSyncAttributes(void *nvSciSyncAttrList, int device, int flags); +# 2188 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetP2PAttribute(int *value, enum cudaDeviceP2PAttr attr, int srcDevice, int dstDevice); +# 2210 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaChooseDevice(int *device, const struct cudaDeviceProp *prop); +# 2239 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags); +# 2285 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetDevice(int device); +# 2307 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDevice(int *device); +# 2338 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetValidDevices(int *device_arr, int len); +# 2408 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetDeviceFlags( unsigned int flags ); +# 2453 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetDeviceFlags( unsigned int *flags ); +# 2497 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamCreate(cudaStream_t *pStream); +# 2533 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithFlags(cudaStream_t *pStream, unsigned int flags); +# 2585 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithPriority(cudaStream_t *pStream, unsigned int flags, int priority); +# 2613 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int *priority); +# 2639 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int *flags); +# 2676 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetId(cudaStream_t hStream, unsigned long long *streamId); +# 2702 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetDevice(cudaStream_t hStream, int *device); +# 2717 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaCtxResetPersistingL2Cache(void); +# 2737 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src); +# 2758 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetAttribute( + cudaStream_t hStream, cudaLaunchAttributeID attr, + cudaLaunchAttributeValue *value_out); +# 2782 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamSetAttribute( + cudaStream_t hStream, cudaLaunchAttributeID attr, + const cudaLaunchAttributeValue *value); +# 2816 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamDestroy(cudaStream_t stream); +# 2847 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags = 0); + + + + + + + +typedef void ( *cudaStreamCallback_t)(cudaStream_t stream, cudaError_t status, void *userData); +# 2922 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamAddCallback(cudaStream_t stream, + cudaStreamCallback_t callback, void *userData, unsigned int flags); +# 2946 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamSynchronize(cudaStream_t stream); +# 2971 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamQuery(cudaStream_t stream); +# 3055 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamAttachMemAsync(cudaStream_t stream, void *devPtr, size_t length = 0, unsigned int flags = 0x04); +# 3094 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamBeginCapture(cudaStream_t stream, enum cudaStreamCaptureMode mode); +# 3135 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t *dependencies, const cudaGraphEdgeData *dependencyData, size_t numDependencies, enum cudaStreamCaptureMode mode); +# 3186 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaThreadExchangeStreamCaptureMode(enum cudaStreamCaptureMode *mode); +# 3215 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t *pGraph); +# 3253 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamIsCapturing(cudaStream_t stream, enum cudaStreamCaptureStatus *pCaptureStatus); +# 3303 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamGetCaptureInfo_v2(cudaStream_t stream, enum cudaStreamCaptureStatus *captureStatus_out, unsigned long long *id_out = 0, cudaGraph_t *graph_out = 0, const cudaGraphNode_t **dependencies_out = 0, size_t *numDependencies_out = 0); +# 3362 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamGetCaptureInfo_v3(cudaStream_t stream, + enum cudaStreamCaptureStatus *captureStatus_out, unsigned long long *id_out = 0, + cudaGraph_t *graph_out = 0, const cudaGraphNode_t **dependencies_out = 0, + const cudaGraphEdgeData **edgeData_out = 0, size_t *numDependencies_out = 0); +# 3402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t *dependencies, size_t numDependencies, unsigned int flags = 0); +# 3437 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamUpdateCaptureDependencies_v2(cudaStream_t stream, cudaGraphNode_t *dependencies, const cudaGraphEdgeData *dependencyData, size_t numDependencies, unsigned int flags = 0); +# 3474 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventCreate(cudaEvent_t *event); +# 3511 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventCreateWithFlags(cudaEvent_t *event, unsigned int flags); +# 3552 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream = 0); +# 3600 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream = 0, unsigned int flags = 0); +# 3633 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventQuery(cudaEvent_t event); +# 3664 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventSynchronize(cudaEvent_t event); +# 3694 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventDestroy(cudaEvent_t event); +# 3739 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventElapsedTime(float *ms, cudaEvent_t start, cudaEvent_t end); +# 3787 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventElapsedTime_v2(float *ms, cudaEvent_t start, cudaEvent_t end); +# 3968 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaImportExternalMemory(cudaExternalMemory_t *extMem_out, const struct cudaExternalMemoryHandleDesc *memHandleDesc); +# 4023 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaExternalMemoryGetMappedBuffer(void **devPtr, cudaExternalMemory_t extMem, const struct cudaExternalMemoryBufferDesc *bufferDesc); +# 4083 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t *mipmap, cudaExternalMemory_t extMem, const struct cudaExternalMemoryMipmappedArrayDesc *mipmapDesc); +# 4107 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem); +# 4261 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t *extSem_out, const struct cudaExternalSemaphoreHandleDesc *semHandleDesc); +# 4344 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSignalExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t *extSemArray, const struct cudaExternalSemaphoreSignalParams *paramsArray, unsigned int numExtSems, cudaStream_t stream = 0); +# 4420 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaWaitExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t *extSemArray, const struct cudaExternalSemaphoreWaitParams *paramsArray, unsigned int numExtSems, cudaStream_t stream = 0); +# 4443 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem); +# 4511 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchKernel(const void *func, dim3 gridDim, dim3 blockDim, void **args, size_t sharedMem, cudaStream_t stream); +# 4574 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchKernelExC(const cudaLaunchConfig_t *config, const void *func, void **args); +# 4632 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchCooperativeKernel(const void *func, dim3 gridDim, dim3 blockDim, void **args, size_t sharedMem, cudaStream_t stream); +# 4733 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaLaunchCooperativeKernelMultiDevice(struct cudaLaunchParams *launchParamsList, unsigned int numDevices, unsigned int flags = 0); +# 4783 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFuncSetCacheConfig(const void *func, enum cudaFuncCache cacheConfig); +# 4818 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetAttributes(struct cudaFuncAttributes *attr, const void *func); +# 4877 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncSetAttribute(const void *func, enum cudaFuncAttribute attr, int value); +# 4903 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetName(const char **name, const void *func); +# 4926 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetParamInfo(const void *func, size_t paramIndex, size_t *paramOffset, size_t *paramSize); +# 4950 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaSetDoubleForDevice(double *d); +# 4974 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaSetDoubleForHost(double *d); +# 5040 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void *userData); +# 5114 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaFuncSetSharedMemConfig(const void *func, enum cudaSharedMemConfig config); +# 5171 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func, int blockSize, size_t dynamicSMemSize); +# 5201 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t *dynamicSmemSize, const void *func, int numBlocks, int blockSize); +# 5247 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *func, int blockSize, size_t dynamicSMemSize, unsigned int flags); +# 5283 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxPotentialClusterSize(int *clusterSize, const void *func, const cudaLaunchConfig_t *launchConfig); +# 5323 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveClusters(int *numClusters, const void *func, const cudaLaunchConfig_t *launchConfig); +# 5443 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMallocManaged(void **devPtr, size_t size, unsigned int flags = 0x01); +# 5476 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMalloc(void **devPtr, size_t size); +# 5513 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocHost(void **ptr, size_t size); +# 5556 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocPitch(void **devPtr, size_t *pitch, size_t width, size_t height); +# 5608 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocArray(cudaArray_t *array, const struct cudaChannelFormatDesc *desc, size_t width, size_t height = 0, unsigned int flags = 0); +# 5647 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFree(void *devPtr); +# 5670 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeHost(void *ptr); +# 5693 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeArray(cudaArray_t array); +# 5716 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray); +# 5782 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostAlloc(void **pHost, size_t size, unsigned int flags); +# 5879 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostRegister(void *ptr, size_t size, unsigned int flags); +# 5902 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostUnregister(void *ptr); +# 5947 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostGetDevicePointer(void **pDevice, void *pHost, unsigned int flags); +# 5969 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostGetFlags(unsigned int *pFlags, void *pHost); +# 6008 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMalloc3D(struct cudaPitchedPtr* pitchedDevPtr, struct cudaExtent extent); +# 6153 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMalloc3DArray(cudaArray_t *array, const struct cudaChannelFormatDesc* desc, struct cudaExtent extent, unsigned int flags = 0); +# 6298 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocMipmappedArray(cudaMipmappedArray_t *mipmappedArray, const struct cudaChannelFormatDesc* desc, struct cudaExtent extent, unsigned int numLevels, unsigned int flags = 0); +# 6331 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t *levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level); +# 6436 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3D(const struct cudaMemcpy3DParms *p); +# 6468 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3DPeer(const struct cudaMemcpy3DPeerParms *p); +# 6586 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy3DAsync(const struct cudaMemcpy3DParms *p, cudaStream_t stream = 0); +# 6613 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3DPeerAsync(const struct cudaMemcpy3DPeerParms *p, cudaStream_t stream = 0); +# 6647 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemGetInfo(size_t *free, size_t *total); +# 6673 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetInfo(struct cudaChannelFormatDesc *desc, struct cudaExtent *extent, unsigned int *flags, cudaArray_t array); +# 6702 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetPlane(cudaArray_t *pPlaneArray, cudaArray_t hArray, unsigned int planeIdx); +# 6725 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetMemoryRequirements(struct cudaArrayMemoryRequirements *memoryRequirements, cudaArray_t array, int device); +# 6749 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMipmappedArrayGetMemoryRequirements(struct cudaArrayMemoryRequirements *memoryRequirements, cudaMipmappedArray_t mipmap, int device); +# 6777 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaArrayGetSparseProperties(struct cudaArraySparseProperties *sparseProperties, cudaArray_t array); +# 6807 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaMipmappedArrayGetSparseProperties(struct cudaArraySparseProperties *sparseProperties, cudaMipmappedArray_t mipmap); +# 6852 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind); +# 6887 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyPeer(void *dst, int dstDevice, const void *src, int srcDevice, size_t count); +# 6936 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2D(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind); +# 6986 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind); +# 7036 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DFromArray(void *dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind); +# 7083 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, enum cudaMemcpyKind kind = cudaMemcpyDeviceToDevice); +# 7126 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyToSymbol(const void *symbol, const void *src, size_t count, size_t offset = 0, enum cudaMemcpyKind kind = cudaMemcpyHostToDevice); +# 7170 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyFromSymbol(void *dst, const void *symbol, size_t count, size_t offset = 0, enum cudaMemcpyKind kind = cudaMemcpyDeviceToHost); +# 7227 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpyAsync(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7262 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyPeerAsync(void *dst, int dstDevice, const void *src, int srcDevice, size_t count, cudaStream_t stream = 0); +# 7334 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyBatchAsync(void **dsts, void **srcs, size_t *sizes, size_t count, struct cudaMemcpyAttributes *attrs, size_t *attrsIdxs, size_t numAttrs, size_t *failIdx, cudaStream_t stream); +# 7402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3DBatchAsync(size_t numOps, struct cudaMemcpy3DBatchOp *opList, size_t *failIdx, unsigned long long flags, cudaStream_t stream); +# 7465 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy2DAsync(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7523 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7580 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DFromArrayAsync(void *dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7631 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyToSymbolAsync(const void *symbol, const void *src, size_t count, size_t offset, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7682 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyFromSymbolAsync(void *dst, const void *symbol, size_t count, size_t offset, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7711 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset(void *devPtr, int value, size_t count); +# 7745 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset2D(void *devPtr, size_t pitch, int value, size_t width, size_t height); +# 7791 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset3D(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent); +# 7827 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemsetAsync(void *devPtr, int value, size_t count, cudaStream_t stream = 0); +# 7868 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemset2DAsync(void *devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream = 0); +# 7921 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemset3DAsync(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream = 0); +# 7949 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSymbolAddress(void **devPtr, const void *symbol); +# 7976 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSymbolSize(size_t *size, const void *symbol); +# 8048 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPrefetchAsync(const void *devPtr, size_t count, int dstDevice, cudaStream_t stream = 0); +# 8129 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPrefetchAsync_v2(const void *devPtr, size_t count, struct cudaMemLocation location, unsigned int flags, cudaStream_t stream = 0); +# 8243 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemAdvise(const void *devPtr, size_t count, enum cudaMemoryAdvise advice, int device); +# 8366 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemAdvise_v2(const void *devPtr, size_t count, enum cudaMemoryAdvise advice, struct cudaMemLocation location); +# 8448 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemRangeGetAttribute(void *data, size_t dataSize, enum cudaMemRangeAttribute attribute, const void *devPtr, size_t count); +# 8491 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemRangeGetAttributes(void **data, size_t *dataSizes, enum cudaMemRangeAttribute *attributes, size_t numAttributes, const void *devPtr, size_t count); +# 8551 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t count, enum cudaMemcpyKind kind); +# 8593 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyFromArray(void *dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, enum cudaMemcpyKind kind); +# 8636 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, enum cudaMemcpyKind kind = cudaMemcpyDeviceToDevice); +# 8687 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 8737 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyFromArrayAsync(void *dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 8806 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocAsync(void **devPtr, size_t size, cudaStream_t hStream); +# 8832 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeAsync(void *devPtr, cudaStream_t hStream); +# 8857 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep); +# 8901 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, enum cudaMemPoolAttr attr, void *value ); +# 8949 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, enum cudaMemPoolAttr attr, void *value ); +# 8964 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const struct cudaMemAccessDesc *descList, size_t count); +# 8977 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolGetAccess(enum cudaMemAccessFlags *flags, cudaMemPool_t memPool, struct cudaMemLocation *location); +# 9021 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolCreate(cudaMemPool_t *memPool, const struct cudaMemPoolProps *poolProps); +# 9043 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool); +# 9079 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocFromPoolAsync(void **ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream); +# 9104 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolExportToShareableHandle( + void *shareableHandle, + cudaMemPool_t memPool, + enum cudaMemAllocationHandleType handleType, + unsigned int flags); +# 9131 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolImportFromShareableHandle( + cudaMemPool_t *memPool, + void *shareableHandle, + enum cudaMemAllocationHandleType handleType, + unsigned int flags); +# 9154 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolExportPointer(struct cudaMemPoolPtrExportData *exportData, void *ptr); +# 9183 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolImportPointer(void **ptr, cudaMemPool_t memPool, struct cudaMemPoolPtrExportData *exportData); +# 9336 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaPointerGetAttributes(struct cudaPointerAttributes *attributes, const void *ptr); +# 9377 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceCanAccessPeer(int *canAccessPeer, int device, int peerDevice); +# 9419 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags); +# 9441 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceDisablePeerAccess(int peerDevice); +# 9505 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource); +# 9540 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags); +# 9579 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t *resources, cudaStream_t stream = 0); +# 9614 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t *resources, cudaStream_t stream = 0); +# 9646 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceGetMappedPointer(void **devPtr, size_t *size, cudaGraphicsResource_t resource); +# 9684 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t *array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel); +# 9713 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t *mipmappedArray, cudaGraphicsResource_t resource); +# 9748 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetChannelDesc(struct cudaChannelFormatDesc *desc, cudaArray_const_t array); +# 9778 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) struct cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, enum cudaChannelFormatKind f); +# 10003 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaCreateTextureObject(cudaTextureObject_t *pTexObject, const struct cudaResourceDesc *pResDesc, const struct cudaTextureDesc *pTexDesc, const struct cudaResourceViewDesc *pResViewDesc); +# 10023 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject); +# 10043 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectResourceDesc(struct cudaResourceDesc *pResDesc, cudaTextureObject_t texObject); +# 10063 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectTextureDesc(struct cudaTextureDesc *pTexDesc, cudaTextureObject_t texObject); +# 10084 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectResourceViewDesc(struct cudaResourceViewDesc *pResViewDesc, cudaTextureObject_t texObject); +# 10129 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t *pSurfObject, const struct cudaResourceDesc *pResDesc); +# 10149 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject); +# 10168 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSurfaceObjectResourceDesc(struct cudaResourceDesc *pResDesc, cudaSurfaceObject_t surfObject); +# 10202 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDriverGetVersion(int *driverVersion); +# 10231 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaRuntimeGetVersion(int *runtimeVersion); +# 10278 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphCreate(cudaGraph_t *pGraph, unsigned int flags); +# 10377 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddKernelNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaKernelNodeParams *pNodeParams); +# 10410 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, struct cudaKernelNodeParams *pNodeParams); +# 10437 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const struct cudaKernelNodeParams *pNodeParams); +# 10457 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeCopyAttributes( + cudaGraphNode_t hSrc, + cudaGraphNode_t hDst); +# 10480 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeGetAttribute( + cudaGraphNode_t hNode, + cudaLaunchAttributeID attr, + cudaLaunchAttributeValue *value_out); +# 10504 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeSetAttribute( + cudaGraphNode_t hNode, + cudaLaunchAttributeID attr, + const cudaLaunchAttributeValue *value); +# 10555 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaMemcpy3DParms *pCopyParams); +# 10614 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNodeToSymbol( + cudaGraphNode_t *pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t *pDependencies, + size_t numDependencies, + const void* symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 10683 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNodeFromSymbol( + cudaGraphNode_t* pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t* pDependencies, + size_t numDependencies, + void* dst, + const void* symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 10751 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNode1D( + cudaGraphNode_t *pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t *pDependencies, + size_t numDependencies, + void* dst, + const void* src, + size_t count, + enum cudaMemcpyKind kind); +# 10783 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, struct cudaMemcpy3DParms *pNodeParams); +# 10810 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const struct cudaMemcpy3DParms *pNodeParams); +# 10849 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParamsToSymbol( + cudaGraphNode_t node, + const void* symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 10895 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParamsFromSymbol( + cudaGraphNode_t node, + void* dst, + const void* symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 10941 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParams1D( + cudaGraphNode_t node, + void* dst, + const void* src, + size_t count, + enum cudaMemcpyKind kind); +# 10989 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddMemsetNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaMemsetParams *pMemsetParams); +# 11012 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, struct cudaMemsetParams *pNodeParams); +# 11036 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const struct cudaMemsetParams *pNodeParams); +# 11078 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddHostNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaHostNodeParams *pNodeParams); +# 11101 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, struct cudaHostNodeParams *pNodeParams); +# 11125 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const struct cudaHostNodeParams *pNodeParams); +# 11166 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddChildGraphNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, cudaGraph_t childGraph); +# 11193 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t *pGraph); +# 11231 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies); +# 11275 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddEventRecordNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, cudaEvent_t event); +# 11302 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t *event_out); +# 11330 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event); +# 11377 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddEventWaitNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, cudaEvent_t event); +# 11404 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t *event_out); +# 11432 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event); +# 11482 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaExternalSemaphoreSignalNodeParams *nodeParams); +# 11515 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, struct cudaExternalSemaphoreSignalNodeParams *params_out); +# 11543 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const struct cudaExternalSemaphoreSignalNodeParams *nodeParams); +# 11593 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaExternalSemaphoreWaitNodeParams *nodeParams); +# 11626 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, struct cudaExternalSemaphoreWaitNodeParams *params_out); +# 11654 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const struct cudaExternalSemaphoreWaitNodeParams *nodeParams); +# 11732 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddMemAllocNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, struct cudaMemAllocNodeParams *nodeParams); +# 11759 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, struct cudaMemAllocNodeParams *params_out); +# 11820 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddMemFreeNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, void *dptr); +# 11844 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void *dptr_out); +# 11872 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGraphMemTrim(int device); +# 11909 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetGraphMemAttribute(int device, enum cudaGraphMemAttributeType attr, void* value); +# 11943 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetGraphMemAttribute(int device, enum cudaGraphMemAttributeType attr, void* value); +# 11971 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphClone(cudaGraph_t *pGraphClone, cudaGraph_t originalGraph); +# 11999 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t *pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph); +# 12030 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, enum cudaGraphNodeType *pType); +# 12061 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t *nodes, size_t *numNodes); +# 12092 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t *pRootNodes, size_t *pNumRootNodes); +# 12126 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t *from, cudaGraphNode_t *to, size_t *numEdges); +# 12166 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetEdges_v2(cudaGraph_t graph, cudaGraphNode_t *from, cudaGraphNode_t *to, cudaGraphEdgeData *edgeData, size_t *numEdges); +# 12197 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t *pDependencies, size_t *pNumDependencies); +# 12234 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependencies_v2(cudaGraphNode_t node, cudaGraphNode_t *pDependencies, cudaGraphEdgeData *edgeData, size_t *pNumDependencies); +# 12266 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t *pDependentNodes, size_t *pNumDependentNodes); +# 12304 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependentNodes_v2(cudaGraphNode_t node, cudaGraphNode_t *pDependentNodes, cudaGraphEdgeData *edgeData, size_t *pNumDependentNodes); +# 12335 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, size_t numDependencies); +# 12367 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, const cudaGraphEdgeData *edgeData, size_t numDependencies); +# 12398 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, size_t numDependencies); +# 12433 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphRemoveDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, const cudaGraphEdgeData *edgeData, size_t numDependencies); +# 12463 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node); +# 12534 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiate(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, unsigned long long flags = 0); +# 12607 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, unsigned long long flags = 0); +# 12714 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiateWithParams(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams *instantiateParams); +# 12739 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long *flags); +# 12799 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaKernelNodeParams *pNodeParams); +# 12850 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaMemcpy3DParms *pNodeParams); +# 12905 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParamsToSymbol( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + const void* symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 12968 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParamsFromSymbol( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + void* dst, + const void* symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 13029 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParams1D( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + void* dst, + const void* src, + size_t count, + enum cudaMemcpyKind kind); +# 13088 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaMemsetParams *pNodeParams); +# 13128 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaHostNodeParams *pNodeParams); +# 13175 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph); +# 13220 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event); +# 13265 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event); +# 13313 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const struct cudaExternalSemaphoreSignalNodeParams *nodeParams); +# 13361 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const struct cudaExternalSemaphoreWaitNodeParams *nodeParams); +# 13401 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled); +# 13435 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int *isEnabled); +# 13529 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo *resultInfo); +# 13554 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream); +# 13585 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream); +# 13608 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec); +# 13629 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDestroy(cudaGraph_t graph); +# 13648 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char *path, unsigned int flags); +# 13684 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaUserObjectCreate(cudaUserObject_t *object_out, void *ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags); +# 13708 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned int count = 1); +# 13736 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned int count = 1); +# 13764 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count = 1, unsigned int flags = 0); +# 13789 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count = 1); +# 13831 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, struct cudaGraphNodeParams *nodeParams); +# 13875 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddNode_v2(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, const cudaGraphEdgeData *dependencyData, size_t numDependencies, struct cudaGraphNodeParams *nodeParams); +# 13904 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeSetParams(cudaGraphNode_t node, struct cudaGraphNodeParams *nodeParams); +# 13953 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, struct cudaGraphNodeParams *nodeParams); +# 13980 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle *pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue = 0, unsigned int flags = 0); +# 14061 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetDriverEntryPoint(const char *symbol, void **funcPtr, unsigned long long flags, enum cudaDriverEntryPointQueryResult *driverStatus = +# 14061 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 3 4 + __null +# 14061 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + ); +# 14137 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetDriverEntryPointByVersion(const char *symbol, void **funcPtr, unsigned int cudaVersion, unsigned long long flags, enum cudaDriverEntryPointQueryResult *driverStatus = +# 14137 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 3 4 + __null +# 14137 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + ); +# 14212 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryLoadData(cudaLibrary_t *library, const void *code, + enum cudaJitOption *jitOptions, void **jitOptionsValues, unsigned int numJitOptions, + enum cudaLibraryOption *libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions); +# 14272 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryLoadFromFile(cudaLibrary_t *library, const char *fileName, + enum cudaJitOption *jitOptions, void **jitOptionsValues, unsigned int numJitOptions, + enum cudaLibraryOption *libraryOptions, void **libraryOptionValues, unsigned int numLibraryOptions); +# 14293 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryUnload(cudaLibrary_t library); +# 14318 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryGetKernel(cudaKernel_t *pKernel, cudaLibrary_t library, const char *name); +# 14352 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryGetGlobal(void **dptr, size_t *bytes, cudaLibrary_t library, const char *name); +# 14385 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryGetManaged(void **dptr, size_t *bytes, cudaLibrary_t library, const char *name); +# 14412 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryGetUnifiedFunction(void **fptr, cudaLibrary_t library, const char *symbol); +# 14434 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryGetKernelCount(unsigned int *count, cudaLibrary_t lib); +# 14456 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryEnumerateKernels(cudaKernel_t *kernels, unsigned int numKernels, cudaLibrary_t lib); +# 14525 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaKernelSetAttributeForDevice(cudaKernel_t kernel, enum cudaFuncAttribute attr, int value, int device); + + + + +extern __attribute__((host)) cudaError_t cudaGetExportTable(const void **ppExportTable, const cudaUUID_t *pExportTableId); +# 14716 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetFuncBySymbol(cudaFunction_t* functionPtr, const void* symbolPtr); +# 14740 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetKernel(cudaKernel_t *kernelPtr, const void *entryFuncAddr); +# 14918 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +} +# 62 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" 2 +# 120 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" +template __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(0, 0, 0, 0, cudaChannelFormatKindNone); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescHalf(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescHalf1(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescHalf2(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindFloat); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescHalf4(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindFloat); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(char) * 8; + + + + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); + +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(signed char) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned char) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(signed char) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned char) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(signed char) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned char) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(signed char) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned char) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(short) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(short) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(int) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned int) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(int) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned int) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(int) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned int) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(int) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned int) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +} +# 392 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(float) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(float) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(float) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindFloat); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(float) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindFloat); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescNV12(void) +{ + int e = (int)sizeof(char) * 8; + + return cudaCreateChannelDesc(e, e, e, 0, cudaChannelFormatKindNV12); +} + +template __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(0, 0, 0, 0, cudaChannelFormatKindNone); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindSignedNormalized8X1); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindSignedNormalized8X2); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindSignedNormalized8X4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindUnsignedNormalized8X1); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindUnsignedNormalized8X2); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedNormalized8X4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 0, 0, 0, cudaChannelFormatKindSignedNormalized16X1); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 0, 0, cudaChannelFormatKindSignedNormalized16X2); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 16, 16, cudaChannelFormatKindSignedNormalized16X4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 0, 0, 0, cudaChannelFormatKindUnsignedNormalized16X1); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 0, 0, cudaChannelFormatKindUnsignedNormalized16X2); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 16, 16, cudaChannelFormatKindUnsignedNormalized16X4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 0, cudaChannelFormatKindNV12); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(10, 10, 10, 2, cudaChannelFormatKindUnsignedNormalized1010102); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed1); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed1SRGB); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed2); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed2SRGB); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed3); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed3SRGB); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindUnsignedBlockCompressed4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindSignedBlockCompressed4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindUnsignedBlockCompressed5); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindSignedBlockCompressed5); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 16, 0, cudaChannelFormatKindUnsignedBlockCompressed6H); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 16, 0, cudaChannelFormatKindSignedBlockCompressed6H); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed7); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed7SRGB); +} +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" 1 +# 53 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 54 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 55 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" 2 +# 79 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static __inline__ __attribute__((host)) struct cudaPitchedPtr make_cudaPitchedPtr(void *d, size_t p, size_t xsz, size_t ysz) +{ + struct cudaPitchedPtr s; + + s.ptr = d; + s.pitch = p; + s.xsize = xsz; + s.ysize = ysz; + + return s; +} +# 106 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static __inline__ __attribute__((host)) struct cudaPos make_cudaPos(size_t x, size_t y, size_t z) +{ + struct cudaPos p; + + p.x = x; + p.y = y; + p.z = z; + + return p; +} +# 132 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static __inline__ __attribute__((host)) struct cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) +{ + struct cudaExtent e; + + e.width = w; + e.height = h; + e.depth = d; + + return e; +} +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 100 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + + + + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.h" 1 +# 77 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.h" +static __inline__ __attribute__((host)) __attribute__((device)) char1 make_char1(signed char x); + +static __inline__ __attribute__((host)) __attribute__((device)) uchar1 make_uchar1(unsigned char x); + +static __inline__ __attribute__((host)) __attribute__((device)) char2 make_char2(signed char x, signed char y); + +static __inline__ __attribute__((host)) __attribute__((device)) uchar2 make_uchar2(unsigned char x, unsigned char y); + +static __inline__ __attribute__((host)) __attribute__((device)) char3 make_char3(signed char x, signed char y, signed char z); + +static __inline__ __attribute__((host)) __attribute__((device)) uchar3 make_uchar3(unsigned char x, unsigned char y, unsigned char z); + +static __inline__ __attribute__((host)) __attribute__((device)) char4 make_char4(signed char x, signed char y, signed char z, signed char w); + +static __inline__ __attribute__((host)) __attribute__((device)) uchar4 make_uchar4(unsigned char x, unsigned char y, unsigned char z, unsigned char w); + +static __inline__ __attribute__((host)) __attribute__((device)) short1 make_short1(short x); + +static __inline__ __attribute__((host)) __attribute__((device)) ushort1 make_ushort1(unsigned short x); + +static __inline__ __attribute__((host)) __attribute__((device)) short2 make_short2(short x, short y); + +static __inline__ __attribute__((host)) __attribute__((device)) ushort2 make_ushort2(unsigned short x, unsigned short y); + +static __inline__ __attribute__((host)) __attribute__((device)) short3 make_short3(short x,short y, short z); + +static __inline__ __attribute__((host)) __attribute__((device)) ushort3 make_ushort3(unsigned short x, unsigned short y, unsigned short z); + +static __inline__ __attribute__((host)) __attribute__((device)) short4 make_short4(short x, short y, short z, short w); + +static __inline__ __attribute__((host)) __attribute__((device)) ushort4 make_ushort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w); + +static __inline__ __attribute__((host)) __attribute__((device)) int1 make_int1(int x); + +static __inline__ __attribute__((host)) __attribute__((device)) uint1 make_uint1(unsigned int x); + +static __inline__ __attribute__((host)) __attribute__((device)) int2 make_int2(int x, int y); + +static __inline__ __attribute__((host)) __attribute__((device)) uint2 make_uint2(unsigned int x, unsigned int y); + +static __inline__ __attribute__((host)) __attribute__((device)) int3 make_int3(int x, int y, int z); + +static __inline__ __attribute__((host)) __attribute__((device)) uint3 make_uint3(unsigned int x, unsigned int y, unsigned int z); + +static __inline__ __attribute__((host)) __attribute__((device)) int4 make_int4(int x, int y, int z, int w); + +static __inline__ __attribute__((host)) __attribute__((device)) uint4 make_uint4(unsigned int x, unsigned int y, unsigned int z, unsigned int w); + +static __inline__ __attribute__((host)) __attribute__((device)) long1 make_long1(long int x); + +static __inline__ __attribute__((host)) __attribute__((device)) ulong1 make_ulong1(unsigned long int x); + +static __inline__ __attribute__((host)) __attribute__((device)) long2 make_long2(long int x, long int y); + +static __inline__ __attribute__((host)) __attribute__((device)) ulong2 make_ulong2(unsigned long int x, unsigned long int y); + +static __inline__ __attribute__((host)) __attribute__((device)) long3 make_long3(long int x, long int y, long int z); + +static __inline__ __attribute__((host)) __attribute__((device)) ulong3 make_ulong3(unsigned long int x, unsigned long int y, unsigned long int z); + +static __inline__ __attribute__((host)) __attribute__((device)) long4 make_long4(long int x, long int y, long int z, long int w); + +static __inline__ __attribute__((host)) __attribute__((device)) ulong4 make_ulong4(unsigned long int x, unsigned long int y, unsigned long int z, unsigned long int w); + +static __inline__ __attribute__((host)) __attribute__((device)) float1 make_float1(float x); + +static __inline__ __attribute__((host)) __attribute__((device)) float2 make_float2(float x, float y); + +static __inline__ __attribute__((host)) __attribute__((device)) float3 make_float3(float x, float y, float z); + +static __inline__ __attribute__((host)) __attribute__((device)) float4 make_float4(float x, float y, float z, float w); + +static __inline__ __attribute__((host)) __attribute__((device)) longlong1 make_longlong1(long long int x); + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong1 make_ulonglong1(unsigned long long int x); + +static __inline__ __attribute__((host)) __attribute__((device)) longlong2 make_longlong2(long long int x, long long int y); + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong2 make_ulonglong2(unsigned long long int x, unsigned long long int y); + +static __inline__ __attribute__((host)) __attribute__((device)) longlong3 make_longlong3(long long int x, long long int y, long long int z); + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong3 make_ulonglong3(unsigned long long int x, unsigned long long int y, unsigned long long int z); + +static __inline__ __attribute__((host)) __attribute__((device)) longlong4 make_longlong4(long long int x, long long int y, long long int z, long long int w); + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong4 make_ulonglong4(unsigned long long int x, unsigned long long int y, unsigned long long int z, unsigned long long int w); + +static __inline__ __attribute__((host)) __attribute__((device)) double1 make_double1(double x); + +static __inline__ __attribute__((host)) __attribute__((device)) double2 make_double2(double x, double y); + +static __inline__ __attribute__((host)) __attribute__((device)) double3 make_double3(double x, double y, double z); + +static __inline__ __attribute__((host)) __attribute__((device)) double4 make_double4(double x, double y, double z, double w); + + + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.hpp" 1 +# 73 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.hpp" +static __inline__ __attribute__((host)) __attribute__((device)) char1 make_char1(signed char x) +{ + char1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uchar1 make_uchar1(unsigned char x) +{ + uchar1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) char2 make_char2(signed char x, signed char y) +{ + char2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uchar2 make_uchar2(unsigned char x, unsigned char y) +{ + uchar2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) char3 make_char3(signed char x, signed char y, signed char z) +{ + char3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uchar3 make_uchar3(unsigned char x, unsigned char y, unsigned char z) +{ + uchar3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) char4 make_char4(signed char x, signed char y, signed char z, signed char w) +{ + char4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uchar4 make_uchar4(unsigned char x, unsigned char y, unsigned char z, unsigned char w) +{ + uchar4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) short1 make_short1(short x) +{ + short1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ushort1 make_ushort1(unsigned short x) +{ + ushort1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) short2 make_short2(short x, short y) +{ + short2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ushort2 make_ushort2(unsigned short x, unsigned short y) +{ + ushort2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) short3 make_short3(short x,short y, short z) +{ + short3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ushort3 make_ushort3(unsigned short x, unsigned short y, unsigned short z) +{ + ushort3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) short4 make_short4(short x, short y, short z, short w) +{ + short4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ushort4 make_ushort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w) +{ + ushort4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) int1 make_int1(int x) +{ + int1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uint1 make_uint1(unsigned int x) +{ + uint1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) int2 make_int2(int x, int y) +{ + int2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uint2 make_uint2(unsigned int x, unsigned int y) +{ + uint2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) int3 make_int3(int x, int y, int z) +{ + int3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uint3 make_uint3(unsigned int x, unsigned int y, unsigned int z) +{ + uint3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) int4 make_int4(int x, int y, int z, int w) +{ + int4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uint4 make_uint4(unsigned int x, unsigned int y, unsigned int z, unsigned int w) +{ + uint4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) long1 make_long1(long int x) +{ + long1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulong1 make_ulong1(unsigned long int x) +{ + ulong1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) long2 make_long2(long int x, long int y) +{ + long2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulong2 make_ulong2(unsigned long int x, unsigned long int y) +{ + ulong2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) long3 make_long3(long int x, long int y, long int z) +{ + long3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulong3 make_ulong3(unsigned long int x, unsigned long int y, unsigned long int z) +{ + ulong3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) long4 make_long4(long int x, long int y, long int z, long int w) +{ + long4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulong4 make_ulong4(unsigned long int x, unsigned long int y, unsigned long int z, unsigned long int w) +{ + ulong4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) float1 make_float1(float x) +{ + float1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) float2 make_float2(float x, float y) +{ + float2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) float3 make_float3(float x, float y, float z) +{ + float3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) float4 make_float4(float x, float y, float z, float w) +{ + float4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) longlong1 make_longlong1(long long int x) +{ + longlong1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong1 make_ulonglong1(unsigned long long int x) +{ + ulonglong1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) longlong2 make_longlong2(long long int x, long long int y) +{ + longlong2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong2 make_ulonglong2(unsigned long long int x, unsigned long long int y) +{ + ulonglong2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) longlong3 make_longlong3(long long int x, long long int y, long long int z) +{ + longlong3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong3 make_ulonglong3(unsigned long long int x, unsigned long long int y, unsigned long long int z) +{ + ulonglong3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) longlong4 make_longlong4(long long int x, long long int y, long long int z, long long int w) +{ + longlong4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong4 make_ulonglong4(unsigned long long int x, unsigned long long int y, unsigned long long int z, unsigned long long int w) +{ + ulonglong4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) double1 make_double1(double x) +{ + double1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) double2 make_double2(double x, double y) +{ + double2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) double3 make_double3(double x, double y, double z) +{ + double3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) double4 make_double4(double x, double y, double z, double w) +{ + double4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} +# 177 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.h" 2 +# 106 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 117 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 1 +# 71 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 72 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 73 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 85 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +# 1 "/usr/include/string.h" 1 3 4 +# 26 "/usr/include/string.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/string.h" 2 3 4 + + +# 28 "/usr/include/string.h" 3 4 +extern "C" { + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 34 "/usr/include/string.h" 2 3 4 +# 43 "/usr/include/string.h" 3 4 +extern void *memcpy (void *__restrict __dest, const void *__restrict __src, + size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern void *memmove (void *__dest, const void *__src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern void *memccpy (void *__restrict __dest, const void *__restrict __src, + int __c, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__write_only__, 1, 4))); + + + + +extern void *memset (void *__s, int __c, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int memcmp (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 80 "/usr/include/string.h" 3 4 +extern int __memcmpeq (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + +extern "C++" +{ +extern void *memchr (void *__s, int __c, size_t __n) + noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const void *memchr (const void *__s, int __c, size_t __n) + noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 105 "/usr/include/string.h" 3 4 +} +# 115 "/usr/include/string.h" 3 4 +extern "C++" void *rawmemchr (void *__s, int __c) + noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const void *rawmemchr (const void *__s, int __c) + noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + + + +extern "C++" void *memrchr (void *__s, int __c, size_t __n) + noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__read_only__, 1, 3))); +extern "C++" const void *memrchr (const void *__s, int __c, size_t __n) + noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__read_only__, 1, 3))); +# 141 "/usr/include/string.h" 3 4 +extern char *strcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strcat (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncat (char *__restrict __dest, const char *__restrict __src, + size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern int strncmp (const char *__s1, const char *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcoll (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern size_t strxfrm (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 1, 3))); + + + + + + +extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + + +extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n, + locale_t __l) noexcept (true) __attribute__ ((__nonnull__ (2, 4))) + __attribute__ ((__access__ (__write_only__, 1, 3))); + + + + + +extern char *strdup (const char *__s) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); + + + + + + +extern char *strndup (const char *__string, size_t __n) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); +# 224 "/usr/include/string.h" 3 4 +extern "C++" +{ +extern char *strchr (char *__s, int __c) + noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *strchr (const char *__s, int __c) + noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 244 "/usr/include/string.h" 3 4 +} + + + + + + +extern "C++" +{ +extern char *strrchr (char *__s, int __c) + noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *strrchr (const char *__s, int __c) + noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 271 "/usr/include/string.h" 3 4 +} +# 281 "/usr/include/string.h" 3 4 +extern "C++" char *strchrnul (char *__s, int __c) + noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const char *strchrnul (const char *__s, int __c) + noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 293 "/usr/include/string.h" 3 4 +extern size_t strcspn (const char *__s, const char *__reject) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern size_t strspn (const char *__s, const char *__accept) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern "C++" +{ +extern char *strpbrk (char *__s, const char *__accept) + noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern const char *strpbrk (const char *__s, const char *__accept) + noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 321 "/usr/include/string.h" 3 4 +} + + + + + + +extern "C++" +{ +extern char *strstr (char *__haystack, const char *__needle) + noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern const char *strstr (const char *__haystack, const char *__needle) + noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 348 "/usr/include/string.h" 3 4 +} + + + + + + + +extern char *strtok (char *__restrict __s, const char *__restrict __delim) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern char *__strtok_r (char *__restrict __s, + const char *__restrict __delim, + char **__restrict __save_ptr) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + +extern char *strtok_r (char *__restrict __s, const char *__restrict __delim, + char **__restrict __save_ptr) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + + + + + +extern "C++" char *strcasestr (char *__haystack, const char *__needle) + noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern "C++" const char *strcasestr (const char *__haystack, + const char *__needle) + noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 389 "/usr/include/string.h" 3 4 +extern void *memmem (const void *__haystack, size_t __haystacklen, + const void *__needle, size_t __needlelen) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3))) + __attribute__ ((__access__ (__read_only__, 1, 2))) + __attribute__ ((__access__ (__read_only__, 3, 4))); + + + +extern void *__mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern void *mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern size_t strlen (const char *__s) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + +extern size_t strnlen (const char *__string, size_t __maxlen) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + +extern char *strerror (int __errnum) noexcept (true); +# 444 "/usr/include/string.h" 3 4 +extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3))); + + + + +extern const char *strerrordesc_np (int __err) noexcept (true); + +extern const char *strerrorname_np (int __err) noexcept (true); + + + + + +extern char *strerror_l (int __errnum, locale_t __l) noexcept (true); + + + +# 1 "/usr/include/strings.h" 1 3 4 +# 23 "/usr/include/strings.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 24 "/usr/include/strings.h" 2 3 4 + + + + + + +extern "C" { + + + +extern int bcmp (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern void bcopy (const void *__src, void *__dest, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern void bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern "C++" +{ +extern char *index (char *__s, int __c) + noexcept (true) __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *index (const char *__s, int __c) + noexcept (true) __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 66 "/usr/include/strings.h" 3 4 +} + + + + + + + +extern "C++" +{ +extern char *rindex (char *__s, int __c) + noexcept (true) __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *rindex (const char *__s, int __c) + noexcept (true) __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 94 "/usr/include/strings.h" 3 4 +} +# 104 "/usr/include/strings.h" 3 4 +extern int ffs (int __i) noexcept (true) __attribute__ ((__const__)); + + + + + +extern int ffsl (long int __l) noexcept (true) __attribute__ ((__const__)); +__extension__ extern int ffsll (long long int __ll) + noexcept (true) __attribute__ ((__const__)); + + + +extern int strcasecmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strncasecmp (const char *__s1, const char *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + + + + +extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + + + +extern int strncasecmp_l (const char *__s1, const char *__s2, + size_t __n, locale_t __loc) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4))); + + +} +# 463 "/usr/include/string.h" 2 3 4 + + + +extern void explicit_bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__write_only__, 1, 2))); + + + +extern char *strsep (char **__restrict __stringp, + const char *__restrict __delim) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern char *strsignal (int __sig) noexcept (true); + + + +extern const char *sigabbrev_np (int __sig) noexcept (true); + + +extern const char *sigdescr_np (int __sig) noexcept (true); + + + +extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern char *stpcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern char *__stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern char *stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern size_t strlcpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__write_only__, 1, 3))); + + + +extern size_t strlcat (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__read_write__, 1, 3))); + + + + +extern int strverscmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strfry (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void *memfrob (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__read_write__, 1, 2))); + + + + + + + +extern "C++" char *basename (char *__filename) + noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); +extern "C++" const char *basename (const char *__filename) + noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); +# 552 "/usr/include/string.h" 3 4 +} +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 1 "/usr/include/time.h" 1 3 4 +# 29 "/usr/include/time.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 30 "/usr/include/time.h" 2 3 4 + + + +# 1 "/usr/include/bits/time.h" 1 3 4 +# 73 "/usr/include/bits/time.h" 3 4 +# 1 "/usr/include/bits/timex.h" 1 3 4 +# 26 "/usr/include/bits/timex.h" 3 4 +struct timex +{ +# 58 "/usr/include/bits/timex.h" 3 4 + unsigned int modes; + __syscall_slong_t offset; + __syscall_slong_t freq; + __syscall_slong_t maxerror; + __syscall_slong_t esterror; + int status; + __syscall_slong_t constant; + __syscall_slong_t precision; + __syscall_slong_t tolerance; + struct timeval time; + __syscall_slong_t tick; + __syscall_slong_t ppsfreq; + __syscall_slong_t jitter; + int shift; + __syscall_slong_t stabil; + __syscall_slong_t jitcnt; + __syscall_slong_t calcnt; + __syscall_slong_t errcnt; + __syscall_slong_t stbcnt; + + int tai; + + + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; + +}; +# 74 "/usr/include/bits/time.h" 2 3 4 + +extern "C" { + + +extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) noexcept (true) __attribute__ ((__nonnull__ (2))); +# 90 "/usr/include/bits/time.h" 3 4 +} +# 34 "/usr/include/time.h" 2 3 4 + + + + + +# 1 "/usr/include/bits/types/struct_tm.h" 1 3 4 + + + + + + +struct tm +{ + int tm_sec; + int tm_min; + int tm_hour; + int tm_mday; + int tm_mon; + int tm_year; + int tm_wday; + int tm_yday; + int tm_isdst; + + + long int tm_gmtoff; + const char *tm_zone; + + + + +}; +# 40 "/usr/include/time.h" 2 3 4 +# 48 "/usr/include/time.h" 3 4 +# 1 "/usr/include/bits/types/struct_itimerspec.h" 1 3 4 + + + + + + + +struct itimerspec + { + struct timespec it_interval; + struct timespec it_value; + }; +# 49 "/usr/include/time.h" 2 3 4 +struct sigevent; +# 68 "/usr/include/time.h" 3 4 +extern "C" { + + + +extern clock_t clock (void) noexcept (true); + + + +extern time_t time (time_t *__timer) noexcept (true); + + +extern double difftime (time_t __time1, time_t __time0); + + +extern time_t mktime (struct tm *__tp) noexcept (true); +# 99 "/usr/include/time.h" 3 4 +extern size_t strftime (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp) + noexcept (true) __attribute__ ((__nonnull__ (1, 3, 4))); + + + + +extern char *strptime (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp) + noexcept (true); + + + + + + +extern size_t strftime_l (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp, + locale_t __loc) noexcept (true); + + + +extern char *strptime_l (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp, + locale_t __loc) noexcept (true); + + + + + + +extern struct tm *gmtime (const time_t *__timer) noexcept (true); + + + +extern struct tm *localtime (const time_t *__timer) noexcept (true); +# 154 "/usr/include/time.h" 3 4 +extern struct tm *gmtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) noexcept (true); + + + +extern struct tm *localtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) noexcept (true); +# 179 "/usr/include/time.h" 3 4 +extern char *asctime (const struct tm *__tp) noexcept (true); + + + +extern char *ctime (const time_t *__timer) noexcept (true); +# 197 "/usr/include/time.h" 3 4 +extern char *asctime_r (const struct tm *__restrict __tp, + char *__restrict __buf) noexcept (true); + + + +extern char *ctime_r (const time_t *__restrict __timer, + char *__restrict __buf) noexcept (true); +# 217 "/usr/include/time.h" 3 4 +extern char *__tzname[2]; +extern int __daylight; +extern long int __timezone; + + + + +extern char *tzname[2]; + + + +extern void tzset (void) noexcept (true); + + + +extern int daylight; +extern long int timezone; +# 246 "/usr/include/time.h" 3 4 +extern time_t timegm (struct tm *__tp) noexcept (true); +# 263 "/usr/include/time.h" 3 4 +extern time_t timelocal (struct tm *__tp) noexcept (true); + + + + + + + +extern int dysize (int __year) noexcept (true) __attribute__ ((__const__)); +# 281 "/usr/include/time.h" 3 4 +extern int nanosleep (const struct timespec *__requested_time, + struct timespec *__remaining); + + +extern int clock_getres (clockid_t __clock_id, struct timespec *__res) noexcept (true); + + +extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + +extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp) + noexcept (true) __attribute__ ((__nonnull__ (2))); +# 323 "/usr/include/time.h" 3 4 +extern int clock_nanosleep (clockid_t __clock_id, int __flags, + const struct timespec *__req, + struct timespec *__rem); +# 338 "/usr/include/time.h" 3 4 +extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) noexcept (true); + + + + +extern int timer_create (clockid_t __clock_id, + struct sigevent *__restrict __evp, + timer_t *__restrict __timerid) noexcept (true); + + +extern int timer_delete (timer_t __timerid) noexcept (true); + + + +extern int timer_settime (timer_t __timerid, int __flags, + const struct itimerspec *__restrict __value, + struct itimerspec *__restrict __ovalue) noexcept (true); + + +extern int timer_gettime (timer_t __timerid, struct itimerspec *__value) + noexcept (true); +# 376 "/usr/include/time.h" 3 4 +extern int timer_getoverrun (timer_t __timerid) noexcept (true); + + + + + + +extern int timespec_get (struct timespec *__ts, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 399 "/usr/include/time.h" 3 4 +extern int timespec_getres (struct timespec *__ts, int __base) + noexcept (true); +# 425 "/usr/include/time.h" 3 4 +extern int getdate_err; +# 434 "/usr/include/time.h" 3 4 +extern struct tm *getdate (const char *__string); +# 448 "/usr/include/time.h" 3 4 +extern int getdate_r (const char *__restrict __string, + struct tm *__restrict __resbufp); + + +} +# 87 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 + + +# 88 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern "C" +{ + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) clock_t clock(void) + + + + +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 +noexcept (true) +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void* memset(void*, int, size_t) +# 96 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 + noexcept (true) +# 96 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void* memcpy(void*, const void*, size_t) +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 + noexcept (true) +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; + +} +# 303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 1 +# 114 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 115 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 116 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 126 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern "C" +{ +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) int abs(int a) +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) long int labs(long int a) +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 255 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) long long int llabs(long long int a) +# 255 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 255 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fabs(double x) +# 283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 306 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fabsf(float x) +# 306 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 306 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 317 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int min(const int a, const int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned int umin(const unsigned int a, const unsigned int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llmin(const long long int a, const long long int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned long long int ullmin(const unsigned long long int a, const unsigned long long int b); +# 359 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fminf(float x, float y) +# 359 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 359 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 379 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmin(double x, double y) +# 379 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 379 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 392 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int max(const int a, const int b); + + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned int umax(const unsigned int a, const unsigned int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llmax(const long long int a, const long long int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned long long int ullmax(const unsigned long long int a, const unsigned long long int b); +# 435 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmaxf(float x, float y) +# 435 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 435 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 455 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmax(double, double) +# 455 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 455 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sin(double x) +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 495 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cos(double x) +# 495 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 495 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 511 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincos(double x, double *sptr, double *cptr) +# 511 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 511 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 524 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincosf(float x, float *sptr, float *cptr) +# 524 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 524 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 547 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tan(double x) +# 547 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 547 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 571 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sqrt(double x) +# 571 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 571 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 597 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rsqrt(double x); +# 621 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rsqrtf(float x); +# 648 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log2(double x) +# 648 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 648 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 677 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp2(double x) +# 677 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 677 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 706 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float exp2f(float x) +# 706 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 706 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 737 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp10(double x) +# 737 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 737 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 764 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float exp10f(float x) +# 764 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 764 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 798 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double expm1(double x) +# 798 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 798 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 831 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float expm1f(float x) +# 831 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 831 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 858 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log2f(float x) +# 858 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 858 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 883 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log10(double x) +# 883 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 883 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 909 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log(double x) +# 909 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 909 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 936 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log1p(double x) +# 936 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 936 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 966 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log1pf(float x) +# 966 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 966 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 992 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double floor(double x) +# 992 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 992 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1021 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp(double x) +# 1021 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1021 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1040 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cosh(double x) +# 1040 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1040 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sinh(double x) +# 1060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1080 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tanh(double x) +# 1080 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1080 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double acosh(double x) +# 1104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1131 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float acoshf(float x) +# 1131 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1131 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1155 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double asinh(double x) +# 1155 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1155 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1179 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float asinhf(float x) +# 1179 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1179 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atanh(double x) +# 1204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1229 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atanhf(float x) +# 1229 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1229 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1247 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double ldexp(double x, int exp) +# 1247 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1247 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1262 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ldexpf(float x, int exp) +# 1262 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1262 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double logb(double x) +# 1283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1307 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float logbf(float x) +# 1307 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1307 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1331 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int ilogb(double x) +# 1331 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1331 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1355 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int ilogbf(float x) +# 1355 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1355 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1383 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double scalbn(double x, int n) +# 1383 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1383 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float scalbnf(float x, int n) +# 1411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1439 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double scalbln(double x, long int n) +# 1439 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1439 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1467 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float scalblnf(float x, long int n) +# 1467 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1467 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1499 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double frexp(double x, int *nptr) +# 1499 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1499 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1528 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float frexpf(float x, int *nptr) +# 1528 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1528 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1551 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double round(double x) +# 1551 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1551 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1577 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float roundf(float x) +# 1577 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1577 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1595 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lround(double x) +# 1595 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1595 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1613 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lroundf(float x) +# 1613 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1613 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1631 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llround(double x) +# 1631 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1631 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1649 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llroundf(float x) +# 1649 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1649 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1719 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rintf(float x) +# 1719 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1719 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1736 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lrint(double x) +# 1736 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1736 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1753 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lrintf(float x) +# 1753 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1753 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1770 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llrint(double x) +# 1770 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1770 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1787 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llrintf(float x) +# 1787 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1787 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nearbyint(double x) +# 1811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1835 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nearbyintf(float x) +# 1835 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1835 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1859 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double ceil(double x) +# 1859 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1859 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1882 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double trunc(double x) +# 1882 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1882 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float truncf(float x) +# 1908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1930 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fdim(double x, double y) +# 1930 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1930 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1951 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fdimf(float x, float y) +# 1951 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1951 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atan2(double y, double x) +# 2034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atan(double x) +# 2060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double acos(double x) +# 2077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2099 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double asin(double x) +# 2099 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2099 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2130 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double hypot(double x, double y) +# 2130 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2130 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2156 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rhypot(double x, double y) +# 2156 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2156 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2187 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float hypotf(float x, float y) +# 2187 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2187 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2213 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rhypotf(float x, float y) +# 2213 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2213 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2231 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double norm3d(double a, double b, double c) +# 2231 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2231 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2249 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm3d(double a, double b, double c) +# 2249 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2249 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double norm4d(double a, double b, double c, double d) +# 2267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm4d(double a, double b, double c, double d) +# 2285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +__attribute__((device)) __attribute__((device_builtin)) double norm(int dim, double const * p) +# 2303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2321 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm(int dim, double const * p) +# 2321 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2321 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnormf(int dim, float const * p) +# 2340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2358 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +__attribute__((device)) __attribute__((device_builtin)) float normf(int dim, float const * p) +# 2358 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2358 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2377 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float norm3df(float a, float b, float c) +# 2377 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2377 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2395 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnorm3df(float a, float b, float c) +# 2395 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2395 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2413 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float norm4df(float a, float b, float c, float d) +# 2413 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2413 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2431 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnorm4df(float a, float b, float c, float d) +# 2431 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2431 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2459 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cbrt(double x) +# 2459 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2459 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2486 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cbrtf(float x) +# 2486 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2486 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2512 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rcbrt(double x); +# 2533 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rcbrtf(float x); +# 2556 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sinpi(double x) noexcept (true); +# 2579 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinpif(float x) noexcept (true); +# 2601 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cospi(double x) noexcept (true); +# 2623 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cospif(float x) noexcept (true); +# 2636 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincospi(double x, double *sptr, double *cptr); +# 2649 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincospif(float x, float *sptr, float *cptr); +# 2735 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double pow(double x, double y) +# 2735 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2735 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2759 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double modf(double x, double *iptr) +# 2759 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2759 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2786 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmod(double x, double y) +# 2786 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2786 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2816 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double remainder(double x, double y) +# 2816 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2816 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2849 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float remainderf(float x, float y) +# 2849 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2849 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2887 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double remquo(double x, double y, int *quo) +# 2887 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2887 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2925 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float remquof(float x, float y, int *quo) +# 2925 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2925 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2946 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double j0(double x) +# 2946 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2946 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2968 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float j0f(float x) +# 2968 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2968 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2995 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double j1(double x) +# 2995 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2995 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3022 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float j1f(float x) +# 3022 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3022 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3045 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double jn(int n, double x) +# 3045 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3045 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3068 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float jnf(int n, float x) +# 3068 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3068 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3095 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double y0(double x) +# 3095 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3095 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3122 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float y0f(float x) +# 3122 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3122 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3149 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double y1(double x) +# 3149 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3149 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3176 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float y1f(float x) +# 3176 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3176 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double yn(int n, double x) +# 3204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3232 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ynf(int n, float x) +# 3232 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3232 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3250 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double cyl_bessel_i0(double x) +# 3250 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3250 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float cyl_bessel_i0f(float x) +# 3267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double cyl_bessel_i1(double x) +# 3285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3302 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float cyl_bessel_i1f(float x) +# 3302 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3302 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erf(double x) +# 3328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erff(float x) +# 3353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3383 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfinv(double x); +# 3406 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfinvf(float x); +# 3430 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfc(double x) +# 3430 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3430 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3453 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcf(float x) +# 3453 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3453 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3485 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double lgamma(double x) +# 3485 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3485 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3513 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfcinv(double x); +# 3534 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcinvf(float x); +# 3556 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double normcdfinv(double x); +# 3578 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normcdfinvf(float x); +# 3597 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double normcdf(double x); +# 3616 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normcdff(float x); +# 3636 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfcx(double x); +# 3656 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcxf(float x); +# 3689 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float lgammaf(float x) +# 3689 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3689 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3718 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tgamma(double x) +# 3718 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3718 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3747 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tgammaf(float x) +# 3747 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3747 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3761 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double copysign(double x, double y) +# 3761 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3761 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3775 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float copysignf(float x, float y) +# 3775 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3775 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3794 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nextafter(double x, double y) +# 3794 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3794 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3813 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nextafterf(float x, float y) +# 3813 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3813 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3829 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nan(const char *tagp) +# 3829 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3829 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3845 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nanf(const char *tagp) +# 3845 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3845 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinff(float) +# 3852 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3852 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnanf(float) +# 3853 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3853 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3863 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finite(double) +# 3863 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3863 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finitef(float) +# 3864 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3864 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbit(double) +# 3865 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3865 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnan(double) +# 3866 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3866 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinf(double) +# 3867 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3867 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitf(float) +# 3870 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3870 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3921 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fma(double x, double y, double z) +# 3921 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3921 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmaf(float x, float y, float z) +# 3971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3982 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitl(long double) +# 3982 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3982 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finitel(long double) +# 3988 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3988 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinfl(long double) +# 3989 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3989 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnanl(long double) +# 3990 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3990 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float acosf(float x) +# 4034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4056 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float asinf(float x) +# 4056 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4056 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4083 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atanf(float x) +# 4083 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4083 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4163 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atan2f(float y, float x) +# 4163 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4163 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4182 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cosf(float x) +# 4182 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4182 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4202 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinf(float x) +# 4202 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4202 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4222 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tanf(float x) +# 4222 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4222 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4241 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float coshf(float x) +# 4241 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4241 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4261 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinhf(float x) +# 4261 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4261 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4281 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tanhf(float x) +# 4281 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4281 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4304 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float logf(float x) +# 4304 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4304 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4334 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float expf(float x) +# 4334 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4334 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4357 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log10f(float x) +# 4357 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4357 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4380 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float modff(float x, float *iptr) +# 4380 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4380 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4463 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float powf(float x, float y) +# 4463 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4463 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4487 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sqrtf(float x) +# 4487 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4487 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4510 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ceilf(float x) +# 4510 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4510 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4533 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float floorf(float x) +# 4533 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4533 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4559 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmodf(float x, float y) +# 4559 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4559 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4574 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +} + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/math.h" 1 3 +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/math.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/requires_hosted.h" 1 3 +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 1 3 +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 2 3 +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + struct __true_type { }; + struct __false_type { }; + + template + struct __truth_type + { typedef __false_type __type; }; + + template<> + struct __truth_type + { typedef __true_type __type; }; + + + + template + struct __traitor + { + enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; + typedef typename __truth_type<__value>::__type __type; + }; + + + template + struct __are_same + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __are_same<_Tp, _Tp> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_void + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_void + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_integer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 185 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 273 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +__extension__ template<> struct __is_integer<__int128> { enum { __value = 1 }; typedef __true_type __type; }; __extension__ template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; +# 290 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + template + struct __is_floating + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 367 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + template + struct __is_pointer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __is_pointer<_Tp*> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_arithmetic + : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > + { }; + + + + + template + struct __is_scalar + : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > + { }; + + + + + template + struct __is_char + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_byte + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + enum class byte : unsigned char; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 471 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + template struct iterator_traits; + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = __is_trivially_copyable(_Tp) }; + }; + + + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = 0 }; + }; + + + template + struct __memcpyable + { + enum { __value = 0 }; + }; + + template + struct __memcpyable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcpyable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + template + struct __memcmpable + { + enum { __value = 0 }; + }; + + + template + struct __memcmpable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + + template::__value + + > + struct __is_memcmp_ordered + { + static const bool __value = _Tp(-1) > _Tp(1); + }; + + template + struct __is_memcmp_ordered<_Tp, false> + { + static const bool __value = false; + }; + + + template + struct __is_memcmp_ordered_with + { + static const bool __value = __is_memcmp_ordered<_Tp>::__value + && __is_memcmp_ordered<_Up>::__value; + }; + + template + struct __is_memcmp_ordered_with<_Tp, _Up, false> + { + static const bool __value = false; + }; +# 580 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + template<> + struct __is_memcmp_ordered_with + { static constexpr bool __value = true; }; + + template + struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> + { static constexpr bool __value = false; }; + + template + struct __is_memcmp_ordered_with + { static constexpr bool __value = false; }; + + + + + + template + struct __is_move_iterator + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + template + + inline _Iterator + __miter_base(_Iterator __it) + { return __it; } + + +} +} +# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 + +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 + + + + +extern "C++" { + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct __enable_if + { }; + + template + struct __enable_if + { typedef _Tp __type; }; + + + + template + struct __conditional_type + { typedef _Iftrue __type; }; + + template + struct __conditional_type + { typedef _Iffalse __type; }; + + + + template + struct __add_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned short __type; }; + + template<> + struct __add_unsigned + { typedef unsigned int __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long long __type; }; + + + template<> + struct __add_unsigned; + + template<> + struct __add_unsigned; + + + + template + struct __remove_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef short __type; }; + + template<> + struct __remove_unsigned + { typedef int __type; }; + + template<> + struct __remove_unsigned + { typedef long __type; }; + + template<> + struct __remove_unsigned + { typedef long long __type; }; + + + template<> + struct __remove_unsigned; + + template<> + struct __remove_unsigned; + + + + template + constexpr + inline bool + __is_null_pointer(_Type* __ptr) + { return __ptr == 0; } + + template + constexpr + inline bool + __is_null_pointer(_Type) + { return false; } + + + constexpr bool + __is_null_pointer(std::nullptr_t) + { return true; } + + + + + template::__value> + struct __promote + { typedef double __type; }; + + + + + template + struct __promote<_Tp, false> + { }; + + template<> + struct __promote + { typedef long double __type; }; + + template<> + struct __promote + { typedef double __type; }; + + template<> + struct __promote + { typedef float __type; }; +# 225 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 + template + using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); + + + + template + using __promote_2 = __promote<__promoted_t<_Tp, _Up>>; + + template + using __promote_3 = __promote<__promoted_t<_Tp, _Up, _Vp>>; + + template + using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>; +# 269 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 + +} +} +# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 + +# 1 "/usr/include/math.h" 1 3 4 +# 27 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 28 "/usr/include/math.h" 2 3 4 + + + + + + +extern "C" { + + + + + +# 1 "/usr/include/bits/math-vector.h" 1 3 4 +# 25 "/usr/include/bits/math-vector.h" 3 4 +# 1 "/usr/include/bits/libm-simd-decl-stubs.h" 1 3 4 +# 26 "/usr/include/bits/math-vector.h" 2 3 4 +# 41 "/usr/include/math.h" 2 3 4 +# 156 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/flt-eval-method.h" 1 3 4 +# 157 "/usr/include/math.h" 2 3 4 +# 167 "/usr/include/math.h" 3 4 +typedef float float_t; +typedef double double_t; +# 208 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/fp-logb.h" 1 3 4 +# 209 "/usr/include/math.h" 2 3 4 +# 251 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/fp-fast.h" 1 3 4 +# 252 "/usr/include/math.h" 2 3 4 + + + +enum + { + FP_INT_UPWARD = + + 0, + FP_INT_DOWNWARD = + + 1, + FP_INT_TOWARDZERO = + + 2, + FP_INT_TONEARESTFROMZERO = + + 3, + FP_INT_TONEAREST = + + 4, + }; + + +# 1 "/usr/include/bits/mathcalls-macros.h" 1 3 4 +# 276 "/usr/include/math.h" 2 3 4 + + + + + +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassify (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbit (double __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinf (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finite (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnan (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsig (double __x, double __y) noexcept (true); + + +extern int __issignaling (double __value) noexcept (true) + __attribute__ ((__const__)); +# 282 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern double acos (double __x) noexcept (true); extern double __acos (double __x) noexcept (true); + + extern double asin (double __x) noexcept (true); extern double __asin (double __x) noexcept (true); + + extern double atan (double __x) noexcept (true); extern double __atan (double __x) noexcept (true); + + extern double atan2 (double __y, double __x) noexcept (true); extern double __atan2 (double __y, double __x) noexcept (true); + + + extern double cos (double __x) noexcept (true); extern double __cos (double __x) noexcept (true); + + extern double sin (double __x) noexcept (true); extern double __sin (double __x) noexcept (true); + + extern double tan (double __x) noexcept (true); extern double __tan (double __x) noexcept (true); + + + +extern double acospi (double __x) noexcept (true); extern double __acospi (double __x) noexcept (true); + +extern double asinpi (double __x) noexcept (true); extern double __asinpi (double __x) noexcept (true); + +extern double atanpi (double __x) noexcept (true); extern double __atanpi (double __x) noexcept (true); + +extern double atan2pi (double __y, double __x) noexcept (true); extern double __atan2pi (double __y, double __x) noexcept (true); + + + extern double cospi (double __x) noexcept (true); extern double __cospi (double __x) noexcept (true); + + extern double sinpi (double __x) noexcept (true); extern double __sinpi (double __x) noexcept (true); + + extern double tanpi (double __x) noexcept (true); extern double __tanpi (double __x) noexcept (true); + + + + + + extern double cosh (double __x) noexcept (true); extern double __cosh (double __x) noexcept (true); + + extern double sinh (double __x) noexcept (true); extern double __sinh (double __x) noexcept (true); + + extern double tanh (double __x) noexcept (true); extern double __tanh (double __x) noexcept (true); + + + + extern void sincos (double __x, double *__sinx, double *__cosx) noexcept (true); extern void __sincos (double __x, double *__sinx, double *__cosx) noexcept (true) + ; + + + + + extern double acosh (double __x) noexcept (true); extern double __acosh (double __x) noexcept (true); + + extern double asinh (double __x) noexcept (true); extern double __asinh (double __x) noexcept (true); + + extern double atanh (double __x) noexcept (true); extern double __atanh (double __x) noexcept (true); + + + + + + extern double exp (double __x) noexcept (true); extern double __exp (double __x) noexcept (true); + + +extern double frexp (double __x, int *__exponent) noexcept (true); extern double __frexp (double __x, int *__exponent) noexcept (true); + + +extern double ldexp (double __x, int __exponent) noexcept (true); extern double __ldexp (double __x, int __exponent) noexcept (true); + + + extern double log (double __x) noexcept (true); extern double __log (double __x) noexcept (true); + + + extern double log10 (double __x) noexcept (true); extern double __log10 (double __x) noexcept (true); + + +extern double modf (double __x, double *__iptr) noexcept (true); extern double __modf (double __x, double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern double exp10 (double __x) noexcept (true); extern double __exp10 (double __x) noexcept (true); + + +extern double exp2m1 (double __x) noexcept (true); extern double __exp2m1 (double __x) noexcept (true); + + +extern double exp10m1 (double __x) noexcept (true); extern double __exp10m1 (double __x) noexcept (true); + + +extern double log2p1 (double __x) noexcept (true); extern double __log2p1 (double __x) noexcept (true); + + +extern double log10p1 (double __x) noexcept (true); extern double __log10p1 (double __x) noexcept (true); + + + extern double logp1 (double __x) noexcept (true); extern double __logp1 (double __x) noexcept (true); + + + + + extern double expm1 (double __x) noexcept (true); extern double __expm1 (double __x) noexcept (true); + + + extern double log1p (double __x) noexcept (true); extern double __log1p (double __x) noexcept (true); + + +extern double logb (double __x) noexcept (true); extern double __logb (double __x) noexcept (true); + + + + + extern double exp2 (double __x) noexcept (true); extern double __exp2 (double __x) noexcept (true); + + + extern double log2 (double __x) noexcept (true); extern double __log2 (double __x) noexcept (true); + + + + + + + extern double pow (double __x, double __y) noexcept (true); extern double __pow (double __x, double __y) noexcept (true); + + +extern double sqrt (double __x) noexcept (true); extern double __sqrt (double __x) noexcept (true); + + + + extern double hypot (double __x, double __y) noexcept (true); extern double __hypot (double __x, double __y) noexcept (true); + + + + + extern double cbrt (double __x) noexcept (true); extern double __cbrt (double __x) noexcept (true); + + + + + + +extern double ceil (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double fabs (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double floor (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double fmod (double __x, double __y) noexcept (true); extern double __fmod (double __x, double __y) noexcept (true); +# 216 "/usr/include/bits/mathcalls.h" 3 4 +extern int finite (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern double drem (double __x, double __y) noexcept (true); extern double __drem (double __x, double __y) noexcept (true); + + + +extern double significand (double __x) noexcept (true); extern double __significand (double __x) noexcept (true); + + + + + + +extern double copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern double nan (const char *__tagb) noexcept (true); extern double __nan (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern double j0 (double) noexcept (true); extern double __j0 (double) noexcept (true); +extern double j1 (double) noexcept (true); extern double __j1 (double) noexcept (true); +extern double jn (int, double) noexcept (true); extern double __jn (int, double) noexcept (true); +extern double y0 (double) noexcept (true); extern double __y0 (double) noexcept (true); +extern double y1 (double) noexcept (true); extern double __y1 (double) noexcept (true); +extern double yn (int, double) noexcept (true); extern double __yn (int, double) noexcept (true); + + + + + + extern double erf (double) noexcept (true); extern double __erf (double) noexcept (true); + extern double erfc (double) noexcept (true); extern double __erfc (double) noexcept (true); +extern double lgamma (double) noexcept (true); extern double __lgamma (double) noexcept (true); + + + + +extern double tgamma (double) noexcept (true); extern double __tgamma (double) noexcept (true); + + + + + +extern double gamma (double) noexcept (true); extern double __gamma (double) noexcept (true); + + + + + + + +extern double lgamma_r (double, int *__signgamp) noexcept (true); extern double __lgamma_r (double, int *__signgamp) noexcept (true); + + + + + + +extern double rint (double __x) noexcept (true); extern double __rint (double __x) noexcept (true); + + +extern double nextafter (double __x, double __y) noexcept (true); extern double __nextafter (double __x, double __y) noexcept (true); + +extern double nexttoward (double __x, long double __y) noexcept (true); extern double __nexttoward (double __x, long double __y) noexcept (true); + + + + +extern double nextdown (double __x) noexcept (true); extern double __nextdown (double __x) noexcept (true); + +extern double nextup (double __x) noexcept (true); extern double __nextup (double __x) noexcept (true); + + + +extern double remainder (double __x, double __y) noexcept (true); extern double __remainder (double __x, double __y) noexcept (true); + + + +extern double scalbn (double __x, int __n) noexcept (true); extern double __scalbn (double __x, int __n) noexcept (true); + + + +extern int ilogb (double __x) noexcept (true); extern int __ilogb (double __x) noexcept (true); + + + + +extern long int llogb (double __x) noexcept (true); extern long int __llogb (double __x) noexcept (true); + + + + +extern double scalbln (double __x, long int __n) noexcept (true); extern double __scalbln (double __x, long int __n) noexcept (true); + + + +extern double nearbyint (double __x) noexcept (true); extern double __nearbyint (double __x) noexcept (true); + + + +extern double round (double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern double trunc (double __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern double remquo (double __x, double __y, int *__quo) noexcept (true); extern double __remquo (double __x, double __y, int *__quo) noexcept (true); + + + + + + +extern long int lrint (double __x) noexcept (true); extern long int __lrint (double __x) noexcept (true); +__extension__ +extern long long int llrint (double __x) noexcept (true); extern long long int __llrint (double __x) noexcept (true); + + + +extern long int lround (double __x) noexcept (true); extern long int __lround (double __x) noexcept (true); +__extension__ +extern long long int llround (double __x) noexcept (true); extern long long int __llround (double __x) noexcept (true); + + + +extern double fdim (double __x, double __y) noexcept (true); extern double __fdim (double __x, double __y) noexcept (true); + + + +extern double fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + +extern double fma (double __x, double __y, double __z) noexcept (true); extern double __fma (double __x, double __y, double __z) noexcept (true); + + + + +extern double roundeven (double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfp (double __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfp (double __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpx (double __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpx (double __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalize (double *__cx, const double *__x) noexcept (true); + + + + + + +extern double fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern double fmaximum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorder (const double *__x, const double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermag (const double *__x, const double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern double getpayload (const double *__x) noexcept (true); extern double __getpayload (const double *__x) noexcept (true); + + +extern int setpayload (double *__x, double __payload) noexcept (true); + + +extern int setpayloadsig (double *__x, double __payload) noexcept (true); + + + + + + + +extern double scalb (double __x, double __n) noexcept (true); extern double __scalb (double __x, double __n) noexcept (true); +# 283 "/usr/include/math.h" 2 3 4 +# 298 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyf (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitf (float __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinff (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitef (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanf (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigf (float __x, float __y) noexcept (true); + + +extern int __issignalingf (float __value) noexcept (true) + __attribute__ ((__const__)); +# 299 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern float acosf (float __x) noexcept (true); extern float __acosf (float __x) noexcept (true); + + extern float asinf (float __x) noexcept (true); extern float __asinf (float __x) noexcept (true); + + extern float atanf (float __x) noexcept (true); extern float __atanf (float __x) noexcept (true); + + extern float atan2f (float __y, float __x) noexcept (true); extern float __atan2f (float __y, float __x) noexcept (true); + + + extern float cosf (float __x) noexcept (true); extern float __cosf (float __x) noexcept (true); + + extern float sinf (float __x) noexcept (true); extern float __sinf (float __x) noexcept (true); + + extern float tanf (float __x) noexcept (true); extern float __tanf (float __x) noexcept (true); + + + +extern float acospif (float __x) noexcept (true); extern float __acospif (float __x) noexcept (true); + +extern float asinpif (float __x) noexcept (true); extern float __asinpif (float __x) noexcept (true); + +extern float atanpif (float __x) noexcept (true); extern float __atanpif (float __x) noexcept (true); + +extern float atan2pif (float __y, float __x) noexcept (true); extern float __atan2pif (float __y, float __x) noexcept (true); + + + extern float cospif (float __x) noexcept (true); extern float __cospif (float __x) noexcept (true); + + extern float sinpif (float __x) noexcept (true); extern float __sinpif (float __x) noexcept (true); + + extern float tanpif (float __x) noexcept (true); extern float __tanpif (float __x) noexcept (true); + + + + + + extern float coshf (float __x) noexcept (true); extern float __coshf (float __x) noexcept (true); + + extern float sinhf (float __x) noexcept (true); extern float __sinhf (float __x) noexcept (true); + + extern float tanhf (float __x) noexcept (true); extern float __tanhf (float __x) noexcept (true); + + + + extern void sincosf (float __x, float *__sinx, float *__cosx) noexcept (true); extern void __sincosf (float __x, float *__sinx, float *__cosx) noexcept (true) + ; + + + + + extern float acoshf (float __x) noexcept (true); extern float __acoshf (float __x) noexcept (true); + + extern float asinhf (float __x) noexcept (true); extern float __asinhf (float __x) noexcept (true); + + extern float atanhf (float __x) noexcept (true); extern float __atanhf (float __x) noexcept (true); + + + + + + extern float expf (float __x) noexcept (true); extern float __expf (float __x) noexcept (true); + + +extern float frexpf (float __x, int *__exponent) noexcept (true); extern float __frexpf (float __x, int *__exponent) noexcept (true); + + +extern float ldexpf (float __x, int __exponent) noexcept (true); extern float __ldexpf (float __x, int __exponent) noexcept (true); + + + extern float logf (float __x) noexcept (true); extern float __logf (float __x) noexcept (true); + + + extern float log10f (float __x) noexcept (true); extern float __log10f (float __x) noexcept (true); + + +extern float modff (float __x, float *__iptr) noexcept (true); extern float __modff (float __x, float *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern float exp10f (float __x) noexcept (true); extern float __exp10f (float __x) noexcept (true); + + +extern float exp2m1f (float __x) noexcept (true); extern float __exp2m1f (float __x) noexcept (true); + + +extern float exp10m1f (float __x) noexcept (true); extern float __exp10m1f (float __x) noexcept (true); + + +extern float log2p1f (float __x) noexcept (true); extern float __log2p1f (float __x) noexcept (true); + + +extern float log10p1f (float __x) noexcept (true); extern float __log10p1f (float __x) noexcept (true); + + + extern float logp1f (float __x) noexcept (true); extern float __logp1f (float __x) noexcept (true); + + + + + extern float expm1f (float __x) noexcept (true); extern float __expm1f (float __x) noexcept (true); + + + extern float log1pf (float __x) noexcept (true); extern float __log1pf (float __x) noexcept (true); + + +extern float logbf (float __x) noexcept (true); extern float __logbf (float __x) noexcept (true); + + + + + extern float exp2f (float __x) noexcept (true); extern float __exp2f (float __x) noexcept (true); + + + extern float log2f (float __x) noexcept (true); extern float __log2f (float __x) noexcept (true); + + + + + + + extern float powf (float __x, float __y) noexcept (true); extern float __powf (float __x, float __y) noexcept (true); + + +extern float sqrtf (float __x) noexcept (true); extern float __sqrtf (float __x) noexcept (true); + + + + extern float hypotf (float __x, float __y) noexcept (true); extern float __hypotf (float __x, float __y) noexcept (true); + + + + + extern float cbrtf (float __x) noexcept (true); extern float __cbrtf (float __x) noexcept (true); + + + + + + +extern float ceilf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float fabsf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float floorf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float fmodf (float __x, float __y) noexcept (true); extern float __fmodf (float __x, float __y) noexcept (true); +# 210 "/usr/include/bits/mathcalls.h" 3 4 +extern int isinff (float __value) noexcept (true) + __attribute__ ((__const__)); + + + + +extern int finitef (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern float dremf (float __x, float __y) noexcept (true); extern float __dremf (float __x, float __y) noexcept (true); + + + +extern float significandf (float __x) noexcept (true); extern float __significandf (float __x) noexcept (true); + + + + + + +extern float copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern float nanf (const char *__tagb) noexcept (true); extern float __nanf (const char *__tagb) noexcept (true); +# 246 "/usr/include/bits/mathcalls.h" 3 4 +extern int isnanf (float __value) noexcept (true) + __attribute__ ((__const__)); + + + + + +extern float j0f (float) noexcept (true); extern float __j0f (float) noexcept (true); +extern float j1f (float) noexcept (true); extern float __j1f (float) noexcept (true); +extern float jnf (int, float) noexcept (true); extern float __jnf (int, float) noexcept (true); +extern float y0f (float) noexcept (true); extern float __y0f (float) noexcept (true); +extern float y1f (float) noexcept (true); extern float __y1f (float) noexcept (true); +extern float ynf (int, float) noexcept (true); extern float __ynf (int, float) noexcept (true); + + + + + + extern float erff (float) noexcept (true); extern float __erff (float) noexcept (true); + extern float erfcf (float) noexcept (true); extern float __erfcf (float) noexcept (true); +extern float lgammaf (float) noexcept (true); extern float __lgammaf (float) noexcept (true); + + + + +extern float tgammaf (float) noexcept (true); extern float __tgammaf (float) noexcept (true); + + + + + +extern float gammaf (float) noexcept (true); extern float __gammaf (float) noexcept (true); + + + + + + + +extern float lgammaf_r (float, int *__signgamp) noexcept (true); extern float __lgammaf_r (float, int *__signgamp) noexcept (true); + + + + + + +extern float rintf (float __x) noexcept (true); extern float __rintf (float __x) noexcept (true); + + +extern float nextafterf (float __x, float __y) noexcept (true); extern float __nextafterf (float __x, float __y) noexcept (true); + +extern float nexttowardf (float __x, long double __y) noexcept (true); extern float __nexttowardf (float __x, long double __y) noexcept (true); + + + + +extern float nextdownf (float __x) noexcept (true); extern float __nextdownf (float __x) noexcept (true); + +extern float nextupf (float __x) noexcept (true); extern float __nextupf (float __x) noexcept (true); + + + +extern float remainderf (float __x, float __y) noexcept (true); extern float __remainderf (float __x, float __y) noexcept (true); + + + +extern float scalbnf (float __x, int __n) noexcept (true); extern float __scalbnf (float __x, int __n) noexcept (true); + + + +extern int ilogbf (float __x) noexcept (true); extern int __ilogbf (float __x) noexcept (true); + + + + +extern long int llogbf (float __x) noexcept (true); extern long int __llogbf (float __x) noexcept (true); + + + + +extern float scalblnf (float __x, long int __n) noexcept (true); extern float __scalblnf (float __x, long int __n) noexcept (true); + + + +extern float nearbyintf (float __x) noexcept (true); extern float __nearbyintf (float __x) noexcept (true); + + + +extern float roundf (float __x) noexcept (true) __attribute__ ((__const__)); + + + +extern float truncf (float __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern float remquof (float __x, float __y, int *__quo) noexcept (true); extern float __remquof (float __x, float __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf (float __x) noexcept (true); extern long int __lrintf (float __x) noexcept (true); +__extension__ +extern long long int llrintf (float __x) noexcept (true); extern long long int __llrintf (float __x) noexcept (true); + + + +extern long int lroundf (float __x) noexcept (true); extern long int __lroundf (float __x) noexcept (true); +__extension__ +extern long long int llroundf (float __x) noexcept (true); extern long long int __llroundf (float __x) noexcept (true); + + + +extern float fdimf (float __x, float __y) noexcept (true); extern float __fdimf (float __x, float __y) noexcept (true); + + + +extern float fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + +extern float fmaf (float __x, float __y, float __z) noexcept (true); extern float __fmaf (float __x, float __y, float __z) noexcept (true); + + + + +extern float roundevenf (float __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf (float __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf (float __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf (float __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef (float *__cx, const float *__x) noexcept (true); + + + + + + +extern float fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern float fmaximumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf (const float *__x, const float *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf (const float *__x, const float *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern float getpayloadf (const float *__x) noexcept (true); extern float __getpayloadf (const float *__x) noexcept (true); + + +extern int setpayloadf (float *__x, float __payload) noexcept (true); + + +extern int setpayloadsigf (float *__x, float __payload) noexcept (true); + + + + + + + +extern float scalbf (float __x, float __n) noexcept (true); extern float __scalbf (float __x, float __n) noexcept (true); +# 300 "/usr/include/math.h" 2 3 4 +# 367 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinfl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitel (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigl (long double __x, long double __y) noexcept (true); + + +extern int __issignalingl (long double __value) noexcept (true) + __attribute__ ((__const__)); +# 368 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern long double acosl (long double __x) noexcept (true); extern long double __acosl (long double __x) noexcept (true); + + extern long double asinl (long double __x) noexcept (true); extern long double __asinl (long double __x) noexcept (true); + + extern long double atanl (long double __x) noexcept (true); extern long double __atanl (long double __x) noexcept (true); + + extern long double atan2l (long double __y, long double __x) noexcept (true); extern long double __atan2l (long double __y, long double __x) noexcept (true); + + + extern long double cosl (long double __x) noexcept (true); extern long double __cosl (long double __x) noexcept (true); + + extern long double sinl (long double __x) noexcept (true); extern long double __sinl (long double __x) noexcept (true); + + extern long double tanl (long double __x) noexcept (true); extern long double __tanl (long double __x) noexcept (true); + + + +extern long double acospil (long double __x) noexcept (true); extern long double __acospil (long double __x) noexcept (true); + +extern long double asinpil (long double __x) noexcept (true); extern long double __asinpil (long double __x) noexcept (true); + +extern long double atanpil (long double __x) noexcept (true); extern long double __atanpil (long double __x) noexcept (true); + +extern long double atan2pil (long double __y, long double __x) noexcept (true); extern long double __atan2pil (long double __y, long double __x) noexcept (true); + + + extern long double cospil (long double __x) noexcept (true); extern long double __cospil (long double __x) noexcept (true); + + extern long double sinpil (long double __x) noexcept (true); extern long double __sinpil (long double __x) noexcept (true); + + extern long double tanpil (long double __x) noexcept (true); extern long double __tanpil (long double __x) noexcept (true); + + + + + + extern long double coshl (long double __x) noexcept (true); extern long double __coshl (long double __x) noexcept (true); + + extern long double sinhl (long double __x) noexcept (true); extern long double __sinhl (long double __x) noexcept (true); + + extern long double tanhl (long double __x) noexcept (true); extern long double __tanhl (long double __x) noexcept (true); + + + + extern void sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true) + ; + + + + + extern long double acoshl (long double __x) noexcept (true); extern long double __acoshl (long double __x) noexcept (true); + + extern long double asinhl (long double __x) noexcept (true); extern long double __asinhl (long double __x) noexcept (true); + + extern long double atanhl (long double __x) noexcept (true); extern long double __atanhl (long double __x) noexcept (true); + + + + + + extern long double expl (long double __x) noexcept (true); extern long double __expl (long double __x) noexcept (true); + + +extern long double frexpl (long double __x, int *__exponent) noexcept (true); extern long double __frexpl (long double __x, int *__exponent) noexcept (true); + + +extern long double ldexpl (long double __x, int __exponent) noexcept (true); extern long double __ldexpl (long double __x, int __exponent) noexcept (true); + + + extern long double logl (long double __x) noexcept (true); extern long double __logl (long double __x) noexcept (true); + + + extern long double log10l (long double __x) noexcept (true); extern long double __log10l (long double __x) noexcept (true); + + +extern long double modfl (long double __x, long double *__iptr) noexcept (true); extern long double __modfl (long double __x, long double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern long double exp10l (long double __x) noexcept (true); extern long double __exp10l (long double __x) noexcept (true); + + +extern long double exp2m1l (long double __x) noexcept (true); extern long double __exp2m1l (long double __x) noexcept (true); + + +extern long double exp10m1l (long double __x) noexcept (true); extern long double __exp10m1l (long double __x) noexcept (true); + + +extern long double log2p1l (long double __x) noexcept (true); extern long double __log2p1l (long double __x) noexcept (true); + + +extern long double log10p1l (long double __x) noexcept (true); extern long double __log10p1l (long double __x) noexcept (true); + + + extern long double logp1l (long double __x) noexcept (true); extern long double __logp1l (long double __x) noexcept (true); + + + + + extern long double expm1l (long double __x) noexcept (true); extern long double __expm1l (long double __x) noexcept (true); + + + extern long double log1pl (long double __x) noexcept (true); extern long double __log1pl (long double __x) noexcept (true); + + +extern long double logbl (long double __x) noexcept (true); extern long double __logbl (long double __x) noexcept (true); + + + + + extern long double exp2l (long double __x) noexcept (true); extern long double __exp2l (long double __x) noexcept (true); + + + extern long double log2l (long double __x) noexcept (true); extern long double __log2l (long double __x) noexcept (true); + + + + + + + extern long double powl (long double __x, long double __y) noexcept (true); extern long double __powl (long double __x, long double __y) noexcept (true); + + +extern long double sqrtl (long double __x) noexcept (true); extern long double __sqrtl (long double __x) noexcept (true); + + + + extern long double hypotl (long double __x, long double __y) noexcept (true); extern long double __hypotl (long double __x, long double __y) noexcept (true); + + + + + extern long double cbrtl (long double __x) noexcept (true); extern long double __cbrtl (long double __x) noexcept (true); + + + + + + +extern long double ceill (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double floorl (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmodl (long double __x, long double __y) noexcept (true); extern long double __fmodl (long double __x, long double __y) noexcept (true); +# 210 "/usr/include/bits/mathcalls.h" 3 4 +extern int isinfl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + + +extern int finitel (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern long double dreml (long double __x, long double __y) noexcept (true); extern long double __dreml (long double __x, long double __y) noexcept (true); + + + +extern long double significandl (long double __x) noexcept (true); extern long double __significandl (long double __x) noexcept (true); + + + + + + +extern long double copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double nanl (const char *__tagb) noexcept (true); extern long double __nanl (const char *__tagb) noexcept (true); +# 246 "/usr/include/bits/mathcalls.h" 3 4 +extern int isnanl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + + + +extern long double j0l (long double) noexcept (true); extern long double __j0l (long double) noexcept (true); +extern long double j1l (long double) noexcept (true); extern long double __j1l (long double) noexcept (true); +extern long double jnl (int, long double) noexcept (true); extern long double __jnl (int, long double) noexcept (true); +extern long double y0l (long double) noexcept (true); extern long double __y0l (long double) noexcept (true); +extern long double y1l (long double) noexcept (true); extern long double __y1l (long double) noexcept (true); +extern long double ynl (int, long double) noexcept (true); extern long double __ynl (int, long double) noexcept (true); + + + + + + extern long double erfl (long double) noexcept (true); extern long double __erfl (long double) noexcept (true); + extern long double erfcl (long double) noexcept (true); extern long double __erfcl (long double) noexcept (true); +extern long double lgammal (long double) noexcept (true); extern long double __lgammal (long double) noexcept (true); + + + + +extern long double tgammal (long double) noexcept (true); extern long double __tgammal (long double) noexcept (true); + + + + + +extern long double gammal (long double) noexcept (true); extern long double __gammal (long double) noexcept (true); + + + + + + + +extern long double lgammal_r (long double, int *__signgamp) noexcept (true); extern long double __lgammal_r (long double, int *__signgamp) noexcept (true); + + + + + + +extern long double rintl (long double __x) noexcept (true); extern long double __rintl (long double __x) noexcept (true); + + +extern long double nextafterl (long double __x, long double __y) noexcept (true); extern long double __nextafterl (long double __x, long double __y) noexcept (true); + +extern long double nexttowardl (long double __x, long double __y) noexcept (true); extern long double __nexttowardl (long double __x, long double __y) noexcept (true); + + + + +extern long double nextdownl (long double __x) noexcept (true); extern long double __nextdownl (long double __x) noexcept (true); + +extern long double nextupl (long double __x) noexcept (true); extern long double __nextupl (long double __x) noexcept (true); + + + +extern long double remainderl (long double __x, long double __y) noexcept (true); extern long double __remainderl (long double __x, long double __y) noexcept (true); + + + +extern long double scalbnl (long double __x, int __n) noexcept (true); extern long double __scalbnl (long double __x, int __n) noexcept (true); + + + +extern int ilogbl (long double __x) noexcept (true); extern int __ilogbl (long double __x) noexcept (true); + + + + +extern long int llogbl (long double __x) noexcept (true); extern long int __llogbl (long double __x) noexcept (true); + + + + +extern long double scalblnl (long double __x, long int __n) noexcept (true); extern long double __scalblnl (long double __x, long int __n) noexcept (true); + + + +extern long double nearbyintl (long double __x) noexcept (true); extern long double __nearbyintl (long double __x) noexcept (true); + + + +extern long double roundl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern long double truncl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double remquol (long double __x, long double __y, int *__quo) noexcept (true); extern long double __remquol (long double __x, long double __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintl (long double __x) noexcept (true); extern long int __lrintl (long double __x) noexcept (true); +__extension__ +extern long long int llrintl (long double __x) noexcept (true); extern long long int __llrintl (long double __x) noexcept (true); + + + +extern long int lroundl (long double __x) noexcept (true); extern long int __lroundl (long double __x) noexcept (true); +__extension__ +extern long long int llroundl (long double __x) noexcept (true); extern long long int __llroundl (long double __x) noexcept (true); + + + +extern long double fdiml (long double __x, long double __y) noexcept (true); extern long double __fdiml (long double __x, long double __y) noexcept (true); + + + +extern long double fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + +extern long double fmal (long double __x, long double __y, long double __z) noexcept (true); extern long double __fmal (long double __x, long double __y, long double __z) noexcept (true); + + + + +extern long double roundevenl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpl (long double __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizel (long double *__cx, const long double *__x) noexcept (true); + + + + + + +extern long double fmaxmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double fmaximuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderl (const long double *__x, const long double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagl (const long double *__x, const long double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern long double getpayloadl (const long double *__x) noexcept (true); extern long double __getpayloadl (const long double *__x) noexcept (true); + + +extern int setpayloadl (long double *__x, long double __payload) noexcept (true); + + +extern int setpayloadsigl (long double *__x, long double __payload) noexcept (true); + + + + + + + +extern long double scalbl (long double __x, long double __n) noexcept (true); extern long double __scalbl (long double __x, long double __n) noexcept (true); +# 369 "/usr/include/math.h" 2 3 4 +# 419 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float32 acosf32 (_Float32 __x) noexcept (true); extern _Float32 __acosf32 (_Float32 __x) noexcept (true); + + extern _Float32 asinf32 (_Float32 __x) noexcept (true); extern _Float32 __asinf32 (_Float32 __x) noexcept (true); + + extern _Float32 atanf32 (_Float32 __x) noexcept (true); extern _Float32 __atanf32 (_Float32 __x) noexcept (true); + + extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); + + + extern _Float32 cosf32 (_Float32 __x) noexcept (true); extern _Float32 __cosf32 (_Float32 __x) noexcept (true); + + extern _Float32 sinf32 (_Float32 __x) noexcept (true); extern _Float32 __sinf32 (_Float32 __x) noexcept (true); + + extern _Float32 tanf32 (_Float32 __x) noexcept (true); extern _Float32 __tanf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 acospif32 (_Float32 __x) noexcept (true); extern _Float32 __acospif32 (_Float32 __x) noexcept (true); + +extern _Float32 asinpif32 (_Float32 __x) noexcept (true); extern _Float32 __asinpif32 (_Float32 __x) noexcept (true); + +extern _Float32 atanpif32 (_Float32 __x) noexcept (true); extern _Float32 __atanpif32 (_Float32 __x) noexcept (true); + +extern _Float32 atan2pif32 (_Float32 __y, _Float32 __x) noexcept (true); extern _Float32 __atan2pif32 (_Float32 __y, _Float32 __x) noexcept (true); + + + extern _Float32 cospif32 (_Float32 __x) noexcept (true); extern _Float32 __cospif32 (_Float32 __x) noexcept (true); + + extern _Float32 sinpif32 (_Float32 __x) noexcept (true); extern _Float32 __sinpif32 (_Float32 __x) noexcept (true); + + extern _Float32 tanpif32 (_Float32 __x) noexcept (true); extern _Float32 __tanpif32 (_Float32 __x) noexcept (true); + + + + + + extern _Float32 coshf32 (_Float32 __x) noexcept (true); extern _Float32 __coshf32 (_Float32 __x) noexcept (true); + + extern _Float32 sinhf32 (_Float32 __x) noexcept (true); extern _Float32 __sinhf32 (_Float32 __x) noexcept (true); + + extern _Float32 tanhf32 (_Float32 __x) noexcept (true); extern _Float32 __tanhf32 (_Float32 __x) noexcept (true); + + + + extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true) + ; + + + + + extern _Float32 acoshf32 (_Float32 __x) noexcept (true); extern _Float32 __acoshf32 (_Float32 __x) noexcept (true); + + extern _Float32 asinhf32 (_Float32 __x) noexcept (true); extern _Float32 __asinhf32 (_Float32 __x) noexcept (true); + + extern _Float32 atanhf32 (_Float32 __x) noexcept (true); extern _Float32 __atanhf32 (_Float32 __x) noexcept (true); + + + + + + extern _Float32 expf32 (_Float32 __x) noexcept (true); extern _Float32 __expf32 (_Float32 __x) noexcept (true); + + +extern _Float32 frexpf32 (_Float32 __x, int *__exponent) noexcept (true); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) noexcept (true); + + +extern _Float32 ldexpf32 (_Float32 __x, int __exponent) noexcept (true); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) noexcept (true); + + + extern _Float32 logf32 (_Float32 __x) noexcept (true); extern _Float32 __logf32 (_Float32 __x) noexcept (true); + + + extern _Float32 log10f32 (_Float32 __x) noexcept (true); extern _Float32 __log10f32 (_Float32 __x) noexcept (true); + + +extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true); extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float32 exp10f32 (_Float32 __x) noexcept (true); extern _Float32 __exp10f32 (_Float32 __x) noexcept (true); + + +extern _Float32 exp2m1f32 (_Float32 __x) noexcept (true); extern _Float32 __exp2m1f32 (_Float32 __x) noexcept (true); + + +extern _Float32 exp10m1f32 (_Float32 __x) noexcept (true); extern _Float32 __exp10m1f32 (_Float32 __x) noexcept (true); + + +extern _Float32 log2p1f32 (_Float32 __x) noexcept (true); extern _Float32 __log2p1f32 (_Float32 __x) noexcept (true); + + +extern _Float32 log10p1f32 (_Float32 __x) noexcept (true); extern _Float32 __log10p1f32 (_Float32 __x) noexcept (true); + + + extern _Float32 logp1f32 (_Float32 __x) noexcept (true); extern _Float32 __logp1f32 (_Float32 __x) noexcept (true); + + + + + extern _Float32 expm1f32 (_Float32 __x) noexcept (true); extern _Float32 __expm1f32 (_Float32 __x) noexcept (true); + + + extern _Float32 log1pf32 (_Float32 __x) noexcept (true); extern _Float32 __log1pf32 (_Float32 __x) noexcept (true); + + +extern _Float32 logbf32 (_Float32 __x) noexcept (true); extern _Float32 __logbf32 (_Float32 __x) noexcept (true); + + + + + extern _Float32 exp2f32 (_Float32 __x) noexcept (true); extern _Float32 __exp2f32 (_Float32 __x) noexcept (true); + + + extern _Float32 log2f32 (_Float32 __x) noexcept (true); extern _Float32 __log2f32 (_Float32 __x) noexcept (true); + + + + + + + extern _Float32 powf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) noexcept (true); + + +extern _Float32 sqrtf32 (_Float32 __x) noexcept (true); extern _Float32 __sqrtf32 (_Float32 __x) noexcept (true); + + + + extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + + + extern _Float32 cbrtf32 (_Float32 __x) noexcept (true); extern _Float32 __cbrtf32 (_Float32 __x) noexcept (true); + + + + + + +extern _Float32 ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); +# 231 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 nanf32 (const char *__tagb) noexcept (true); extern _Float32 __nanf32 (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32 j0f32 (_Float32) noexcept (true); extern _Float32 __j0f32 (_Float32) noexcept (true); +extern _Float32 j1f32 (_Float32) noexcept (true); extern _Float32 __j1f32 (_Float32) noexcept (true); +extern _Float32 jnf32 (int, _Float32) noexcept (true); extern _Float32 __jnf32 (int, _Float32) noexcept (true); +extern _Float32 y0f32 (_Float32) noexcept (true); extern _Float32 __y0f32 (_Float32) noexcept (true); +extern _Float32 y1f32 (_Float32) noexcept (true); extern _Float32 __y1f32 (_Float32) noexcept (true); +extern _Float32 ynf32 (int, _Float32) noexcept (true); extern _Float32 __ynf32 (int, _Float32) noexcept (true); + + + + + + extern _Float32 erff32 (_Float32) noexcept (true); extern _Float32 __erff32 (_Float32) noexcept (true); + extern _Float32 erfcf32 (_Float32) noexcept (true); extern _Float32 __erfcf32 (_Float32) noexcept (true); +extern _Float32 lgammaf32 (_Float32) noexcept (true); extern _Float32 __lgammaf32 (_Float32) noexcept (true); + + + + +extern _Float32 tgammaf32 (_Float32) noexcept (true); extern _Float32 __tgammaf32 (_Float32) noexcept (true); +# 285 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32 lgammaf32_r (_Float32, int *__signgamp) noexcept (true); extern _Float32 __lgammaf32_r (_Float32, int *__signgamp) noexcept (true); + + + + + + +extern _Float32 rintf32 (_Float32 __x) noexcept (true); extern _Float32 __rintf32 (_Float32 __x) noexcept (true); + + +extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + + + + +extern _Float32 nextdownf32 (_Float32 __x) noexcept (true); extern _Float32 __nextdownf32 (_Float32 __x) noexcept (true); + +extern _Float32 nextupf32 (_Float32 __x) noexcept (true); extern _Float32 __nextupf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + +extern _Float32 scalbnf32 (_Float32 __x, int __n) noexcept (true); extern _Float32 __scalbnf32 (_Float32 __x, int __n) noexcept (true); + + + +extern int ilogbf32 (_Float32 __x) noexcept (true); extern int __ilogbf32 (_Float32 __x) noexcept (true); + + + + +extern long int llogbf32 (_Float32 __x) noexcept (true); extern long int __llogbf32 (_Float32 __x) noexcept (true); + + + + +extern _Float32 scalblnf32 (_Float32 __x, long int __n) noexcept (true); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) noexcept (true); + + + +extern _Float32 nearbyintf32 (_Float32 __x) noexcept (true); extern _Float32 __nearbyintf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32 truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf32 (_Float32 __x) noexcept (true); extern long int __lrintf32 (_Float32 __x) noexcept (true); +__extension__ +extern long long int llrintf32 (_Float32 __x) noexcept (true); extern long long int __llrintf32 (_Float32 __x) noexcept (true); + + + +extern long int lroundf32 (_Float32 __x) noexcept (true); extern long int __lroundf32 (_Float32 __x) noexcept (true); +__extension__ +extern long long int llroundf32 (_Float32 __x) noexcept (true); extern long long int __llroundf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + +extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); + + + + +extern _Float32 roundevenf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) noexcept (true); + + + + + + +extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 fmaximumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float32 getpayloadf32 (const _Float32 *__x) noexcept (true); extern _Float32 __getpayloadf32 (const _Float32 *__x) noexcept (true); + + +extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) noexcept (true); + + +extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) noexcept (true); +# 420 "/usr/include/math.h" 2 3 4 +# 436 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float64 acosf64 (_Float64 __x) noexcept (true); extern _Float64 __acosf64 (_Float64 __x) noexcept (true); + + extern _Float64 asinf64 (_Float64 __x) noexcept (true); extern _Float64 __asinf64 (_Float64 __x) noexcept (true); + + extern _Float64 atanf64 (_Float64 __x) noexcept (true); extern _Float64 __atanf64 (_Float64 __x) noexcept (true); + + extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); extern _Float64 __atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); + + + extern _Float64 cosf64 (_Float64 __x) noexcept (true); extern _Float64 __cosf64 (_Float64 __x) noexcept (true); + + extern _Float64 sinf64 (_Float64 __x) noexcept (true); extern _Float64 __sinf64 (_Float64 __x) noexcept (true); + + extern _Float64 tanf64 (_Float64 __x) noexcept (true); extern _Float64 __tanf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 acospif64 (_Float64 __x) noexcept (true); extern _Float64 __acospif64 (_Float64 __x) noexcept (true); + +extern _Float64 asinpif64 (_Float64 __x) noexcept (true); extern _Float64 __asinpif64 (_Float64 __x) noexcept (true); + +extern _Float64 atanpif64 (_Float64 __x) noexcept (true); extern _Float64 __atanpif64 (_Float64 __x) noexcept (true); + +extern _Float64 atan2pif64 (_Float64 __y, _Float64 __x) noexcept (true); extern _Float64 __atan2pif64 (_Float64 __y, _Float64 __x) noexcept (true); + + + extern _Float64 cospif64 (_Float64 __x) noexcept (true); extern _Float64 __cospif64 (_Float64 __x) noexcept (true); + + extern _Float64 sinpif64 (_Float64 __x) noexcept (true); extern _Float64 __sinpif64 (_Float64 __x) noexcept (true); + + extern _Float64 tanpif64 (_Float64 __x) noexcept (true); extern _Float64 __tanpif64 (_Float64 __x) noexcept (true); + + + + + + extern _Float64 coshf64 (_Float64 __x) noexcept (true); extern _Float64 __coshf64 (_Float64 __x) noexcept (true); + + extern _Float64 sinhf64 (_Float64 __x) noexcept (true); extern _Float64 __sinhf64 (_Float64 __x) noexcept (true); + + extern _Float64 tanhf64 (_Float64 __x) noexcept (true); extern _Float64 __tanhf64 (_Float64 __x) noexcept (true); + + + + extern void sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) noexcept (true); extern void __sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) noexcept (true) + ; + + + + + extern _Float64 acoshf64 (_Float64 __x) noexcept (true); extern _Float64 __acoshf64 (_Float64 __x) noexcept (true); + + extern _Float64 asinhf64 (_Float64 __x) noexcept (true); extern _Float64 __asinhf64 (_Float64 __x) noexcept (true); + + extern _Float64 atanhf64 (_Float64 __x) noexcept (true); extern _Float64 __atanhf64 (_Float64 __x) noexcept (true); + + + + + + extern _Float64 expf64 (_Float64 __x) noexcept (true); extern _Float64 __expf64 (_Float64 __x) noexcept (true); + + +extern _Float64 frexpf64 (_Float64 __x, int *__exponent) noexcept (true); extern _Float64 __frexpf64 (_Float64 __x, int *__exponent) noexcept (true); + + +extern _Float64 ldexpf64 (_Float64 __x, int __exponent) noexcept (true); extern _Float64 __ldexpf64 (_Float64 __x, int __exponent) noexcept (true); + + + extern _Float64 logf64 (_Float64 __x) noexcept (true); extern _Float64 __logf64 (_Float64 __x) noexcept (true); + + + extern _Float64 log10f64 (_Float64 __x) noexcept (true); extern _Float64 __log10f64 (_Float64 __x) noexcept (true); + + +extern _Float64 modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true); extern _Float64 __modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float64 exp10f64 (_Float64 __x) noexcept (true); extern _Float64 __exp10f64 (_Float64 __x) noexcept (true); + + +extern _Float64 exp2m1f64 (_Float64 __x) noexcept (true); extern _Float64 __exp2m1f64 (_Float64 __x) noexcept (true); + + +extern _Float64 exp10m1f64 (_Float64 __x) noexcept (true); extern _Float64 __exp10m1f64 (_Float64 __x) noexcept (true); + + +extern _Float64 log2p1f64 (_Float64 __x) noexcept (true); extern _Float64 __log2p1f64 (_Float64 __x) noexcept (true); + + +extern _Float64 log10p1f64 (_Float64 __x) noexcept (true); extern _Float64 __log10p1f64 (_Float64 __x) noexcept (true); + + + extern _Float64 logp1f64 (_Float64 __x) noexcept (true); extern _Float64 __logp1f64 (_Float64 __x) noexcept (true); + + + + + extern _Float64 expm1f64 (_Float64 __x) noexcept (true); extern _Float64 __expm1f64 (_Float64 __x) noexcept (true); + + + extern _Float64 log1pf64 (_Float64 __x) noexcept (true); extern _Float64 __log1pf64 (_Float64 __x) noexcept (true); + + +extern _Float64 logbf64 (_Float64 __x) noexcept (true); extern _Float64 __logbf64 (_Float64 __x) noexcept (true); + + + + + extern _Float64 exp2f64 (_Float64 __x) noexcept (true); extern _Float64 __exp2f64 (_Float64 __x) noexcept (true); + + + extern _Float64 log2f64 (_Float64 __x) noexcept (true); extern _Float64 __log2f64 (_Float64 __x) noexcept (true); + + + + + + + extern _Float64 powf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __powf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float64 sqrtf64 (_Float64 __x) noexcept (true); extern _Float64 __sqrtf64 (_Float64 __x) noexcept (true); + + + + extern _Float64 hypotf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __hypotf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + + + extern _Float64 cbrtf64 (_Float64 __x) noexcept (true); extern _Float64 __cbrtf64 (_Float64 __x) noexcept (true); + + + + + + +extern _Float64 ceilf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fabsf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 floorf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmodf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __fmodf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 231 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64 nanf64 (const char *__tagb) noexcept (true); extern _Float64 __nanf64 (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64 j0f64 (_Float64) noexcept (true); extern _Float64 __j0f64 (_Float64) noexcept (true); +extern _Float64 j1f64 (_Float64) noexcept (true); extern _Float64 __j1f64 (_Float64) noexcept (true); +extern _Float64 jnf64 (int, _Float64) noexcept (true); extern _Float64 __jnf64 (int, _Float64) noexcept (true); +extern _Float64 y0f64 (_Float64) noexcept (true); extern _Float64 __y0f64 (_Float64) noexcept (true); +extern _Float64 y1f64 (_Float64) noexcept (true); extern _Float64 __y1f64 (_Float64) noexcept (true); +extern _Float64 ynf64 (int, _Float64) noexcept (true); extern _Float64 __ynf64 (int, _Float64) noexcept (true); + + + + + + extern _Float64 erff64 (_Float64) noexcept (true); extern _Float64 __erff64 (_Float64) noexcept (true); + extern _Float64 erfcf64 (_Float64) noexcept (true); extern _Float64 __erfcf64 (_Float64) noexcept (true); +extern _Float64 lgammaf64 (_Float64) noexcept (true); extern _Float64 __lgammaf64 (_Float64) noexcept (true); + + + + +extern _Float64 tgammaf64 (_Float64) noexcept (true); extern _Float64 __tgammaf64 (_Float64) noexcept (true); +# 285 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64 lgammaf64_r (_Float64, int *__signgamp) noexcept (true); extern _Float64 __lgammaf64_r (_Float64, int *__signgamp) noexcept (true); + + + + + + +extern _Float64 rintf64 (_Float64 __x) noexcept (true); extern _Float64 __rintf64 (_Float64 __x) noexcept (true); + + +extern _Float64 nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + + + + +extern _Float64 nextdownf64 (_Float64 __x) noexcept (true); extern _Float64 __nextdownf64 (_Float64 __x) noexcept (true); + +extern _Float64 nextupf64 (_Float64 __x) noexcept (true); extern _Float64 __nextupf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 remainderf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __remainderf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + +extern _Float64 scalbnf64 (_Float64 __x, int __n) noexcept (true); extern _Float64 __scalbnf64 (_Float64 __x, int __n) noexcept (true); + + + +extern int ilogbf64 (_Float64 __x) noexcept (true); extern int __ilogbf64 (_Float64 __x) noexcept (true); + + + + +extern long int llogbf64 (_Float64 __x) noexcept (true); extern long int __llogbf64 (_Float64 __x) noexcept (true); + + + + +extern _Float64 scalblnf64 (_Float64 __x, long int __n) noexcept (true); extern _Float64 __scalblnf64 (_Float64 __x, long int __n) noexcept (true); + + + +extern _Float64 nearbyintf64 (_Float64 __x) noexcept (true); extern _Float64 __nearbyintf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 roundf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64 truncf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64 remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcept (true); extern _Float64 __remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf64 (_Float64 __x) noexcept (true); extern long int __lrintf64 (_Float64 __x) noexcept (true); +__extension__ +extern long long int llrintf64 (_Float64 __x) noexcept (true); extern long long int __llrintf64 (_Float64 __x) noexcept (true); + + + +extern long int lroundf64 (_Float64 __x) noexcept (true); extern long int __lroundf64 (_Float64 __x) noexcept (true); +__extension__ +extern long long int llroundf64 (_Float64 __x) noexcept (true); extern long long int __llroundf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 fdimf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __fdimf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + +extern _Float64 fmaxf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64 fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); extern _Float64 __fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); + + + + +extern _Float64 roundevenf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef64 (_Float64 *__cx, const _Float64 *__x) noexcept (true); + + + + + + +extern _Float64 fmaxmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64 fmaximumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf64 (const _Float64 *__x, const _Float64 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf64 (const _Float64 *__x, const _Float64 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float64 getpayloadf64 (const _Float64 *__x) noexcept (true); extern _Float64 __getpayloadf64 (const _Float64 *__x) noexcept (true); + + +extern int setpayloadf64 (_Float64 *__x, _Float64 __payload) noexcept (true); + + +extern int setpayloadsigf64 (_Float64 *__x, _Float64 __payload) noexcept (true); +# 437 "/usr/include/math.h" 2 3 4 +# 450 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyf128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitf128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinff128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitef128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanf128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern int __issignalingf128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); +# 451 "/usr/include/math.h" 2 3 4 + + +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float128 acosf128 (_Float128 __x) noexcept (true); extern _Float128 __acosf128 (_Float128 __x) noexcept (true); + + extern _Float128 asinf128 (_Float128 __x) noexcept (true); extern _Float128 __asinf128 (_Float128 __x) noexcept (true); + + extern _Float128 atanf128 (_Float128 __x) noexcept (true); extern _Float128 __atanf128 (_Float128 __x) noexcept (true); + + extern _Float128 atan2f128 (_Float128 __y, _Float128 __x) noexcept (true); extern _Float128 __atan2f128 (_Float128 __y, _Float128 __x) noexcept (true); + + + extern _Float128 cosf128 (_Float128 __x) noexcept (true); extern _Float128 __cosf128 (_Float128 __x) noexcept (true); + + extern _Float128 sinf128 (_Float128 __x) noexcept (true); extern _Float128 __sinf128 (_Float128 __x) noexcept (true); + + extern _Float128 tanf128 (_Float128 __x) noexcept (true); extern _Float128 __tanf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 acospif128 (_Float128 __x) noexcept (true); extern _Float128 __acospif128 (_Float128 __x) noexcept (true); + +extern _Float128 asinpif128 (_Float128 __x) noexcept (true); extern _Float128 __asinpif128 (_Float128 __x) noexcept (true); + +extern _Float128 atanpif128 (_Float128 __x) noexcept (true); extern _Float128 __atanpif128 (_Float128 __x) noexcept (true); + +extern _Float128 atan2pif128 (_Float128 __y, _Float128 __x) noexcept (true); extern _Float128 __atan2pif128 (_Float128 __y, _Float128 __x) noexcept (true); + + + extern _Float128 cospif128 (_Float128 __x) noexcept (true); extern _Float128 __cospif128 (_Float128 __x) noexcept (true); + + extern _Float128 sinpif128 (_Float128 __x) noexcept (true); extern _Float128 __sinpif128 (_Float128 __x) noexcept (true); + + extern _Float128 tanpif128 (_Float128 __x) noexcept (true); extern _Float128 __tanpif128 (_Float128 __x) noexcept (true); + + + + + + extern _Float128 coshf128 (_Float128 __x) noexcept (true); extern _Float128 __coshf128 (_Float128 __x) noexcept (true); + + extern _Float128 sinhf128 (_Float128 __x) noexcept (true); extern _Float128 __sinhf128 (_Float128 __x) noexcept (true); + + extern _Float128 tanhf128 (_Float128 __x) noexcept (true); extern _Float128 __tanhf128 (_Float128 __x) noexcept (true); + + + + extern void sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) noexcept (true); extern void __sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) noexcept (true) + ; + + + + + extern _Float128 acoshf128 (_Float128 __x) noexcept (true); extern _Float128 __acoshf128 (_Float128 __x) noexcept (true); + + extern _Float128 asinhf128 (_Float128 __x) noexcept (true); extern _Float128 __asinhf128 (_Float128 __x) noexcept (true); + + extern _Float128 atanhf128 (_Float128 __x) noexcept (true); extern _Float128 __atanhf128 (_Float128 __x) noexcept (true); + + + + + + extern _Float128 expf128 (_Float128 __x) noexcept (true); extern _Float128 __expf128 (_Float128 __x) noexcept (true); + + +extern _Float128 frexpf128 (_Float128 __x, int *__exponent) noexcept (true); extern _Float128 __frexpf128 (_Float128 __x, int *__exponent) noexcept (true); + + +extern _Float128 ldexpf128 (_Float128 __x, int __exponent) noexcept (true); extern _Float128 __ldexpf128 (_Float128 __x, int __exponent) noexcept (true); + + + extern _Float128 logf128 (_Float128 __x) noexcept (true); extern _Float128 __logf128 (_Float128 __x) noexcept (true); + + + extern _Float128 log10f128 (_Float128 __x) noexcept (true); extern _Float128 __log10f128 (_Float128 __x) noexcept (true); + + +extern _Float128 modff128 (_Float128 __x, _Float128 *__iptr) noexcept (true); extern _Float128 __modff128 (_Float128 __x, _Float128 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float128 exp10f128 (_Float128 __x) noexcept (true); extern _Float128 __exp10f128 (_Float128 __x) noexcept (true); + + +extern _Float128 exp2m1f128 (_Float128 __x) noexcept (true); extern _Float128 __exp2m1f128 (_Float128 __x) noexcept (true); + + +extern _Float128 exp10m1f128 (_Float128 __x) noexcept (true); extern _Float128 __exp10m1f128 (_Float128 __x) noexcept (true); + + +extern _Float128 log2p1f128 (_Float128 __x) noexcept (true); extern _Float128 __log2p1f128 (_Float128 __x) noexcept (true); + + +extern _Float128 log10p1f128 (_Float128 __x) noexcept (true); extern _Float128 __log10p1f128 (_Float128 __x) noexcept (true); + + + extern _Float128 logp1f128 (_Float128 __x) noexcept (true); extern _Float128 __logp1f128 (_Float128 __x) noexcept (true); + + + + + extern _Float128 expm1f128 (_Float128 __x) noexcept (true); extern _Float128 __expm1f128 (_Float128 __x) noexcept (true); + + + extern _Float128 log1pf128 (_Float128 __x) noexcept (true); extern _Float128 __log1pf128 (_Float128 __x) noexcept (true); + + +extern _Float128 logbf128 (_Float128 __x) noexcept (true); extern _Float128 __logbf128 (_Float128 __x) noexcept (true); + + + + + extern _Float128 exp2f128 (_Float128 __x) noexcept (true); extern _Float128 __exp2f128 (_Float128 __x) noexcept (true); + + + extern _Float128 log2f128 (_Float128 __x) noexcept (true); extern _Float128 __log2f128 (_Float128 __x) noexcept (true); + + + + + + + extern _Float128 powf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __powf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float128 sqrtf128 (_Float128 __x) noexcept (true); extern _Float128 __sqrtf128 (_Float128 __x) noexcept (true); + + + + extern _Float128 hypotf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __hypotf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + + + extern _Float128 cbrtf128 (_Float128 __x) noexcept (true); extern _Float128 __cbrtf128 (_Float128 __x) noexcept (true); + + + + + + +extern _Float128 ceilf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fabsf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 floorf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmodf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __fmodf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 231 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float128 copysignf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 nanf128 (const char *__tagb) noexcept (true); extern _Float128 __nanf128 (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float128 j0f128 (_Float128) noexcept (true); extern _Float128 __j0f128 (_Float128) noexcept (true); +extern _Float128 j1f128 (_Float128) noexcept (true); extern _Float128 __j1f128 (_Float128) noexcept (true); +extern _Float128 jnf128 (int, _Float128) noexcept (true); extern _Float128 __jnf128 (int, _Float128) noexcept (true); +extern _Float128 y0f128 (_Float128) noexcept (true); extern _Float128 __y0f128 (_Float128) noexcept (true); +extern _Float128 y1f128 (_Float128) noexcept (true); extern _Float128 __y1f128 (_Float128) noexcept (true); +extern _Float128 ynf128 (int, _Float128) noexcept (true); extern _Float128 __ynf128 (int, _Float128) noexcept (true); + + + + + + extern _Float128 erff128 (_Float128) noexcept (true); extern _Float128 __erff128 (_Float128) noexcept (true); + extern _Float128 erfcf128 (_Float128) noexcept (true); extern _Float128 __erfcf128 (_Float128) noexcept (true); +extern _Float128 lgammaf128 (_Float128) noexcept (true); extern _Float128 __lgammaf128 (_Float128) noexcept (true); + + + + +extern _Float128 tgammaf128 (_Float128) noexcept (true); extern _Float128 __tgammaf128 (_Float128) noexcept (true); +# 285 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float128 lgammaf128_r (_Float128, int *__signgamp) noexcept (true); extern _Float128 __lgammaf128_r (_Float128, int *__signgamp) noexcept (true); + + + + + + +extern _Float128 rintf128 (_Float128 __x) noexcept (true); extern _Float128 __rintf128 (_Float128 __x) noexcept (true); + + +extern _Float128 nextafterf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __nextafterf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + + + + +extern _Float128 nextdownf128 (_Float128 __x) noexcept (true); extern _Float128 __nextdownf128 (_Float128 __x) noexcept (true); + +extern _Float128 nextupf128 (_Float128 __x) noexcept (true); extern _Float128 __nextupf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 remainderf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __remainderf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + +extern _Float128 scalbnf128 (_Float128 __x, int __n) noexcept (true); extern _Float128 __scalbnf128 (_Float128 __x, int __n) noexcept (true); + + + +extern int ilogbf128 (_Float128 __x) noexcept (true); extern int __ilogbf128 (_Float128 __x) noexcept (true); + + + + +extern long int llogbf128 (_Float128 __x) noexcept (true); extern long int __llogbf128 (_Float128 __x) noexcept (true); + + + + +extern _Float128 scalblnf128 (_Float128 __x, long int __n) noexcept (true); extern _Float128 __scalblnf128 (_Float128 __x, long int __n) noexcept (true); + + + +extern _Float128 nearbyintf128 (_Float128 __x) noexcept (true); extern _Float128 __nearbyintf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 roundf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float128 truncf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 remquof128 (_Float128 __x, _Float128 __y, int *__quo) noexcept (true); extern _Float128 __remquof128 (_Float128 __x, _Float128 __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf128 (_Float128 __x) noexcept (true); extern long int __lrintf128 (_Float128 __x) noexcept (true); +__extension__ +extern long long int llrintf128 (_Float128 __x) noexcept (true); extern long long int __llrintf128 (_Float128 __x) noexcept (true); + + + +extern long int lroundf128 (_Float128 __x) noexcept (true); extern long int __lroundf128 (_Float128 __x) noexcept (true); +__extension__ +extern long long int llroundf128 (_Float128 __x) noexcept (true); extern long long int __llroundf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 fdimf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __fdimf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + +extern _Float128 fmaxf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float128 fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); extern _Float128 __fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + + + +extern _Float128 roundevenf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef128 (_Float128 *__cx, const _Float128 *__x) noexcept (true); + + + + + + +extern _Float128 fmaxmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 fmaximumf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimumf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmaximum_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmaximum_magf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_magf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmaximum_mag_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_mag_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf128 (const _Float128 *__x, const _Float128 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf128 (const _Float128 *__x, const _Float128 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float128 getpayloadf128 (const _Float128 *__x) noexcept (true); extern _Float128 __getpayloadf128 (const _Float128 *__x) noexcept (true); + + +extern int setpayloadf128 (_Float128 *__x, _Float128 __payload) noexcept (true); + + +extern int setpayloadsigf128 (_Float128 *__x, _Float128 __payload) noexcept (true); +# 454 "/usr/include/math.h" 2 3 4 +# 470 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float32x acosf32x (_Float32x __x) noexcept (true); extern _Float32x __acosf32x (_Float32x __x) noexcept (true); + + extern _Float32x asinf32x (_Float32x __x) noexcept (true); extern _Float32x __asinf32x (_Float32x __x) noexcept (true); + + extern _Float32x atanf32x (_Float32x __x) noexcept (true); extern _Float32x __atanf32x (_Float32x __x) noexcept (true); + + extern _Float32x atan2f32x (_Float32x __y, _Float32x __x) noexcept (true); extern _Float32x __atan2f32x (_Float32x __y, _Float32x __x) noexcept (true); + + + extern _Float32x cosf32x (_Float32x __x) noexcept (true); extern _Float32x __cosf32x (_Float32x __x) noexcept (true); + + extern _Float32x sinf32x (_Float32x __x) noexcept (true); extern _Float32x __sinf32x (_Float32x __x) noexcept (true); + + extern _Float32x tanf32x (_Float32x __x) noexcept (true); extern _Float32x __tanf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x acospif32x (_Float32x __x) noexcept (true); extern _Float32x __acospif32x (_Float32x __x) noexcept (true); + +extern _Float32x asinpif32x (_Float32x __x) noexcept (true); extern _Float32x __asinpif32x (_Float32x __x) noexcept (true); + +extern _Float32x atanpif32x (_Float32x __x) noexcept (true); extern _Float32x __atanpif32x (_Float32x __x) noexcept (true); + +extern _Float32x atan2pif32x (_Float32x __y, _Float32x __x) noexcept (true); extern _Float32x __atan2pif32x (_Float32x __y, _Float32x __x) noexcept (true); + + + extern _Float32x cospif32x (_Float32x __x) noexcept (true); extern _Float32x __cospif32x (_Float32x __x) noexcept (true); + + extern _Float32x sinpif32x (_Float32x __x) noexcept (true); extern _Float32x __sinpif32x (_Float32x __x) noexcept (true); + + extern _Float32x tanpif32x (_Float32x __x) noexcept (true); extern _Float32x __tanpif32x (_Float32x __x) noexcept (true); + + + + + + extern _Float32x coshf32x (_Float32x __x) noexcept (true); extern _Float32x __coshf32x (_Float32x __x) noexcept (true); + + extern _Float32x sinhf32x (_Float32x __x) noexcept (true); extern _Float32x __sinhf32x (_Float32x __x) noexcept (true); + + extern _Float32x tanhf32x (_Float32x __x) noexcept (true); extern _Float32x __tanhf32x (_Float32x __x) noexcept (true); + + + + extern void sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) noexcept (true); extern void __sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) noexcept (true) + ; + + + + + extern _Float32x acoshf32x (_Float32x __x) noexcept (true); extern _Float32x __acoshf32x (_Float32x __x) noexcept (true); + + extern _Float32x asinhf32x (_Float32x __x) noexcept (true); extern _Float32x __asinhf32x (_Float32x __x) noexcept (true); + + extern _Float32x atanhf32x (_Float32x __x) noexcept (true); extern _Float32x __atanhf32x (_Float32x __x) noexcept (true); + + + + + + extern _Float32x expf32x (_Float32x __x) noexcept (true); extern _Float32x __expf32x (_Float32x __x) noexcept (true); + + +extern _Float32x frexpf32x (_Float32x __x, int *__exponent) noexcept (true); extern _Float32x __frexpf32x (_Float32x __x, int *__exponent) noexcept (true); + + +extern _Float32x ldexpf32x (_Float32x __x, int __exponent) noexcept (true); extern _Float32x __ldexpf32x (_Float32x __x, int __exponent) noexcept (true); + + + extern _Float32x logf32x (_Float32x __x) noexcept (true); extern _Float32x __logf32x (_Float32x __x) noexcept (true); + + + extern _Float32x log10f32x (_Float32x __x) noexcept (true); extern _Float32x __log10f32x (_Float32x __x) noexcept (true); + + +extern _Float32x modff32x (_Float32x __x, _Float32x *__iptr) noexcept (true); extern _Float32x __modff32x (_Float32x __x, _Float32x *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float32x exp10f32x (_Float32x __x) noexcept (true); extern _Float32x __exp10f32x (_Float32x __x) noexcept (true); + + +extern _Float32x exp2m1f32x (_Float32x __x) noexcept (true); extern _Float32x __exp2m1f32x (_Float32x __x) noexcept (true); + + +extern _Float32x exp10m1f32x (_Float32x __x) noexcept (true); extern _Float32x __exp10m1f32x (_Float32x __x) noexcept (true); + + +extern _Float32x log2p1f32x (_Float32x __x) noexcept (true); extern _Float32x __log2p1f32x (_Float32x __x) noexcept (true); + + +extern _Float32x log10p1f32x (_Float32x __x) noexcept (true); extern _Float32x __log10p1f32x (_Float32x __x) noexcept (true); + + + extern _Float32x logp1f32x (_Float32x __x) noexcept (true); extern _Float32x __logp1f32x (_Float32x __x) noexcept (true); + + + + + extern _Float32x expm1f32x (_Float32x __x) noexcept (true); extern _Float32x __expm1f32x (_Float32x __x) noexcept (true); + + + extern _Float32x log1pf32x (_Float32x __x) noexcept (true); extern _Float32x __log1pf32x (_Float32x __x) noexcept (true); + + +extern _Float32x logbf32x (_Float32x __x) noexcept (true); extern _Float32x __logbf32x (_Float32x __x) noexcept (true); + + + + + extern _Float32x exp2f32x (_Float32x __x) noexcept (true); extern _Float32x __exp2f32x (_Float32x __x) noexcept (true); + + + extern _Float32x log2f32x (_Float32x __x) noexcept (true); extern _Float32x __log2f32x (_Float32x __x) noexcept (true); + + + + + + + extern _Float32x powf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __powf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32x sqrtf32x (_Float32x __x) noexcept (true); extern _Float32x __sqrtf32x (_Float32x __x) noexcept (true); + + + + extern _Float32x hypotf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __hypotf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + + + extern _Float32x cbrtf32x (_Float32x __x) noexcept (true); extern _Float32x __cbrtf32x (_Float32x __x) noexcept (true); + + + + + + +extern _Float32x ceilf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x floorf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); +# 231 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x nanf32x (const char *__tagb) noexcept (true); extern _Float32x __nanf32x (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32x j0f32x (_Float32x) noexcept (true); extern _Float32x __j0f32x (_Float32x) noexcept (true); +extern _Float32x j1f32x (_Float32x) noexcept (true); extern _Float32x __j1f32x (_Float32x) noexcept (true); +extern _Float32x jnf32x (int, _Float32x) noexcept (true); extern _Float32x __jnf32x (int, _Float32x) noexcept (true); +extern _Float32x y0f32x (_Float32x) noexcept (true); extern _Float32x __y0f32x (_Float32x) noexcept (true); +extern _Float32x y1f32x (_Float32x) noexcept (true); extern _Float32x __y1f32x (_Float32x) noexcept (true); +extern _Float32x ynf32x (int, _Float32x) noexcept (true); extern _Float32x __ynf32x (int, _Float32x) noexcept (true); + + + + + + extern _Float32x erff32x (_Float32x) noexcept (true); extern _Float32x __erff32x (_Float32x) noexcept (true); + extern _Float32x erfcf32x (_Float32x) noexcept (true); extern _Float32x __erfcf32x (_Float32x) noexcept (true); +extern _Float32x lgammaf32x (_Float32x) noexcept (true); extern _Float32x __lgammaf32x (_Float32x) noexcept (true); + + + + +extern _Float32x tgammaf32x (_Float32x) noexcept (true); extern _Float32x __tgammaf32x (_Float32x) noexcept (true); +# 285 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32x lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true); extern _Float32x __lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true); + + + + + + +extern _Float32x rintf32x (_Float32x __x) noexcept (true); extern _Float32x __rintf32x (_Float32x __x) noexcept (true); + + +extern _Float32x nextafterf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __nextafterf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + + + + +extern _Float32x nextdownf32x (_Float32x __x) noexcept (true); extern _Float32x __nextdownf32x (_Float32x __x) noexcept (true); + +extern _Float32x nextupf32x (_Float32x __x) noexcept (true); extern _Float32x __nextupf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x remainderf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __remainderf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + +extern _Float32x scalbnf32x (_Float32x __x, int __n) noexcept (true); extern _Float32x __scalbnf32x (_Float32x __x, int __n) noexcept (true); + + + +extern int ilogbf32x (_Float32x __x) noexcept (true); extern int __ilogbf32x (_Float32x __x) noexcept (true); + + + + +extern long int llogbf32x (_Float32x __x) noexcept (true); extern long int __llogbf32x (_Float32x __x) noexcept (true); + + + + +extern _Float32x scalblnf32x (_Float32x __x, long int __n) noexcept (true); extern _Float32x __scalblnf32x (_Float32x __x, long int __n) noexcept (true); + + + +extern _Float32x nearbyintf32x (_Float32x __x) noexcept (true); extern _Float32x __nearbyintf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x roundf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32x truncf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) noexcept (true); extern _Float32x __remquof32x (_Float32x __x, _Float32x __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf32x (_Float32x __x) noexcept (true); extern long int __lrintf32x (_Float32x __x) noexcept (true); +__extension__ +extern long long int llrintf32x (_Float32x __x) noexcept (true); extern long long int __llrintf32x (_Float32x __x) noexcept (true); + + + +extern long int lroundf32x (_Float32x __x) noexcept (true); extern long int __lroundf32x (_Float32x __x) noexcept (true); +__extension__ +extern long long int llroundf32x (_Float32x __x) noexcept (true); extern long long int __llroundf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x fdimf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fdimf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + +extern _Float32x fmaxf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32x fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); extern _Float32x __fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); + + + + +extern _Float32x roundevenf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef32x (_Float32x *__cx, const _Float32x *__x) noexcept (true); + + + + + + +extern _Float32x fmaxmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x fmaximumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf32x (const _Float32x *__x, const _Float32x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf32x (const _Float32x *__x, const _Float32x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float32x getpayloadf32x (const _Float32x *__x) noexcept (true); extern _Float32x __getpayloadf32x (const _Float32x *__x) noexcept (true); + + +extern int setpayloadf32x (_Float32x *__x, _Float32x __payload) noexcept (true); + + +extern int setpayloadsigf32x (_Float32x *__x, _Float32x __payload) noexcept (true); +# 471 "/usr/include/math.h" 2 3 4 +# 487 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float64x acosf64x (_Float64x __x) noexcept (true); extern _Float64x __acosf64x (_Float64x __x) noexcept (true); + + extern _Float64x asinf64x (_Float64x __x) noexcept (true); extern _Float64x __asinf64x (_Float64x __x) noexcept (true); + + extern _Float64x atanf64x (_Float64x __x) noexcept (true); extern _Float64x __atanf64x (_Float64x __x) noexcept (true); + + extern _Float64x atan2f64x (_Float64x __y, _Float64x __x) noexcept (true); extern _Float64x __atan2f64x (_Float64x __y, _Float64x __x) noexcept (true); + + + extern _Float64x cosf64x (_Float64x __x) noexcept (true); extern _Float64x __cosf64x (_Float64x __x) noexcept (true); + + extern _Float64x sinf64x (_Float64x __x) noexcept (true); extern _Float64x __sinf64x (_Float64x __x) noexcept (true); + + extern _Float64x tanf64x (_Float64x __x) noexcept (true); extern _Float64x __tanf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x acospif64x (_Float64x __x) noexcept (true); extern _Float64x __acospif64x (_Float64x __x) noexcept (true); + +extern _Float64x asinpif64x (_Float64x __x) noexcept (true); extern _Float64x __asinpif64x (_Float64x __x) noexcept (true); + +extern _Float64x atanpif64x (_Float64x __x) noexcept (true); extern _Float64x __atanpif64x (_Float64x __x) noexcept (true); + +extern _Float64x atan2pif64x (_Float64x __y, _Float64x __x) noexcept (true); extern _Float64x __atan2pif64x (_Float64x __y, _Float64x __x) noexcept (true); + + + extern _Float64x cospif64x (_Float64x __x) noexcept (true); extern _Float64x __cospif64x (_Float64x __x) noexcept (true); + + extern _Float64x sinpif64x (_Float64x __x) noexcept (true); extern _Float64x __sinpif64x (_Float64x __x) noexcept (true); + + extern _Float64x tanpif64x (_Float64x __x) noexcept (true); extern _Float64x __tanpif64x (_Float64x __x) noexcept (true); + + + + + + extern _Float64x coshf64x (_Float64x __x) noexcept (true); extern _Float64x __coshf64x (_Float64x __x) noexcept (true); + + extern _Float64x sinhf64x (_Float64x __x) noexcept (true); extern _Float64x __sinhf64x (_Float64x __x) noexcept (true); + + extern _Float64x tanhf64x (_Float64x __x) noexcept (true); extern _Float64x __tanhf64x (_Float64x __x) noexcept (true); + + + + extern void sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) noexcept (true); extern void __sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) noexcept (true) + ; + + + + + extern _Float64x acoshf64x (_Float64x __x) noexcept (true); extern _Float64x __acoshf64x (_Float64x __x) noexcept (true); + + extern _Float64x asinhf64x (_Float64x __x) noexcept (true); extern _Float64x __asinhf64x (_Float64x __x) noexcept (true); + + extern _Float64x atanhf64x (_Float64x __x) noexcept (true); extern _Float64x __atanhf64x (_Float64x __x) noexcept (true); + + + + + + extern _Float64x expf64x (_Float64x __x) noexcept (true); extern _Float64x __expf64x (_Float64x __x) noexcept (true); + + +extern _Float64x frexpf64x (_Float64x __x, int *__exponent) noexcept (true); extern _Float64x __frexpf64x (_Float64x __x, int *__exponent) noexcept (true); + + +extern _Float64x ldexpf64x (_Float64x __x, int __exponent) noexcept (true); extern _Float64x __ldexpf64x (_Float64x __x, int __exponent) noexcept (true); + + + extern _Float64x logf64x (_Float64x __x) noexcept (true); extern _Float64x __logf64x (_Float64x __x) noexcept (true); + + + extern _Float64x log10f64x (_Float64x __x) noexcept (true); extern _Float64x __log10f64x (_Float64x __x) noexcept (true); + + +extern _Float64x modff64x (_Float64x __x, _Float64x *__iptr) noexcept (true); extern _Float64x __modff64x (_Float64x __x, _Float64x *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float64x exp10f64x (_Float64x __x) noexcept (true); extern _Float64x __exp10f64x (_Float64x __x) noexcept (true); + + +extern _Float64x exp2m1f64x (_Float64x __x) noexcept (true); extern _Float64x __exp2m1f64x (_Float64x __x) noexcept (true); + + +extern _Float64x exp10m1f64x (_Float64x __x) noexcept (true); extern _Float64x __exp10m1f64x (_Float64x __x) noexcept (true); + + +extern _Float64x log2p1f64x (_Float64x __x) noexcept (true); extern _Float64x __log2p1f64x (_Float64x __x) noexcept (true); + + +extern _Float64x log10p1f64x (_Float64x __x) noexcept (true); extern _Float64x __log10p1f64x (_Float64x __x) noexcept (true); + + + extern _Float64x logp1f64x (_Float64x __x) noexcept (true); extern _Float64x __logp1f64x (_Float64x __x) noexcept (true); + + + + + extern _Float64x expm1f64x (_Float64x __x) noexcept (true); extern _Float64x __expm1f64x (_Float64x __x) noexcept (true); + + + extern _Float64x log1pf64x (_Float64x __x) noexcept (true); extern _Float64x __log1pf64x (_Float64x __x) noexcept (true); + + +extern _Float64x logbf64x (_Float64x __x) noexcept (true); extern _Float64x __logbf64x (_Float64x __x) noexcept (true); + + + + + extern _Float64x exp2f64x (_Float64x __x) noexcept (true); extern _Float64x __exp2f64x (_Float64x __x) noexcept (true); + + + extern _Float64x log2f64x (_Float64x __x) noexcept (true); extern _Float64x __log2f64x (_Float64x __x) noexcept (true); + + + + + + + extern _Float64x powf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __powf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64x sqrtf64x (_Float64x __x) noexcept (true); extern _Float64x __sqrtf64x (_Float64x __x) noexcept (true); + + + + extern _Float64x hypotf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __hypotf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + + + extern _Float64x cbrtf64x (_Float64x __x) noexcept (true); extern _Float64x __cbrtf64x (_Float64x __x) noexcept (true); + + + + + + +extern _Float64x ceilf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x floorf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 231 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x nanf64x (const char *__tagb) noexcept (true); extern _Float64x __nanf64x (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64x j0f64x (_Float64x) noexcept (true); extern _Float64x __j0f64x (_Float64x) noexcept (true); +extern _Float64x j1f64x (_Float64x) noexcept (true); extern _Float64x __j1f64x (_Float64x) noexcept (true); +extern _Float64x jnf64x (int, _Float64x) noexcept (true); extern _Float64x __jnf64x (int, _Float64x) noexcept (true); +extern _Float64x y0f64x (_Float64x) noexcept (true); extern _Float64x __y0f64x (_Float64x) noexcept (true); +extern _Float64x y1f64x (_Float64x) noexcept (true); extern _Float64x __y1f64x (_Float64x) noexcept (true); +extern _Float64x ynf64x (int, _Float64x) noexcept (true); extern _Float64x __ynf64x (int, _Float64x) noexcept (true); + + + + + + extern _Float64x erff64x (_Float64x) noexcept (true); extern _Float64x __erff64x (_Float64x) noexcept (true); + extern _Float64x erfcf64x (_Float64x) noexcept (true); extern _Float64x __erfcf64x (_Float64x) noexcept (true); +extern _Float64x lgammaf64x (_Float64x) noexcept (true); extern _Float64x __lgammaf64x (_Float64x) noexcept (true); + + + + +extern _Float64x tgammaf64x (_Float64x) noexcept (true); extern _Float64x __tgammaf64x (_Float64x) noexcept (true); +# 285 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64x lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true); extern _Float64x __lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true); + + + + + + +extern _Float64x rintf64x (_Float64x __x) noexcept (true); extern _Float64x __rintf64x (_Float64x __x) noexcept (true); + + +extern _Float64x nextafterf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __nextafterf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + + + + +extern _Float64x nextdownf64x (_Float64x __x) noexcept (true); extern _Float64x __nextdownf64x (_Float64x __x) noexcept (true); + +extern _Float64x nextupf64x (_Float64x __x) noexcept (true); extern _Float64x __nextupf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x remainderf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __remainderf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + +extern _Float64x scalbnf64x (_Float64x __x, int __n) noexcept (true); extern _Float64x __scalbnf64x (_Float64x __x, int __n) noexcept (true); + + + +extern int ilogbf64x (_Float64x __x) noexcept (true); extern int __ilogbf64x (_Float64x __x) noexcept (true); + + + + +extern long int llogbf64x (_Float64x __x) noexcept (true); extern long int __llogbf64x (_Float64x __x) noexcept (true); + + + + +extern _Float64x scalblnf64x (_Float64x __x, long int __n) noexcept (true); extern _Float64x __scalblnf64x (_Float64x __x, long int __n) noexcept (true); + + + +extern _Float64x nearbyintf64x (_Float64x __x) noexcept (true); extern _Float64x __nearbyintf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x roundf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64x truncf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) noexcept (true); extern _Float64x __remquof64x (_Float64x __x, _Float64x __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf64x (_Float64x __x) noexcept (true); extern long int __lrintf64x (_Float64x __x) noexcept (true); +__extension__ +extern long long int llrintf64x (_Float64x __x) noexcept (true); extern long long int __llrintf64x (_Float64x __x) noexcept (true); + + + +extern long int lroundf64x (_Float64x __x) noexcept (true); extern long int __lroundf64x (_Float64x __x) noexcept (true); +__extension__ +extern long long int llroundf64x (_Float64x __x) noexcept (true); extern long long int __llroundf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x fdimf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fdimf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + +extern _Float64x fmaxf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64x fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); extern _Float64x __fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + + + +extern _Float64x roundevenf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef64x (_Float64x *__cx, const _Float64x *__x) noexcept (true); + + + + + + +extern _Float64x fmaxmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x fmaximumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf64x (const _Float64x *__x, const _Float64x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf64x (const _Float64x *__x, const _Float64x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float64x getpayloadf64x (const _Float64x *__x) noexcept (true); extern _Float64x __getpayloadf64x (const _Float64x *__x) noexcept (true); + + +extern int setpayloadf64x (_Float64x *__x, _Float64x __payload) noexcept (true); + + +extern int setpayloadsigf64x (_Float64x *__x, _Float64x __payload) noexcept (true); +# 488 "/usr/include/math.h" 2 3 4 +# 535 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern float fadd (double __x, double __y) noexcept (true); + + +extern float fdiv (double __x, double __y) noexcept (true); + + +extern float ffma (double __x, double __y, double __z) noexcept (true); + + +extern float fmul (double __x, double __y) noexcept (true); + + +extern float fsqrt (double __x) noexcept (true); + + +extern float fsub (double __x, double __y) noexcept (true); +# 536 "/usr/include/math.h" 2 3 4 +# 556 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern float faddl (long double __x, long double __y) noexcept (true); + + +extern float fdivl (long double __x, long double __y) noexcept (true); + + +extern float ffmal (long double __x, long double __y, long double __z) noexcept (true); + + +extern float fmull (long double __x, long double __y) noexcept (true); + + +extern float fsqrtl (long double __x) noexcept (true); + + +extern float fsubl (long double __x, long double __y) noexcept (true); +# 557 "/usr/include/math.h" 2 3 4 +# 585 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern double daddl (long double __x, long double __y) noexcept (true); + + +extern double ddivl (long double __x, long double __y) noexcept (true); + + +extern double dfmal (long double __x, long double __y, long double __z) noexcept (true); + + +extern double dmull (long double __x, long double __y) noexcept (true); + + +extern double dsqrtl (long double __x) noexcept (true); + + +extern double dsubl (long double __x, long double __y) noexcept (true); +# 586 "/usr/include/math.h" 2 3 4 +# 666 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32divf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); + + +extern _Float32 f32mulf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32sqrtf32x (_Float32x __x) noexcept (true); + + +extern _Float32 f32subf32x (_Float32x __x, _Float32x __y) noexcept (true); +# 667 "/usr/include/math.h" 2 3 4 +# 676 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32divf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); + + +extern _Float32 f32mulf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32sqrtf64 (_Float64 __x) noexcept (true); + + +extern _Float32 f32subf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 677 "/usr/include/math.h" 2 3 4 +# 686 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32divf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + +extern _Float32 f32mulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32sqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float32 f32subf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 687 "/usr/include/math.h" 2 3 4 +# 696 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32divf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float32 f32mulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32sqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float32 f32subf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 697 "/usr/include/math.h" 2 3 4 +# 716 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xdivf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xfmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); + + +extern _Float32x f32xmulf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xsqrtf64 (_Float64 __x) noexcept (true); + + +extern _Float32x f32xsubf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 717 "/usr/include/math.h" 2 3 4 +# 726 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xdivf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xfmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + +extern _Float32x f32xmulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xsqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float32x f32xsubf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 727 "/usr/include/math.h" 2 3 4 +# 736 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xdivf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xfmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float32x f32xmulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xsqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float32x f32xsubf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 737 "/usr/include/math.h" 2 3 4 +# 756 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float64 f64addf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64divf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + +extern _Float64 f64mulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64sqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float64 f64subf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 757 "/usr/include/math.h" 2 3 4 +# 766 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float64 f64addf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64divf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float64 f64mulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64sqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float64 f64subf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 767 "/usr/include/math.h" 2 3 4 +# 786 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float64x f64xaddf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xdivf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xfmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float64x f64xmulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xsqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float64x f64xsubf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 787 "/usr/include/math.h" 2 3 4 +# 823 "/usr/include/math.h" 3 4 +extern int signgam; +# 903 "/usr/include/math.h" 3 4 +enum + { + FP_NAN = + + 0, + FP_INFINITE = + + 1, + FP_ZERO = + + 2, + FP_SUBNORMAL = + + 3, + FP_NORMAL = + + 4 + }; +# 1024 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/iscanonical.h" 1 3 4 +# 23 "/usr/include/bits/iscanonical.h" 3 4 +extern int __iscanonicall (long double __x) + noexcept (true) __attribute__ ((__const__)); +# 46 "/usr/include/bits/iscanonical.h" 3 4 +extern "C++" { +inline int iscanonical (float __val) { return ((void) (__typeof (__val)) (__val), 1); } +inline int iscanonical (double __val) { return ((void) (__typeof (__val)) (__val), 1); } +inline int iscanonical (long double __val) { return __iscanonicall (__val); } + +inline int iscanonical (_Float128 __val) { return ((void) (__typeof (__val)) (__val), 1); } + +} +# 1025 "/usr/include/math.h" 2 3 4 +# 1036 "/usr/include/math.h" 3 4 +extern "C++" { +inline int issignaling (float __val) { return __issignalingf (__val); } +inline int issignaling (double __val) { return __issignaling (__val); } +inline int +issignaling (long double __val) +{ + + + + return __issignalingl (__val); + +} + + + +inline int issignaling (_Float128 __val) { return __issignalingf128 (__val); } + +} +# 1067 "/usr/include/math.h" 3 4 +extern "C++" { +# 1098 "/usr/include/math.h" 3 4 +template inline bool +iszero (__T __val) +{ + return __val == 0; +} + +} +# 1333 "/usr/include/math.h" 3 4 +extern "C++" { +template struct __iseqsig_type; + +template<> struct __iseqsig_type +{ + static int __call (float __x, float __y) throw () + { + return __iseqsigf (__x, __y); + } +}; + +template<> struct __iseqsig_type +{ + static int __call (double __x, double __y) throw () + { + return __iseqsig (__x, __y); + } +}; + +template<> struct __iseqsig_type +{ + static int __call (long double __x, long double __y) throw () + { + + return __iseqsigl (__x, __y); + + + + } +}; + + +template<> struct __iseqsig_type<_Float32> +{ + static int __call (_Float32 __x, _Float32 __y) throw () + { + return __iseqsigf (__x, __y); + } +}; + + + +template<> struct __iseqsig_type<_Float64> +{ + static int __call (_Float64 __x, _Float64 __y) throw () + { + return __iseqsig (__x, __y); + } +}; + + + + + +template<> struct __iseqsig_type<_Float128> +{ + static int __call (_Float128 __x, _Float128 __y) throw () + { + + return __iseqsigf128 (__x, __y); + + + + } +}; + + + +template<> struct __iseqsig_type<_Float32x> +{ + static int __call (_Float32x __x, _Float32x __y) throw () + { + return __iseqsig (__x, __y); + } +}; + + + +template<> struct __iseqsig_type<_Float64x> +{ + static int __call (_Float64x __x, _Float64x __y) throw () + { + + return __iseqsigl (__x, __y); + + + + } +}; + + +template +inline int +iseqsig (_T1 __x, _T2 __y) throw () +{ + + typedef decltype (((__x) + (__y) + 0.0f)) _T3; + + + + return __iseqsig_type<_T3>::__call (__x, __y); +} + +} + + + + +} +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 +# 56 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 +# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::acos; + + + inline constexpr float + acos(float __x) + { return __builtin_acosf(__x); } + + inline constexpr long double + acos(long double __x) + { return __builtin_acosl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acos(_Tp __x) + { return __builtin_acos(__x); } + + using ::asin; + + + inline constexpr float + asin(float __x) + { return __builtin_asinf(__x); } + + inline constexpr long double + asin(long double __x) + { return __builtin_asinl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asin(_Tp __x) + { return __builtin_asin(__x); } + + using ::atan; + + + inline constexpr float + atan(float __x) + { return __builtin_atanf(__x); } + + inline constexpr long double + atan(long double __x) + { return __builtin_atanl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atan(_Tp __x) + { return __builtin_atan(__x); } + + using ::atan2; + + + inline constexpr float + atan2(float __y, float __x) + { return __builtin_atan2f(__y, __x); } + + inline constexpr long double + atan2(long double __y, long double __x) + { return __builtin_atan2l(__y, __x); } + + + using ::ceil; + + + inline constexpr float + ceil(float __x) + { return __builtin_ceilf(__x); } + + inline constexpr long double + ceil(long double __x) + { return __builtin_ceill(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ceil(_Tp __x) + { return __builtin_ceil(__x); } + + using ::cos; + + + inline constexpr float + cos(float __x) + { return __builtin_cosf(__x); } + + inline constexpr long double + cos(long double __x) + { return __builtin_cosl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cos(_Tp __x) + { return __builtin_cos(__x); } + + using ::cosh; + + + inline constexpr float + cosh(float __x) + { return __builtin_coshf(__x); } + + inline constexpr long double + cosh(long double __x) + { return __builtin_coshl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cosh(_Tp __x) + { return __builtin_cosh(__x); } + + using ::exp; + + + inline constexpr float + exp(float __x) + { return __builtin_expf(__x); } + + inline constexpr long double + exp(long double __x) + { return __builtin_expl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp(_Tp __x) + { return __builtin_exp(__x); } + + using ::fabs; + + + inline constexpr float + fabs(float __x) + { return __builtin_fabsf(__x); } + + inline constexpr long double + fabs(long double __x) + { return __builtin_fabsl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + fabs(_Tp __x) + { return __builtin_fabs(__x); } + + using ::floor; + + + inline constexpr float + floor(float __x) + { return __builtin_floorf(__x); } + + inline constexpr long double + floor(long double __x) + { return __builtin_floorl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + floor(_Tp __x) + { return __builtin_floor(__x); } + + using ::fmod; + + + inline constexpr float + fmod(float __x, float __y) + { return __builtin_fmodf(__x, __y); } + + inline constexpr long double + fmod(long double __x, long double __y) + { return __builtin_fmodl(__x, __y); } + + + using ::frexp; + + + inline float + frexp(float __x, int* __exp) + { return __builtin_frexpf(__x, __exp); } + + inline long double + frexp(long double __x, int* __exp) + { return __builtin_frexpl(__x, __exp); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + frexp(_Tp __x, int* __exp) + { return __builtin_frexp(__x, __exp); } + + using ::ldexp; + + + inline constexpr float + ldexp(float __x, int __exp) + { return __builtin_ldexpf(__x, __exp); } + + inline constexpr long double + ldexp(long double __x, int __exp) + { return __builtin_ldexpl(__x, __exp); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ldexp(_Tp __x, int __exp) + { return __builtin_ldexp(__x, __exp); } + + using ::log; + + + inline constexpr float + log(float __x) + { return __builtin_logf(__x); } + + inline constexpr long double + log(long double __x) + { return __builtin_logl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log(_Tp __x) + { return __builtin_log(__x); } + + using ::log10; + + + inline constexpr float + log10(float __x) + { return __builtin_log10f(__x); } + + inline constexpr long double + log10(long double __x) + { return __builtin_log10l(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log10(_Tp __x) + { return __builtin_log10(__x); } + + using ::modf; + + + inline float + modf(float __x, float* __iptr) + { return __builtin_modff(__x, __iptr); } + + inline long double + modf(long double __x, long double* __iptr) + { return __builtin_modfl(__x, __iptr); } + + + using ::pow; + + + inline constexpr float + pow(float __x, float __y) + { return __builtin_powf(__x, __y); } + + inline constexpr long double + pow(long double __x, long double __y) + { return __builtin_powl(__x, __y); } +# 400 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + using ::sin; + + + inline constexpr float + sin(float __x) + { return __builtin_sinf(__x); } + + inline constexpr long double + sin(long double __x) + { return __builtin_sinl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sin(_Tp __x) + { return __builtin_sin(__x); } + + using ::sinh; + + + inline constexpr float + sinh(float __x) + { return __builtin_sinhf(__x); } + + inline constexpr long double + sinh(long double __x) + { return __builtin_sinhl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sinh(_Tp __x) + { return __builtin_sinh(__x); } + + using ::sqrt; + + + inline constexpr float + sqrt(float __x) + { return __builtin_sqrtf(__x); } + + inline constexpr long double + sqrt(long double __x) + { return __builtin_sqrtl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sqrt(_Tp __x) + { return __builtin_sqrt(__x); } + + using ::tan; + + + inline constexpr float + tan(float __x) + { return __builtin_tanf(__x); } + + inline constexpr long double + tan(long double __x) + { return __builtin_tanl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tan(_Tp __x) + { return __builtin_tan(__x); } + + using ::tanh; + + + inline constexpr float + tanh(float __x) + { return __builtin_tanhf(__x); } + + inline constexpr long double + tanh(long double __x) + { return __builtin_tanhl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tanh(_Tp __x) + { return __builtin_tanh(__x); } +# 1053 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + atan2(_Tp __y, _Up __x) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return atan2(__type(__y), __type(__x)); + } + + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmod(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmod(__type(__x), __type(__y)); + } + + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + pow(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return pow(__type(__x), __type(__y)); + } +# 1100 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + constexpr int + fpclassify(float __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + constexpr int + fpclassify(double __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + constexpr int + fpclassify(long double __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + int>::__type + fpclassify(_Tp __x) + { return __x != 0 ? 4 : 2; } + + + + constexpr bool + isfinite(float __x) + { return __builtin_isfinite(__x); } + + constexpr bool + isfinite(double __x) + { return __builtin_isfinite(__x); } + + constexpr bool + isfinite(long double __x) + { return __builtin_isfinite(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isfinite(_Tp) + { return true; } + + + + constexpr bool + isinf(float __x) + { return __builtin_isinf(__x); } + + + + + + constexpr bool + isinf(double __x) + { return __builtin_isinf(__x); } + + + constexpr bool + isinf(long double __x) + { return __builtin_isinf(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isinf(_Tp) + { return false; } + + + + constexpr bool + isnan(float __x) + { return __builtin_isnan(__x); } + + + + + + constexpr bool + isnan(double __x) + { return __builtin_isnan(__x); } + + + constexpr bool + isnan(long double __x) + { return __builtin_isnan(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isnan(_Tp) + { return false; } + + + + constexpr bool + isnormal(float __x) + { return __builtin_isnormal(__x); } + + constexpr bool + isnormal(double __x) + { return __builtin_isnormal(__x); } + + constexpr bool + isnormal(long double __x) + { return __builtin_isnormal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isnormal(_Tp __x) + { return __x != 0 ? true : false; } + + + + + constexpr bool + signbit(float __x) + { return __builtin_signbit(__x); } + + constexpr bool + signbit(double __x) + { return __builtin_signbit(__x); } + + constexpr bool + signbit(long double __x) + { return __builtin_signbit(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + signbit(_Tp __x) + { return __x < 0 ? true : false; } + + + + constexpr bool + isgreater(float __x, float __y) + { return __builtin_isgreater(__x, __y); } + + constexpr bool + isgreater(double __x, double __y) + { return __builtin_isgreater(__x, __y); } + + constexpr bool + isgreater(long double __x, long double __y) + { return __builtin_isgreater(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isgreater(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isgreater(__type(__x), __type(__y)); + } + + + + constexpr bool + isgreaterequal(float __x, float __y) + { return __builtin_isgreaterequal(__x, __y); } + + constexpr bool + isgreaterequal(double __x, double __y) + { return __builtin_isgreaterequal(__x, __y); } + + constexpr bool + isgreaterequal(long double __x, long double __y) + { return __builtin_isgreaterequal(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isgreaterequal(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isgreaterequal(__type(__x), __type(__y)); + } + + + + constexpr bool + isless(float __x, float __y) + { return __builtin_isless(__x, __y); } + + constexpr bool + isless(double __x, double __y) + { return __builtin_isless(__x, __y); } + + constexpr bool + isless(long double __x, long double __y) + { return __builtin_isless(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isless(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isless(__type(__x), __type(__y)); + } + + + + constexpr bool + islessequal(float __x, float __y) + { return __builtin_islessequal(__x, __y); } + + constexpr bool + islessequal(double __x, double __y) + { return __builtin_islessequal(__x, __y); } + + constexpr bool + islessequal(long double __x, long double __y) + { return __builtin_islessequal(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + islessequal(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_islessequal(__type(__x), __type(__y)); + } + + + + constexpr bool + islessgreater(float __x, float __y) + { return __builtin_islessgreater(__x, __y); } + + constexpr bool + islessgreater(double __x, double __y) + { return __builtin_islessgreater(__x, __y); } + + constexpr bool + islessgreater(long double __x, long double __y) + { return __builtin_islessgreater(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + islessgreater(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_islessgreater(__type(__x), __type(__y)); + } + + + + constexpr bool + isunordered(float __x, float __y) + { return __builtin_isunordered(__x, __y); } + + constexpr bool + isunordered(double __x, double __y) + { return __builtin_isunordered(__x, __y); } + + constexpr bool + isunordered(long double __x, long double __y) + { return __builtin_isunordered(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isunordered(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isunordered(__type(__x), __type(__y)); + } +# 1820 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + using ::acosf; + + + using ::acosl; + + + + using ::asinf; + + + using ::asinl; + + + + using ::atanf; + + + using ::atanl; + + + + using ::atan2f; + + + using ::atan2l; + + + + using ::ceilf; + + + using ::ceill; + + + + using ::cosf; + + + using ::cosl; + + + + using ::coshf; + + + using ::coshl; + + + + using ::expf; + + + using ::expl; + + + + using ::fabsf; + + + using ::fabsl; + + + + using ::floorf; + + + using ::floorl; + + + + using ::fmodf; + + + using ::fmodl; + + + + using ::frexpf; + + + using ::frexpl; + + + + using ::ldexpf; + + + using ::ldexpl; + + + + using ::logf; + + + using ::logl; + + + + using ::log10f; + + + using ::log10l; + + + + using ::modff; + + + using ::modfl; + + + + using ::powf; + + + using ::powl; + + + + using ::sinf; + + + using ::sinl; + + + + using ::sinhf; + + + using ::sinhl; + + + + using ::sqrtf; + + + using ::sqrtl; + + + + using ::tanf; + + + using ::tanl; + + + + using ::tanhf; + + + using ::tanhl; +# 2085 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + using ::double_t; + using ::float_t; + + + + using ::acosh; + using ::acoshf; + using ::acoshl; + + using ::asinh; + using ::asinhf; + using ::asinhl; + + using ::atanh; + using ::atanhf; + using ::atanhl; + + using ::cbrt; + using ::cbrtf; + using ::cbrtl; + + using ::copysign; + using ::copysignf; + using ::copysignl; + + using ::erf; + using ::erff; + using ::erfl; + + using ::erfc; + using ::erfcf; + using ::erfcl; + + using ::exp2; + using ::exp2f; + using ::exp2l; + + using ::expm1; + using ::expm1f; + using ::expm1l; + + using ::fdim; + using ::fdimf; + using ::fdiml; + + using ::fma; + using ::fmaf; + using ::fmal; + + using ::fmax; + using ::fmaxf; + using ::fmaxl; + + using ::fmin; + using ::fminf; + using ::fminl; + + using ::hypot; + using ::hypotf; + using ::hypotl; + + using ::ilogb; + using ::ilogbf; + using ::ilogbl; + + using ::lgamma; + using ::lgammaf; + using ::lgammal; + + + using ::llrint; + using ::llrintf; + using ::llrintl; + + using ::llround; + using ::llroundf; + using ::llroundl; + + + using ::log1p; + using ::log1pf; + using ::log1pl; + + using ::log2; + using ::log2f; + using ::log2l; + + using ::logb; + using ::logbf; + using ::logbl; + + using ::lrint; + using ::lrintf; + using ::lrintl; + + using ::lround; + using ::lroundf; + using ::lroundl; + + using ::nan; + using ::nanf; + using ::nanl; + + using ::nearbyint; + using ::nearbyintf; + using ::nearbyintl; + + using ::nextafter; + using ::nextafterf; + using ::nextafterl; + + using ::nexttoward; + using ::nexttowardf; + using ::nexttowardl; + + using ::remainder; + using ::remainderf; + using ::remainderl; + + using ::remquo; + using ::remquof; + using ::remquol; + + using ::rint; + using ::rintf; + using ::rintl; + + using ::round; + using ::roundf; + using ::roundl; + + using ::scalbln; + using ::scalblnf; + using ::scalblnl; + + using ::scalbn; + using ::scalbnf; + using ::scalbnl; + + using ::tgamma; + using ::tgammaf; + using ::tgammal; + + using ::trunc; + using ::truncf; + using ::truncl; + + + + constexpr float + acosh(float __x) + { return __builtin_acoshf(__x); } + + constexpr long double + acosh(long double __x) + { return __builtin_acoshl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acosh(_Tp __x) + { return __builtin_acosh(__x); } + + + + constexpr float + asinh(float __x) + { return __builtin_asinhf(__x); } + + constexpr long double + asinh(long double __x) + { return __builtin_asinhl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asinh(_Tp __x) + { return __builtin_asinh(__x); } + + + + constexpr float + atanh(float __x) + { return __builtin_atanhf(__x); } + + constexpr long double + atanh(long double __x) + { return __builtin_atanhl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atanh(_Tp __x) + { return __builtin_atanh(__x); } + + + + constexpr float + cbrt(float __x) + { return __builtin_cbrtf(__x); } + + constexpr long double + cbrt(long double __x) + { return __builtin_cbrtl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cbrt(_Tp __x) + { return __builtin_cbrt(__x); } + + + + constexpr float + copysign(float __x, float __y) + { return __builtin_copysignf(__x, __y); } + + constexpr long double + copysign(long double __x, long double __y) + { return __builtin_copysignl(__x, __y); } + + + + constexpr float + erf(float __x) + { return __builtin_erff(__x); } + + constexpr long double + erf(long double __x) + { return __builtin_erfl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erf(_Tp __x) + { return __builtin_erf(__x); } + + + + constexpr float + erfc(float __x) + { return __builtin_erfcf(__x); } + + constexpr long double + erfc(long double __x) + { return __builtin_erfcl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erfc(_Tp __x) + { return __builtin_erfc(__x); } + + + + constexpr float + exp2(float __x) + { return __builtin_exp2f(__x); } + + constexpr long double + exp2(long double __x) + { return __builtin_exp2l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp2(_Tp __x) + { return __builtin_exp2(__x); } + + + + constexpr float + expm1(float __x) + { return __builtin_expm1f(__x); } + + constexpr long double + expm1(long double __x) + { return __builtin_expm1l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + expm1(_Tp __x) + { return __builtin_expm1(__x); } + + + + constexpr float + fdim(float __x, float __y) + { return __builtin_fdimf(__x, __y); } + + constexpr long double + fdim(long double __x, long double __y) + { return __builtin_fdiml(__x, __y); } + + + + constexpr float + fma(float __x, float __y, float __z) + { return __builtin_fmaf(__x, __y, __z); } + + constexpr long double + fma(long double __x, long double __y, long double __z) + { return __builtin_fmal(__x, __y, __z); } + + + + constexpr float + fmax(float __x, float __y) + { return __builtin_fmaxf(__x, __y); } + + constexpr long double + fmax(long double __x, long double __y) + { return __builtin_fmaxl(__x, __y); } + + + + constexpr float + fmin(float __x, float __y) + { return __builtin_fminf(__x, __y); } + + constexpr long double + fmin(long double __x, long double __y) + { return __builtin_fminl(__x, __y); } + + + + constexpr float + hypot(float __x, float __y) + { return __builtin_hypotf(__x, __y); } + + constexpr long double + hypot(long double __x, long double __y) + { return __builtin_hypotl(__x, __y); } + + + + constexpr int + ilogb(float __x) + { return __builtin_ilogbf(__x); } + + constexpr int + ilogb(long double __x) + { return __builtin_ilogbl(__x); } + + + + template + constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + int>::__type + ilogb(_Tp __x) + { return __builtin_ilogb(__x); } + + + + constexpr float + lgamma(float __x) + { return __builtin_lgammaf(__x); } + + constexpr long double + lgamma(long double __x) + { return __builtin_lgammal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + lgamma(_Tp __x) + { return __builtin_lgamma(__x); } + + + + constexpr long long + llrint(float __x) + { return __builtin_llrintf(__x); } + + constexpr long long + llrint(long double __x) + { return __builtin_llrintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llrint(_Tp __x) + { return __builtin_llrint(__x); } + + + + constexpr long long + llround(float __x) + { return __builtin_llroundf(__x); } + + constexpr long long + llround(long double __x) + { return __builtin_llroundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llround(_Tp __x) + { return __builtin_llround(__x); } + + + + constexpr float + log1p(float __x) + { return __builtin_log1pf(__x); } + + constexpr long double + log1p(long double __x) + { return __builtin_log1pl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log1p(_Tp __x) + { return __builtin_log1p(__x); } + + + + + constexpr float + log2(float __x) + { return __builtin_log2f(__x); } + + constexpr long double + log2(long double __x) + { return __builtin_log2l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log2(_Tp __x) + { return __builtin_log2(__x); } + + + + constexpr float + logb(float __x) + { return __builtin_logbf(__x); } + + constexpr long double + logb(long double __x) + { return __builtin_logbl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + logb(_Tp __x) + { return __builtin_logb(__x); } + + + + constexpr long + lrint(float __x) + { return __builtin_lrintf(__x); } + + constexpr long + lrint(long double __x) + { return __builtin_lrintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lrint(_Tp __x) + { return __builtin_lrint(__x); } + + + + constexpr long + lround(float __x) + { return __builtin_lroundf(__x); } + + constexpr long + lround(long double __x) + { return __builtin_lroundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lround(_Tp __x) + { return __builtin_lround(__x); } + + + + constexpr float + nearbyint(float __x) + { return __builtin_nearbyintf(__x); } + + constexpr long double + nearbyint(long double __x) + { return __builtin_nearbyintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nearbyint(_Tp __x) + { return __builtin_nearbyint(__x); } + + + + constexpr float + nextafter(float __x, float __y) + { return __builtin_nextafterf(__x, __y); } + + constexpr long double + nextafter(long double __x, long double __y) + { return __builtin_nextafterl(__x, __y); } + + + + constexpr float + nexttoward(float __x, long double __y) + { return __builtin_nexttowardf(__x, __y); } + + constexpr long double + nexttoward(long double __x, long double __y) + { return __builtin_nexttowardl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nexttoward(_Tp __x, long double __y) + { return __builtin_nexttoward(__x, __y); } + + + + constexpr float + remainder(float __x, float __y) + { return __builtin_remainderf(__x, __y); } + + constexpr long double + remainder(long double __x, long double __y) + { return __builtin_remainderl(__x, __y); } + + + + inline float + remquo(float __x, float __y, int* __pquo) + { return __builtin_remquof(__x, __y, __pquo); } + + inline long double + remquo(long double __x, long double __y, int* __pquo) + { return __builtin_remquol(__x, __y, __pquo); } + + + + constexpr float + rint(float __x) + { return __builtin_rintf(__x); } + + constexpr long double + rint(long double __x) + { return __builtin_rintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + rint(_Tp __x) + { return __builtin_rint(__x); } + + + + constexpr float + round(float __x) + { return __builtin_roundf(__x); } + + constexpr long double + round(long double __x) + { return __builtin_roundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + round(_Tp __x) + { return __builtin_round(__x); } + + + + constexpr float + scalbln(float __x, long __ex) + { return __builtin_scalblnf(__x, __ex); } + + constexpr long double + scalbln(long double __x, long __ex) + { return __builtin_scalblnl(__x, __ex); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbln(_Tp __x, long __ex) + { return __builtin_scalbln(__x, __ex); } + + + + constexpr float + scalbn(float __x, int __ex) + { return __builtin_scalbnf(__x, __ex); } + + constexpr long double + scalbn(long double __x, int __ex) + { return __builtin_scalbnl(__x, __ex); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbn(_Tp __x, int __ex) + { return __builtin_scalbn(__x, __ex); } + + + + constexpr float + tgamma(float __x) + { return __builtin_tgammaf(__x); } + + constexpr long double + tgamma(long double __x) + { return __builtin_tgammal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tgamma(_Tp __x) + { return __builtin_tgamma(__x); } + + + + constexpr float + trunc(float __x) + { return __builtin_truncf(__x); } + + constexpr long double + trunc(long double __x) + { return __builtin_truncl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + trunc(_Tp __x) + { return __builtin_trunc(__x); } +# 3682 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + copysign(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return copysign(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fdim(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fdim(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmax(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmax(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmin(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmin(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + hypot(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return hypot(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + nextafter(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return nextafter(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remainder(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remainder(__type(__x), __type(__y)); + } + + template + inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remquo(_Tp __x, _Up __y, int* __pquo) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remquo(__type(__x), __type(__y), __pquo); + } + + template + constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type + fma(_Tp __x, _Up __y, _Vp __z) + { + typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; + return fma(__type(__x), __type(__y), __type(__z)); + } + + + + + + + + template + inline _Tp + __hypot3(_Tp __x, _Tp __y, _Tp __z) + { + __x = std::abs(__x); + __y = std::abs(__y); + __z = std::abs(__z); + if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x) + return __a * std::sqrt((__x / __a) * (__x / __a) + + (__y / __a) * (__y / __a) + + (__z / __a) * (__z / __a)); + else + return {}; + } + + inline float + hypot(float __x, float __y, float __z) + { return std::__hypot3(__x, __y, __z); } + + inline double + hypot(double __x, double __y, double __z) + { return std::__hypot3(__x, __y, __z); } + + inline long double + hypot(long double __x, long double __y, long double __z) + { return std::__hypot3(__x, __y, __z); } + + template + __gnu_cxx::__promoted_t<_Tp, _Up, _Vp> + hypot(_Tp __x, _Up __y, _Vp __z) + { + using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>; + return std::__hypot3<__type>(__x, __y, __z); + } +# 3902 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + +} + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 1 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 1 3 +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h" 1 3 +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/exception_defines.h" 1 3 +# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + void + __throw_bad_exception(void) __attribute__((__noreturn__)); + + + void + __throw_bad_alloc(void) __attribute__((__noreturn__)); + + void + __throw_bad_array_new_length(void) __attribute__((__noreturn__)); + + + void + __throw_bad_cast(void) __attribute__((__noreturn__,__cold__)); + + void + __throw_bad_typeid(void) __attribute__((__noreturn__,__cold__)); + + + void + __throw_logic_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_domain_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_invalid_argument(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_length_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_out_of_range(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__,__cold__)) + __attribute__((__format__(__gnu_printf__, 1, 2))); + + void + __throw_runtime_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_range_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_overflow_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_underflow_error(const char*) __attribute__((__noreturn__,__cold__)); + + + void + __throw_ios_failure(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_ios_failure(const char*, int) __attribute__((__noreturn__,__cold__)); + + + void + __throw_system_error(int) __attribute__((__noreturn__,__cold__)); + + + void + __throw_future_error(int) __attribute__((__noreturn__,__cold__)); + + + void + __throw_bad_function_call() __attribute__((__noreturn__,__cold__)); +# 140 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h" 3 + +} +# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + template + struct __is_integer_nonstrict + : public std::__is_integer<_Tp> + { + using std::__is_integer<_Tp>::__value; + + + enum { __width = __value ? sizeof(_Tp) * 8 : 0 }; + }; + + template + struct __numeric_traits_integer + { + + static_assert(__is_integer_nonstrict<_Value>::__value, + "invalid specialization"); + + + + + static const bool __is_signed = (_Value)(-1) < 0; + static const int __digits + = __is_integer_nonstrict<_Value>::__width - __is_signed; + + + static const _Value __max = __is_signed + ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1) + : ~(_Value)0; + static const _Value __min = __is_signed ? -__max - 1 : (_Value)0; + }; + + template + const _Value __numeric_traits_integer<_Value>::__min; + + template + const _Value __numeric_traits_integer<_Value>::__max; + + template + const bool __numeric_traits_integer<_Value>::__is_signed; + + template + const int __numeric_traits_integer<_Value>::__digits; +# 137 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + template + using __int_traits = __numeric_traits_integer<_Tp>; +# 157 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + template + struct __numeric_traits_floating + { + + static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136); + + + static const bool __is_signed = true; + static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18); + static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932); + }; + + template + const int __numeric_traits_floating<_Value>::__max_digits10; + + template + const bool __numeric_traits_floating<_Value>::__is_signed; + + template + const int __numeric_traits_floating<_Value>::__digits10; + + template + const int __numeric_traits_floating<_Value>::__max_exponent10; + + + + + + + template + struct __numeric_traits + : public __numeric_traits_integer<_Value> + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; +# 238 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + +} +# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 1 3 +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + class reference_wrapper; +# 86 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct integral_constant + { + static constexpr _Tp value = __v; + using value_type = _Tp; + using type = integral_constant<_Tp, __v>; + constexpr operator value_type() const noexcept { return value; } + + + constexpr value_type operator()() const noexcept { return value; } + + }; +# 106 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + using __bool_constant = integral_constant; + + + + using true_type = __bool_constant; + + + using false_type = __bool_constant; + + + + + template + using bool_constant = __bool_constant<__v>; + + + + + + + template + struct enable_if + { }; + + + template + struct enable_if + { using type = _Tp; }; + + + template + using __enable_if_t = typename enable_if<_Cond, _Tp>::type; + + template + struct __conditional + { + template + using type = _Tp; + }; + + template<> + struct __conditional + { + template + using type = _Up; + }; + + + template + using __conditional_t + = typename __conditional<_Cond>::template type<_If, _Else>; + + + template + struct __type_identity + { using type = _Type; }; + + template + using __type_identity_t = typename __type_identity<_Tp>::type; + + namespace __detail + { + + template + using __first_t = _Tp; + + + template + auto __or_fn(int) -> __first_t...>; + + template + auto __or_fn(...) -> true_type; + + template + auto __and_fn(int) -> __first_t...>; + + template + auto __and_fn(...) -> false_type; + } + + + + + template + struct __or_ + : decltype(__detail::__or_fn<_Bn...>(0)) + { }; + + template + struct __and_ + : decltype(__detail::__and_fn<_Bn...>(0)) + { }; + + template + struct __not_ + : __bool_constant + { }; + + + + + + template + inline constexpr bool __or_v = __or_<_Bn...>::value; + template + inline constexpr bool __and_v = __and_<_Bn...>::value; + + namespace __detail + { + template + struct __disjunction_impl + { using type = _B1; }; + + template + struct __disjunction_impl<__enable_if_t, _B1, _B2, _Bn...> + { using type = typename __disjunction_impl::type; }; + + template + struct __conjunction_impl + { using type = _B1; }; + + template + struct __conjunction_impl<__enable_if_t, _B1, _B2, _Bn...> + { using type = typename __conjunction_impl::type; }; + } + + + template + struct conjunction + : __detail::__conjunction_impl::type + { }; + + template<> + struct conjunction<> + : true_type + { }; + + template + struct disjunction + : __detail::__disjunction_impl::type + { }; + + template<> + struct disjunction<> + : false_type + { }; + + template + struct negation + : __not_<_Pp>::type + { }; + + + + + template + inline constexpr bool conjunction_v = conjunction<_Bn...>::value; + + template + inline constexpr bool disjunction_v = disjunction<_Bn...>::value; + + template + inline constexpr bool negation_v = negation<_Pp>::value; + + + + + + template + struct is_reference; + template + struct is_function; + template + struct is_void; + template + struct remove_cv; + template + struct is_const; + + + template + struct __is_array_unknown_bounds; + + + + + template + constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>) + { return {}; } + + template + constexpr typename __or_< + is_reference<_NestedType>, + is_function<_NestedType>, + is_void<_NestedType>, + __is_array_unknown_bounds<_NestedType> + >::type __is_complete_or_unbounded(_TypeIdentity) + { return {}; } + + + template + using __remove_cv_t = typename remove_cv<_Tp>::type; + + + + + + template + struct is_void + : public false_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + + template + struct __is_integral_helper + : public false_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + + + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + __extension__ + template<> + struct __is_integral_helper<__int128> + : public true_type { }; + + __extension__ + template<> + struct __is_integral_helper + : public true_type { }; +# 460 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_integral + : public __is_integral_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct __is_floating_point_helper + : public false_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; +# 513 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template<> + struct __is_floating_point_helper<__float128> + : public true_type { }; + + + + + template + struct is_floating_point + : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type + { }; + + + + template + struct is_array + : public __bool_constant<__is_array(_Tp)> + { }; +# 545 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct __is_pointer_helper + : public false_type { }; + + template + struct __is_pointer_helper<_Tp*> + : public true_type { }; + + + template + struct is_pointer + : public __is_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_lvalue_reference + : public false_type { }; + + template + struct is_lvalue_reference<_Tp&> + : public true_type { }; + + + template + struct is_rvalue_reference + : public false_type { }; + + template + struct is_rvalue_reference<_Tp&&> + : public true_type { }; + + + + template + struct is_member_object_pointer + : public __bool_constant<__is_member_object_pointer(_Tp)> + { }; +# 601 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_member_function_pointer + : public __bool_constant<__is_member_function_pointer(_Tp)> + { }; +# 622 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_enum + : public __bool_constant<__is_enum(_Tp)> + { }; + + + template + struct is_union + : public __bool_constant<__is_union(_Tp)> + { }; + + + template + struct is_class + : public __bool_constant<__is_class(_Tp)> + { }; + + + + template + struct is_function + : public __bool_constant<__is_function(_Tp)> + { }; +# 661 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_null_pointer + : public false_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + + + template + struct __is_nullptr_t + : public is_null_pointer<_Tp> + { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead"))); + + + + + + + template + struct is_reference + : public __bool_constant<__is_reference(_Tp)> + { }; +# 715 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_arithmetic + : public __or_, is_floating_point<_Tp>>::type + { }; + + + template + struct is_fundamental + : public __or_, is_void<_Tp>, + is_null_pointer<_Tp>>::type + { }; + + + + template + struct is_object + : public __bool_constant<__is_object(_Tp)> + { }; +# 741 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_member_pointer; + + + template + struct is_scalar + : public __or_, is_enum<_Tp>, is_pointer<_Tp>, + is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type + { }; + + + template + struct is_compound + : public __bool_constant::value> { }; + + + + template + struct is_member_pointer + : public __bool_constant<__is_member_pointer(_Tp)> + { }; +# 779 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_same; + + + template + using __is_one_of = __or_...>; + + + __extension__ + template + using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, + signed char, signed short, signed int, signed long, + signed long long + + , signed __int128 +# 804 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + >; + + + __extension__ + template + using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>, + unsigned char, unsigned short, unsigned int, unsigned long, + unsigned long long + + , unsigned __int128 +# 824 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + >; + + + template + using __is_standard_integer + = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>; + + + template using __void_t = void; + + + + + + template + struct is_const + : public false_type { }; + + template + struct is_const<_Tp const> + : public true_type { }; + + + template + struct is_volatile + : public false_type { }; + + template + struct is_volatile<_Tp volatile> + : public true_type { }; + + + template + struct is_trivial + : public __bool_constant<__is_trivial(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copyable + : public __bool_constant<__is_trivially_copyable(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_standard_layout + : public __bool_constant<__is_standard_layout(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + template + struct + + is_pod + : public __bool_constant<__is_pod(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct + [[__deprecated__]] + is_literal_type + : public __bool_constant<__is_literal_type(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_empty + : public __bool_constant<__is_empty(_Tp)> + { }; + + + template + struct is_polymorphic + : public __bool_constant<__is_polymorphic(_Tp)> + { }; + + + + + template + struct is_final + : public __bool_constant<__is_final(_Tp)> + { }; + + + + template + struct is_abstract + : public __bool_constant<__is_abstract(_Tp)> + { }; + + + template::value> + struct __is_signed_helper + : public false_type { }; + + template + struct __is_signed_helper<_Tp, true> + : public __bool_constant<_Tp(-1) < _Tp(0)> + { }; + + + + template + struct is_signed + : public __is_signed_helper<_Tp>::type + { }; + + + template + struct is_unsigned + : public __and_, __not_>>::type + { }; + + + template + _Up + __declval(int); + + template + _Tp + __declval(long); + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)); + + template + struct remove_all_extents; + + + template + struct __is_array_known_bounds + : public false_type + { }; + + template + struct __is_array_known_bounds<_Tp[_Size]> + : public true_type + { }; + + template + struct __is_array_unknown_bounds + : public false_type + { }; + + template + struct __is_array_unknown_bounds<_Tp[]> + : public true_type + { }; +# 1006 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + struct __do_is_destructible_impl + { + template().~_Tp())> + static true_type __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_destructible_impl + : public __do_is_destructible_impl + { + using type = decltype(__test<_Tp>(0)); + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_destructible_safe; + + template + struct __is_destructible_safe<_Tp, false, false> + : public __is_destructible_impl::type>::type + { }; + + template + struct __is_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_destructible + : public __is_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + + struct __do_is_nt_destructible_impl + { + template + static __bool_constant().~_Tp())> + __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_nt_destructible_impl + : public __do_is_nt_destructible_impl + { + using type = decltype(__test<_Tp>(0)); + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_nt_destructible_safe; + + template + struct __is_nt_destructible_safe<_Tp, false, false> + : public __is_nt_destructible_impl::type>::type + { }; + + template + struct __is_nt_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_nt_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_nothrow_destructible + : public __is_nt_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_constructible_impl + = __bool_constant<__is_constructible(_Tp, _Args...)>; + + + + template + struct is_constructible + : public __is_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_default_constructible + : public __is_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct __add_lvalue_reference_helper + { using type = _Tp; }; + + template + struct __add_lvalue_reference_helper<_Tp, __void_t<_Tp&>> + { using type = _Tp&; }; + + template + using __add_lval_ref_t = typename __add_lvalue_reference_helper<_Tp>::type; + + + + template + struct is_copy_constructible + : public __is_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct __add_rvalue_reference_helper + { using type = _Tp; }; + + template + struct __add_rvalue_reference_helper<_Tp, __void_t<_Tp&&>> + { using type = _Tp&&; }; + + template + using __add_rval_ref_t = typename __add_rvalue_reference_helper<_Tp>::type; + + + + template + struct is_move_constructible + : public __is_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_constructible_impl + = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>; + + + + template + struct is_nothrow_constructible + : public __is_nothrow_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_default_constructible + : public __is_nothrow_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_copy_constructible + : public __is_nothrow_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_move_constructible + : public __is_nothrow_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_assignable_impl = __bool_constant<__is_assignable(_Tp, _Up)>; + + + + template + struct is_assignable + : public __is_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_copy_assignable + : public __is_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_move_assignable + : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_assignable_impl + = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>; + + + + template + struct is_nothrow_assignable + : public __is_nothrow_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_copy_assignable + : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_move_assignable + : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_trivially_constructible_impl + = __bool_constant<__is_trivially_constructible(_Tp, _Args...)>; + + + + template + struct is_trivially_constructible + : public __is_trivially_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_default_constructible + : public __is_trivially_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; +# 1319 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + struct __do_is_implicitly_default_constructible_impl + { + template + static void __helper(const _Tp&); + + template + static true_type __test(const _Tp&, + decltype(__helper({}))* = 0); + + static false_type __test(...); + }; + + template + struct __is_implicitly_default_constructible_impl + : public __do_is_implicitly_default_constructible_impl + { + using type = decltype(__test(declval<_Tp>())); + }; + + template + struct __is_implicitly_default_constructible_safe + : public __is_implicitly_default_constructible_impl<_Tp>::type + { }; + + template + struct __is_implicitly_default_constructible + : public __and_<__is_constructible_impl<_Tp>, + __is_implicitly_default_constructible_safe<_Tp>>::type + { }; + + + + template + struct is_trivially_copy_constructible + : public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_move_constructible + : public __is_trivially_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_trivially_assignable_impl + = __bool_constant<__is_trivially_assignable(_Tp, _Up)>; + + + + template + struct is_trivially_assignable + : public __is_trivially_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copy_assignable + : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_move_assignable + : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_destructible + : public __and_<__is_destructible_safe<_Tp>, + __bool_constant<__has_trivial_destructor(_Tp)>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + struct has_virtual_destructor + : public __bool_constant<__has_virtual_destructor(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct alignment_of + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct rank + : public integral_constant { }; + + template + struct rank<_Tp[_Size]> + : public integral_constant::value> { }; + + template + struct rank<_Tp[]> + : public integral_constant::value> { }; + + + template + struct extent + : public integral_constant { }; + + template + struct extent<_Tp[_Size], 0> + : public integral_constant { }; + + template + struct extent<_Tp[_Size], _Uint> + : public extent<_Tp, _Uint - 1>::type { }; + + template + struct extent<_Tp[], 0> + : public integral_constant { }; + + template + struct extent<_Tp[], _Uint> + : public extent<_Tp, _Uint - 1>::type { }; + + + + + + + template + struct is_same + : public __bool_constant<__is_same(_Tp, _Up)> + { }; +# 1491 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_base_of + : public __bool_constant<__is_base_of(_Base, _Derived)> + { }; + + + template + struct is_convertible + : public __bool_constant<__is_convertible(_From, _To)> + { }; +# 1540 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + using __is_array_convertible + = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; +# 1600 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++14-extensions" + template + struct __is_nothrow_new_constructible_impl + : __bool_constant< + noexcept(::new(std::declval()) _Tp(std::declval<_Args>()...)) + > + { }; + + template + inline constexpr bool __is_nothrow_new_constructible + = __and_, + __is_nothrow_new_constructible_impl<_Tp, _Args...>>::value; +#pragma GCC diagnostic pop + + + + + template + struct remove_const + { using type = _Tp; }; + + template + struct remove_const<_Tp const> + { using type = _Tp; }; + + + template + struct remove_volatile + { using type = _Tp; }; + + template + struct remove_volatile<_Tp volatile> + { using type = _Tp; }; + + + + template + struct remove_cv + { using type = __remove_cv(_Tp); }; +# 1659 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct add_const + { using type = _Tp const; }; + + + template + struct add_volatile + { using type = _Tp volatile; }; + + + template + struct add_cv + { using type = _Tp const volatile; }; + + + + template + using remove_const_t = typename remove_const<_Tp>::type; + + + template + using remove_volatile_t = typename remove_volatile<_Tp>::type; + + + template + using remove_cv_t = typename remove_cv<_Tp>::type; + + + template + using add_const_t = typename add_const<_Tp>::type; + + + template + using add_volatile_t = typename add_volatile<_Tp>::type; + + + template + using add_cv_t = typename add_cv<_Tp>::type; + + + + + + + template + struct remove_reference + { using type = __remove_reference(_Tp); }; +# 1721 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct add_lvalue_reference + { using type = __add_lval_ref_t<_Tp>; }; + + + template + struct add_rvalue_reference + { using type = __add_rval_ref_t<_Tp>; }; + + + + template + using remove_reference_t = typename remove_reference<_Tp>::type; + + + template + using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; + + + template + using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; + + + + + + + + template + struct __cv_selector; + + template + struct __cv_selector<_Unqualified, false, false> + { using __type = _Unqualified; }; + + template + struct __cv_selector<_Unqualified, false, true> + { using __type = volatile _Unqualified; }; + + template + struct __cv_selector<_Unqualified, true, false> + { using __type = const _Unqualified; }; + + template + struct __cv_selector<_Unqualified, true, true> + { using __type = const volatile _Unqualified; }; + + template::value, + bool _IsVol = is_volatile<_Qualified>::value> + class __match_cv_qualifiers + { + using __match = __cv_selector<_Unqualified, _IsConst, _IsVol>; + + public: + using __type = typename __match::__type; + }; + + + template + struct __make_unsigned + { using __type = _Tp; }; + + template<> + struct __make_unsigned + { using __type = unsigned char; }; + + template<> + struct __make_unsigned + { using __type = unsigned char; }; + + template<> + struct __make_unsigned + { using __type = unsigned short; }; + + template<> + struct __make_unsigned + { using __type = unsigned int; }; + + template<> + struct __make_unsigned + { using __type = unsigned long; }; + + template<> + struct __make_unsigned + { using __type = unsigned long long; }; + + + __extension__ + template<> + struct __make_unsigned<__int128> + { using __type = unsigned __int128; }; +# 1834 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template::value, + bool _IsEnum = __is_enum(_Tp)> + class __make_unsigned_selector; + + template + class __make_unsigned_selector<_Tp, true, false> + { + using __unsigned_type + = typename __make_unsigned<__remove_cv_t<_Tp>>::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + class __make_unsigned_selector_base + { + protected: + template struct _List { }; + + template + struct _List<_Tp, _Up...> : _List<_Up...> + { static constexpr size_t __size = sizeof(_Tp); }; + + template + struct __select; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, true> + { using __type = _Uint; }; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, false> + : __select<_Sz, _List<_UInts...>> + { }; + }; + + + template + class __make_unsigned_selector<_Tp, false, true> + : __make_unsigned_selector_base + { + + using _UInts = _List; + + using __unsigned_type = typename __select::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + + + + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; +# 1908 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + + + + + + template + struct make_unsigned + { using type = typename __make_unsigned_selector<_Tp>::__type; }; + + + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + + + + + template + struct __make_signed + { using __type = _Tp; }; + + template<> + struct __make_signed + { using __type = signed char; }; + + template<> + struct __make_signed + { using __type = signed char; }; + + template<> + struct __make_signed + { using __type = signed short; }; + + template<> + struct __make_signed + { using __type = signed int; }; + + template<> + struct __make_signed + { using __type = signed long; }; + + template<> + struct __make_signed + { using __type = signed long long; }; + + + __extension__ + template<> + struct __make_signed + { using __type = __int128; }; +# 1994 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template::value, + bool _IsEnum = __is_enum(_Tp)> + class __make_signed_selector; + + template + class __make_signed_selector<_Tp, true, false> + { + using __signed_type + = typename __make_signed<__remove_cv_t<_Tp>>::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __signed_type>::__type; + }; + + + template + class __make_signed_selector<_Tp, false, true> + { + using __unsigned_type = typename __make_unsigned_selector<_Tp>::__type; + + public: + using __type = typename __make_signed_selector<__unsigned_type>::__type; + }; + + + + + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; +# 2040 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + + + + + + template + struct make_signed + { using type = typename __make_signed_selector<_Tp>::__type; }; + + + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + + + + template + using make_signed_t = typename make_signed<_Tp>::type; + + + template + using make_unsigned_t = typename make_unsigned<_Tp>::type; + + + + + + template + struct remove_extent + { using type = _Tp; }; + + template + struct remove_extent<_Tp[_Size]> + { using type = _Tp; }; + + template + struct remove_extent<_Tp[]> + { using type = _Tp; }; + + + template + struct remove_all_extents + { using type = _Tp; }; + + template + struct remove_all_extents<_Tp[_Size]> + { using type = typename remove_all_extents<_Tp>::type; }; + + template + struct remove_all_extents<_Tp[]> + { using type = typename remove_all_extents<_Tp>::type; }; + + + + template + using remove_extent_t = typename remove_extent<_Tp>::type; + + + template + using remove_all_extents_t = typename remove_all_extents<_Tp>::type; + + + + + + + template + struct remove_pointer + { using type = __remove_pointer(_Tp); }; +# 2139 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct __add_pointer_helper + { using type = _Tp; }; + + template + struct __add_pointer_helper<_Tp, __void_t<_Tp*>> + { using type = _Tp*; }; + + + template + struct add_pointer + : public __add_pointer_helper<_Tp> + { }; + + template + struct add_pointer<_Tp&> + { using type = _Tp*; }; + + template + struct add_pointer<_Tp&&> + { using type = _Tp*; }; + + + + template + using remove_pointer_t = typename remove_pointer<_Tp>::type; + + + template + using add_pointer_t = typename add_pointer<_Tp>::type; + + + template + struct __aligned_storage_msa + { + union __type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__)) { } __align; + }; + }; +# 2194 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template::__type)> + struct + + aligned_storage + { + union type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__((_Align)))) { } __align; + }; + }; + + template + struct __strictest_alignment + { + static const size_t _S_alignment = 0; + static const size_t _S_size = 0; + }; + + template + struct __strictest_alignment<_Tp, _Types...> + { + static const size_t _S_alignment = + alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment + ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; + static const size_t _S_size = + sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size + ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 2240 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct + + aligned_union + { + private: + static_assert(sizeof...(_Types) != 0, "At least one type is required"); + + using __strictest = __strictest_alignment<_Types...>; + static const size_t _S_len = _Len > __strictest::_S_size + ? _Len : __strictest::_S_size; + public: + + static const size_t alignment_value = __strictest::_S_alignment; + + using type = typename aligned_storage<_S_len, alignment_value>::type; + }; + + template + const size_t aligned_union<_Len, _Types...>::alignment_value; +#pragma GCC diagnostic pop + + + + + + template + struct __decay_selector + : __conditional_t::value, + remove_cv<_Up>, + add_pointer<_Up>> + { }; + + template + struct __decay_selector<_Up[_Nm]> + { using type = _Up*; }; + + template + struct __decay_selector<_Up[]> + { using type = _Up*; }; + + + + + template + struct decay + { using type = typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&> + { using type = typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&&> + { using type = typename __decay_selector<_Tp>::type; }; + + + + + template + struct __strip_reference_wrapper + { + using __type = _Tp; + }; + + template + struct __strip_reference_wrapper > + { + using __type = _Tp&; + }; + + + template + using __decay_t = typename decay<_Tp>::type; + + template + using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; + + + + + + template + using _Require = __enable_if_t<__and_<_Cond...>::value>; + + + template + using __remove_cvref_t + = typename remove_cv::type>::type; + + + + + template + struct conditional + { using type = _Iftrue; }; + + + template + struct conditional + { using type = _Iffalse; }; + + + template + struct common_type; +# 2355 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct __success_type + { using type = _Tp; }; + + struct __failure_type + { }; + + struct __do_common_type_impl + { + template + using __cond_t + = decltype(true ? std::declval<_Tp>() : std::declval<_Up>()); + + + + template + static __success_type<__decay_t<__cond_t<_Tp, _Up>>> + _S_test(int); +# 2382 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + static __failure_type + _S_test_2(...); + + template + static decltype(_S_test_2<_Tp, _Up>(0)) + _S_test(...); + }; + + + template<> + struct common_type<> + { }; + + + template + struct common_type<_Tp0> + : public common_type<_Tp0, _Tp0> + { }; + + + template, typename _Dp2 = __decay_t<_Tp2>> + struct __common_type_impl + { + + + using type = common_type<_Dp1, _Dp2>; + }; + + template + struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> + : private __do_common_type_impl + { + + + using type = decltype(_S_test<_Tp1, _Tp2>(0)); + }; + + + template + struct common_type<_Tp1, _Tp2> + : public __common_type_impl<_Tp1, _Tp2>::type + { }; + + template + struct __common_type_pack + { }; + + template + struct __common_type_fold; + + + template + struct common_type<_Tp1, _Tp2, _Rp...> + : public __common_type_fold, + __common_type_pack<_Rp...>> + { }; + + + + + template + struct __common_type_fold<_CTp, __common_type_pack<_Rp...>, + __void_t> + : public common_type + { }; + + + template + struct __common_type_fold<_CTp, _Rp, void> + { }; + + template + struct __underlying_type_impl + { + using type = __underlying_type(_Tp); + }; + + template + struct __underlying_type_impl<_Tp, false> + { }; + + + + template + struct underlying_type + : public __underlying_type_impl<_Tp> + { }; + + + template + struct __declval_protector + { + static const bool __stop = false; + }; + + + + + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)) + { + static_assert(__declval_protector<_Tp>::__stop, + "declval() must not be used!"); + return __declval<_Tp>(0); + } + + + template + struct result_of; + + + + + struct __invoke_memfun_ref { }; + struct __invoke_memfun_deref { }; + struct __invoke_memobj_ref { }; + struct __invoke_memobj_deref { }; + struct __invoke_other { }; + + + template + struct __result_of_success : __success_type<_Tp> + { using __invoke_type = _Tag; }; + + + struct __result_of_memfun_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_ref + : private __result_of_memfun_ref_impl + { + using type = decltype(_S_test<_MemPtr, _Arg, _Args...>(0)); + }; + + + struct __result_of_memfun_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_deref + : private __result_of_memfun_deref_impl + { + using type = decltype(_S_test<_MemPtr, _Arg, _Args...>(0)); + }; + + + struct __result_of_memobj_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>() + ), __invoke_memobj_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_ref + : private __result_of_memobj_ref_impl + { + using type = decltype(_S_test<_MemPtr, _Arg>(0)); + }; + + + struct __result_of_memobj_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>() + ), __invoke_memobj_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_deref + : private __result_of_memobj_deref_impl + { + using type = decltype(_S_test<_MemPtr, _Arg>(0)); + }; + + template + struct __result_of_memobj; + + template + struct __result_of_memobj<_Res _Class::*, _Arg> + { + using _Argval = __remove_cvref_t<_Arg>; + using _MemPtr = _Res _Class::*; + using type = typename __conditional_t<__or_, + is_base_of<_Class, _Argval>>::value, + __result_of_memobj_ref<_MemPtr, _Arg>, + __result_of_memobj_deref<_MemPtr, _Arg> + >::type; + }; + + template + struct __result_of_memfun; + + template + struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> + { + using _Argval = typename remove_reference<_Arg>::type; + using _MemPtr = _Res _Class::*; + using type = typename __conditional_t::value, + __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, + __result_of_memfun_deref<_MemPtr, _Arg, _Args...> + >::type; + }; + + + + + + + template> + struct __inv_unwrap + { + using type = _Tp; + }; + + template + struct __inv_unwrap<_Tp, reference_wrapper<_Up>> + { + using type = _Up&; + }; + + template + struct __result_of_impl + { + using type = __failure_type; + }; + + template + struct __result_of_impl + : public __result_of_memobj<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type> + { }; + + template + struct __result_of_impl + : public __result_of_memfun<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type, _Args...> + { }; + + + struct __result_of_other_impl + { + template + static __result_of_success()(std::declval<_Args>()...) + ), __invoke_other> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_impl + : private __result_of_other_impl + { + using type = decltype(_S_test<_Functor, _ArgTypes...>(0)); + }; + + + template + struct __invoke_result + : public __result_of_impl< + is_member_object_pointer< + typename remove_reference<_Functor>::type + >::value, + is_member_function_pointer< + typename remove_reference<_Functor>::type + >::value, + _Functor, _ArgTypes... + >::type + { }; + + + template + using __invoke_result_t = typename __invoke_result<_Fn, _Args...>::type; + + + template + struct result_of<_Functor(_ArgTypes...)> + : public __invoke_result<_Functor, _ArgTypes...> + { } __attribute__ ((__deprecated__ ("use '" "std::invoke_result" "' instead"))); + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + template::__type)> + using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; + + template + using aligned_union_t = typename aligned_union<_Len, _Types...>::type; +#pragma GCC diagnostic pop + + + template + using decay_t = typename decay<_Tp>::type; + + + template + using enable_if_t = typename enable_if<_Cond, _Tp>::type; + + + template + using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; + + + template + using common_type_t = typename common_type<_Tp...>::type; + + + template + using underlying_type_t = typename underlying_type<_Tp>::type; + + + template + using result_of_t = typename result_of<_Tp>::type; + + + + + template using void_t = void; +# 2759 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template class _Op, typename... _Args> + struct __detector + { + using type = _Default; + using __is_detected = false_type; + }; + + + template class _Op, + typename... _Args> + struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> + { + using type = _Op<_Args...>; + using __is_detected = true_type; + }; + + template class _Op, + typename... _Args> + using __detected_or = __detector<_Default, void, _Op, _Args...>; + + + + template class _Op, + typename... _Args> + using __detected_or_t + = typename __detected_or<_Default, _Op, _Args...>::type; +# 2801 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct __is_swappable; + + template + struct __is_nothrow_swappable; + + template + struct __is_tuple_like_impl : false_type + { }; + + + template + struct __is_tuple_like + : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type + { }; + + + template + + inline + _Require<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>> + swap(_Tp&, _Tp&) + noexcept(__and_, + is_nothrow_move_assignable<_Tp>>::value); + + template + + inline + __enable_if_t<__is_swappable<_Tp>::value> + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value); + + + namespace __swappable_details { + using std::swap; + + struct __do_is_swappable_impl + { + template(), std::declval<_Tp&>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_impl + : public __swappable_details::__do_is_swappable_impl + { + using type = decltype(__test<_Tp>(0)); + }; + + template + struct __is_nothrow_swappable_impl + : public __swappable_details::__do_is_nothrow_swappable_impl + { + using type = decltype(__test<_Tp>(0)); + }; + + template + struct __is_swappable + : public __is_swappable_impl<_Tp>::type + { }; + + template + struct __is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { }; + + + + + + + template + struct is_swappable + : public __is_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_v = + is_swappable<_Tp>::value; + + + template + inline constexpr bool is_nothrow_swappable_v = + is_nothrow_swappable<_Tp>::value; + + + + namespace __swappable_with_details { + using std::swap; + + struct __do_is_swappable_with_impl + { + template(), std::declval<_Up>())), + typename + = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_with_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) + && + noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_with_impl + : public __swappable_with_details::__do_is_swappable_with_impl + { + using type = decltype(__test<_Tp, _Up>(0)); + }; + + + template + struct __is_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_swappable_impl + { + using type = decltype(__test<_Tp&>(0)); + }; + + template + struct __is_nothrow_swappable_with_impl + : public __swappable_with_details::__do_is_nothrow_swappable_with_impl + { + using type = decltype(__test<_Tp, _Up>(0)); + }; + + + template + struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_nothrow_swappable_impl + { + using type = decltype(__test<_Tp&>(0)); + }; + + + + template + struct is_swappable_with + : public __is_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable_with + : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_with_v = + is_swappable_with<_Tp, _Up>::value; + + + template + inline constexpr bool is_nothrow_swappable_with_v = + is_nothrow_swappable_with<_Tp, _Up>::value; +# 3023 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template::value, typename = void> + struct __is_invocable_impl + : false_type + { + using __nothrow_conv = false_type; + }; + + + template + struct __is_invocable_impl<_Result, _Ret, + true, + __void_t> + : true_type + { + using __nothrow_conv = true_type; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + + template + struct __is_invocable_impl<_Result, _Ret, + false, + __void_t> + { + private: + + using _Res_t = typename _Result::type; + + + + static _Res_t _S_get() noexcept; + + + template + static void _S_conv(__type_identity_t<_Tp>) noexcept; + + + template(_S_get())), + typename = decltype(_S_conv<_Tp>(_S_get())), + + bool _Dangle = __reference_converts_from_temporary(_Tp, _Res_t) + + + + > + static __bool_constant<_Nothrow && !_Dangle> + _S_test(int); + + template + static false_type + _S_test(...); + + public: + + using type = decltype(_S_test<_Ret, true>(1)); + + + using __nothrow_conv = decltype(_S_test<_Ret>(1)); + }; +#pragma GCC diagnostic pop + + template + struct __is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { }; + + template + constexpr bool __call_is_nt(__invoke_memfun_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept((std::declval<_Up>().*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memfun_deref) + { + return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept(std::declval<_Up>().*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_deref) + { + return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_other) + { + return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); + } + + template + struct __call_is_nothrow + : __bool_constant< + std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) + > + { }; + + template + using __call_is_nothrow_ + = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; + + + template + struct __is_nothrow_invocable + : __and_<__is_invocable<_Fn, _Args...>, + __call_is_nothrow_<_Fn, _Args...>>::type + { }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + struct __nonesuchbase {}; + struct __nonesuch : private __nonesuchbase { + ~__nonesuch() = delete; + __nonesuch(__nonesuch const&) = delete; + void operator=(__nonesuch const&) = delete; + }; +#pragma GCC diagnostic pop + + + + + template + struct invoke_result + : public __invoke_result<_Functor, _ArgTypes...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}), + "_Functor must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; + + + template + struct is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + struct is_invocable_r + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_invocable + : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + + + + template + using __is_nt_invocable_impl + = typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv; + + + + template + struct is_nothrow_invocable_r + : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; +# 3251 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template + inline constexpr bool is_void_v = is_void<_Tp>::value; +template + inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; +template + inline constexpr bool is_integral_v = is_integral<_Tp>::value; +template + inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; + + +template + inline constexpr bool is_array_v = __is_array(_Tp); +# 3272 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template + inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; +template + inline constexpr bool is_lvalue_reference_v = false; +template + inline constexpr bool is_lvalue_reference_v<_Tp&> = true; +template + inline constexpr bool is_rvalue_reference_v = false; +template + inline constexpr bool is_rvalue_reference_v<_Tp&&> = true; + + +template + inline constexpr bool is_member_object_pointer_v = + __is_member_object_pointer(_Tp); + + + + + + + +template + inline constexpr bool is_member_function_pointer_v = + __is_member_function_pointer(_Tp); + + + + + + +template + inline constexpr bool is_enum_v = __is_enum(_Tp); +template + inline constexpr bool is_union_v = __is_union(_Tp); +template + inline constexpr bool is_class_v = __is_class(_Tp); + + + +template + inline constexpr bool is_reference_v = __is_reference(_Tp); +# 3323 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template + inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; +template + inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; + + +template + inline constexpr bool is_object_v = __is_object(_Tp); + + + + + +template + inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; +template + inline constexpr bool is_compound_v = !is_fundamental_v<_Tp>; + + +template + inline constexpr bool is_member_pointer_v = __is_member_pointer(_Tp); + + + + + +template + inline constexpr bool is_const_v = false; +template + inline constexpr bool is_const_v = true; + + +template + inline constexpr bool is_function_v = __is_function(_Tp); +# 3366 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template + inline constexpr bool is_volatile_v = false; +template + inline constexpr bool is_volatile_v = true; + +template + inline constexpr bool is_trivial_v = __is_trivial(_Tp); +template + inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp); +template + inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp); +template + + inline constexpr bool is_pod_v = __is_pod(_Tp); +template + [[__deprecated__]] + inline constexpr bool is_literal_type_v = __is_literal_type(_Tp); +template + inline constexpr bool is_empty_v = __is_empty(_Tp); +template + inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp); +template + inline constexpr bool is_abstract_v = __is_abstract(_Tp); +template + inline constexpr bool is_final_v = __is_final(_Tp); + +template + inline constexpr bool is_signed_v = is_signed<_Tp>::value; +template + inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; + +template + inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...); +template + inline constexpr bool is_default_constructible_v = __is_constructible(_Tp); +template + inline constexpr bool is_copy_constructible_v + = __is_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_move_constructible_v + = __is_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Up); +template + inline constexpr bool is_copy_assignable_v + = __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t); +template + inline constexpr bool is_move_assignable_v + = __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; + +template + inline constexpr bool is_trivially_constructible_v + = __is_trivially_constructible(_Tp, _Args...); +template + inline constexpr bool is_trivially_default_constructible_v + = __is_trivially_constructible(_Tp); +template + inline constexpr bool is_trivially_copy_constructible_v + = __is_trivially_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_constructible_v + = __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_trivially_assignable_v + = __is_trivially_assignable(_Tp, _Up); +template + inline constexpr bool is_trivially_copy_assignable_v + = __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_assignable_v + = __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>); +# 3461 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template + inline constexpr bool is_trivially_destructible_v = + is_trivially_destructible<_Tp>::value; + + +template + inline constexpr bool is_nothrow_constructible_v + = __is_nothrow_constructible(_Tp, _Args...); +template + inline constexpr bool is_nothrow_default_constructible_v + = __is_nothrow_constructible(_Tp); +template + inline constexpr bool is_nothrow_copy_constructible_v + = __is_nothrow_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_constructible_v + = __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_assignable_v + = __is_nothrow_assignable(_Tp, _Up); +template + inline constexpr bool is_nothrow_copy_assignable_v + = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_assignable_v + = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_destructible_v = + is_nothrow_destructible<_Tp>::value; + +template + inline constexpr bool has_virtual_destructor_v + = __has_virtual_destructor(_Tp); + +template + inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; + +template + inline constexpr size_t rank_v = 0; +template + inline constexpr size_t rank_v<_Tp[_Size]> = 1 + rank_v<_Tp>; +template + inline constexpr size_t rank_v<_Tp[]> = 1 + rank_v<_Tp>; + +template + inline constexpr size_t extent_v = 0; +template + inline constexpr size_t extent_v<_Tp[_Size], 0> = _Size; +template + inline constexpr size_t extent_v<_Tp[_Size], _Idx> = extent_v<_Tp, _Idx - 1>; +template + inline constexpr size_t extent_v<_Tp[], 0> = 0; +template + inline constexpr size_t extent_v<_Tp[], _Idx> = extent_v<_Tp, _Idx - 1>; + + +template + inline constexpr bool is_same_v = __is_same(_Tp, _Up); + + + + + + +template + inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived); + +template + inline constexpr bool is_convertible_v = __is_convertible(_From, _To); + + + + +template + inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_v + = is_nothrow_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_invocable_r_v + = is_invocable_r<_Ret, _Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_r_v + = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; + + + + + + + template + struct has_unique_object_representations + : bool_constant<__has_unique_object_representations( + remove_cv_t> + )> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool has_unique_object_representations_v + = has_unique_object_representations<_Tp>::value; + + + + + + + template + struct is_aggregate + : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> + { }; + + + + + + + template + inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>); +# 4017 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + +} +# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 1 3 +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + inline constexpr _Tp* + __addressof(_Tp& __r) noexcept + { return __builtin_addressof(__r); } +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Tp&&>(__t); } +# 81 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type&& __t) noexcept + { + static_assert(!std::is_lvalue_reference<_Tp>::value, + "std::forward must not be used to convert an rvalue to an lvalue"); + return static_cast<_Tp&&>(__t); + } +# 134 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr typename std::remove_reference<_Tp>::type&& + move(_Tp&& __t) noexcept + { return static_cast::type&&>(__t); } + + + template + struct __move_if_noexcept_cond + : public __and_<__not_>, + is_copy_constructible<_Tp>>::type { }; +# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr + __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&> + move_if_noexcept(_Tp& __x) noexcept + { return std::move(__x); } +# 172 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + [[__nodiscard__]] + inline constexpr _Tp* + addressof(_Tp& __r) noexcept + { return std::__addressof(__r); } + + + + template + const _Tp* addressof(const _Tp&&) = delete; + + + template + + inline _Tp + __exchange(_Tp& __obj, _Up&& __new_val) + { + _Tp __old_val = std::move(__obj); + __obj = std::forward<_Up>(__new_val); + return __old_val; + } +# 216 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + + inline + + typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>>::value>::type + + + + swap(_Tp& __a, _Tp& __b) + noexcept(__and_, is_nothrow_move_assignable<_Tp>>::value) + + { + + + + + _Tp __tmp = std::move(__a); + __a = std::move(__b); + __b = std::move(__tmp); + } + + + + + template + + inline + + typename enable_if<__is_swappable<_Tp>::value>::type + + + + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value) + { + for (size_t __n = 0; __n < _Nm; ++__n) + swap(__a[__n], __b[__n]); + } + + + +} +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 1 3 +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 + +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct tuple_size; + + + + + + template::type, + typename = typename enable_if::value>::type, + size_t = tuple_size<_Tp>::value> + using __enable_if_has_tuple_size = _Tp; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + + template + inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value; + + + + template + struct tuple_element; + + + template + using __tuple_element_t = typename tuple_element<__i, _Tp>::type; + + template + struct tuple_element<__i, const _Tp> + { + using type = const __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, volatile _Tp> + { + using type = volatile __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, const volatile _Tp> + { + using type = const volatile __tuple_element_t<__i, _Tp>; + }; + + + + + + template + constexpr size_t + __find_uniq_type_in_pack() + { + constexpr size_t __sz = sizeof...(_Types); + constexpr bool __found[__sz] = { __is_same(_Tp, _Types) ... }; + size_t __n = __sz; + for (size_t __i = 0; __i < __sz; ++__i) + { + if (__found[__i]) + { + if (__n < __sz) + return __sz; + __n = __i; + } + } + return __n; + } +# 134 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 + template + using tuple_element_t = typename tuple_element<__i, _Tp>::type; + + + + + template struct _Index_tuple { }; + + + template + struct _Build_index_tuple + { +# 154 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 + using __type = _Index_tuple<__integer_pack(_Num)...>; + + }; + + + + + template + struct integer_sequence + { + + + + typedef _Tp value_type; + static constexpr size_t size() noexcept { return sizeof...(_Idx); } + }; + + + template + using make_integer_sequence + + + + = integer_sequence<_Tp, __integer_pack(_Num)...>; + + + + template + using index_sequence = integer_sequence; + + + template + using make_index_sequence = make_integer_sequence; + + + template + using index_sequence_for = make_index_sequence; + + + + + struct in_place_t { + explicit in_place_t() = default; + }; + + inline constexpr in_place_t in_place{}; + + template struct in_place_type_t + { + explicit in_place_type_t() = default; + }; + + template + inline constexpr in_place_type_t<_Tp> in_place_type{}; + + template struct in_place_index_t + { + explicit in_place_index_t() = default; + }; + + template + inline constexpr in_place_index_t<_Idx> in_place_index{}; + + template + inline constexpr bool __is_in_place_type_v = false; + + template + inline constexpr bool __is_in_place_type_v> = true; + + template + using __is_in_place_type = bool_constant<__is_in_place_type_v<_Tp>>; + + template + inline constexpr bool __is_in_place_index_v = false; + + template + inline constexpr bool __is_in_place_index_v> = true; + + + + + template + struct _Nth_type + { using type = __type_pack_element<_Np, _Types...>; }; +# 283 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 + +} +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + struct piecewise_construct_t { explicit piecewise_construct_t() = default; }; + + + inline constexpr piecewise_construct_t piecewise_construct = + piecewise_construct_t(); + + + + + template + struct pair; + + template + class tuple; + + + + + + template + struct array; + + template + struct _Index_tuple; + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(pair<_Tp1, _Tp2>& __in) noexcept; + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(pair<_Tp1, _Tp2>&& __in) noexcept; + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(const pair<_Tp1, _Tp2>& __in) noexcept; + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(const pair<_Tp1, _Tp2>&& __in) noexcept; + + template + constexpr __tuple_element_t<__i, tuple<_Elements...>>& + get(tuple<_Elements...>& __t) noexcept; + + template + constexpr const __tuple_element_t<__i, tuple<_Elements...>>& + get(const tuple<_Elements...>& __t) noexcept; + + template + constexpr __tuple_element_t<__i, tuple<_Elements...>>&& + get(tuple<_Elements...>&& __t) noexcept; + + template + constexpr const __tuple_element_t<__i, tuple<_Elements...>>&& + get(const tuple<_Elements...>&& __t) noexcept; + + template + constexpr _Tp& + get(array<_Tp, _Nm>&) noexcept; + + template + constexpr _Tp&& + get(array<_Tp, _Nm>&&) noexcept; + + template + constexpr const _Tp& + get(const array<_Tp, _Nm>&) noexcept; + + template + constexpr const _Tp&& + get(const array<_Tp, _Nm>&&) noexcept; + + + + + + + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return __and_, + is_constructible<_T2, const _U2&>>::value; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return __and_, + is_convertible>::value; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return __and_, + is_constructible<_T2, _U2&&>>::value; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return __and_, + is_convertible<_U2&&, _T2>>::value; + } + }; + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return false; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return false; + } + }; +# 260 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template class __pair_base + { + + template friend struct pair; + __pair_base() = default; + ~__pair_base() = default; + __pair_base(const __pair_base&) = default; + __pair_base& operator=(const __pair_base&) = delete; + + }; +# 283 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + struct pair + : public __pair_base<_T1, _T2> + { + typedef _T1 first_type; + typedef _T2 second_type; + + _T1 first; + _T2 second; + + + constexpr pair(const pair&) = default; + constexpr pair(pair&&) = default; + + template + + pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); + + + void + swap(pair& __p) + noexcept(__and_<__is_nothrow_swappable<_T1>, + __is_nothrow_swappable<_T2>>::value) + { + using std::swap; + swap(first, __p.first); + swap(second, __p.second); + } +# 331 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + private: + template + + pair(tuple<_Args1...>&, tuple<_Args2...>&, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); + public: +# 719 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template , + __is_implicitly_default_constructible<_U2>> + ::value, bool>::type = true> + constexpr pair() + : first(), second() { } + + template , + is_default_constructible<_U2>, + __not_< + __and_<__is_implicitly_default_constructible<_U1>, + __is_implicitly_default_constructible<_U2>>>> + ::value, bool>::type = false> + explicit constexpr pair() + : first(), second() { } + + + + using _PCCP = _PCC; + + + + template() + && _PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + template() + && !_PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + + template + using _PCCFP = _PCC::value + || !is_same<_T2, _U2>::value, + _T1, _T2>; + + + template::template + _ConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) + { ; } + + template::template + _ConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) + { ; } +# 803 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + private: + + + + struct __zero_as_null_pointer_constant + { + __zero_as_null_pointer_constant(int __zero_as_null_pointer_constant::*) + { } + template::value>> + __zero_as_null_pointer_constant(_Tp) = delete; + }; + + public: + + + + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + is_convertible<_U1, _T1>>::value, + bool> = true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + constexpr + pair(_U1&& __x, __zero_as_null_pointer_constant, ...) + : first(std::forward<_U1>(__x)), second(nullptr) + { ; } + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + __not_>>::value, + bool> = false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + explicit constexpr + pair(_U1&& __x, __zero_as_null_pointer_constant, ...) + : first(std::forward<_U1>(__x)), second(nullptr) + { ; } + + template, + __not_>, + is_constructible<_T2, _U2>, + __not_>, + is_convertible<_U2, _T2>>::value, + bool> = true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + constexpr + pair(__zero_as_null_pointer_constant, _U2&& __y, ...) + : first(nullptr), second(std::forward<_U2>(__y)) + { ; } + + template, + __not_>, + is_constructible<_T2, _U2>, + __not_>, + __not_>>::value, + bool> = false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + explicit constexpr + pair(__zero_as_null_pointer_constant, _U2&& __y, ...) + : first(nullptr), second(std::forward<_U2>(__y)) + { ; } + + + + template() + && _PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) + { ; } + + template() + && !_PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) + { ; } + + + template::template + _MoveConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) + { ; } + + template::template + _MoveConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) + { ; } + + + + pair& + operator=(__conditional_t<__and_, + is_copy_assignable<_T2>>::value, + const pair&, const __nonesuch&> __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + pair& + operator=(__conditional_t<__and_, + is_move_assignable<_T2>>::value, + pair&&, __nonesuch&&> __p) + noexcept(__and_, + is_nothrow_move_assignable<_T2>>::value) + { + first = std::forward(__p.first); + second = std::forward(__p.second); + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, const _U2&>>::value, + pair&>::type + operator=(const pair<_U1, _U2>& __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, _U2&&>>::value, + pair&>::type + operator=(pair<_U1, _U2>&& __p) + { + first = std::forward<_U1>(__p.first); + second = std::forward<_U2>(__p.second); + return *this; + } +# 995 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + }; + + + + + template pair(_T1, _T2) -> pair<_T1, _T2>; +# 1031 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + inline constexpr bool + operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first == __y.first && __x.second == __y.second; } +# 1043 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + inline constexpr bool + operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first < __y.first + || (!(__y.first < __x.first) && __x.second < __y.second); } + + + template + inline constexpr bool + operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x == __y); } + + + template + inline constexpr bool + operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __y < __x; } + + + template + inline constexpr bool + operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__y < __x); } + + + template + inline constexpr bool + operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x < __y); } +# 1080 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + inline + + + typename enable_if<__and_<__is_swappable<_T1>, + __is_swappable<_T2>>::value>::type + + + + swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } +# 1103 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + typename enable_if, + __is_swappable<_T2>>::value>::type + swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete; +# 1129 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + constexpr pair::__type, + typename __decay_and_strip<_T2>::__type> + make_pair(_T1&& __x, _T2&& __y) + { + typedef typename __decay_and_strip<_T1>::__type __ds_type1; + typedef typename __decay_and_strip<_T2>::__type __ds_type2; + typedef pair<__ds_type1, __ds_type2> __pair_type; + return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y)); + } +# 1152 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + struct __is_tuple_like_impl> : true_type + { }; + + + + template + struct tuple_size> + : public integral_constant { }; + + + template + struct tuple_element<0, pair<_Tp1, _Tp2>> + { typedef _Tp1 type; }; + + + template + struct tuple_element<1, pair<_Tp1, _Tp2>> + { typedef _Tp2 type; }; + + + + template + struct tuple_element<__i, tuple<_Types...>>; + + + template + inline constexpr size_t tuple_size_v> = 2; + + template + inline constexpr size_t tuple_size_v> = 2; + + template + inline constexpr bool __is_pair = false; + + template + inline constexpr bool __is_pair> = true; + + + + template + struct __pair_get; + + template<> + struct __pair_get<0> + { + template + static constexpr _Tp1& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr _Tp1&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp1>(__pair.first); } + + template + static constexpr const _Tp1& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr const _Tp1&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.first); } + }; + + template<> + struct __pair_get<1> + { + template + static constexpr _Tp2& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr _Tp2&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp2>(__pair.second); } + + template + static constexpr const _Tp2& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr const _Tp2&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.second); } + }; + + + + + + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__get(__in); } + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__move_get(std::move(__in)); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(const pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__const_get(__in); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(const pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__const_move_get(std::move(__in)); } + + + + template + constexpr _Tp& + get(pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr const _Tp& + get(const pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr _Tp&& + get(pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr const _Tp&& + get(const pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr _Tp& + get(pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr const _Tp& + get(const pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr _Tp&& + get(pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } + + template + constexpr const _Tp&& + get(const pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } +# 1332 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + +} +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 1 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 + +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 +# 74 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 93 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 + struct input_iterator_tag { }; + + + struct output_iterator_tag { }; + + + struct forward_iterator_tag : public input_iterator_tag { }; + + + + struct bidirectional_iterator_tag : public forward_iterator_tag { }; + + + + struct random_access_iterator_tag : public bidirectional_iterator_tag { }; +# 125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 + template + struct [[__deprecated__]] iterator + { + + typedef _Category iterator_category; + + typedef _Tp value_type; + + typedef _Distance difference_type; + + typedef _Pointer pointer; + + typedef _Reference reference; + }; +# 149 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits; + + + + + template> + struct __iterator_traits { }; + + + + template + struct __iterator_traits<_Iterator, + __void_t> + { + typedef typename _Iterator::iterator_category iterator_category; + typedef typename _Iterator::value_type value_type; + typedef typename _Iterator::difference_type difference_type; + typedef typename _Iterator::pointer pointer; + typedef typename _Iterator::reference reference; + }; + + + template + struct iterator_traits + : public __iterator_traits<_Iterator> { }; +# 209 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits<_Tp*> + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef _Tp* pointer; + typedef _Tp& reference; + }; + + + template + struct iterator_traits + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef const _Tp* pointer; + typedef const _Tp& reference; + }; + + + + + + + template + __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_Iter>::iterator_category + __iterator_category(const _Iter&) + { return typename iterator_traits<_Iter>::iterator_category(); } + + + + + template + using __iter_category_t + = typename iterator_traits<_Iter>::iterator_category; + + template + using _RequireInputIter = + __enable_if_t, + input_iterator_tag>::value>; + + template> + struct __is_random_access_iter + : is_base_of + { + typedef is_base_of _Base; + enum { __value = _Base::value }; + }; + + + + + + + + +} +# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 1 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 + +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/concept_check.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/concept_check.h" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/concept_check.h" 3 +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/debug/assertions.h" 1 3 +# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template struct _List_iterator; + template struct _List_const_iterator; + + + template + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + __distance(_InputIterator __first, _InputIterator __last, + input_iterator_tag) + { + + + + typename iterator_traits<_InputIterator>::difference_type __n = 0; + while (__first != __last) + { + ++__first; + ++__n; + } + return __n; + } + + template + __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_RandomAccessIterator>::difference_type + __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, + random_access_iterator_tag) + { + + + + return __last - __first; + } + + + + template + ptrdiff_t + __distance(std::_List_iterator<_Tp>, + std::_List_iterator<_Tp>, + input_iterator_tag); + + template + ptrdiff_t + __distance(std::_List_const_iterator<_Tp>, + std::_List_const_iterator<_Tp>, + input_iterator_tag); + + + + + template + void + __distance(_OutputIterator, _OutputIterator, output_iterator_tag) = delete; +# 144 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 + template + [[__nodiscard__]] __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + distance(_InputIterator __first, _InputIterator __last) + { + + return std::__distance(__first, __last, + std::__iterator_category(__first)); + } + + template + inline constexpr void + __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) + { + + + do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) std::__glibcxx_assert_fail(); } while (false); + while (__n--) + ++__i; + } + + template + inline constexpr void + __advance(_BidirectionalIterator& __i, _Distance __n, + bidirectional_iterator_tag) + { + + + + if (__n > 0) + while (__n--) + ++__i; + else + while (__n++) + --__i; + } + + template + inline constexpr void + __advance(_RandomAccessIterator& __i, _Distance __n, + random_access_iterator_tag) + { + + + + if (__builtin_constant_p(__n) && __n == 1) + ++__i; + else if (__builtin_constant_p(__n) && __n == -1) + --__i; + else + __i += __n; + } + + + + template + void + __advance(_OutputIterator&, _Distance, output_iterator_tag) = delete; +# 217 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 + template + __attribute__((__always_inline__)) + inline constexpr void + advance(_InputIterator& __i, _Distance __n) + { + + typename iterator_traits<_InputIterator>::difference_type __d = __n; + std::__advance(__i, __d, std::__iterator_category(__i)); + } + + + + template + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _InputIterator + next(_InputIterator __x, typename + iterator_traits<_InputIterator>::difference_type __n = 1) + { + + + std::advance(__x, __n); + return __x; + } + + template + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _BidirectionalIterator + prev(_BidirectionalIterator __x, typename + iterator_traits<_BidirectionalIterator>::difference_type __n = 1) + { + + + + std::advance(__x, -__n); + return __x; + } + + + + +} +# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 1 3 +# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/ptr_traits.h" 1 3 +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/ptr_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + class __undefined; + + + + template + struct __get_first_arg + { using type = __undefined; }; + + template class _SomeTemplate, typename _Tp, + typename... _Types> + struct __get_first_arg<_SomeTemplate<_Tp, _Types...>> + { using type = _Tp; }; + + + + template + struct __replace_first_arg + { }; + + template class _SomeTemplate, typename _Up, + typename _Tp, typename... _Types> + struct __replace_first_arg<_SomeTemplate<_Tp, _Types...>, _Up> + { using type = _SomeTemplate<_Up, _Types...>; }; + + + template + struct __ptr_traits_elem : __get_first_arg<_Ptr> + { }; + + + + + + + + template + struct __ptr_traits_elem<_Ptr, __void_t> + { using type = typename _Ptr::element_type; }; + + + template + using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type; + + + + + template::value> + struct __ptr_traits_ptr_to + { + using pointer = _Ptr; + using element_type = _Elt; + + + + + + + + static pointer + pointer_to(element_type& __r) + + + + + + { return pointer::pointer_to(__r); } + }; + + + template + struct __ptr_traits_ptr_to<_Ptr, _Elt, true> + { }; + + + template + struct __ptr_traits_ptr_to<_Tp*, _Tp, false> + { + using pointer = _Tp*; + using element_type = _Tp; + + + + + + + static pointer + pointer_to(element_type& __r) noexcept + { return std::addressof(__r); } + }; + + template + struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt> + { + private: + template + using __diff_t = typename _Tp::difference_type; + + template + using __rebind = __type_identity>; + + public: + + using pointer = _Ptr; + + + using element_type = _Elt; + + + using difference_type = __detected_or_t; + + + template + using rebind = typename __detected_or_t<__replace_first_arg<_Ptr, _Up>, + __rebind, _Ptr, _Up>::type; + }; + + + + template + struct __ptr_traits_impl<_Ptr, __undefined> + { }; + + + + + + + + template + struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>> + { }; + + + + + + + + template + struct pointer_traits<_Tp*> : __ptr_traits_ptr_to<_Tp*, _Tp> + { + + typedef _Tp* pointer; + + typedef _Tp element_type; + + typedef ptrdiff_t difference_type; + + template using rebind = _Up*; + }; + + + template + using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>; + + template + constexpr _Tp* + __to_address(_Tp* __ptr) noexcept + { + static_assert(!std::is_function<_Tp>::value, "not a function pointer"); + return __ptr; + } + + + template + constexpr typename std::pointer_traits<_Ptr>::element_type* + __to_address(const _Ptr& __ptr) + { return std::__to_address(__ptr.operator->()); } +# 257 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/ptr_traits.h" 3 + +} +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 2 3 +# 85 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 106 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + +# 106 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 128 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class reverse_iterator + : public iterator::iterator_category, + typename iterator_traits<_Iterator>::value_type, + typename iterator_traits<_Iterator>::difference_type, + typename iterator_traits<_Iterator>::pointer, + typename iterator_traits<_Iterator>::reference> + { + template + friend class reverse_iterator; +# 147 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + protected: + _Iterator current; + + typedef iterator_traits<_Iterator> __traits_type; + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::pointer pointer; + + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; +# 178 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + constexpr + reverse_iterator() + noexcept(noexcept(_Iterator())) + : current() + { } + + + + + explicit constexpr + reverse_iterator(iterator_type __x) + noexcept(noexcept(_Iterator(__x))) + : current(__x) + { } + + + + + constexpr + reverse_iterator(const reverse_iterator& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + reverse_iterator& operator=(const reverse_iterator&) = default; + + + + + + + template + + + + constexpr + reverse_iterator(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + template + + + + + constexpr + reverse_iterator& + operator=(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(current = __x.current)) + { + current = __x.current; + return *this; + } + + + + + + [[__nodiscard__]] + constexpr iterator_type + base() const + noexcept(noexcept(_Iterator(current))) + { return current; } +# 255 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + { + _Iterator __tmp = current; + return *--__tmp; + } + + + + + + + [[__nodiscard__]] + constexpr pointer + operator->() const + + + + + { + + + _Iterator __tmp = current; + --__tmp; + return _S_to_pointer(__tmp); + } + + + + + + + constexpr reverse_iterator& + operator++() + { + --current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator++(int) + { + reverse_iterator __tmp = *this; + --current; + return __tmp; + } + + + + + + + constexpr reverse_iterator& + operator--() + { + ++current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator--(int) + { + reverse_iterator __tmp = *this; + ++current; + return __tmp; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator+(difference_type __n) const + { return reverse_iterator(current - __n); } + + + + + + + + constexpr reverse_iterator& + operator+=(difference_type __n) + { + current -= __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator-(difference_type __n) const + { return reverse_iterator(current + __n); } + + + + + + + + constexpr reverse_iterator& + operator-=(difference_type __n) + { + current += __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + { return *(*this + __n); } +# 415 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + private: + template + static constexpr _Tp* + _S_to_pointer(_Tp* __p) + { return __p; } + + template + static constexpr pointer + _S_to_pointer(_Tp __t) + { return __t.operator->(); } + }; +# 438 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator==(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y.base() < __x.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() == __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() > __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() != __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() < __y.base(); } + + template + inline constexpr bool + operator<=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() >= __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() <= __y.base(); } +# 615 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr auto + operator-(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + -> decltype(__y.base() - __x.base()) + { return __y.base() - __x.base(); } + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Iterator> + operator+(typename reverse_iterator<_Iterator>::difference_type __n, + const reverse_iterator<_Iterator>& __x) + { return reverse_iterator<_Iterator>(__x.base() - __n); } + + + + template + inline constexpr reverse_iterator<_Iterator> + __make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Iterator> + make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } +# 657 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + + auto + __niter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__niter_base(__it.base()))) + { return __make_reverse_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + : __is_move_iterator<_Iterator> + { }; + + template + + auto + __miter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__miter_base(__it.base()))) + { return __make_reverse_iterator(__miter_base(__it.base())); } +# 688 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class back_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + explicit + back_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 726 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + + back_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_back(__value); + return *this; + } + + + back_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_back(std::move(__value)); + return *this; + } + + + + [[__nodiscard__]] + back_insert_iterator& + operator*() + { return *this; } + + + + back_insert_iterator& + operator++() + { return *this; } + + + + back_insert_iterator + operator++(int) + { return *this; } + }; +# 773 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline back_insert_iterator<_Container> + back_inserter(_Container& __x) + { return back_insert_iterator<_Container>(__x); } +# 789 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class front_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + explicit + front_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 827 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + + front_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_front(__value); + return *this; + } + + + front_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_front(std::move(__value)); + return *this; + } + + + + [[__nodiscard__]] + front_insert_iterator& + operator*() + { return *this; } + + + + front_insert_iterator& + operator++() + { return *this; } + + + + front_insert_iterator + operator++(int) + { return *this; } + }; +# 874 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline front_insert_iterator<_Container> + front_inserter(_Container& __x) + { return front_insert_iterator<_Container>(__x); } +# 894 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class insert_iterator + : public iterator + { + + + + typedef typename _Container::iterator _Iter; + + protected: + _Container* container; + _Iter iter; + + public: + + typedef _Container container_type; +# 919 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + + insert_iterator(_Container& __x, _Iter __i) + : container(std::__addressof(__x)), iter(__i) {} +# 955 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + + insert_iterator& + operator=(const typename _Container::value_type& __value) + { + iter = container->insert(iter, __value); + ++iter; + return *this; + } + + + insert_iterator& + operator=(typename _Container::value_type&& __value) + { + iter = container->insert(iter, std::move(__value)); + ++iter; + return *this; + } + + + + [[__nodiscard__]] + insert_iterator& + operator*() + { return *this; } + + + + insert_iterator& + operator++() + { return *this; } + + + + insert_iterator& + operator++(int) + { return *this; } + }; + +#pragma GCC diagnostic pop +# 1014 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline insert_iterator<_Container> + inserter(_Container& __x, typename _Container::iterator __i) + { return insert_iterator<_Container>(__x, __i); } + + + + + +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 1037 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class __normal_iterator + { + protected: + _Iterator _M_current; + + typedef std::iterator_traits<_Iterator> __traits_type; + + + template + using __convertible_from + = std::__enable_if_t::value>; + + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; + typedef typename __traits_type::pointer pointer; + + + + + + constexpr __normal_iterator() noexcept + : _M_current(_Iterator()) { } + + explicit + __normal_iterator(const _Iterator& __i) noexcept + : _M_current(__i) { } + + + + template> + + __normal_iterator(const __normal_iterator<_Iter, _Container>& __i) + noexcept +# 1085 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + : _M_current(__i.base()) { } + + + + reference + operator*() const noexcept + { return *_M_current; } + + + pointer + operator->() const noexcept + { return _M_current; } + + + __normal_iterator& + operator++() noexcept + { + ++_M_current; + return *this; + } + + + __normal_iterator + operator++(int) noexcept + { return __normal_iterator(_M_current++); } + + + + __normal_iterator& + operator--() noexcept + { + --_M_current; + return *this; + } + + + __normal_iterator + operator--(int) noexcept + { return __normal_iterator(_M_current--); } + + + + reference + operator[](difference_type __n) const noexcept + { return _M_current[__n]; } + + + __normal_iterator& + operator+=(difference_type __n) noexcept + { _M_current += __n; return *this; } + + + __normal_iterator + operator+(difference_type __n) const noexcept + { return __normal_iterator(_M_current + __n); } + + + __normal_iterator& + operator-=(difference_type __n) noexcept + { _M_current -= __n; return *this; } + + + __normal_iterator + operator-(difference_type __n) const noexcept + { return __normal_iterator(_M_current - __n); } + + + const _Iterator& + base() const noexcept + { return _M_current; } + }; +# 1205 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline bool + operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator==(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + + + + + + template + + + [[__nodiscard__]] + inline auto + operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept + -> decltype(__lhs.base() - __rhs.base()) + + + + + + { return __lhs.base() - __rhs.base(); } + + template + [[__nodiscard__]] + inline typename __normal_iterator<_Iterator, _Container>::difference_type + operator-(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() - __rhs.base(); } + + template + [[__nodiscard__]] + inline __normal_iterator<_Iterator, _Container> + operator+(typename __normal_iterator<_Iterator, _Container>::difference_type + __n, const __normal_iterator<_Iterator, _Container>& __i) + noexcept + { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } + + +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + + _Iterator + __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it.base(); } + + + + + + + template + constexpr auto + __to_address(const __gnu_cxx::__normal_iterator<_Iterator, + _Container>& __it) noexcept + -> decltype(std::__to_address(__it.base())) + { return std::__to_address(__it.base()); } +# 1412 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + namespace __detail + { +# 1428 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + } +# 1439 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class move_iterator + + + + { + _Iterator _M_current; + + using __traits_type = iterator_traits<_Iterator>; + + using __base_ref = typename __traits_type::reference; + + + template + friend class move_iterator; +# 1478 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + public: + using iterator_type = _Iterator; +# 1490 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + + typedef _Iterator pointer; + + + using reference + = __conditional_t::value, + typename remove_reference<__base_ref>::type&&, + __base_ref>; + + + constexpr + move_iterator() + : _M_current() { } + + explicit constexpr + move_iterator(iterator_type __i) + : _M_current(std::move(__i)) { } + + template + + + + constexpr + move_iterator(const move_iterator<_Iter>& __i) + : _M_current(__i._M_current) { } + + template + + + + + constexpr + move_iterator& operator=(const move_iterator<_Iter>& __i) + { + _M_current = __i._M_current; + return *this; + } + + + [[__nodiscard__]] + constexpr iterator_type + base() const + { return _M_current; } +# 1548 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + + + + { return static_cast(*_M_current); } + + + [[__nodiscard__]] + constexpr pointer + operator->() const + { return _M_current; } + + constexpr move_iterator& + operator++() + { + ++_M_current; + return *this; + } + + constexpr move_iterator + operator++(int) + { + move_iterator __tmp = *this; + ++_M_current; + return __tmp; + } + + + + + + + + constexpr move_iterator& + operator--() + { + --_M_current; + return *this; + } + + constexpr move_iterator + operator--(int) + { + move_iterator __tmp = *this; + --_M_current; + return __tmp; + } + + [[__nodiscard__]] + constexpr move_iterator + operator+(difference_type __n) const + { return move_iterator(_M_current + __n); } + + constexpr move_iterator& + operator+=(difference_type __n) + { + _M_current += __n; + return *this; + } + + [[__nodiscard__]] + constexpr move_iterator + operator-(difference_type __n) const + { return move_iterator(_M_current - __n); } + + constexpr move_iterator& + operator-=(difference_type __n) + { + _M_current -= __n; + return *this; + } + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + + + + { return std::move(_M_current[__n]); } +# 1662 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + }; + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() == __y.base(); } +# 1683 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return !(__x == __y); } + + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() < __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + + { return __x.base() == __y.base(); } +# 1750 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() < __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + template + [[__nodiscard__]] + inline constexpr auto + operator-(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + -> decltype(__x.base() - __y.base()) + { return __x.base() - __y.base(); } + + template + [[__nodiscard__]] + inline constexpr move_iterator<_Iterator> + operator+(typename move_iterator<_Iterator>::difference_type __n, + const move_iterator<_Iterator>& __x) + + + + { return __x + __n; } + + template + [[__nodiscard__]] + inline constexpr move_iterator<_Iterator> + make_move_iterator(_Iterator __i) + { return move_iterator<_Iterator>(std::move(__i)); } + + template::value_type>::value, + _Iterator, move_iterator<_Iterator>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Iterator __i) + { return _ReturnType(__i); } + + + + template::value, + const _Tp*, move_iterator<_Tp*>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Tp* __i) + { return _ReturnType(__i); } +# 2964 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + + auto + __niter_base(move_iterator<_Iterator> __it) + -> decltype(make_move_iterator(__niter_base(__it.base()))) + { return make_move_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template + + auto + __miter_base(move_iterator<_Iterator> __it) + -> decltype(__miter_base(__it.base())) + { return __miter_base(__it.base()); } +# 2996 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + using __iter_key_t = remove_const_t< + + + + typename iterator_traits<_InputIterator>::value_type::first_type>; + + + template + using __iter_val_t + + + + = typename iterator_traits<_InputIterator>::value_type::second_type; + + + template + struct pair; + + template + using __iter_to_alloc_t + = pair, __iter_val_t<_InputIterator>>; + + + +} +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/debug/debug.h" 1 3 +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/debug/debug.h" 3 +namespace std +{ + namespace __debug { } +} + + + + +namespace __gnu_debug +{ + using namespace std::__debug; + + template + struct _Safe_iterator; +} +# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/predefined_ops.h" 1 3 +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/predefined_ops.h" 3 +namespace __gnu_cxx +{ +namespace __ops +{ + struct _Iter_less_iter + { + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 < *__it2; } + }; + + constexpr + inline _Iter_less_iter + __iter_less_iter() + { return _Iter_less_iter(); } + + struct _Iter_less_val + { + + constexpr _Iter_less_val() = default; + + + + + + explicit + _Iter_less_val(_Iter_less_iter) { } + + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it < __val; } + }; + + + inline _Iter_less_val + __iter_less_val() + { return _Iter_less_val(); } + + + inline _Iter_less_val + __iter_comp_val(_Iter_less_iter) + { return _Iter_less_val(); } + + struct _Val_less_iter + { + + constexpr _Val_less_iter() = default; + + + + + + explicit + _Val_less_iter(_Iter_less_iter) { } + + template + + bool + operator()(_Value& __val, _Iterator __it) const + { return __val < *__it; } + }; + + + inline _Val_less_iter + __val_less_iter() + { return _Val_less_iter(); } + + + inline _Val_less_iter + __val_comp_iter(_Iter_less_iter) + { return _Val_less_iter(); } + + struct _Iter_equal_to_iter + { + template + + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 == *__it2; } + }; + + + inline _Iter_equal_to_iter + __iter_equal_to_iter() + { return _Iter_equal_to_iter(); } + + struct _Iter_equal_to_val + { + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it == __val; } + }; + + + inline _Iter_equal_to_val + __iter_equal_to_val() + { return _Iter_equal_to_val(); } + + + inline _Iter_equal_to_val + __iter_comp_val(_Iter_equal_to_iter) + { return _Iter_equal_to_val(); } + + template + struct _Iter_comp_iter + { + _Compare _M_comp; + + explicit constexpr + _Iter_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) + { return bool(_M_comp(*__it1, *__it2)); } + }; + + template + constexpr + inline _Iter_comp_iter<_Compare> + __iter_comp_iter(_Compare __comp) + { return _Iter_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_comp_val + { + _Compare _M_comp; + + + explicit + _Iter_comp_val(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Iterator __it, _Value& __val) + { return bool(_M_comp(*__it, __val)); } + }; + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Compare __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Iter_comp_iter<_Compare> __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + struct _Val_comp_iter + { + _Compare _M_comp; + + + explicit + _Val_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Value& __val, _Iterator __it) + { return bool(_M_comp(__val, *__it)); } + }; + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Compare __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Iter_comp_iter<_Compare> __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_equals_val + { + _Value& _M_value; + + + explicit + _Iter_equals_val(_Value& __value) + : _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return *__it == _M_value; } + }; + + template + + inline _Iter_equals_val<_Value> + __iter_equals_val(_Value& __val) + { return _Iter_equals_val<_Value>(__val); } + + template + struct _Iter_equals_iter + { + _Iterator1 _M_it1; + + + explicit + _Iter_equals_iter(_Iterator1 __it1) + : _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return *__it2 == *_M_it1; } + }; + + template + + inline _Iter_equals_iter<_Iterator> + __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) + { return _Iter_equals_iter<_Iterator>(__it); } + + template + struct _Iter_pred + { + _Predicate _M_pred; + + + explicit + _Iter_pred(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_pred<_Predicate> + __pred_iter(_Predicate __pred) + { return _Iter_pred<_Predicate>(std::move(__pred)); } + + template + struct _Iter_comp_to_val + { + _Compare _M_comp; + _Value& _M_value; + + + _Iter_comp_to_val(_Compare __comp, _Value& __value) + : _M_comp(std::move(__comp)), _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_comp(*__it, _M_value)); } + }; + + template + _Iter_comp_to_val<_Compare, _Value> + + __iter_comp_val(_Compare __comp, _Value &__val) + { + return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val); + } + + template + struct _Iter_comp_to_iter + { + _Compare _M_comp; + _Iterator1 _M_it1; + + + _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) + : _M_comp(std::move(__comp)), _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return bool(_M_comp(*__it2, *_M_it1)); } + }; + + template + + inline _Iter_comp_to_iter<_Compare, _Iterator> + __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) + { + return _Iter_comp_to_iter<_Compare, _Iterator>( + std::move(__comp._M_comp), __it); + } + + template + struct _Iter_negate + { + _Predicate _M_pred; + + + explicit + _Iter_negate(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return !bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_negate<_Predicate> + __negate(_Iter_pred<_Predicate> __pred) + { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } + +} +} +# 72 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 + +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/concepts" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/concepts" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/concepts" 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/concepts" 2 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 2 3 +# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 + template + constexpr _Tp + __rotl(_Tp __x, int __s) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) == 0) + { + + + constexpr unsigned __uNd = _Nd; + const unsigned __r = __s; + return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd)); + } + const int __r = __s % _Nd; + if (__r == 0) + return __x; + else if (__r > 0) + return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); + else + return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); + } + + template + constexpr _Tp + __rotr(_Tp __x, int __s) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) == 0) + { + + + constexpr unsigned __uNd = _Nd; + const unsigned __r = __s; + return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd)); + } + const int __r = __s % _Nd; + if (__r == 0) + return __x; + else if (__r > 0) + return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); + else + return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); + } + + template + constexpr int + __countl_zero(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + if (__x == 0) + return _Nd; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + { + constexpr int __diff = _Nd_u - _Nd; + return __builtin_clz(__x) - __diff; + } + else if constexpr (_Nd <= _Nd_ul) + { + constexpr int __diff = _Nd_ul - _Nd; + return __builtin_clzl(__x) - __diff; + } + else if constexpr (_Nd <= _Nd_ull) + { + constexpr int __diff = _Nd_ull - _Nd; + return __builtin_clzll(__x) - __diff; + } + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + unsigned long long __high = __x >> _Nd_ull; + if (__high != 0) + { + constexpr int __diff = (2 * _Nd_ull) - _Nd; + return __builtin_clzll(__high) - __diff; + } + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + return (_Nd - _Nd_ull) + __builtin_clzll(__low); + } + } + + template + constexpr int + __countl_one(_Tp __x) noexcept + { + return std::__countl_zero<_Tp>((_Tp)~__x); + } + + template + constexpr int + __countr_zero(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + if (__x == 0) + return _Nd; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + return __builtin_ctz(__x); + else if constexpr (_Nd <= _Nd_ul) + return __builtin_ctzl(__x); + else if constexpr (_Nd <= _Nd_ull) + return __builtin_ctzll(__x); + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + if (__low != 0) + return __builtin_ctzll(__low); + unsigned long long __high = __x >> _Nd_ull; + return __builtin_ctzll(__high) + _Nd_ull; + } + } + + template + constexpr int + __countr_one(_Tp __x) noexcept + { + return std::__countr_zero((_Tp)~__x); + } + + template + constexpr int + __popcount(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + return __builtin_popcount(__x); + else if constexpr (_Nd <= _Nd_ul) + return __builtin_popcountl(__x); + else if constexpr (_Nd <= _Nd_ull) + return __builtin_popcountll(__x); + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + unsigned long long __high = __x >> _Nd_ull; + return __builtin_popcountll(__low) + __builtin_popcountll(__high); + } + } + + template + constexpr bool + __has_single_bit(_Tp __x) noexcept + { return std::__popcount(__x) == 1; } + + template + constexpr _Tp + __bit_ceil(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + if (__x == 0 || __x == 1) + return 1; + auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u)); + + + + + if (!std::__is_constant_evaluated()) + { + do { if (std::__is_constant_evaluated() && !bool(__shift_exponent != __int_traits<_Tp>::__digits)) std::__glibcxx_assert_fail(); } while (false); + } + + using __promoted_type = decltype(__x << 1); + if constexpr (!is_same<__promoted_type, _Tp>::value) + { + + + + + + const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; + __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; + } + return (_Tp)1u << __shift_exponent; + } + + template + constexpr _Tp + __bit_floor(_Tp __x) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if (__x == 0) + return 0; + return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1))); + } + + template + constexpr int + __bit_width(_Tp __x) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + return _Nd - std::__countl_zero(__x); + } +# 482 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 + +} +# 77 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + template + constexpr + inline int + __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num) + { + + static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp"); +# 108 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); + } +# 152 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline void + iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) + { + + + + +# 185 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + swap(*__a, *__b); + + } +# 201 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + _ForwardIterator2 + swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + std::iter_swap(__first1, __first2); + return __first2; + } +# 230 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b) + { + + + + if (__b < __a) + return __b; + return __a; + } +# 254 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b) + { + + + + if (__a < __b) + return __b; + return __a; + } +# 278 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__b, __a)) + return __b; + return __a; + } +# 300 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__a, __b)) + return __b; + return __a; + } + + + + template + + inline _Iterator + __niter_base(_Iterator __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it; } +# 332 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + decltype(std::__niter_base(std::declval<_Ite>())) + __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, + std::random_access_iterator_tag>&) + noexcept(std::is_nothrow_copy_constructible<_Ite>::value); + + + + + + template + + inline _From + __niter_wrap(_From __from, _To __res) + { return __from + (std::__niter_base(__res) - std::__niter_base(__from)); } + + + template + + inline _Iterator + __niter_wrap(const _Iterator&, _Iterator __res) + { return __res; } + + + + + + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = *__first; + return __result; + } + }; + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = std::move(*__first); + return __result; + } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = *__first; + ++__first; + ++__result; + } + return __result; + } + + template + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to = *__from; } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = std::move(*__first); + ++__first; + ++__result; + } + return __result; + } + + template + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to = std::move(*__from); } + }; + + + template + struct __copy_move<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_m(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num = __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); + else if (_Num == 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result, __first); + return __result + _Num; + } + }; + + + + template + struct _Deque_iterator; + + struct _Bit_iterator; + + + + + + + template + struct char_traits; + + template + class istreambuf_iterator; + + template + class ostreambuf_iterator; + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(_CharT*, _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(const _CharT*, const _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + _CharT*>::__type + __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_move_a2( + istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>); + + + template + + inline _OI + __copy_move_a2(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::iterator_category _Category; + + + + + + return std::__copy_move<_IsMove, __memcpyable<_OI, _II>::__value, + _Category>::__copy_m(__first, __last, __result); + } + + template + _OI + __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + std::_Deque_iterator<_OTp, _OTp&, _OTp*> + __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_OTp, _OTp&, _OTp*>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, + std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + + inline _OI + __copy_move_a1(_II __first, _II __last, _OI __result) + { return std::__copy_move_a2<_IsMove>(__first, __last, __result); } + + template + + inline _OI + __copy_move_a(_II __first, _II __last, _OI __result) + { + return std::__niter_wrap(__result, + std::__copy_move_a1<_IsMove>(std::__niter_base(__first), + std::__niter_base(__last), + std::__niter_base(__result))); + } + + template + + _OI + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + + ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); + + template + + _OutputIterator + __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, + bool) + { + if (__n > 0) + { + while (true) + { + *__result = *__first; + ++__result; + if (--__n > 0) + ++__first; + else + break; + } + } + return __result; + } + + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, _CharT*>::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, + _Size, _CharT*, bool); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, _Size, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>, + bool); +# 639 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _OI + copy(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a<__is_move_iterator<_II>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 672 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _OI + move(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a(std::__miter_base(__first), + std::__miter_base(__last), __result); + } + + + + + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = *--__last; + return __result; + } + }; + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n = __last - __first; + for (; __n > 0; --__n) + *--__result = *--__last; + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n = __last - __first; + for (; __n > 0; --__n) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template + struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_move_b(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num = __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); + else if (_Num == 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result - 1, __first); + return __result - _Num; + } + }; + + template + + inline _BI2 + __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) + { + typedef typename iterator_traits<_BI1>::iterator_category _Category; + + + + + + return std::__copy_move_backward<_IsMove, + __memcpyable<_BI2, _BI1>::__value, + _Category>::__copy_move_b(__first, + __last, + __result); + } + + template + + inline _BI2 + __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) + { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); } + + template + _OI + __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + std::_Deque_iterator<_OTp, _OTp&, _OTp*> + __copy_move_backward_a1( + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_OTp, _OTp&, _OTp*>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, + std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __copy_move_backward_a1(_II, _II, + std::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + + inline _OI + __copy_move_backward_a(_II __first, _II __last, _OI __result) + { + return std::__niter_wrap(__result, + std::__copy_move_backward_a1<_IsMove> + (std::__niter_base(__first), std::__niter_base(__last), + std::__niter_base(__result))); + } + + template + + _OI + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_backward_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + + ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); +# 875 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _BI2 + copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + ; + + return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 910 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _BI2 + move_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + ; + + return std::__copy_move_backward_a(std::__miter_base(__first), + std::__miter_base(__last), + __result); + } + + + + + + + template + + inline typename + __gnu_cxx::__enable_if::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + for (; __first != __last; ++__first) + *__first = __value; + } + + template + + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __first != __last; ++__first) + *__first = __tmp; + } + + + template + + inline typename + __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type + __fill_a1(_Tp* __first, _Tp* __last, const _Tp& __c) + { + const _Tp __tmp = __c; +# 971 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + if (const size_t __len = __last - __first) + __builtin_memset(__first, static_cast(__tmp), __len); + } + + template + + inline void + __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first, + ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last, + const _Tp& __value) + { std::__fill_a1(__first.base(), __last.base(), __value); } + + template + void + __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const _VTp&); + + + void + __fill_a1(std::_Bit_iterator, std::_Bit_iterator, + const bool&); + + template + + inline void + __fill_a(_FIte __first, _FIte __last, const _Tp& __value) + { std::__fill_a1(__first, __last, __value); } + + template + + void + __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const _Tp&); +# 1019 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline void + fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) + { + + + + ; + + std::__fill_a(__first, __last, __value); + } + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wlong-long" + + inline constexpr int + __size_to_integer(int __n) { return __n; } + inline constexpr unsigned + __size_to_integer(unsigned __n) { return __n; } + inline constexpr long + __size_to_integer(long __n) { return __n; } + inline constexpr unsigned long + __size_to_integer(unsigned long __n) { return __n; } + inline constexpr long long + __size_to_integer(long long __n) { return __n; } + inline constexpr unsigned long long + __size_to_integer(unsigned long long __n) { return __n; } + + + __extension__ inline constexpr __int128 + __size_to_integer(__int128 __n) { return __n; } + __extension__ inline constexpr unsigned __int128 + __size_to_integer(unsigned __int128 __n) { return __n; } +# 1073 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + inline constexpr long long + __size_to_integer(float __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(double __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(long double __n) { return (long long)__n; } + + __extension__ inline constexpr long long + __size_to_integer(__float128 __n) { return (long long)__n; } + +#pragma GCC diagnostic pop + + template + + inline typename + __gnu_cxx::__enable_if::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + for (; __n > 0; --__n, (void) ++__first) + *__first = __value; + return __first; + } + + template + + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __n > 0; --__n, (void) ++__first) + *__first = __tmp; + return __first; + } + + template + + ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first, + _Size __n, const _Tp& __value, + std::input_iterator_tag); + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::output_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + return __fill_n_a1(__first, __n, __value); + } + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::input_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + return __fill_n_a1(__first, __n, __value); + } + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::random_access_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + if (__n <= 0) + return __first; + + ; + + std::__fill_a(__first, __first + __n, __value); + return __first + __n; + } +# 1175 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _OI + fill_n(_OI __first, _Size __n, const _Tp& __value) + { + + + + return std::__fill_n_a(__first, std::__size_to_integer(__n), __value, + std::__iterator_category(__first)); + } + + template + struct __equal + { + template + + static bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + for (; __first1 != __last1; ++__first1, (void) ++__first2) + if (!(*__first1 == *__first2)) + return false; + return true; + } + }; + + template<> + struct __equal + { + template + + static bool + equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) + { + if (const size_t __len = (__last1 - __first1)) + return !std::__memcmp(__first1, __first2, __len); + return true; + } + }; + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _II); + + template + bool + __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(_II, _II, + std::_Deque_iterator<_Tp, _Ref, _Ptr>); + + template + + inline bool + __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + const bool __simple = ((__is_integer<_ValueType1>::__value + || __is_pointer<_ValueType1>::__value) + && __memcmpable<_II1, _II2>::__value); + return std::__equal<__simple>::equal(__first1, __last1, __first2); + } + + template + + inline bool + __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) + { + return std::__equal_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2)); + } + + template + + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + _II2); + + template + + bool + __equal_aux(_II1, _II1, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + struct __lc_rai + { + template + + static _II1 + __newlast1(_II1, _II1 __last1, _II2, _II2) + { return __last1; } + + template + + static bool + __cnd2(_II __first, _II __last) + { return __first != __last; } + }; + + template<> + struct __lc_rai + { + template + + static _RAI1 + __newlast1(_RAI1 __first1, _RAI1 __last1, + _RAI2 __first2, _RAI2 __last2) + { + const typename iterator_traits<_RAI1>::difference_type + __diff1 = __last1 - __first1; + const typename iterator_traits<_RAI2>::difference_type + __diff2 = __last2 - __first2; + return __diff2 < __diff1 ? __first1 + __diff2 : __last1; + } + + template + static bool + __cnd2(_RAI, _RAI) + { return true; } + }; + + template + + bool + __lexicographical_compare_impl(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, + _Compare __comp) + { + typedef typename iterator_traits<_II1>::iterator_category _Category1; + typedef typename iterator_traits<_II2>::iterator_category _Category2; + typedef std::__lc_rai<_Category1, _Category2> __rai_type; + + __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); + for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); + ++__first1, (void)++__first2) + { + if (__comp(__first1, __first2)) + return true; + if (__comp(__first2, __first1)) + return false; + } + return __first1 == __last1 && __first2 != __last2; + } + + template + struct __lexicographical_compare + { + template + + static bool + __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using __gnu_cxx::__ops::__iter_less_iter; + return std::__lexicographical_compare_impl(__first1, __last1, + __first2, __last2, + __iter_less_iter()); + } + + template + + static int + __3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + while (__first1 != __last1) + { + if (__first2 == __last2) + return +1; + if (*__first1 < *__first2) + return -1; + if (*__first2 < *__first1) + return +1; + ++__first1; + ++__first2; + } + return int(__first2 == __last2) - 1; + } + }; + + template<> + struct __lexicographical_compare + { + template + + static bool + __lc(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { return __3way(__first1, __last1, __first2, __last2) < 0; } + + template + + static ptrdiff_t + __3way(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { + const size_t __len1 = __last1 - __first1; + const size_t __len2 = __last2 - __first2; + if (const size_t __len = std::min(__len1, __len2)) + if (int __result = std::__memcmp(__first1, __first2, __len)) + return __result; + return ptrdiff_t(__len1 - __len2); + } + }; + + template + + inline bool + __lexicographical_compare_aux1(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + typedef typename iterator_traits<_II2>::value_type _ValueType2; + const bool __simple = + (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value + && __is_pointer<_II1>::__value + && __is_pointer<_II2>::__value + + + + + + + + ); + + return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, + __first2, __last2); + } + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + _Tp2*, _Tp2*); + + template + bool + __lexicographical_compare_aux1(_Tp1*, _Tp1*, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + + inline bool + __lexicographical_compare_aux(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + return std::__lexicographical_compare_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2), + std::__niter_base(__last2)); + } + + template + + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + _II2, _II2); + + template + + bool + __lexicographical_compare_aux( + _II1, _II1, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + + _ForwardIterator + __lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len = std::distance(__first, __last); + + while (__len > 0) + { + _DistanceType __half = __len >> 1; + _ForwardIterator __middle = __first; + std::advance(__middle, __half); + if (__comp(__middle, __val)) + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + else + __len = __half; + } + return __first; + } +# 1527 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline _ForwardIterator + lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + + + + + ; + + return std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val()); + } + + + + template + inline constexpr _Tp + __lg(_Tp __n) + { + + return std::__bit_width(make_unsigned_t<_Tp>(__n)) - 1; +# 1563 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + } + + +# 1579 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + + + + + + + ; + + return std::__equal_aux(__first1, __last1, __first2); + } +# 1610 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return true; + } + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++17-extensions" + + + template + + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if constexpr (_RAIters::value) + { + if ((__last1 - __first1) != (__last2 - __first2)) + return false; + return std::equal(__first1, __last1, __first2); + } + else + { + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!(*__first1 == *__first2)) + return false; + return __first1 == __last1 && __first2 == __last2; + } + } + + + template + + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, + _BinaryPredicate __binary_pred) + { + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if constexpr (_RAIters::value) + { + if ((__last1 - __first1) != (__last2 - __first2)) + return false; + return std::equal(__first1, __last1, __first2, + __binary_pred); + } + else + { + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return __first1 == __last1 && __first2 == __last2; + } + } +#pragma GCC diagnostic pop +# 1701 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + + + + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2); + } +# 1734 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2, + __binary_pred); + } +# 1766 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + + + + + + + + + + ; + ; + + return std::__lexicographical_compare_aux(__first1, __last1, + __first2, __last2); + } +# 1801 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, _Compare __comp) + { + + + + ; + ; + + return std::__lexicographical_compare_impl + (__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 1916 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 1944 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2) + { + + + + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 1978 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + template + + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __first2 != __last2 + && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 2026 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2) + { + + + + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 2062 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + + + template + + inline _InputIterator + __find_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred, input_iterator_tag) + { + while (__first != __last && !__pred(__first)) + ++__first; + return __first; + } + + + template + + _RandomAccessIterator + __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Predicate __pred, random_access_iterator_tag) + { + typename iterator_traits<_RandomAccessIterator>::difference_type + __trip_count = (__last - __first) >> 2; + + for (; __trip_count > 0; --__trip_count) + { + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + } + + switch (__last - __first) + { + case 3: + if (__pred(__first)) + return __first; + ++__first; + + case 2: + if (__pred(__first)) + return __first; + ++__first; + + case 1: + if (__pred(__first)) + return __first; + ++__first; + + case 0: + default: + return __last; + } + } + + template + + inline _Iterator + __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) + { + return __find_if(__first, __last, __pred, + std::__iterator_category(__first)); + } + + template + + typename iterator_traits<_InputIterator>::difference_type + __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { + typename iterator_traits<_InputIterator>::difference_type __n = 0; + for (; __first != __last; ++__first) + if (__pred(__first)) + ++__n; + return __n; + } + + template + + _ForwardIterator + __remove_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + __first = std::__find_if(__first, __last, __pred); + if (__first == __last) + return __first; + _ForwardIterator __result = __first; + ++__first; + for (; __first != __last; ++__first) + if (!__pred(__first)) + { + *__result = std::move(*__first); + ++__result; + } + return __result; + } + + template + + _ForwardIterator1 + __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __predicate) + { + + if (__first1 == __last1 || __first2 == __last2) + return __first1; + + + _ForwardIterator2 __p1(__first2); + if (++__p1 == __last2) + return std::__find_if(__first1, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); + + + _ForwardIterator1 __current = __first1; + + for (;;) + { + __first1 = + std::__find_if(__first1, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); + + if (__first1 == __last1) + return __last1; + + _ForwardIterator2 __p = __p1; + __current = __first1; + if (++__current == __last1) + return __last1; + + while (__predicate(__current, __p)) + { + if (++__p == __last2) + return __first1; + if (++__current == __last1) + return __last1; + } + ++__first1; + } + return __first1; + } + + + template + + bool + __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _BinaryPredicate __pred) + { + + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!__pred(__first1, __first2)) + break; + + if (__first1 == __last1) + return true; + + + + _ForwardIterator2 __last2 = __first2; + std::advance(__last2, std::distance(__first1, __last1)); + for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) + { + if (__scan != std::__find_if(__first1, __scan, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) + continue; + + auto __matches + = std::__count_if(__first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); + if (0 == __matches || + std::__count_if(__scan, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) + != __matches) + return false; + } + return true; + } +# 2286 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + + ; + + return std::__is_permutation(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } + + + +# 2328 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _ForwardIterator1 + search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __predicate) + { + + + + + + + ; + ; + + return std::__search(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__predicate)); + } + + + +} +# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 1 3 +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + +# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +# 158 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + enum float_round_style + { + round_indeterminate = -1, + round_toward_zero = 0, + round_to_nearest = 1, + round_toward_infinity = 2, + round_toward_neg_infinity = 3 + }; + + + + + + + + enum float_denorm_style + { + + denorm_indeterminate = -1, + + denorm_absent = 0, + + denorm_present = 1 + }; +# 202 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + struct __numeric_limits_base + { + + + static constexpr bool is_specialized = false; + + + + + static constexpr int digits = 0; + + + static constexpr int digits10 = 0; + + + + + static constexpr int max_digits10 = 0; + + + + static constexpr bool is_signed = false; + + + static constexpr bool is_integer = false; + + + + + static constexpr bool is_exact = false; + + + + static constexpr int radix = 0; + + + + static constexpr int min_exponent = 0; + + + + static constexpr int min_exponent10 = 0; + + + + + static constexpr int max_exponent = 0; + + + + static constexpr int max_exponent10 = 0; + + + static constexpr bool has_infinity = false; + + + + static constexpr bool has_quiet_NaN = false; + + + + static constexpr bool has_signaling_NaN = false; + + + static constexpr float_denorm_style has_denorm = denorm_absent; + + + + static constexpr bool has_denorm_loss = false; + + + + static constexpr bool is_iec559 = false; + + + + + static constexpr bool is_bounded = false; +# 288 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + static constexpr bool is_modulo = false; + + + static constexpr bool traps = false; + + + static constexpr bool tinyness_before = false; + + + + + static constexpr float_round_style round_style = + round_toward_zero; + }; +# 311 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + template + struct numeric_limits : public __numeric_limits_base + { + + + static constexpr _Tp + min() noexcept { return _Tp(); } + + + static constexpr _Tp + max() noexcept { return _Tp(); } + + + + + static constexpr _Tp + lowest() noexcept { return _Tp(); } + + + + + static constexpr _Tp + epsilon() noexcept { return _Tp(); } + + + static constexpr _Tp + round_error() noexcept { return _Tp(); } + + + static constexpr _Tp + infinity() noexcept { return _Tp(); } + + + + static constexpr _Tp + quiet_NaN() noexcept { return _Tp(); } + + + + static constexpr _Tp + signaling_NaN() noexcept { return _Tp(); } + + + + + static constexpr _Tp + denorm_min() noexcept { return _Tp(); } + }; + + + + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; +# 383 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr bool + min() noexcept { return false; } + + static constexpr bool + max() noexcept { return true; } + + + static constexpr bool + lowest() noexcept { return min(); } + + static constexpr int digits = 1; + static constexpr int digits10 = 0; + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr bool + epsilon() noexcept { return false; } + + static constexpr bool + round_error() noexcept { return false; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr bool + infinity() noexcept { return false; } + + static constexpr bool + quiet_NaN() noexcept { return false; } + + static constexpr bool + signaling_NaN() noexcept { return false; } + + static constexpr bool + denorm_min() noexcept { return false; } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + + + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char + min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); } + + static constexpr char + max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); } + + + static constexpr char + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = ((char)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char + epsilon() noexcept { return 0; } + + static constexpr char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr + char infinity() noexcept { return char(); } + + static constexpr char + quiet_NaN() noexcept { return char(); } + + static constexpr char + signaling_NaN() noexcept { return char(); } + + static constexpr char + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr signed char + min() noexcept { return -0x7f - 1; } + + static constexpr signed char + max() noexcept { return 0x7f; } + + + static constexpr signed char + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr signed char + epsilon() noexcept { return 0; } + + static constexpr signed char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr signed char + infinity() noexcept { return static_cast(0); } + + static constexpr signed char + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr signed char + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr signed char + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned char + min() noexcept { return 0; } + + static constexpr unsigned char + max() noexcept { return 0x7f * 2U + 1; } + + + static constexpr unsigned char + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned char + epsilon() noexcept { return 0; } + + static constexpr unsigned char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned char + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned char + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned char + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned char + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr wchar_t + min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); } + + static constexpr wchar_t + max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); } + + + static constexpr wchar_t + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = ((wchar_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr wchar_t + epsilon() noexcept { return 0; } + + static constexpr wchar_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr wchar_t + infinity() noexcept { return wchar_t(); } + + static constexpr wchar_t + quiet_NaN() noexcept { return wchar_t(); } + + static constexpr wchar_t + signaling_NaN() noexcept { return wchar_t(); } + + static constexpr wchar_t + denorm_min() noexcept { return wchar_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; +# 796 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char16_t + min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); } + + static constexpr char16_t + max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); } + + static constexpr char16_t + lowest() noexcept { return min(); } + + static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136); + static constexpr int max_digits10 = 0; + static constexpr bool is_signed = ((char16_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char16_t + epsilon() noexcept { return 0; } + + static constexpr char16_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr char16_t + infinity() noexcept { return char16_t(); } + + static constexpr char16_t + quiet_NaN() noexcept { return char16_t(); } + + static constexpr char16_t + signaling_NaN() noexcept { return char16_t(); } + + static constexpr char16_t + denorm_min() noexcept { return char16_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char32_t + min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); } + + static constexpr char32_t + max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); } + + static constexpr char32_t + lowest() noexcept { return min(); } + + static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136); + static constexpr int max_digits10 = 0; + static constexpr bool is_signed = ((char32_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char32_t + epsilon() noexcept { return 0; } + + static constexpr char32_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr char32_t + infinity() noexcept { return char32_t(); } + + static constexpr char32_t + quiet_NaN() noexcept { return char32_t(); } + + static constexpr char32_t + signaling_NaN() noexcept { return char32_t(); } + + static constexpr char32_t + denorm_min() noexcept { return char32_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style = round_toward_zero; + }; + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr short + min() noexcept { return -0x7fff - 1; } + + static constexpr short + max() noexcept { return 0x7fff; } + + + static constexpr short + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0)); + static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr short + epsilon() noexcept { return 0; } + + static constexpr short + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr short + infinity() noexcept { return short(); } + + static constexpr short + quiet_NaN() noexcept { return short(); } + + static constexpr short + signaling_NaN() noexcept { return short(); } + + static constexpr short + denorm_min() noexcept { return short(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned short + min() noexcept { return 0; } + + static constexpr unsigned short + max() noexcept { return 0x7fff * 2U + 1; } + + + static constexpr unsigned short + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned short + epsilon() noexcept { return 0; } + + static constexpr unsigned short + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned short + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned short + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned short + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned short + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr int + min() noexcept { return -0x7fffffff - 1; } + + static constexpr int + max() noexcept { return 0x7fffffff; } + + + static constexpr int + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0)); + static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr int + epsilon() noexcept { return 0; } + + static constexpr int + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr int + infinity() noexcept { return static_cast(0); } + + static constexpr int + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr int + signaling_NaN() noexcept { return static_cast(0); } + + static constexpr int + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned int + min() noexcept { return 0; } + + static constexpr unsigned int + max() noexcept { return 0x7fffffff * 2U + 1; } + + + static constexpr unsigned int + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned int + epsilon() noexcept { return 0; } + + static constexpr unsigned int + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned int + infinity() noexcept { return static_cast(0); } + + static constexpr unsigned int + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned int + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned int + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr long + min() noexcept { return -0x7fffffffffffffffL - 1; } + + static constexpr long + max() noexcept { return 0x7fffffffffffffffL; } + + + static constexpr long + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0)); + static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr long + epsilon() noexcept { return 0; } + + static constexpr long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr long + infinity() noexcept { return static_cast(0); } + + static constexpr long + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr long + signaling_NaN() noexcept { return static_cast(0); } + + static constexpr long + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned long + min() noexcept { return 0; } + + static constexpr unsigned long + max() noexcept { return 0x7fffffffffffffffL * 2UL + 1; } + + + static constexpr unsigned long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned long + epsilon() noexcept { return 0; } + + static constexpr unsigned long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned long + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned long + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr long long + min() noexcept { return -0x7fffffffffffffffLL - 1; } + + static constexpr long long + max() noexcept { return 0x7fffffffffffffffLL; } + + + static constexpr long long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(long long) * 8 - ((long long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr long long + epsilon() noexcept { return 0; } + + static constexpr long long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr long long + infinity() noexcept { return static_cast(0); } + + static constexpr long long + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr long long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr long long + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned long long + min() noexcept { return 0; } + + static constexpr unsigned long long + max() noexcept { return 0x7fffffffffffffffLL * 2ULL + 1; } + + + static constexpr unsigned long long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned long long + epsilon() noexcept { return 0; } + + static constexpr unsigned long long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned long long + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; +# 1637 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + __extension__ template<> struct numeric_limits<__int128> { static constexpr bool is_specialized = true; static constexpr __int128 min() noexcept { return (((__int128)(-1) < 0) ? -(((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0) - 1 : (__int128)0); } static constexpr __int128 max() noexcept { return (((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0); } static constexpr int digits = 128 - 1; static constexpr int digits10 = (128 - 1) * 643L / 2136; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr __int128 epsilon() noexcept { return 0; } static constexpr __int128 round_error() noexcept { return 0; } static constexpr __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 0; static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr __int128 infinity() noexcept { return static_cast<__int128>(0); } static constexpr __int128 quiet_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 signaling_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 denorm_min() noexcept { return static_cast<__int128>(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; __extension__ template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr unsigned __int128 min() noexcept { return 0; } static constexpr unsigned __int128 max() noexcept { return (((unsigned __int128)(-1) < 0) ? (((((unsigned __int128)1 << ((128 - ((unsigned __int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(unsigned __int128)0); } static constexpr unsigned __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 0; static constexpr int digits = 128; static constexpr int digits10 = 128 * 643L / 2136; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr unsigned __int128 epsilon() noexcept { return 0; } static constexpr unsigned __int128 round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr unsigned __int128 infinity() noexcept { return static_cast(0); } static constexpr unsigned __int128 quiet_NaN() noexcept { return static_cast(0); } static constexpr unsigned __int128 signaling_NaN() noexcept { return static_cast(0); } static constexpr unsigned __int128 denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = true; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; +# 1669 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr float + min() noexcept { return 1.17549435082228750796873653722224568e-38F; } + + static constexpr float + max() noexcept { return 3.40282346638528859811704183484516925e+38F; } + + + static constexpr float + lowest() noexcept { return -3.40282346638528859811704183484516925e+38F; } + + + static constexpr int digits = 24; + static constexpr int digits10 = 6; + + static constexpr int max_digits10 + = (2 + (24) * 643L / 2136); + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr float + epsilon() noexcept { return 1.19209289550781250000000000000000000e-7F; } + + static constexpr float + round_error() noexcept { return 0.5F; } + + static constexpr int min_exponent = (-125); + static constexpr int min_exponent10 = (-37); + static constexpr int max_exponent = 128; + static constexpr int max_exponent10 = 38; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + static constexpr bool has_signaling_NaN = has_quiet_NaN; + static constexpr float_denorm_style has_denorm + = bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + = false; + + static constexpr float + infinity() noexcept { return __builtin_huge_valf(); } + + static constexpr float + quiet_NaN() noexcept { return __builtin_nanf(""); } + + static constexpr float + signaling_NaN() noexcept { return __builtin_nansf(""); } + + static constexpr float + denorm_min() noexcept { return 1.40129846432481707092372958328991613e-45F; } + + static constexpr bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before + = false; + static constexpr float_round_style round_style + = round_to_nearest; + }; + + + + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr double + min() noexcept { return double(2.22507385850720138309023271733240406e-308L); } + + static constexpr double + max() noexcept { return double(1.79769313486231570814527423731704357e+308L); } + + + static constexpr double + lowest() noexcept { return -double(1.79769313486231570814527423731704357e+308L); } + + + static constexpr int digits = 53; + static constexpr int digits10 = 15; + + static constexpr int max_digits10 + = (2 + (53) * 643L / 2136); + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr double + epsilon() noexcept { return double(2.22044604925031308084726333618164062e-16L); } + + static constexpr double + round_error() noexcept { return 0.5; } + + static constexpr int min_exponent = (-1021); + static constexpr int min_exponent10 = (-307); + static constexpr int max_exponent = 1024; + static constexpr int max_exponent10 = 308; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + static constexpr bool has_signaling_NaN = has_quiet_NaN; + static constexpr float_denorm_style has_denorm + = bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + = false; + + static constexpr double + infinity() noexcept { return __builtin_huge_val(); } + + static constexpr double + quiet_NaN() noexcept { return __builtin_nan(""); } + + static constexpr double + signaling_NaN() noexcept { return __builtin_nans(""); } + + static constexpr double + denorm_min() noexcept { return double(4.94065645841246544176568792868221372e-324L); } + + static constexpr bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before + = false; + static constexpr float_round_style round_style + = round_to_nearest; + }; + + + + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr long double + min() noexcept { return 3.36210314311209350626267781732175260e-4932L; } + + static constexpr long double + max() noexcept { return 1.18973149535723176502126385303097021e+4932L; } + + + static constexpr long double + lowest() noexcept { return -1.18973149535723176502126385303097021e+4932L; } + + + static constexpr int digits = 64; + static constexpr int digits10 = 18; + + static constexpr int max_digits10 + = (2 + (64) * 643L / 2136); + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr long double + epsilon() noexcept { return 1.08420217248550443400745280086994171e-19L; } + + static constexpr long double + round_error() noexcept { return 0.5L; } + + static constexpr int min_exponent = (-16381); + static constexpr int min_exponent10 = (-4931); + static constexpr int max_exponent = 16384; + static constexpr int max_exponent10 = 4932; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + static constexpr bool has_signaling_NaN = has_quiet_NaN; + static constexpr float_denorm_style has_denorm + = bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + = false; + + static constexpr long double + infinity() noexcept { return __builtin_huge_vall(); } + + static constexpr long double + quiet_NaN() noexcept { return __builtin_nanl(""); } + + static constexpr long double + signaling_NaN() noexcept { return __builtin_nansl(""); } + + static constexpr long double + denorm_min() noexcept { return 3.64519953188247460252840593361941982e-4951L; } + + static constexpr bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before = + false; + static constexpr float_round_style round_style = + round_to_nearest; + }; +# 1989 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +__extension__ template<> struct numeric_limits<_Float32> { static constexpr bool is_specialized = true; static constexpr _Float32 min() noexcept { return 1.17549435082228750796873653722224568e-38F32; } static constexpr _Float32 max() noexcept { return 3.40282346638528859811704183484516925e+38F32; } static constexpr _Float32 lowest() noexcept { return -3.40282346638528859811704183484516925e+38F32; } static constexpr int digits = 24; static constexpr int digits10 = 6; static constexpr int max_digits10 = (2 + (24) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr _Float32 epsilon() noexcept { return 1.19209289550781250000000000000000000e-7F32; } static constexpr _Float32 round_error() noexcept { return 0.5F32; } static constexpr int min_exponent = (-125); static constexpr int min_exponent10 = (-37); static constexpr int max_exponent = 128; static constexpr int max_exponent10 = 38; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr _Float32 infinity() noexcept { return __builtin_huge_valf32(); } static constexpr _Float32 quiet_NaN() noexcept { return __builtin_nanf32(""); } static constexpr _Float32 signaling_NaN() noexcept { return __builtin_nansf32(""); } static constexpr _Float32 denorm_min() noexcept { return 1.40129846432481707092372958328991613e-45F32; } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; + + +__extension__ template<> struct numeric_limits<_Float64> { static constexpr bool is_specialized = true; static constexpr _Float64 min() noexcept { return 2.22507385850720138309023271733240406e-308F64; } static constexpr _Float64 max() noexcept { return 1.79769313486231570814527423731704357e+308F64; } static constexpr _Float64 lowest() noexcept { return -1.79769313486231570814527423731704357e+308F64; } static constexpr int digits = 53; static constexpr int digits10 = 15; static constexpr int max_digits10 = (2 + (53) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr _Float64 epsilon() noexcept { return 2.22044604925031308084726333618164062e-16F64; } static constexpr _Float64 round_error() noexcept { return 0.5F64; } static constexpr int min_exponent = (-1021); static constexpr int min_exponent10 = (-307); static constexpr int max_exponent = 1024; static constexpr int max_exponent10 = 308; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr _Float64 infinity() noexcept { return __builtin_huge_valf64(); } static constexpr _Float64 quiet_NaN() noexcept { return __builtin_nanf64(""); } static constexpr _Float64 signaling_NaN() noexcept { return __builtin_nansf64(""); } static constexpr _Float64 denorm_min() noexcept { return 4.94065645841246544176568792868221372e-324F64; } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; + + +__extension__ template<> struct numeric_limits<_Float128> { static constexpr bool is_specialized = true; static constexpr _Float128 min() noexcept { return 3.36210314311209350626267781732175260e-4932F128; } static constexpr _Float128 max() noexcept { return 1.18973149535723176508575932662800702e+4932F128; } static constexpr _Float128 lowest() noexcept { return -1.18973149535723176508575932662800702e+4932F128; } static constexpr int digits = 113; static constexpr int digits10 = 33; static constexpr int max_digits10 = (2 + (113) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr _Float128 epsilon() noexcept { return 1.92592994438723585305597794258492732e-34F128; } static constexpr _Float128 round_error() noexcept { return 0.5F128; } static constexpr int min_exponent = (-16381); static constexpr int min_exponent10 = (-4931); static constexpr int max_exponent = 16384; static constexpr int max_exponent10 = 4932; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr _Float128 infinity() noexcept { return __builtin_huge_valf128(); } static constexpr _Float128 quiet_NaN() noexcept { return __builtin_nanf128(""); } static constexpr _Float128 signaling_NaN() noexcept { return __builtin_nansf128(""); } static constexpr _Float128 denorm_min() noexcept { return 6.47517511943802511092443895822764655e-4966F128; } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; +# 2087 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + __extension__ + template<> + struct numeric_limits<__float128> + { + static constexpr bool is_specialized = true; + + static constexpr __float128 + min() noexcept + { + + + + + return __extension__ 0x1.0p-16382Q; + + } + + static constexpr __float128 + max() noexcept + { + + + + + + + + return __extension__ 0x1.ffffffffffffffffffffffffffffp+16383Q; + + } + + static constexpr __float128 + lowest() noexcept + { return -max(); } + + static constexpr int digits = 113; + static constexpr int digits10 = 33; + + static constexpr int max_digits10 = 35; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr __float128 + epsilon() noexcept + { return double(1.9259299443872359e-34); } + + static constexpr __float128 + round_error() noexcept { return 0.5; } + + static constexpr int min_exponent = -16381; + static constexpr int min_exponent10 = -4931; + static constexpr int max_exponent = 16384; + static constexpr int max_exponent10 = 4932; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + + + static constexpr bool has_signaling_NaN = true; + + + + static constexpr float_denorm_style has_denorm + = denorm_present; + static constexpr bool has_denorm_loss = false; + + static constexpr __float128 + infinity() noexcept + { return __builtin_huge_val(); } + + static constexpr __float128 + quiet_NaN() noexcept + { return __builtin_nan(""); } + + static constexpr __float128 + signaling_NaN() noexcept + { + + return __builtin_nansq(""); + + + + + + } + + static constexpr __float128 + denorm_min() noexcept + { + + + + + return __extension__ 0x1.0p-16494Q; + + } + + static constexpr bool is_iec559 = has_signaling_NaN; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_to_nearest; +# 2218 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + }; + + + + +} +# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 1 3 +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 + namespace __detail + { + + + + template + struct __floating_point_constant + { + static const _Tp __value; + }; + + + + template + struct __numeric_constants + { + + static _Tp __pi() throw() + { return static_cast<_Tp>(3.1415926535897932384626433832795029L); } + + static _Tp __pi_2() throw() + { return static_cast<_Tp>(1.5707963267948966192313216916397514L); } + + static _Tp __pi_3() throw() + { return static_cast<_Tp>(1.0471975511965977461542144610931676L); } + + static _Tp __pi_4() throw() + { return static_cast<_Tp>(0.7853981633974483096156608458198757L); } + + static _Tp __1_pi() throw() + { return static_cast<_Tp>(0.3183098861837906715377675267450287L); } + + static _Tp __2_sqrtpi() throw() + { return static_cast<_Tp>(1.1283791670955125738961589031215452L); } + + static _Tp __sqrt2() throw() + { return static_cast<_Tp>(1.4142135623730950488016887242096981L); } + + static _Tp __sqrt3() throw() + { return static_cast<_Tp>(1.7320508075688772935274463415058723L); } + + static _Tp __sqrtpio2() throw() + { return static_cast<_Tp>(1.2533141373155002512078826424055226L); } + + static _Tp __sqrt1_2() throw() + { return static_cast<_Tp>(0.7071067811865475244008443621048490L); } + + static _Tp __lnpi() throw() + { return static_cast<_Tp>(1.1447298858494001741434273513530587L); } + + static _Tp __gamma_e() throw() + { return static_cast<_Tp>(0.5772156649015328606065120900824024L); } + + static _Tp __euler() throw() + { return static_cast<_Tp>(2.7182818284590452353602874713526625L); } + }; +# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 + template + inline bool __isnan(_Tp __x) + { return std::isnan(__x); } +# 133 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 + } + + + + + +} +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + namespace __detail + { +# 76 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __bernoulli_series(unsigned int __n) + { + + static const _Tp __num[28] = { + _Tp(1UL), -_Tp(1UL) / _Tp(2UL), + _Tp(1UL) / _Tp(6UL), _Tp(0UL), + -_Tp(1UL) / _Tp(30UL), _Tp(0UL), + _Tp(1UL) / _Tp(42UL), _Tp(0UL), + -_Tp(1UL) / _Tp(30UL), _Tp(0UL), + _Tp(5UL) / _Tp(66UL), _Tp(0UL), + -_Tp(691UL) / _Tp(2730UL), _Tp(0UL), + _Tp(7UL) / _Tp(6UL), _Tp(0UL), + -_Tp(3617UL) / _Tp(510UL), _Tp(0UL), + _Tp(43867UL) / _Tp(798UL), _Tp(0UL), + -_Tp(174611) / _Tp(330UL), _Tp(0UL), + _Tp(854513UL) / _Tp(138UL), _Tp(0UL), + -_Tp(236364091UL) / _Tp(2730UL), _Tp(0UL), + _Tp(8553103UL) / _Tp(6UL), _Tp(0UL) + }; + + if (__n == 0) + return _Tp(1); + + if (__n == 1) + return -_Tp(1) / _Tp(2); + + + if (__n % 2 == 1) + return _Tp(0); + + + if (__n < 28) + return __num[__n]; + + + _Tp __fact = _Tp(1); + if ((__n / 2) % 2 == 0) + __fact *= _Tp(-1); + for (unsigned int __k = 1; __k <= __n; ++__k) + __fact *= __k / (_Tp(2) * __numeric_constants<_Tp>::__pi()); + __fact *= _Tp(2); + + _Tp __sum = _Tp(0); + for (unsigned int __i = 1; __i < 1000; ++__i) + { + _Tp __term = std::pow(_Tp(__i), -_Tp(__n)); + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + __sum += __term; + } + + return __fact * __sum; + } +# 139 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + inline _Tp + __bernoulli(int __n) + { return __bernoulli_series<_Tp>(__n); } +# 153 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma_bernoulli(_Tp __x) + { + _Tp __lg = (__x - _Tp(0.5L)) * std::log(__x) - __x + + _Tp(0.5L) * std::log(_Tp(2) + * __numeric_constants<_Tp>::__pi()); + + const _Tp __xx = __x * __x; + _Tp __help = _Tp(1) / __x; + for ( unsigned int __i = 1; __i < 20; ++__i ) + { + const _Tp __2i = _Tp(2 * __i); + __help /= __2i * (__2i - _Tp(1)) * __xx; + __lg += __bernoulli<_Tp>(2 * __i) * __help; + } + + return __lg; + } +# 181 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma_lanczos(_Tp __x) + { + const _Tp __xm1 = __x - _Tp(1); + + static const _Tp __lanczos_cheb_7[9] = { + _Tp( 0.99999999999980993227684700473478L), + _Tp( 676.520368121885098567009190444019L), + _Tp(-1259.13921672240287047156078755283L), + _Tp( 771.3234287776530788486528258894L), + _Tp(-176.61502916214059906584551354L), + _Tp( 12.507343278686904814458936853L), + _Tp(-0.13857109526572011689554707L), + _Tp( 9.984369578019570859563e-6L), + _Tp( 1.50563273514931155834e-7L) + }; + + static const _Tp __LOGROOT2PI + = _Tp(0.9189385332046727417803297364056176L); + + _Tp __sum = __lanczos_cheb_7[0]; + for(unsigned int __k = 1; __k < 9; ++__k) + __sum += __lanczos_cheb_7[__k] / (__xm1 + __k); + + const _Tp __term1 = (__xm1 + _Tp(0.5L)) + * std::log((__xm1 + _Tp(7.5L)) + / __numeric_constants<_Tp>::__euler()); + const _Tp __term2 = __LOGROOT2PI + std::log(__sum); + const _Tp __result = __term1 + (__term2 - _Tp(7)); + + return __result; + } +# 225 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma(_Tp __x) + { + if (__x > _Tp(0.5L)) + return __log_gamma_lanczos(__x); + else + { + const _Tp __sin_fact + = std::abs(std::sin(__numeric_constants<_Tp>::__pi() * __x)); + if (__sin_fact == _Tp(0)) + std::__throw_domain_error(("Argument is nonpositive integer " "in __log_gamma") + ); + return __numeric_constants<_Tp>::__lnpi() + - std::log(__sin_fact) + - __log_gamma_lanczos(_Tp(1) - __x); + } + } +# 252 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma_sign(_Tp __x) + { + if (__x > _Tp(0)) + return _Tp(1); + else + { + const _Tp __sin_fact + = std::sin(__numeric_constants<_Tp>::__pi() * __x); + if (__sin_fact > _Tp(0)) + return (1); + else if (__sin_fact < _Tp(0)) + return -_Tp(1); + else + return _Tp(0); + } + } +# 283 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __log_bincoef(unsigned int __n, unsigned int __k) + { + + static const _Tp __max_bincoeff + = std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + _Tp __coeff = ::std::lgamma(_Tp(1 + __n)) + - ::std::lgamma(_Tp(1 + __k)) + - ::std::lgamma(_Tp(1 + __n - __k)); + + + + + + } +# 314 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __bincoef(unsigned int __n, unsigned int __k) + { + + static const _Tp __max_bincoeff + = std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + const _Tp __log_coeff = __log_bincoef<_Tp>(__n, __k); + if (__log_coeff > __max_bincoeff) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return std::exp(__log_coeff); + } +# 337 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + inline _Tp + __gamma(_Tp __x) + { return std::exp(__log_gamma(__x)); } +# 356 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __psi_series(_Tp __x) + { + _Tp __sum = -__numeric_constants<_Tp>::__gamma_e() - _Tp(1) / __x; + const unsigned int __max_iter = 100000; + for (unsigned int __k = 1; __k < __max_iter; ++__k) + { + const _Tp __term = __x / (__k * (__k + __x)); + __sum += __term; + if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon()) + break; + } + return __sum; + } +# 386 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __psi_asymp(_Tp __x) + { + _Tp __sum = std::log(__x) - _Tp(0.5L) / __x; + const _Tp __xx = __x * __x; + _Tp __xp = __xx; + const unsigned int __max_iter = 100; + for (unsigned int __k = 1; __k < __max_iter; ++__k) + { + const _Tp __term = __bernoulli<_Tp>(2 * __k) / (2 * __k * __xp); + __sum -= __term; + if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon()) + break; + __xp *= __xx; + } + return __sum; + } +# 417 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __psi(_Tp __x) + { + const int __n = static_cast(__x + 0.5L); + const _Tp __eps = _Tp(4) * std::numeric_limits<_Tp>::epsilon(); + if (__n <= 0 && std::abs(__x - _Tp(__n)) < __eps) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x < _Tp(0)) + { + const _Tp __pi = __numeric_constants<_Tp>::__pi(); + return __psi(_Tp(1) - __x) + - __pi * std::cos(__pi * __x) / std::sin(__pi * __x); + } + else if (__x > _Tp(100)) + return __psi_asymp(__x); + else + return __psi_series(__x); + } +# 446 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __psi(unsigned int __n, _Tp __x) + { + if (__x <= _Tp(0)) + std::__throw_domain_error(("Argument out of range " "in __psi") + ); + else if (__n == 0) + return __psi(__x); + else + { + const _Tp __hzeta = __hurwitz_zeta(_Tp(__n + 1), __x); + + const _Tp __ln_nfact = ::std::lgamma(_Tp(__n + 1)); + + + + _Tp __result = std::exp(__ln_nfact) * __hzeta; + if (__n % 2 == 1) + __result = -__result; + return __result; + } + } + } + + + + + + +} +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 1 3 +# 55 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 71 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + namespace __detail + { +# 98 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + void + __gamma_temme(_Tp __mu, + _Tp & __gam1, _Tp & __gam2, _Tp & __gampl, _Tp & __gammi) + { + + __gampl = _Tp(1) / ::std::tgamma(_Tp(1) + __mu); + __gammi = _Tp(1) / ::std::tgamma(_Tp(1) - __mu); + + + + + + if (std::abs(__mu) < std::numeric_limits<_Tp>::epsilon()) + __gam1 = -_Tp(__numeric_constants<_Tp>::__gamma_e()); + else + __gam1 = (__gammi - __gampl) / (_Tp(2) * __mu); + + __gam2 = (__gammi + __gampl) / (_Tp(2)); + + return; + } +# 136 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + void + __bessel_jn(_Tp __nu, _Tp __x, + _Tp & __Jnu, _Tp & __Nnu, _Tp & __Jpnu, _Tp & __Npnu) + { + if (__x == _Tp(0)) + { + if (__nu == _Tp(0)) + { + __Jnu = _Tp(1); + __Jpnu = _Tp(0); + } + else if (__nu == _Tp(1)) + { + __Jnu = _Tp(0); + __Jpnu = _Tp(0.5L); + } + else + { + __Jnu = _Tp(0); + __Jpnu = _Tp(0); + } + __Nnu = -std::numeric_limits<_Tp>::infinity(); + __Npnu = std::numeric_limits<_Tp>::infinity(); + return; + } + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + + + + const _Tp __fp_min = std::sqrt(std::numeric_limits<_Tp>::min()); + const int __max_iter = 15000; + const _Tp __x_min = _Tp(2); + + const int __nl = (__x < __x_min + ? static_cast(__nu + _Tp(0.5L)) + : std::max(0, static_cast(__nu - __x + _Tp(1.5L)))); + + const _Tp __mu = __nu - __nl; + const _Tp __mu2 = __mu * __mu; + const _Tp __xi = _Tp(1) / __x; + const _Tp __xi2 = _Tp(2) * __xi; + _Tp __w = __xi2 / __numeric_constants<_Tp>::__pi(); + int __isign = 1; + _Tp __h = __nu * __xi; + if (__h < __fp_min) + __h = __fp_min; + _Tp __b = __xi2 * __nu; + _Tp __d = _Tp(0); + _Tp __c = __h; + int __i; + for (__i = 1; __i <= __max_iter; ++__i) + { + __b += __xi2; + __d = __b - __d; + if (std::abs(__d) < __fp_min) + __d = __fp_min; + __c = __b - _Tp(1) / __c; + if (std::abs(__c) < __fp_min) + __c = __fp_min; + __d = _Tp(1) / __d; + const _Tp __del = __c * __d; + __h *= __del; + if (__d < _Tp(0)) + __isign = -__isign; + if (std::abs(__del - _Tp(1)) < __eps) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Argument x too large in __bessel_jn; " "try asymptotic expansion.") + ); + _Tp __Jnul = __isign * __fp_min; + _Tp __Jpnul = __h * __Jnul; + _Tp __Jnul1 = __Jnul; + _Tp __Jpnu1 = __Jpnul; + _Tp __fact = __nu * __xi; + for ( int __l = __nl; __l >= 1; --__l ) + { + const _Tp __Jnutemp = __fact * __Jnul + __Jpnul; + __fact -= __xi; + __Jpnul = __fact * __Jnutemp - __Jnul; + __Jnul = __Jnutemp; + } + if (__Jnul == _Tp(0)) + __Jnul = __eps; + _Tp __f= __Jpnul / __Jnul; + _Tp __Nmu, __Nnu1, __Npmu, __Jmu; + if (__x < __x_min) + { + const _Tp __x2 = __x / _Tp(2); + const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu; + _Tp __fact = (std::abs(__pimu) < __eps + ? _Tp(1) : __pimu / std::sin(__pimu)); + _Tp __d = -std::log(__x2); + _Tp __e = __mu * __d; + _Tp __fact2 = (std::abs(__e) < __eps + ? _Tp(1) : std::sinh(__e) / __e); + _Tp __gam1, __gam2, __gampl, __gammi; + __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi); + _Tp __ff = (_Tp(2) / __numeric_constants<_Tp>::__pi()) + * __fact * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d); + __e = std::exp(__e); + _Tp __p = __e / (__numeric_constants<_Tp>::__pi() * __gampl); + _Tp __q = _Tp(1) / (__e * __numeric_constants<_Tp>::__pi() * __gammi); + const _Tp __pimu2 = __pimu / _Tp(2); + _Tp __fact3 = (std::abs(__pimu2) < __eps + ? _Tp(1) : std::sin(__pimu2) / __pimu2 ); + _Tp __r = __numeric_constants<_Tp>::__pi() * __pimu2 * __fact3 * __fact3; + _Tp __c = _Tp(1); + __d = -__x2 * __x2; + _Tp __sum = __ff + __r * __q; + _Tp __sum1 = __p; + for (__i = 1; __i <= __max_iter; ++__i) + { + __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2); + __c *= __d / _Tp(__i); + __p /= _Tp(__i) - __mu; + __q /= _Tp(__i) + __mu; + const _Tp __del = __c * (__ff + __r * __q); + __sum += __del; + const _Tp __del1 = __c * __p - __i * __del; + __sum1 += __del1; + if ( std::abs(__del) < __eps * (_Tp(1) + std::abs(__sum)) ) + break; + } + if ( __i > __max_iter ) + std::__throw_runtime_error(("Bessel y series failed to converge " "in __bessel_jn.") + ); + __Nmu = -__sum; + __Nnu1 = -__sum1 * __xi2; + __Npmu = __mu * __xi * __Nmu - __Nnu1; + __Jmu = __w / (__Npmu - __f * __Nmu); + } + else + { + _Tp __a = _Tp(0.25L) - __mu2; + _Tp __q = _Tp(1); + _Tp __p = -__xi / _Tp(2); + _Tp __br = _Tp(2) * __x; + _Tp __bi = _Tp(2); + _Tp __fact = __a * __xi / (__p * __p + __q * __q); + _Tp __cr = __br + __q * __fact; + _Tp __ci = __bi + __p * __fact; + _Tp __den = __br * __br + __bi * __bi; + _Tp __dr = __br / __den; + _Tp __di = -__bi / __den; + _Tp __dlr = __cr * __dr - __ci * __di; + _Tp __dli = __cr * __di + __ci * __dr; + _Tp __temp = __p * __dlr - __q * __dli; + __q = __p * __dli + __q * __dlr; + __p = __temp; + int __i; + for (__i = 2; __i <= __max_iter; ++__i) + { + __a += _Tp(2 * (__i - 1)); + __bi += _Tp(2); + __dr = __a * __dr + __br; + __di = __a * __di + __bi; + if (std::abs(__dr) + std::abs(__di) < __fp_min) + __dr = __fp_min; + __fact = __a / (__cr * __cr + __ci * __ci); + __cr = __br + __cr * __fact; + __ci = __bi - __ci * __fact; + if (std::abs(__cr) + std::abs(__ci) < __fp_min) + __cr = __fp_min; + __den = __dr * __dr + __di * __di; + __dr /= __den; + __di /= -__den; + __dlr = __cr * __dr - __ci * __di; + __dli = __cr * __di + __ci * __dr; + __temp = __p * __dlr - __q * __dli; + __q = __p * __dli + __q * __dlr; + __p = __temp; + if (std::abs(__dlr - _Tp(1)) + std::abs(__dli) < __eps) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Lentz's method failed " "in __bessel_jn.") + ); + const _Tp __gam = (__p - __f) / __q; + __Jmu = std::sqrt(__w / ((__p - __f) * __gam + __q)); + + __Jmu = ::std::copysign(__Jmu, __Jnul); + + + + + __Nmu = __gam * __Jmu; + __Npmu = (__p + __q / __gam) * __Nmu; + __Nnu1 = __mu * __xi * __Nmu - __Npmu; + } + __fact = __Jmu / __Jnul; + __Jnu = __fact * __Jnul1; + __Jpnu = __fact * __Jpnu1; + for (__i = 1; __i <= __nl; ++__i) + { + const _Tp __Nnutemp = (__mu + __i) * __xi2 * __Nnu1 - __Nmu; + __Nmu = __Nnu1; + __Nnu1 = __Nnutemp; + } + __Nnu = __Nmu; + __Npnu = __nu * __xi * __Nmu - __Nnu1; + + return; + } +# 361 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + void + __cyl_bessel_jn_asymp(_Tp __nu, _Tp __x, _Tp & __Jnu, _Tp & __Nnu) + { + const _Tp __mu = _Tp(4) * __nu * __nu; + const _Tp __8x = _Tp(8) * __x; + + _Tp __P = _Tp(0); + _Tp __Q = _Tp(0); + + _Tp __k = _Tp(0); + _Tp __term = _Tp(1); + + int __epsP = 0; + int __epsQ = 0; + + _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + do + { + __term *= (__k == 0 + ? _Tp(1) + : -(__mu - (2 * __k - 1) * (2 * __k - 1)) / (__k * __8x)); + + __epsP = std::abs(__term) < __eps * std::abs(__P); + __P += __term; + + __k++; + + __term *= (__mu - (2 * __k - 1) * (2 * __k - 1)) / (__k * __8x); + __epsQ = std::abs(__term) < __eps * std::abs(__Q); + __Q += __term; + + if (__epsP && __epsQ && __k > (__nu / 2.)) + break; + + __k++; + } + while (__k < 1000); + + const _Tp __chi = __x - (__nu + _Tp(0.5L)) + * __numeric_constants<_Tp>::__pi_2(); + + const _Tp __c = std::cos(__chi); + const _Tp __s = std::sin(__chi); + + const _Tp __coef = std::sqrt(_Tp(2) + / (__numeric_constants<_Tp>::__pi() * __x)); + + __Jnu = __coef * (__c * __P - __s * __Q); + __Nnu = __coef * (__s * __P + __c * __Q); + + return; + } +# 444 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_bessel_ij_series(_Tp __nu, _Tp __x, _Tp __sgn, + unsigned int __max_iter) + { + if (__x == _Tp(0)) + return __nu == _Tp(0) ? _Tp(1) : _Tp(0); + + const _Tp __x2 = __x / _Tp(2); + _Tp __fact = __nu * std::log(__x2); + + __fact -= ::std::lgamma(__nu + _Tp(1)); + + + + __fact = std::exp(__fact); + const _Tp __xx4 = __sgn * __x2 * __x2; + _Tp __Jn = _Tp(1); + _Tp __term = _Tp(1); + + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + __term *= __xx4 / (_Tp(__i) * (__nu + _Tp(__i))); + __Jn += __term; + if (std::abs(__term / __Jn) < std::numeric_limits<_Tp>::epsilon()) + break; + } + + return __fact * __Jn; + } +# 490 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_bessel_j(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_j.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x * __x < _Tp(10) * (__nu + _Tp(1))) + return __cyl_bessel_ij_series(__nu, __x, -_Tp(1), 200); + else if (__x > _Tp(1000)) + { + _Tp __J_nu, __N_nu; + __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); + return __J_nu; + } + else + { + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + return __J_nu; + } + } +# 532 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_neumann_n(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_neumann_n.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x > _Tp(1000)) + { + _Tp __J_nu, __N_nu; + __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); + return __N_nu; + } + else + { + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + return __N_nu; + } + } +# 569 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + void + __sph_bessel_jn(unsigned int __n, _Tp __x, + _Tp & __j_n, _Tp & __n_n, _Tp & __jp_n, _Tp & __np_n) + { + const _Tp __nu = _Tp(__n) + _Tp(0.5L); + + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + + const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2() + / std::sqrt(__x); + + __j_n = __factor * __J_nu; + __n_n = __factor * __N_nu; + __jp_n = __factor * __Jp_nu - __j_n / (_Tp(2) * __x); + __np_n = __factor * __Np_nu - __n_n / (_Tp(2) * __x); + + return; + } +# 604 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + _Tp + __sph_bessel(unsigned int __n, _Tp __x) + { + if (__x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __sph_bessel.") + ); + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x == _Tp(0)) + { + if (__n == 0) + return _Tp(1); + else + return _Tp(0); + } + else + { + _Tp __j_n, __n_n, __jp_n, __np_n; + __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n); + return __j_n; + } + } +# 642 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + _Tp + __sph_neumann(unsigned int __n, _Tp __x) + { + if (__x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __sph_neumann.") + ); + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x == _Tp(0)) + return -std::numeric_limits<_Tp>::infinity(); + else + { + _Tp __j_n, __n_n, __jp_n, __np_n; + __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n); + return __n_n; + } + } + } + + + + + + +} +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 1 3 +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + namespace __detail + { +# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + template + _Tp + __beta_gamma(_Tp __x, _Tp __y) + { + + _Tp __bet; + + if (__x > __y) + { + __bet = ::std::tgamma(__x) + / ::std::tgamma(__x + __y); + __bet *= ::std::tgamma(__y); + } + else + { + __bet = ::std::tgamma(__y) + / ::std::tgamma(__x + __y); + __bet *= ::std::tgamma(__x); + } +# 111 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + return __bet; + } +# 127 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + template + _Tp + __beta_lgamma(_Tp __x, _Tp __y) + { + + _Tp __bet = ::std::lgamma(__x) + + ::std::lgamma(__y) + - ::std::lgamma(__x + __y); + + + + + + __bet = std::exp(__bet); + return __bet; + } +# 158 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + template + _Tp + __beta_product(_Tp __x, _Tp __y) + { + + _Tp __bet = (__x + __y) / (__x * __y); + + unsigned int __max_iter = 1000000; + for (unsigned int __k = 1; __k < __max_iter; ++__k) + { + _Tp __term = (_Tp(1) + (__x + __y) / __k) + / ((_Tp(1) + __x / __k) * (_Tp(1) + __y / __k)); + __bet *= __term; + } + + return __bet; + } +# 189 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + template + inline _Tp + __beta(_Tp __x, _Tp __y) + { + if (__isnan(__x) || __isnan(__y)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __beta_lgamma(__x, __y); + } + } + + + + + + +} +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 1 3 +# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + namespace __detail + { +# 76 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rf(_Tp __x, _Tp __y, _Tp __z) + { + const _Tp __min = std::numeric_limits<_Tp>::min(); + const _Tp __lolim = _Tp(5) * __min; + + if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0)) + std::__throw_domain_error(("Argument less than zero " "in __ellint_rf.") + ); + else if (__x + __y < __lolim || __x + __z < __lolim + || __y + __z < __lolim) + std::__throw_domain_error(("Argument too small in __ellint_rf")); + else + { + const _Tp __c0 = _Tp(1) / _Tp(4); + const _Tp __c1 = _Tp(1) / _Tp(24); + const _Tp __c2 = _Tp(1) / _Tp(10); + const _Tp __c3 = _Tp(3) / _Tp(44); + const _Tp __c4 = _Tp(1) / _Tp(14); + + _Tp __xn = __x; + _Tp __yn = __y; + _Tp __zn = __z; + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol = std::pow(__eps, _Tp(1) / _Tp(6)); + _Tp __mu; + _Tp __xndev, __yndev, __zndev; + + const unsigned int __max_iter = 100; + for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) + { + __mu = (__xn + __yn + __zn) / _Tp(3); + __xndev = 2 - (__mu + __xn) / __mu; + __yndev = 2 - (__mu + __yn) / __mu; + __zndev = 2 - (__mu + __zn) / __mu; + _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); + __epsilon = std::max(__epsilon, std::abs(__zndev)); + if (__epsilon < __errtol) + break; + const _Tp __xnroot = std::sqrt(__xn); + const _Tp __ynroot = std::sqrt(__yn); + const _Tp __znroot = std::sqrt(__zn); + const _Tp __lambda = __xnroot * (__ynroot + __znroot) + + __ynroot * __znroot; + __xn = __c0 * (__xn + __lambda); + __yn = __c0 * (__yn + __lambda); + __zn = __c0 * (__zn + __lambda); + } + + const _Tp __e2 = __xndev * __yndev - __zndev * __zndev; + const _Tp __e3 = __xndev * __yndev * __zndev; + const _Tp __s = _Tp(1) + (__c1 * __e2 - __c2 - __c3 * __e3) * __e2 + + __c4 * __e3; + + return __s / std::sqrt(__mu); + } + } +# 153 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_1_series(_Tp __k) + { + + const _Tp __kk = __k * __k; + + _Tp __term = __kk / _Tp(4); + _Tp __sum = _Tp(1) + __term; + + const unsigned int __max_iter = 1000; + for (unsigned int __i = 2; __i < __max_iter; ++__i) + { + __term *= (2 * __i - 1) * __kk / (2 * __i); + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + __sum += __term; + } + + return __numeric_constants<_Tp>::__pi_2() * __sum; + } +# 191 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_1(_Tp __k) + { + + if (__isnan(__k)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) >= _Tp(1)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __ellint_rf(_Tp(0), _Tp(1) - __k * __k, _Tp(1)); + } +# 219 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_1(_Tp __k, _Tp __phi) + { + + if (__isnan(__k) || __isnan(__phi)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __ellint_1.")); + else + { + + const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + + _Tp(0.5L)); + const _Tp __phi_red = __phi + - __n * __numeric_constants<_Tp>::__pi(); + + const _Tp __s = std::sin(__phi_red); + const _Tp __c = std::cos(__phi_red); + + const _Tp __F = __s + * __ellint_rf(__c * __c, + _Tp(1) - __k * __k * __s * __s, _Tp(1)); + + if (__n == 0) + return __F; + else + return __F + _Tp(2) * __n * __comp_ellint_1(__k); + } + } +# 266 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_2_series(_Tp __k) + { + + const _Tp __kk = __k * __k; + + _Tp __term = __kk; + _Tp __sum = __term; + + const unsigned int __max_iter = 1000; + for (unsigned int __i = 2; __i < __max_iter; ++__i) + { + const _Tp __i2m = 2 * __i - 1; + const _Tp __i2 = 2 * __i; + __term *= __i2m * __i2m * __kk / (__i2 * __i2); + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + __sum += __term / __i2m; + } + + return __numeric_constants<_Tp>::__pi_2() * (_Tp(1) - __sum); + } +# 314 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rd(_Tp __x, _Tp __y, _Tp __z) + { + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6)); + const _Tp __max = std::numeric_limits<_Tp>::max(); + const _Tp __lolim = _Tp(2) / std::pow(__max, _Tp(2) / _Tp(3)); + + if (__x < _Tp(0) || __y < _Tp(0)) + std::__throw_domain_error(("Argument less than zero " "in __ellint_rd.") + ); + else if (__x + __y < __lolim || __z < __lolim) + std::__throw_domain_error(("Argument too small " "in __ellint_rd.") + ); + else + { + const _Tp __c0 = _Tp(1) / _Tp(4); + const _Tp __c1 = _Tp(3) / _Tp(14); + const _Tp __c2 = _Tp(1) / _Tp(6); + const _Tp __c3 = _Tp(9) / _Tp(22); + const _Tp __c4 = _Tp(3) / _Tp(26); + + _Tp __xn = __x; + _Tp __yn = __y; + _Tp __zn = __z; + _Tp __sigma = _Tp(0); + _Tp __power4 = _Tp(1); + + _Tp __mu; + _Tp __xndev, __yndev, __zndev; + + const unsigned int __max_iter = 100; + for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) + { + __mu = (__xn + __yn + _Tp(3) * __zn) / _Tp(5); + __xndev = (__mu - __xn) / __mu; + __yndev = (__mu - __yn) / __mu; + __zndev = (__mu - __zn) / __mu; + _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); + __epsilon = std::max(__epsilon, std::abs(__zndev)); + if (__epsilon < __errtol) + break; + _Tp __xnroot = std::sqrt(__xn); + _Tp __ynroot = std::sqrt(__yn); + _Tp __znroot = std::sqrt(__zn); + _Tp __lambda = __xnroot * (__ynroot + __znroot) + + __ynroot * __znroot; + __sigma += __power4 / (__znroot * (__zn + __lambda)); + __power4 *= __c0; + __xn = __c0 * (__xn + __lambda); + __yn = __c0 * (__yn + __lambda); + __zn = __c0 * (__zn + __lambda); + } + + _Tp __ea = __xndev * __yndev; + _Tp __eb = __zndev * __zndev; + _Tp __ec = __ea - __eb; + _Tp __ed = __ea - _Tp(6) * __eb; + _Tp __ef = __ed + __ec + __ec; + _Tp __s1 = __ed * (-__c1 + __c3 * __ed + / _Tp(3) - _Tp(3) * __c4 * __zndev * __ef + / _Tp(2)); + _Tp __s2 = __zndev + * (__c2 * __ef + + __zndev * (-__c3 * __ec - __zndev * __c4 - __ea)); + + return _Tp(3) * __sigma + __power4 * (_Tp(1) + __s1 + __s2) + / (__mu * std::sqrt(__mu)); + } + } +# 399 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_2(_Tp __k) + { + + if (__isnan(__k)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) == 1) + return _Tp(1); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __comp_ellint_2.")); + else + { + const _Tp __kk = __k * __k; + + return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1)) + - __kk * __ellint_rd(_Tp(0), _Tp(1) - __kk, _Tp(1)) / _Tp(3); + } + } +# 433 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_2(_Tp __k, _Tp __phi) + { + + if (__isnan(__k) || __isnan(__phi)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __ellint_2.")); + else + { + + const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + + _Tp(0.5L)); + const _Tp __phi_red = __phi + - __n * __numeric_constants<_Tp>::__pi(); + + const _Tp __kk = __k * __k; + const _Tp __s = std::sin(__phi_red); + const _Tp __ss = __s * __s; + const _Tp __sss = __ss * __s; + const _Tp __c = std::cos(__phi_red); + const _Tp __cc = __c * __c; + + const _Tp __E = __s + * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1)) + - __kk * __sss + * __ellint_rd(__cc, _Tp(1) - __kk * __ss, _Tp(1)) + / _Tp(3); + + if (__n == 0) + return __E; + else + return __E + _Tp(2) * __n * __comp_ellint_2(__k); + } + } +# 492 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rc(_Tp __x, _Tp __y) + { + const _Tp __min = std::numeric_limits<_Tp>::min(); + const _Tp __lolim = _Tp(5) * __min; + + if (__x < _Tp(0) || __y < _Tp(0) || __x + __y < __lolim) + std::__throw_domain_error(("Argument less than zero " "in __ellint_rc.") + ); + else + { + const _Tp __c0 = _Tp(1) / _Tp(4); + const _Tp __c1 = _Tp(1) / _Tp(7); + const _Tp __c2 = _Tp(9) / _Tp(22); + const _Tp __c3 = _Tp(3) / _Tp(10); + const _Tp __c4 = _Tp(3) / _Tp(8); + + _Tp __xn = __x; + _Tp __yn = __y; + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol = std::pow(__eps / _Tp(30), _Tp(1) / _Tp(6)); + _Tp __mu; + _Tp __sn; + + const unsigned int __max_iter = 100; + for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) + { + __mu = (__xn + _Tp(2) * __yn) / _Tp(3); + __sn = (__yn + __mu) / __mu - _Tp(2); + if (std::abs(__sn) < __errtol) + break; + const _Tp __lambda = _Tp(2) * std::sqrt(__xn) * std::sqrt(__yn) + + __yn; + __xn = __c0 * (__xn + __lambda); + __yn = __c0 * (__yn + __lambda); + } + + _Tp __s = __sn * __sn + * (__c3 + __sn*(__c1 + __sn * (__c4 + __sn * __c2))); + + return (_Tp(1) + __s) / std::sqrt(__mu); + } + } +# 561 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rj(_Tp __x, _Tp __y, _Tp __z, _Tp __p) + { + const _Tp __min = std::numeric_limits<_Tp>::min(); + const _Tp __lolim = std::pow(_Tp(5) * __min, _Tp(1)/_Tp(3)); + + if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0)) + std::__throw_domain_error(("Argument less than zero " "in __ellint_rj.") + ); + else if (__x + __y < __lolim || __x + __z < __lolim + || __y + __z < __lolim || __p < __lolim) + std::__throw_domain_error(("Argument too small " "in __ellint_rj") + ); + else + { + const _Tp __c0 = _Tp(1) / _Tp(4); + const _Tp __c1 = _Tp(3) / _Tp(14); + const _Tp __c2 = _Tp(1) / _Tp(3); + const _Tp __c3 = _Tp(3) / _Tp(22); + const _Tp __c4 = _Tp(3) / _Tp(26); + + _Tp __xn = __x; + _Tp __yn = __y; + _Tp __zn = __z; + _Tp __pn = __p; + _Tp __sigma = _Tp(0); + _Tp __power4 = _Tp(1); + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6)); + + _Tp __mu; + _Tp __xndev, __yndev, __zndev, __pndev; + + const unsigned int __max_iter = 100; + for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) + { + __mu = (__xn + __yn + __zn + _Tp(2) * __pn) / _Tp(5); + __xndev = (__mu - __xn) / __mu; + __yndev = (__mu - __yn) / __mu; + __zndev = (__mu - __zn) / __mu; + __pndev = (__mu - __pn) / __mu; + _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); + __epsilon = std::max(__epsilon, std::abs(__zndev)); + __epsilon = std::max(__epsilon, std::abs(__pndev)); + if (__epsilon < __errtol) + break; + const _Tp __xnroot = std::sqrt(__xn); + const _Tp __ynroot = std::sqrt(__yn); + const _Tp __znroot = std::sqrt(__zn); + const _Tp __lambda = __xnroot * (__ynroot + __znroot) + + __ynroot * __znroot; + const _Tp __alpha1 = __pn * (__xnroot + __ynroot + __znroot) + + __xnroot * __ynroot * __znroot; + const _Tp __alpha2 = __alpha1 * __alpha1; + const _Tp __beta = __pn * (__pn + __lambda) + * (__pn + __lambda); + __sigma += __power4 * __ellint_rc(__alpha2, __beta); + __power4 *= __c0; + __xn = __c0 * (__xn + __lambda); + __yn = __c0 * (__yn + __lambda); + __zn = __c0 * (__zn + __lambda); + __pn = __c0 * (__pn + __lambda); + } + + _Tp __ea = __xndev * (__yndev + __zndev) + __yndev * __zndev; + _Tp __eb = __xndev * __yndev * __zndev; + _Tp __ec = __pndev * __pndev; + _Tp __e2 = __ea - _Tp(3) * __ec; + _Tp __e3 = __eb + _Tp(2) * __pndev * (__ea - __ec); + _Tp __s1 = _Tp(1) + __e2 * (-__c1 + _Tp(3) * __c3 * __e2 / _Tp(4) + - _Tp(3) * __c4 * __e3 / _Tp(2)); + _Tp __s2 = __eb * (__c2 / _Tp(2) + + __pndev * (-__c3 - __c3 + __pndev * __c4)); + _Tp __s3 = __pndev * __ea * (__c2 - __pndev * __c3) + - __c2 * __pndev * __ec; + + return _Tp(3) * __sigma + __power4 * (__s1 + __s2 + __s3) + / (__mu * std::sqrt(__mu)); + } + } +# 661 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_3(_Tp __k, _Tp __nu) + { + + if (__isnan(__k) || __isnan(__nu)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__nu == _Tp(1)) + return std::numeric_limits<_Tp>::infinity(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __comp_ellint_3.")); + else + { + const _Tp __kk = __k * __k; + + return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1)) + + __nu + * __ellint_rj(_Tp(0), _Tp(1) - __kk, _Tp(1), _Tp(1) - __nu) + / _Tp(3); + } + } +# 701 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_3(_Tp __k, _Tp __nu, _Tp __phi) + { + + if (__isnan(__k) || __isnan(__nu) || __isnan(__phi)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __ellint_3.")); + else + { + + const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + + _Tp(0.5L)); + const _Tp __phi_red = __phi + - __n * __numeric_constants<_Tp>::__pi(); + + const _Tp __kk = __k * __k; + const _Tp __s = std::sin(__phi_red); + const _Tp __ss = __s * __s; + const _Tp __sss = __ss * __s; + const _Tp __c = std::cos(__phi_red); + const _Tp __cc = __c * __c; + + const _Tp __Pi = __s + * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1)) + + __nu * __sss + * __ellint_rj(__cc, _Tp(1) - __kk * __ss, _Tp(1), + _Tp(1) - __nu * __ss) / _Tp(3); + + if (__n == 0) + return __Pi; + else + return __Pi + _Tp(2) * __n * __comp_ellint_3(__k, __nu); + } + } + } + + + + + +} +# 51 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 1 3 +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + namespace __detail + { + template _Tp __expint_E1(_Tp); +# 81 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_E1_series(_Tp __x) + { + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + _Tp __term = _Tp(1); + _Tp __esum = _Tp(0); + _Tp __osum = _Tp(0); + const unsigned int __max_iter = 1000; + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + __term *= - __x / __i; + if (std::abs(__term) < __eps) + break; + if (__term >= _Tp(0)) + __esum += __term / __i; + else + __osum += __term / __i; + } + + return - __esum - __osum + - __numeric_constants<_Tp>::__gamma_e() - std::log(__x); + } +# 118 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_E1_asymp(_Tp __x) + { + _Tp __term = _Tp(1); + _Tp __esum = _Tp(1); + _Tp __osum = _Tp(0); + const unsigned int __max_iter = 1000; + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + _Tp __prev = __term; + __term *= - __i / __x; + if (std::abs(__term) > std::abs(__prev)) + break; + if (__term >= _Tp(0)) + __esum += __term; + else + __osum += __term; + } + + return std::exp(- __x) * (__esum + __osum) / __x; + } +# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_En_series(unsigned int __n, _Tp __x) + { + const unsigned int __max_iter = 1000; + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const int __nm1 = __n - 1; + _Tp __ans = (__nm1 != 0 + ? _Tp(1) / __nm1 : -std::log(__x) + - __numeric_constants<_Tp>::__gamma_e()); + _Tp __fact = _Tp(1); + for (int __i = 1; __i <= __max_iter; ++__i) + { + __fact *= -__x / _Tp(__i); + _Tp __del; + if ( __i != __nm1 ) + __del = -__fact / _Tp(__i - __nm1); + else + { + _Tp __psi = -__numeric_constants<_Tp>::gamma_e(); + for (int __ii = 1; __ii <= __nm1; ++__ii) + __psi += _Tp(1) / _Tp(__ii); + __del = __fact * (__psi - std::log(__x)); + } + __ans += __del; + if (std::abs(__del) < __eps * std::abs(__ans)) + return __ans; + } + std::__throw_runtime_error(("Series summation failed " "in __expint_En_series.") + ); + } +# 201 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_En_cont_frac(unsigned int __n, _Tp __x) + { + const unsigned int __max_iter = 1000; + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __fp_min = std::numeric_limits<_Tp>::min(); + const int __nm1 = __n - 1; + _Tp __b = __x + _Tp(__n); + _Tp __c = _Tp(1) / __fp_min; + _Tp __d = _Tp(1) / __b; + _Tp __h = __d; + for ( unsigned int __i = 1; __i <= __max_iter; ++__i ) + { + _Tp __a = -_Tp(__i * (__nm1 + __i)); + __b += _Tp(2); + __d = _Tp(1) / (__a * __d + __b); + __c = __b + __a / __c; + const _Tp __del = __c * __d; + __h *= __del; + if (std::abs(__del - _Tp(1)) < __eps) + { + const _Tp __ans = __h * std::exp(-__x); + return __ans; + } + } + std::__throw_runtime_error(("Continued fraction failed " "in __expint_En_cont_frac.") + ); + } +# 246 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_En_recursion(unsigned int __n, _Tp __x) + { + _Tp __En; + _Tp __E1 = __expint_E1(__x); + if (__x < _Tp(__n)) + { + + __En = __E1; + for (unsigned int __j = 2; __j < __n; ++__j) + __En = (std::exp(-__x) - __x * __En) / _Tp(__j - 1); + } + else + { + + __En = _Tp(1); + const int __N = __n + 20; + _Tp __save = _Tp(0); + for (int __j = __N; __j > 0; --__j) + { + __En = (std::exp(-__x) - __j * __En) / __x; + if (__j == __n) + __save = __En; + } + _Tp __norm = __En / __E1; + __En /= __norm; + } + + return __En; + } +# 290 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_Ei_series(_Tp __x) + { + _Tp __term = _Tp(1); + _Tp __sum = _Tp(0); + const unsigned int __max_iter = 1000; + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + __term *= __x / __i; + __sum += __term / __i; + if (__term < std::numeric_limits<_Tp>::epsilon() * __sum) + break; + } + + return __numeric_constants<_Tp>::__gamma_e() + __sum + std::log(__x); + } +# 321 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_Ei_asymp(_Tp __x) + { + _Tp __term = _Tp(1); + _Tp __sum = _Tp(1); + const unsigned int __max_iter = 1000; + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + _Tp __prev = __term; + __term *= __i / __x; + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + if (__term >= __prev) + break; + __sum += __term; + } + + return std::exp(__x) * __sum / __x; + } +# 354 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_Ei(_Tp __x) + { + if (__x < _Tp(0)) + return -__expint_E1(-__x); + else if (__x < -std::log(std::numeric_limits<_Tp>::epsilon())) + return __expint_Ei_series(__x); + else + return __expint_Ei_asymp(__x); + } +# 378 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_E1(_Tp __x) + { + if (__x < _Tp(0)) + return -__expint_Ei(-__x); + else if (__x < _Tp(1)) + return __expint_E1_series(__x); + else if (__x < _Tp(100)) + return __expint_En_cont_frac(1, __x); + else + return __expint_E1_asymp(__x); + } +# 408 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_asymp(unsigned int __n, _Tp __x) + { + _Tp __term = _Tp(1); + _Tp __sum = _Tp(1); + for (unsigned int __i = 1; __i <= __n; ++__i) + { + _Tp __prev = __term; + __term *= -(__n - __i + 1) / __x; + if (std::abs(__term) > std::abs(__prev)) + break; + __sum += __term; + } + + return std::exp(-__x) * __sum / __x; + } +# 442 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_large_n(unsigned int __n, _Tp __x) + { + const _Tp __xpn = __x + __n; + const _Tp __xpn2 = __xpn * __xpn; + _Tp __term = _Tp(1); + _Tp __sum = _Tp(1); + for (unsigned int __i = 1; __i <= __n; ++__i) + { + _Tp __prev = __term; + __term *= (__n - 2 * (__i - 1) * __x) / __xpn2; + if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon()) + break; + __sum += __term; + } + + return std::exp(-__x) * __sum / __xpn; + } +# 476 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint(unsigned int __n, _Tp __x) + { + + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__n <= 1 && __x == _Tp(0)) + return std::numeric_limits<_Tp>::infinity(); + else + { + _Tp __E0 = std::exp(__x) / __x; + if (__n == 0) + return __E0; + + _Tp __E1 = __expint_E1(__x); + if (__n == 1) + return __E1; + + if (__x == _Tp(0)) + return _Tp(1) / static_cast<_Tp>(__n - 1); + + _Tp __En = __expint_En_recursion(__n, __x); + + return __En; + } + } +# 516 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + inline _Tp + __expint(_Tp __x) + { + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __expint_Ei(__x); + } + } + + + + + +} +# 52 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 1 3 +# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + namespace __detail + { +# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __conf_hyperg_series(_Tp __a, _Tp __c, _Tp __x) + { + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + _Tp __term = _Tp(1); + _Tp __Fac = _Tp(1); + const unsigned int __max_iter = 100000; + unsigned int __i; + for (__i = 0; __i < __max_iter; ++__i) + { + __term *= (__a + _Tp(__i)) * __x + / ((__c + _Tp(__i)) * _Tp(1 + __i)); + if (std::abs(__term) < __eps) + { + break; + } + __Fac += __term; + } + if (__i == __max_iter) + std::__throw_runtime_error(("Series failed to converge " "in __conf_hyperg_series.") + ); + + return __Fac; + } +# 120 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __conf_hyperg_luke(_Tp __a, _Tp __c, _Tp __xin) + { + const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L)); + const int __nmax = 20000; + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __x = -__xin; + const _Tp __x3 = __x * __x * __x; + const _Tp __t0 = __a / __c; + const _Tp __t1 = (__a + _Tp(1)) / (_Tp(2) * __c); + const _Tp __t2 = (__a + _Tp(2)) / (_Tp(2) * (__c + _Tp(1))); + _Tp __F = _Tp(1); + _Tp __prec; + + _Tp __Bnm3 = _Tp(1); + _Tp __Bnm2 = _Tp(1) + __t1 * __x; + _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x); + + _Tp __Anm3 = _Tp(1); + _Tp __Anm2 = __Bnm2 - __t0 * __x; + _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x + + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x; + + int __n = 3; + while(1) + { + _Tp __npam1 = _Tp(__n - 1) + __a; + _Tp __npcm1 = _Tp(__n - 1) + __c; + _Tp __npam2 = _Tp(__n - 2) + __a; + _Tp __npcm2 = _Tp(__n - 2) + __c; + _Tp __tnm1 = _Tp(2 * __n - 1); + _Tp __tnm3 = _Tp(2 * __n - 3); + _Tp __tnm5 = _Tp(2 * __n - 5); + _Tp __F1 = (_Tp(__n - 2) - __a) / (_Tp(2) * __tnm3 * __npcm1); + _Tp __F2 = (_Tp(__n) + __a) * __npam1 + / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1); + _Tp __F3 = -__npam2 * __npam1 * (_Tp(__n - 2) - __a) + / (_Tp(8) * __tnm3 * __tnm3 * __tnm5 + * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1); + _Tp __E = -__npam1 * (_Tp(__n - 1) - __c) + / (_Tp(2) * __tnm3 * __npcm2 * __npcm1); + + _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1 + + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3; + _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1 + + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3; + _Tp __r = __An / __Bn; + + __prec = std::abs((__F - __r) / __F); + __F = __r; + + if (__prec < __eps || __n > __nmax) + break; + + if (std::abs(__An) > __big || std::abs(__Bn) > __big) + { + __An /= __big; + __Bn /= __big; + __Anm1 /= __big; + __Bnm1 /= __big; + __Anm2 /= __big; + __Bnm2 /= __big; + __Anm3 /= __big; + __Bnm3 /= __big; + } + else if (std::abs(__An) < _Tp(1) / __big + || std::abs(__Bn) < _Tp(1) / __big) + { + __An *= __big; + __Bn *= __big; + __Anm1 *= __big; + __Bnm1 *= __big; + __Anm2 *= __big; + __Bnm2 *= __big; + __Anm3 *= __big; + __Bnm3 *= __big; + } + + ++__n; + __Bnm3 = __Bnm2; + __Bnm2 = __Bnm1; + __Bnm1 = __Bn; + __Anm3 = __Anm2; + __Anm2 = __Anm1; + __Anm1 = __An; + } + + if (__n >= __nmax) + std::__throw_runtime_error(("Iteration failed to converge " "in __conf_hyperg_luke.") + ); + + return __F; + } +# 227 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __conf_hyperg(_Tp __a, _Tp __c, _Tp __x) + { + + const _Tp __c_nint = ::std::nearbyint(__c); + + + + if (__isnan(__a) || __isnan(__c) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__c_nint == __c && __c_nint <= 0) + return std::numeric_limits<_Tp>::infinity(); + else if (__a == _Tp(0)) + return _Tp(1); + else if (__c == __a) + return std::exp(__x); + else if (__x < _Tp(0)) + return __conf_hyperg_luke(__a, __c, __x); + else + return __conf_hyperg_series(__a, __c, __x); + } +# 271 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __hyperg_series(_Tp __a, _Tp __b, _Tp __c, _Tp __x) + { + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + _Tp __term = _Tp(1); + _Tp __Fabc = _Tp(1); + const unsigned int __max_iter = 100000; + unsigned int __i; + for (__i = 0; __i < __max_iter; ++__i) + { + __term *= (__a + _Tp(__i)) * (__b + _Tp(__i)) * __x + / ((__c + _Tp(__i)) * _Tp(1 + __i)); + if (std::abs(__term) < __eps) + { + break; + } + __Fabc += __term; + } + if (__i == __max_iter) + std::__throw_runtime_error(("Series failed to converge " "in __hyperg_series.") + ); + + return __Fabc; + } + + + + + + + + template + _Tp + __hyperg_luke(_Tp __a, _Tp __b, _Tp __c, _Tp __xin) + { + const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L)); + const int __nmax = 20000; + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __x = -__xin; + const _Tp __x3 = __x * __x * __x; + const _Tp __t0 = __a * __b / __c; + const _Tp __t1 = (__a + _Tp(1)) * (__b + _Tp(1)) / (_Tp(2) * __c); + const _Tp __t2 = (__a + _Tp(2)) * (__b + _Tp(2)) + / (_Tp(2) * (__c + _Tp(1))); + + _Tp __F = _Tp(1); + + _Tp __Bnm3 = _Tp(1); + _Tp __Bnm2 = _Tp(1) + __t1 * __x; + _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x); + + _Tp __Anm3 = _Tp(1); + _Tp __Anm2 = __Bnm2 - __t0 * __x; + _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x + + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x; + + int __n = 3; + while (1) + { + const _Tp __npam1 = _Tp(__n - 1) + __a; + const _Tp __npbm1 = _Tp(__n - 1) + __b; + const _Tp __npcm1 = _Tp(__n - 1) + __c; + const _Tp __npam2 = _Tp(__n - 2) + __a; + const _Tp __npbm2 = _Tp(__n - 2) + __b; + const _Tp __npcm2 = _Tp(__n - 2) + __c; + const _Tp __tnm1 = _Tp(2 * __n - 1); + const _Tp __tnm3 = _Tp(2 * __n - 3); + const _Tp __tnm5 = _Tp(2 * __n - 5); + const _Tp __n2 = __n * __n; + const _Tp __F1 = (_Tp(3) * __n2 + (__a + __b - _Tp(6)) * __n + + _Tp(2) - __a * __b - _Tp(2) * (__a + __b)) + / (_Tp(2) * __tnm3 * __npcm1); + const _Tp __F2 = -(_Tp(3) * __n2 - (__a + __b + _Tp(6)) * __n + + _Tp(2) - __a * __b) * __npam1 * __npbm1 + / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1); + const _Tp __F3 = (__npam2 * __npam1 * __npbm2 * __npbm1 + * (_Tp(__n - 2) - __a) * (_Tp(__n - 2) - __b)) + / (_Tp(8) * __tnm3 * __tnm3 * __tnm5 + * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1); + const _Tp __E = -__npam1 * __npbm1 * (_Tp(__n - 1) - __c) + / (_Tp(2) * __tnm3 * __npcm2 * __npcm1); + + _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1 + + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3; + _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1 + + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3; + const _Tp __r = __An / __Bn; + + const _Tp __prec = std::abs((__F - __r) / __F); + __F = __r; + + if (__prec < __eps || __n > __nmax) + break; + + if (std::abs(__An) > __big || std::abs(__Bn) > __big) + { + __An /= __big; + __Bn /= __big; + __Anm1 /= __big; + __Bnm1 /= __big; + __Anm2 /= __big; + __Bnm2 /= __big; + __Anm3 /= __big; + __Bnm3 /= __big; + } + else if (std::abs(__An) < _Tp(1) / __big + || std::abs(__Bn) < _Tp(1) / __big) + { + __An *= __big; + __Bn *= __big; + __Anm1 *= __big; + __Bnm1 *= __big; + __Anm2 *= __big; + __Bnm2 *= __big; + __Anm3 *= __big; + __Bnm3 *= __big; + } + + ++__n; + __Bnm3 = __Bnm2; + __Bnm2 = __Bnm1; + __Bnm1 = __Bn; + __Anm3 = __Anm2; + __Anm2 = __Anm1; + __Anm1 = __An; + } + + if (__n >= __nmax) + std::__throw_runtime_error(("Iteration failed to converge " "in __hyperg_luke.") + ); + + return __F; + } +# 438 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __hyperg_reflect(_Tp __a, _Tp __b, _Tp __c, _Tp __x) + { + const _Tp __d = __c - __a - __b; + const int __intd = std::floor(__d + _Tp(0.5L)); + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __toler = _Tp(1000) * __eps; + const _Tp __log_max = std::log(std::numeric_limits<_Tp>::max()); + const bool __d_integer = (std::abs(__d - __intd) < __toler); + + if (__d_integer) + { + const _Tp __ln_omx = std::log(_Tp(1) - __x); + const _Tp __ad = std::abs(__d); + _Tp __F1, __F2; + + _Tp __d1, __d2; + if (__d >= _Tp(0)) + { + __d1 = __d; + __d2 = _Tp(0); + } + else + { + __d1 = _Tp(0); + __d2 = __d; + } + + const _Tp __lng_c = __log_gamma(__c); + + + if (__ad < __eps) + { + + __F1 = _Tp(0); + } + else + { + + bool __ok_d1 = true; + _Tp __lng_ad, __lng_ad1, __lng_bd1; + try + { + __lng_ad = __log_gamma(__ad); + __lng_ad1 = __log_gamma(__a + __d1); + __lng_bd1 = __log_gamma(__b + __d1); + } + catch(...) + { + __ok_d1 = false; + } + + if (__ok_d1) + { + + + + _Tp __sum1 = _Tp(1); + _Tp __term = _Tp(1); + _Tp __ln_pre1 = __lng_ad + __lng_c + __d2 * __ln_omx + - __lng_ad1 - __lng_bd1; + + + + for (int __i = 1; __i < __ad; ++__i) + { + const int __j = __i - 1; + __term *= (__a + __d2 + __j) * (__b + __d2 + __j) + / (_Tp(1) + __d2 + __j) / __i * (_Tp(1) - __x); + __sum1 += __term; + } + + if (__ln_pre1 > __log_max) + std::__throw_runtime_error(("Overflow of gamma functions" " in __hyperg_luke.") + ); + else + __F1 = std::exp(__ln_pre1) * __sum1; + } + else + { + + + __F1 = _Tp(0); + } + } + + + bool __ok_d2 = true; + _Tp __lng_ad2, __lng_bd2; + try + { + __lng_ad2 = __log_gamma(__a + __d2); + __lng_bd2 = __log_gamma(__b + __d2); + } + catch(...) + { + __ok_d2 = false; + } + + if (__ok_d2) + { + + + const int __maxiter = 2000; + const _Tp __psi_1 = -__numeric_constants<_Tp>::__gamma_e(); + const _Tp __psi_1pd = __psi(_Tp(1) + __ad); + const _Tp __psi_apd1 = __psi(__a + __d1); + const _Tp __psi_bpd1 = __psi(__b + __d1); + + _Tp __psi_term = __psi_1 + __psi_1pd - __psi_apd1 + - __psi_bpd1 - __ln_omx; + _Tp __fact = _Tp(1); + _Tp __sum2 = __psi_term; + _Tp __ln_pre2 = __lng_c + __d1 * __ln_omx + - __lng_ad2 - __lng_bd2; + + + int __j; + for (__j = 1; __j < __maxiter; ++__j) + { + + + const _Tp __term1 = _Tp(1) / _Tp(__j) + + _Tp(1) / (__ad + __j); + const _Tp __term2 = _Tp(1) / (__a + __d1 + _Tp(__j - 1)) + + _Tp(1) / (__b + __d1 + _Tp(__j - 1)); + __psi_term += __term1 - __term2; + __fact *= (__a + __d1 + _Tp(__j - 1)) + * (__b + __d1 + _Tp(__j - 1)) + / ((__ad + __j) * __j) * (_Tp(1) - __x); + const _Tp __delta = __fact * __psi_term; + __sum2 += __delta; + if (std::abs(__delta) < __eps * std::abs(__sum2)) + break; + } + if (__j == __maxiter) + std::__throw_runtime_error(("Sum F2 failed to converge " "in __hyperg_reflect") + ); + + if (__sum2 == _Tp(0)) + __F2 = _Tp(0); + else + __F2 = std::exp(__ln_pre2) * __sum2; + } + else + { + + + __F2 = _Tp(0); + } + + const _Tp __sgn_2 = (__intd % 2 == 1 ? -_Tp(1) : _Tp(1)); + const _Tp __F = __F1 + __sgn_2 * __F2; + + return __F; + } + else + { + + + + + bool __ok1 = true; + _Tp __sgn_g1ca = _Tp(0), __ln_g1ca = _Tp(0); + _Tp __sgn_g1cb = _Tp(0), __ln_g1cb = _Tp(0); + try + { + __sgn_g1ca = __log_gamma_sign(__c - __a); + __ln_g1ca = __log_gamma(__c - __a); + __sgn_g1cb = __log_gamma_sign(__c - __b); + __ln_g1cb = __log_gamma(__c - __b); + } + catch(...) + { + __ok1 = false; + } + + bool __ok2 = true; + _Tp __sgn_g2a = _Tp(0), __ln_g2a = _Tp(0); + _Tp __sgn_g2b = _Tp(0), __ln_g2b = _Tp(0); + try + { + __sgn_g2a = __log_gamma_sign(__a); + __ln_g2a = __log_gamma(__a); + __sgn_g2b = __log_gamma_sign(__b); + __ln_g2b = __log_gamma(__b); + } + catch(...) + { + __ok2 = false; + } + + const _Tp __sgn_gc = __log_gamma_sign(__c); + const _Tp __ln_gc = __log_gamma(__c); + const _Tp __sgn_gd = __log_gamma_sign(__d); + const _Tp __ln_gd = __log_gamma(__d); + const _Tp __sgn_gmd = __log_gamma_sign(-__d); + const _Tp __ln_gmd = __log_gamma(-__d); + + const _Tp __sgn1 = __sgn_gc * __sgn_gd * __sgn_g1ca * __sgn_g1cb; + const _Tp __sgn2 = __sgn_gc * __sgn_gmd * __sgn_g2a * __sgn_g2b; + + _Tp __pre1, __pre2; + if (__ok1 && __ok2) + { + _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb; + _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b + + __d * std::log(_Tp(1) - __x); + if (__ln_pre1 < __log_max && __ln_pre2 < __log_max) + { + __pre1 = std::exp(__ln_pre1); + __pre2 = std::exp(__ln_pre2); + __pre1 *= __sgn1; + __pre2 *= __sgn2; + } + else + { + std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect") + ); + } + } + else if (__ok1 && !__ok2) + { + _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb; + if (__ln_pre1 < __log_max) + { + __pre1 = std::exp(__ln_pre1); + __pre1 *= __sgn1; + __pre2 = _Tp(0); + } + else + { + std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect") + ); + } + } + else if (!__ok1 && __ok2) + { + _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b + + __d * std::log(_Tp(1) - __x); + if (__ln_pre2 < __log_max) + { + __pre1 = _Tp(0); + __pre2 = std::exp(__ln_pre2); + __pre2 *= __sgn2; + } + else + { + std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect") + ); + } + } + else + { + __pre1 = _Tp(0); + __pre2 = _Tp(0); + std::__throw_runtime_error(("Underflow of gamma functions " "in __hyperg_reflect") + ); + } + + const _Tp __F1 = __hyperg_series(__a, __b, _Tp(1) - __d, + _Tp(1) - __x); + const _Tp __F2 = __hyperg_series(__c - __a, __c - __b, _Tp(1) + __d, + _Tp(1) - __x); + + const _Tp __F = __pre1 * __F1 + __pre2 * __F2; + + return __F; + } + } +# 728 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __hyperg(_Tp __a, _Tp __b, _Tp __c, _Tp __x) + { + + const _Tp __a_nint = ::std::nearbyint(__a); + const _Tp __b_nint = ::std::nearbyint(__b); + const _Tp __c_nint = ::std::nearbyint(__c); + + + + + + const _Tp __toler = _Tp(1000) * std::numeric_limits<_Tp>::epsilon(); + if (std::abs(__x) >= _Tp(1)) + std::__throw_domain_error(("Argument outside unit circle " "in __hyperg.") + ); + else if (__isnan(__a) || __isnan(__b) + || __isnan(__c) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__c_nint == __c && __c_nint <= _Tp(0)) + return std::numeric_limits<_Tp>::infinity(); + else if (std::abs(__c - __b) < __toler || std::abs(__c - __a) < __toler) + return std::pow(_Tp(1) - __x, __c - __a - __b); + else if (__a >= _Tp(0) && __b >= _Tp(0) && __c >= _Tp(0) + && __x >= _Tp(0) && __x < _Tp(0.995L)) + return __hyperg_series(__a, __b, __c, __x); + else if (std::abs(__a) < _Tp(10) && std::abs(__b) < _Tp(10)) + { + + + if (__a < _Tp(0) && std::abs(__a - __a_nint) < __toler) + return __hyperg_series(__a_nint, __b, __c, __x); + else if (__b < _Tp(0) && std::abs(__b - __b_nint) < __toler) + return __hyperg_series(__a, __b_nint, __c, __x); + else if (__x < -_Tp(0.25L)) + return __hyperg_luke(__a, __b, __c, __x); + else if (__x < _Tp(0.5L)) + return __hyperg_series(__a, __b, __c, __x); + else + if (std::abs(__c) > _Tp(10)) + return __hyperg_series(__a, __b, __c, __x); + else + return __hyperg_reflect(__a, __b, __c, __x); + } + else + return __hyperg_luke(__a, __b, __c, __x); + } + } + + + + + + +} +# 53 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 1 3 +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 + namespace __detail + { +# 80 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 + template + _Tp + __poly_legendre_p(unsigned int __l, _Tp __x) + { + + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x == +_Tp(1)) + return +_Tp(1); + else if (__x == -_Tp(1)) + return (__l % 2 == 1 ? -_Tp(1) : +_Tp(1)); + else + { + _Tp __p_lm2 = _Tp(1); + if (__l == 0) + return __p_lm2; + + _Tp __p_lm1 = __x; + if (__l == 1) + return __p_lm1; + + _Tp __p_l = 0; + for (unsigned int __ll = 2; __ll <= __l; ++__ll) + { + + + __p_l = _Tp(2) * __x * __p_lm1 - __p_lm2 + - (__x * __p_lm1 - __p_lm2) / _Tp(__ll); + __p_lm2 = __p_lm1; + __p_lm1 = __p_l; + } + + return __p_l; + } + } +# 136 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 + template + _Tp + __assoc_legendre_p(unsigned int __l, unsigned int __m, _Tp __x, + _Tp __phase = _Tp(+1)) + { + + if (__m > __l) + return _Tp(0); + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__m == 0) + return __poly_legendre_p(__l, __x); + else + { + _Tp __p_mm = _Tp(1); + if (__m > 0) + { + + + _Tp __root = std::sqrt(_Tp(1) - __x) * std::sqrt(_Tp(1) + __x); + _Tp __fact = _Tp(1); + for (unsigned int __i = 1; __i <= __m; ++__i) + { + __p_mm *= __phase * __fact * __root; + __fact += _Tp(2); + } + } + if (__l == __m) + return __p_mm; + + _Tp __p_mp1m = _Tp(2 * __m + 1) * __x * __p_mm; + if (__l == __m + 1) + return __p_mp1m; + + _Tp __p_lm2m = __p_mm; + _Tp __P_lm1m = __p_mp1m; + _Tp __p_lm = _Tp(0); + for (unsigned int __j = __m + 2; __j <= __l; ++__j) + { + __p_lm = (_Tp(2 * __j - 1) * __x * __P_lm1m + - _Tp(__j + __m - 1) * __p_lm2m) / _Tp(__j - __m); + __p_lm2m = __P_lm1m; + __P_lm1m = __p_lm; + } + + return __p_lm; + } + } +# 214 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 + template + _Tp + __sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta) + { + if (__isnan(__theta)) + return std::numeric_limits<_Tp>::quiet_NaN(); + + const _Tp __x = std::cos(__theta); + + if (__m > __l) + return _Tp(0); + else if (__m == 0) + { + _Tp __P = __poly_legendre_p(__l, __x); + _Tp __fact = std::sqrt(_Tp(2 * __l + 1) + / (_Tp(4) * __numeric_constants<_Tp>::__pi())); + __P *= __fact; + return __P; + } + else if (__x == _Tp(1) || __x == -_Tp(1)) + { + + return _Tp(0); + } + else + { + + + + + + const _Tp __sgn = ( __m % 2 == 1 ? -_Tp(1) : _Tp(1)); + const _Tp __y_mp1m_factor = __x * std::sqrt(_Tp(2 * __m + 3)); + + const _Tp __lncirc = ::std::log1p(-__x * __x); + + + + + + const _Tp __lnpoch = ::std::lgamma(_Tp(__m + _Tp(0.5L))) + - ::std::lgamma(_Tp(__m)); + + + + + const _Tp __lnpre_val = + -_Tp(0.25L) * __numeric_constants<_Tp>::__lnpi() + + _Tp(0.5L) * (__lnpoch + __m * __lncirc); + const _Tp __sr = std::sqrt((_Tp(2) + _Tp(1) / __m) + / (_Tp(4) * __numeric_constants<_Tp>::__pi())); + _Tp __y_mm = __sgn * __sr * std::exp(__lnpre_val); + _Tp __y_mp1m = __y_mp1m_factor * __y_mm; + + if (__l == __m) + return __y_mm; + else if (__l == __m + 1) + return __y_mp1m; + else + { + _Tp __y_lm = _Tp(0); + + + for (unsigned int __ll = __m + 2; __ll <= __l; ++__ll) + { + const _Tp __rat1 = _Tp(__ll - __m) / _Tp(__ll + __m); + const _Tp __rat2 = _Tp(__ll - __m - 1) / _Tp(__ll + __m - 1); + const _Tp __fact1 = std::sqrt(__rat1 * _Tp(2 * __ll + 1) + * _Tp(2 * __ll - 1)); + const _Tp __fact2 = std::sqrt(__rat1 * __rat2 * _Tp(2 * __ll + 1) + / _Tp(2 * __ll - 3)); + __y_lm = (__x * __y_mp1m * __fact1 + - (__ll + __m - 1) * __y_mm * __fact2) / _Tp(__ll - __m); + __y_mm = __y_mp1m; + __y_mp1m = __y_lm; + } + + return __y_lm; + } + } + } + } + + + + + + +} +# 54 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 1 3 +# 51 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + namespace __detail + { +# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + template + void + __bessel_ik(_Tp __nu, _Tp __x, + _Tp & __Inu, _Tp & __Knu, _Tp & __Ipnu, _Tp & __Kpnu) + { + if (__x == _Tp(0)) + { + if (__nu == _Tp(0)) + { + __Inu = _Tp(1); + __Ipnu = _Tp(0); + } + else if (__nu == _Tp(1)) + { + __Inu = _Tp(0); + __Ipnu = _Tp(0.5L); + } + else + { + __Inu = _Tp(0); + __Ipnu = _Tp(0); + } + __Knu = std::numeric_limits<_Tp>::infinity(); + __Kpnu = -std::numeric_limits<_Tp>::infinity(); + return; + } + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __fp_min = _Tp(10) * std::numeric_limits<_Tp>::epsilon(); + const int __max_iter = 15000; + const _Tp __x_min = _Tp(2); + + const int __nl = static_cast(__nu + _Tp(0.5L)); + + const _Tp __mu = __nu - __nl; + const _Tp __mu2 = __mu * __mu; + const _Tp __xi = _Tp(1) / __x; + const _Tp __xi2 = _Tp(2) * __xi; + _Tp __h = __nu * __xi; + if ( __h < __fp_min ) + __h = __fp_min; + _Tp __b = __xi2 * __nu; + _Tp __d = _Tp(0); + _Tp __c = __h; + int __i; + for ( __i = 1; __i <= __max_iter; ++__i ) + { + __b += __xi2; + __d = _Tp(1) / (__b + __d); + __c = __b + _Tp(1) / __c; + const _Tp __del = __c * __d; + __h *= __del; + if (std::abs(__del - _Tp(1)) < __eps) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Argument x too large " "in __bessel_ik; " "try asymptotic expansion.") + + ); + _Tp __Inul = __fp_min; + _Tp __Ipnul = __h * __Inul; + _Tp __Inul1 = __Inul; + _Tp __Ipnu1 = __Ipnul; + _Tp __fact = __nu * __xi; + for (int __l = __nl; __l >= 1; --__l) + { + const _Tp __Inutemp = __fact * __Inul + __Ipnul; + __fact -= __xi; + __Ipnul = __fact * __Inutemp + __Inul; + __Inul = __Inutemp; + } + _Tp __f = __Ipnul / __Inul; + _Tp __Kmu, __Knu1; + if (__x < __x_min) + { + const _Tp __x2 = __x / _Tp(2); + const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu; + const _Tp __fact = (std::abs(__pimu) < __eps + ? _Tp(1) : __pimu / std::sin(__pimu)); + _Tp __d = -std::log(__x2); + _Tp __e = __mu * __d; + const _Tp __fact2 = (std::abs(__e) < __eps + ? _Tp(1) : std::sinh(__e) / __e); + _Tp __gam1, __gam2, __gampl, __gammi; + __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi); + _Tp __ff = __fact + * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d); + _Tp __sum = __ff; + __e = std::exp(__e); + _Tp __p = __e / (_Tp(2) * __gampl); + _Tp __q = _Tp(1) / (_Tp(2) * __e * __gammi); + _Tp __c = _Tp(1); + __d = __x2 * __x2; + _Tp __sum1 = __p; + int __i; + for (__i = 1; __i <= __max_iter; ++__i) + { + __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2); + __c *= __d / __i; + __p /= __i - __mu; + __q /= __i + __mu; + const _Tp __del = __c * __ff; + __sum += __del; + const _Tp __del1 = __c * (__p - __i * __ff); + __sum1 += __del1; + if (std::abs(__del) < __eps * std::abs(__sum)) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Bessel k series failed to converge " "in __bessel_ik.") + ); + __Kmu = __sum; + __Knu1 = __sum1 * __xi2; + } + else + { + _Tp __b = _Tp(2) * (_Tp(1) + __x); + _Tp __d = _Tp(1) / __b; + _Tp __delh = __d; + _Tp __h = __delh; + _Tp __q1 = _Tp(0); + _Tp __q2 = _Tp(1); + _Tp __a1 = _Tp(0.25L) - __mu2; + _Tp __q = __c = __a1; + _Tp __a = -__a1; + _Tp __s = _Tp(1) + __q * __delh; + int __i; + for (__i = 2; __i <= __max_iter; ++__i) + { + __a -= 2 * (__i - 1); + __c = -__a * __c / __i; + const _Tp __qnew = (__q1 - __b * __q2) / __a; + __q1 = __q2; + __q2 = __qnew; + __q += __c * __qnew; + __b += _Tp(2); + __d = _Tp(1) / (__b + __a * __d); + __delh = (__b * __d - _Tp(1)) * __delh; + __h += __delh; + const _Tp __dels = __q * __delh; + __s += __dels; + if ( std::abs(__dels / __s) < __eps ) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Steed's method failed " "in __bessel_ik.") + ); + __h = __a1 * __h; + __Kmu = std::sqrt(__numeric_constants<_Tp>::__pi() / (_Tp(2) * __x)) + * std::exp(-__x) / __s; + __Knu1 = __Kmu * (__mu + __x + _Tp(0.5L) - __h) * __xi; + } + + _Tp __Kpmu = __mu * __xi * __Kmu - __Knu1; + _Tp __Inumu = __xi / (__f * __Kmu - __Kpmu); + __Inu = __Inumu * __Inul1 / __Inul; + __Ipnu = __Inumu * __Ipnu1 / __Inul; + for ( __i = 1; __i <= __nl; ++__i ) + { + const _Tp __Knutemp = (__mu + __i) * __xi2 * __Knu1 + __Kmu; + __Kmu = __Knu1; + __Knu1 = __Knutemp; + } + __Knu = __Kmu; + __Kpnu = __nu * __xi * __Kmu - __Knu1; + + return; + } +# 267 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + template + _Tp + __cyl_bessel_i(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_i.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x * __x < _Tp(10) * (__nu + _Tp(1))) + return __cyl_bessel_ij_series(__nu, __x, +_Tp(1), 200); + else + { + _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + return __I_nu; + } + } +# 303 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + template + _Tp + __cyl_bessel_k(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_k.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + { + _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + return __K_nu; + } + } +# 337 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + template + void + __sph_bessel_ik(unsigned int __n, _Tp __x, + _Tp & __i_n, _Tp & __k_n, _Tp & __ip_n, _Tp & __kp_n) + { + const _Tp __nu = _Tp(__n) + _Tp(0.5L); + + _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + + const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2() + / std::sqrt(__x); + + __i_n = __factor * __I_nu; + __k_n = __factor * __K_nu; + __ip_n = __factor * __Ip_nu - __i_n / (_Tp(2) * __x); + __kp_n = __factor * __Kp_nu - __k_n / (_Tp(2) * __x); + + return; + } +# 373 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + template + void + __airy(_Tp __x, _Tp & __Ai, _Tp & __Bi, _Tp & __Aip, _Tp & __Bip) + { + const _Tp __absx = std::abs(__x); + const _Tp __rootx = std::sqrt(__absx); + const _Tp __z = _Tp(2) * __absx * __rootx / _Tp(3); + const _Tp _S_inf = std::numeric_limits<_Tp>::infinity(); + + if (__isnan(__x)) + __Bip = __Aip = __Bi = __Ai = std::numeric_limits<_Tp>::quiet_NaN(); + else if (__z == _S_inf) + { + __Aip = __Ai = _Tp(0); + __Bip = __Bi = _S_inf; + } + else if (__z == -_S_inf) + __Bip = __Aip = __Bi = __Ai = _Tp(0); + else if (__x > _Tp(0)) + { + _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu; + + __bessel_ik(_Tp(1) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + __Ai = __rootx * __K_nu + / (__numeric_constants<_Tp>::__sqrt3() + * __numeric_constants<_Tp>::__pi()); + __Bi = __rootx * (__K_nu / __numeric_constants<_Tp>::__pi() + + _Tp(2) * __I_nu / __numeric_constants<_Tp>::__sqrt3()); + + __bessel_ik(_Tp(2) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + __Aip = -__x * __K_nu + / (__numeric_constants<_Tp>::__sqrt3() + * __numeric_constants<_Tp>::__pi()); + __Bip = __x * (__K_nu / __numeric_constants<_Tp>::__pi() + + _Tp(2) * __I_nu + / __numeric_constants<_Tp>::__sqrt3()); + } + else if (__x < _Tp(0)) + { + _Tp __J_nu, __Jp_nu, __N_nu, __Np_nu; + + __bessel_jn(_Tp(1) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu); + __Ai = __rootx * (__J_nu + - __N_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2); + __Bi = -__rootx * (__N_nu + + __J_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2); + + __bessel_jn(_Tp(2) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu); + __Aip = __absx * (__N_nu / __numeric_constants<_Tp>::__sqrt3() + + __J_nu) / _Tp(2); + __Bip = __absx * (__J_nu / __numeric_constants<_Tp>::__sqrt3() + - __N_nu) / _Tp(2); + } + else + { + + + + __Ai = _Tp(0.35502805388781723926L); + __Bi = __Ai * __numeric_constants<_Tp>::__sqrt3(); + + + + + __Aip = -_Tp(0.25881940379280679840L); + __Bip = -__Aip * __numeric_constants<_Tp>::__sqrt3(); + } + + return; + } + } + + + + + +} +# 55 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 1 3 +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 56 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 + namespace __detail + { +# 72 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 + template + _Tp + __poly_hermite_recursion(unsigned int __n, _Tp __x) + { + + _Tp __H_0 = 1; + if (__n == 0) + return __H_0; + + + _Tp __H_1 = 2 * __x; + if (__n == 1) + return __H_1; + + + _Tp __H_n, __H_nm1, __H_nm2; + unsigned int __i; + for (__H_nm2 = __H_0, __H_nm1 = __H_1, __i = 2; __i <= __n; ++__i) + { + __H_n = 2 * (__x * __H_nm1 - (__i - 1) * __H_nm2); + __H_nm2 = __H_nm1; + __H_nm1 = __H_n; + } + + return __H_n; + } +# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 + template + inline _Tp + __poly_hermite(unsigned int __n, _Tp __x) + { + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __poly_hermite_recursion(__n, __x); + } + } + + + + + +} +# 56 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 1 3 +# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + namespace __detail + { +# 75 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre_large_n(unsigned __n, _Tpa __alpha1, _Tp __x) + { + const _Tp __a = -_Tp(__n); + const _Tp __b = _Tp(__alpha1) + _Tp(1); + const _Tp __eta = _Tp(2) * __b - _Tp(4) * __a; + const _Tp __cos2th = __x / __eta; + const _Tp __sin2th = _Tp(1) - __cos2th; + const _Tp __th = std::acos(std::sqrt(__cos2th)); + const _Tp __pre_h = __numeric_constants<_Tp>::__pi_2() + * __numeric_constants<_Tp>::__pi_2() + * __eta * __eta * __cos2th * __sin2th; + + + const _Tp __lg_b = ::std::lgamma(_Tp(__n) + __b); + const _Tp __lnfact = ::std::lgamma(_Tp(__n + 1)); + + + + + + _Tp __pre_term1 = _Tp(0.5L) * (_Tp(1) - __b) + * std::log(_Tp(0.25L) * __x * __eta); + _Tp __pre_term2 = _Tp(0.25L) * std::log(__pre_h); + _Tp __lnpre = __lg_b - __lnfact + _Tp(0.5L) * __x + + __pre_term1 - __pre_term2; + _Tp __ser_term1 = std::sin(__a * __numeric_constants<_Tp>::__pi()); + _Tp __ser_term2 = std::sin(_Tp(0.25L) * __eta + * (_Tp(2) * __th + - std::sin(_Tp(2) * __th)) + + __numeric_constants<_Tp>::__pi_4()); + _Tp __ser = __ser_term1 + __ser_term2; + + return std::exp(__lnpre) * __ser; + } +# 129 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre_hyperg(unsigned int __n, _Tpa __alpha1, _Tp __x) + { + const _Tp __b = _Tp(__alpha1) + _Tp(1); + const _Tp __mx = -__x; + const _Tp __tc_sgn = (__x < _Tp(0) ? _Tp(1) + : ((__n % 2 == 1) ? -_Tp(1) : _Tp(1))); + + _Tp __tc = _Tp(1); + const _Tp __ax = std::abs(__x); + for (unsigned int __k = 1; __k <= __n; ++__k) + __tc *= (__ax / __k); + + _Tp __term = __tc * __tc_sgn; + _Tp __sum = __term; + for (int __k = int(__n) - 1; __k >= 0; --__k) + { + __term *= ((__b + _Tp(__k)) / _Tp(int(__n) - __k)) + * _Tp(__k + 1) / __mx; + __sum += __term; + } + + return __sum; + } +# 185 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre_recursion(unsigned int __n, _Tpa __alpha1, _Tp __x) + { + + _Tp __l_0 = _Tp(1); + if (__n == 0) + return __l_0; + + + _Tp __l_1 = -__x + _Tp(1) + _Tp(__alpha1); + if (__n == 1) + return __l_1; + + + _Tp __l_n2 = __l_0; + _Tp __l_n1 = __l_1; + _Tp __l_n = _Tp(0); + for (unsigned int __nn = 2; __nn <= __n; ++__nn) + { + __l_n = (_Tp(2 * __nn - 1) + _Tp(__alpha1) - __x) + * __l_n1 / _Tp(__nn) + - (_Tp(__nn - 1) + _Tp(__alpha1)) * __l_n2 / _Tp(__nn); + __l_n2 = __l_n1; + __l_n1 = __l_n; + } + + return __l_n; + } +# 244 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre(unsigned int __n, _Tpa __alpha1, _Tp __x) + { + if (__x < _Tp(0)) + std::__throw_domain_error(("Negative argument " "in __poly_laguerre.") + ); + + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__n == 0) + return _Tp(1); + else if (__n == 1) + return _Tp(1) + _Tp(__alpha1) - __x; + else if (__x == _Tp(0)) + { + _Tp __prod = _Tp(__alpha1) + _Tp(1); + for (unsigned int __k = 2; __k <= __n; ++__k) + __prod *= (_Tp(__alpha1) + _Tp(__k)) / _Tp(__k); + return __prod; + } + else if (__n > 10000000 && _Tp(__alpha1) > -_Tp(1) + && __x < _Tp(2) * (_Tp(__alpha1) + _Tp(1)) + _Tp(4 * __n)) + return __poly_laguerre_large_n(__n, __alpha1, __x); + else if (_Tp(__alpha1) >= _Tp(0) + || (__x > _Tp(0) && _Tp(__alpha1) < -_Tp(__n + 1))) + return __poly_laguerre_recursion(__n, __alpha1, __x); + else + return __poly_laguerre_hyperg(__n, __alpha1, __x); + } +# 296 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + inline _Tp + __assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x) + { return __poly_laguerre(__n, __m, __x); } +# 316 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + inline _Tp + __laguerre(unsigned int __n, _Tp __x) + { return __poly_laguerre(__n, 0, __x); } + } + + + + + + +} +# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + namespace __detail + { +# 78 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_sum(_Tp __s) + { + + if (__s < _Tp(1)) + std::__throw_domain_error(("Bad argument in zeta sum.")); + + const unsigned int max_iter = 10000; + _Tp __zeta = _Tp(0); + for (unsigned int __k = 1; __k < max_iter; ++__k) + { + _Tp __term = std::pow(static_cast<_Tp>(__k), -__s); + if (__term < std::numeric_limits<_Tp>::epsilon()) + { + break; + } + __zeta += __term; + } + + return __zeta; + } +# 115 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_alt(_Tp __s) + { + _Tp __sgn = _Tp(1); + _Tp __zeta = _Tp(0); + for (unsigned int __i = 1; __i < 10000000; ++__i) + { + _Tp __term = __sgn / std::pow(__i, __s); + if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon()) + break; + __zeta += __term; + __sgn *= _Tp(-1); + } + __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s); + + return __zeta; + } +# 157 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_glob(_Tp __s) + { + _Tp __zeta = _Tp(0); + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + + + if (__s < _Tp(0)) + { + + if (::std::fmod(__s,_Tp(2)) == _Tp(0)) + return _Tp(0); + else + + { + _Tp __zeta = __riemann_zeta_glob(_Tp(1) - __s); + __zeta *= std::pow(_Tp(2) + * __numeric_constants<_Tp>::__pi(), __s) + * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) + + * std::exp(::std::lgamma(_Tp(1) - __s)) + + + + / __numeric_constants<_Tp>::__pi(); + return __zeta; + } + } + + _Tp __num = _Tp(0.5L); + const unsigned int __maxit = 10000; + for (unsigned int __i = 0; __i < __maxit; ++__i) + { + bool __punt = false; + _Tp __sgn = _Tp(1); + _Tp __term = _Tp(0); + for (unsigned int __j = 0; __j <= __i; ++__j) + { + + _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i)) + - ::std::lgamma(_Tp(1 + __j)) + - ::std::lgamma(_Tp(1 + __i - __j)); + + + + + + if (__bincoeff > __max_bincoeff) + { + + __punt = true; + break; + } + __bincoeff = std::exp(__bincoeff); + __term += __sgn * __bincoeff * std::pow(_Tp(1 + __j), -__s); + __sgn *= _Tp(-1); + } + if (__punt) + break; + __term *= __num; + __zeta += __term; + if (std::abs(__term/__zeta) < __eps) + break; + __num *= _Tp(0.5L); + } + + __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s); + + return __zeta; + } +# 252 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_product(_Tp __s) + { + static const _Tp __prime[] = { + _Tp(2), _Tp(3), _Tp(5), _Tp(7), _Tp(11), _Tp(13), _Tp(17), _Tp(19), + _Tp(23), _Tp(29), _Tp(31), _Tp(37), _Tp(41), _Tp(43), _Tp(47), + _Tp(53), _Tp(59), _Tp(61), _Tp(67), _Tp(71), _Tp(73), _Tp(79), + _Tp(83), _Tp(89), _Tp(97), _Tp(101), _Tp(103), _Tp(107), _Tp(109) + }; + static const unsigned int __num_primes = sizeof(__prime) / sizeof(_Tp); + + _Tp __zeta = _Tp(1); + for (unsigned int __i = 0; __i < __num_primes; ++__i) + { + const _Tp __fact = _Tp(1) - std::pow(__prime[__i], -__s); + __zeta *= __fact; + if (_Tp(1) - __fact < std::numeric_limits<_Tp>::epsilon()) + break; + } + + __zeta = _Tp(1) / __zeta; + + return __zeta; + } +# 293 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta(_Tp __s) + { + if (__isnan(__s)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__s == _Tp(1)) + return std::numeric_limits<_Tp>::infinity(); + else if (__s < -_Tp(19)) + { + _Tp __zeta = __riemann_zeta_product(_Tp(1) - __s); + __zeta *= std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s) + * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) + + * std::exp(::std::lgamma(_Tp(1) - __s)) + + + + / __numeric_constants<_Tp>::__pi(); + return __zeta; + } + else if (__s < _Tp(20)) + { + + bool __glob = true; + if (__glob) + return __riemann_zeta_glob(__s); + else + { + if (__s > _Tp(1)) + return __riemann_zeta_sum(__s); + else + { + _Tp __zeta = std::pow(_Tp(2) + * __numeric_constants<_Tp>::__pi(), __s) + * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) + + * ::std::tgamma(_Tp(1) - __s) + + + + * __riemann_zeta_sum(_Tp(1) - __s); + return __zeta; + } + } + } + else + return __riemann_zeta_product(__s); + } +# 365 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __hurwitz_zeta_glob(_Tp __a, _Tp __s) + { + _Tp __zeta = _Tp(0); + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + const unsigned int __maxit = 10000; + for (unsigned int __i = 0; __i < __maxit; ++__i) + { + bool __punt = false; + _Tp __sgn = _Tp(1); + _Tp __term = _Tp(0); + for (unsigned int __j = 0; __j <= __i; ++__j) + { + + _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i)) + - ::std::lgamma(_Tp(1 + __j)) + - ::std::lgamma(_Tp(1 + __i - __j)); + + + + + + if (__bincoeff > __max_bincoeff) + { + + __punt = true; + break; + } + __bincoeff = std::exp(__bincoeff); + __term += __sgn * __bincoeff * std::pow(_Tp(__a + __j), -__s); + __sgn *= _Tp(-1); + } + if (__punt) + break; + __term /= _Tp(__i + 1); + if (std::abs(__term / __zeta) < __eps) + break; + __zeta += __term; + } + + __zeta /= __s - _Tp(1); + + return __zeta; + } +# 430 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + inline _Tp + __hurwitz_zeta(_Tp __a, _Tp __s) + { return __hurwitz_zeta_glob(__a, __s); } + } + + + + + + +} +# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 203 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + assoc_laguerref(unsigned int __n, unsigned int __m, float __x) + { return __detail::__assoc_laguerre(__n, __m, __x); } + + + + + + + + inline long double + assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x) + { return __detail::__assoc_laguerre(__n, __m, __x); } +# 248 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__assoc_laguerre<__type>(__n, __m, __x); + } +# 264 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + assoc_legendref(unsigned int __l, unsigned int __m, float __x) + { return __detail::__assoc_legendre_p(__l, __m, __x); } + + + + + + + inline long double + assoc_legendrel(unsigned int __l, unsigned int __m, long double __x) + { return __detail::__assoc_legendre_p(__l, __m, __x); } +# 294 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__assoc_legendre_p<__type>(__l, __m, __x); + } +# 309 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + betaf(float __a, float __b) + { return __detail::__beta(__a, __b); } + + + + + + + + inline long double + betal(long double __a, long double __b) + { return __detail::__beta(__a, __b); } +# 339 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type + beta(_Tpa __a, _Tpb __b) + { + typedef typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type __type; + return __detail::__beta<__type>(__a, __b); + } +# 355 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + comp_ellint_1f(float __k) + { return __detail::__comp_ellint_1(__k); } + + + + + + + + inline long double + comp_ellint_1l(long double __k) + { return __detail::__comp_ellint_1(__k); } +# 387 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + comp_ellint_1(_Tp __k) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__comp_ellint_1<__type>(__k); + } +# 403 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + comp_ellint_2f(float __k) + { return __detail::__comp_ellint_2(__k); } + + + + + + + + inline long double + comp_ellint_2l(long double __k) + { return __detail::__comp_ellint_2(__k); } +# 434 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + comp_ellint_2(_Tp __k) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__comp_ellint_2<__type>(__k); + } +# 450 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + comp_ellint_3f(float __k, float __nu) + { return __detail::__comp_ellint_3(__k, __nu); } + + + + + + + + inline long double + comp_ellint_3l(long double __k, long double __nu) + { return __detail::__comp_ellint_3(__k, __nu); } +# 485 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type + comp_ellint_3(_Tp __k, _Tpn __nu) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type; + return __detail::__comp_ellint_3<__type>(__k, __nu); + } +# 501 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + cyl_bessel_if(float __nu, float __x) + { return __detail::__cyl_bessel_i(__nu, __x); } + + + + + + + + inline long double + cyl_bessel_il(long double __nu, long double __x) + { return __detail::__cyl_bessel_i(__nu, __x); } +# 531 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_bessel_i(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_bessel_i<__type>(__nu, __x); + } +# 547 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + cyl_bessel_jf(float __nu, float __x) + { return __detail::__cyl_bessel_j(__nu, __x); } + + + + + + + + inline long double + cyl_bessel_jl(long double __nu, long double __x) + { return __detail::__cyl_bessel_j(__nu, __x); } +# 577 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_bessel_j(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_bessel_j<__type>(__nu, __x); + } +# 593 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + cyl_bessel_kf(float __nu, float __x) + { return __detail::__cyl_bessel_k(__nu, __x); } + + + + + + + + inline long double + cyl_bessel_kl(long double __nu, long double __x) + { return __detail::__cyl_bessel_k(__nu, __x); } +# 629 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_bessel_k(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_bessel_k<__type>(__nu, __x); + } +# 645 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + cyl_neumannf(float __nu, float __x) + { return __detail::__cyl_neumann_n(__nu, __x); } + + + + + + + + inline long double + cyl_neumannl(long double __nu, long double __x) + { return __detail::__cyl_neumann_n(__nu, __x); } +# 677 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_neumann(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_neumann_n<__type>(__nu, __x); + } +# 693 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + ellint_1f(float __k, float __phi) + { return __detail::__ellint_1(__k, __phi); } + + + + + + + + inline long double + ellint_1l(long double __k, long double __phi) + { return __detail::__ellint_1(__k, __phi); } +# 725 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type + ellint_1(_Tp __k, _Tpp __phi) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type; + return __detail::__ellint_1<__type>(__k, __phi); + } +# 741 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + ellint_2f(float __k, float __phi) + { return __detail::__ellint_2(__k, __phi); } + + + + + + + + inline long double + ellint_2l(long double __k, long double __phi) + { return __detail::__ellint_2(__k, __phi); } +# 773 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type + ellint_2(_Tp __k, _Tpp __phi) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type; + return __detail::__ellint_2<__type>(__k, __phi); + } +# 789 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + ellint_3f(float __k, float __nu, float __phi) + { return __detail::__ellint_3(__k, __nu, __phi); } + + + + + + + + inline long double + ellint_3l(long double __k, long double __nu, long double __phi) + { return __detail::__ellint_3(__k, __nu, __phi); } +# 826 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type + ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi) + { + typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type; + return __detail::__ellint_3<__type>(__k, __nu, __phi); + } +# 841 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + expintf(float __x) + { return __detail::__expint(__x); } + + + + + + + + inline long double + expintl(long double __x) + { return __detail::__expint(__x); } +# 866 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + expint(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__expint<__type>(__x); + } +# 882 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + hermitef(unsigned int __n, float __x) + { return __detail::__poly_hermite(__n, __x); } + + + + + + + + inline long double + hermitel(unsigned int __n, long double __x) + { return __detail::__poly_hermite(__n, __x); } +# 914 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + hermite(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__poly_hermite<__type>(__n, __x); + } +# 930 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + laguerref(unsigned int __n, float __x) + { return __detail::__laguerre(__n, __x); } + + + + + + + + inline long double + laguerrel(unsigned int __n, long double __x) + { return __detail::__laguerre(__n, __x); } +# 958 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + laguerre(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__laguerre<__type>(__n, __x); + } +# 974 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + legendref(unsigned int __l, float __x) + { return __detail::__poly_legendre_p(__l, __x); } + + + + + + + + inline long double + legendrel(unsigned int __l, long double __x) + { return __detail::__poly_legendre_p(__l, __x); } +# 1003 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + legendre(unsigned int __l, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__poly_legendre_p<__type>(__l, __x); + } +# 1019 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + riemann_zetaf(float __s) + { return __detail::__riemann_zeta(__s); } + + + + + + + + inline long double + riemann_zetal(long double __s) + { return __detail::__riemann_zeta(__s); } +# 1054 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + riemann_zeta(_Tp __s) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__riemann_zeta<__type>(__s); + } +# 1070 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + sph_besself(unsigned int __n, float __x) + { return __detail::__sph_bessel(__n, __x); } + + + + + + + + inline long double + sph_bessell(unsigned int __n, long double __x) + { return __detail::__sph_bessel(__n, __x); } +# 1098 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + sph_bessel(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__sph_bessel<__type>(__n, __x); + } +# 1114 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + sph_legendref(unsigned int __l, unsigned int __m, float __theta) + { return __detail::__sph_legendre(__l, __m, __theta); } +# 1125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline long double + sph_legendrel(unsigned int __l, unsigned int __m, long double __theta) + { return __detail::__sph_legendre(__l, __m, __theta); } +# 1145 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__sph_legendre<__type>(__l, __m, __theta); + } +# 1161 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + sph_neumannf(unsigned int __n, float __x) + { return __detail::__sph_neumann(__n, __x); } + + + + + + + + inline long double + sph_neumannl(unsigned int __n, long double __x) + { return __detail::__sph_neumann(__n, __x); } +# 1189 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + sph_neumann(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__sph_neumann<__type>(__n, __x); + } + + + + +} + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 1216 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + airy_aif(float __x) + { + float __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Ai; + } + + + + + inline long double + airy_ail(long double __x) + { + long double __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Ai; + } + + + + + template + inline typename __gnu_cxx::__promote<_Tp>::__type + airy_ai(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + __type __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy<__type>(__x, __Ai, __Bi, __Aip, __Bip); + return __Ai; + } + + + + + inline float + airy_bif(float __x) + { + float __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Bi; + } + + + + + inline long double + airy_bil(long double __x) + { + long double __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Bi; + } + + + + + template + inline typename __gnu_cxx::__promote<_Tp>::__type + airy_bi(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + __type __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy<__type>(__x, __Ai, __Bi, __Aip, __Bip); + return __Bi; + } +# 1292 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + conf_hypergf(float __a, float __c, float __x) + { return std::__detail::__conf_hyperg(__a, __c, __x); } +# 1303 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline long double + conf_hypergl(long double __a, long double __c, long double __x) + { return std::__detail::__conf_hyperg(__a, __c, __x); } +# 1323 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type + conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x) + { + typedef typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type __type; + return std::__detail::__conf_hyperg<__type>(__a, __c, __x); + } +# 1340 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + hypergf(float __a, float __b, float __c, float __x) + { return std::__detail::__hyperg(__a, __b, __c, __x); } +# 1351 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline long double + hypergl(long double __a, long double __b, long double __c, long double __x) + { return std::__detail::__hyperg(__a, __b, __c, __x); } +# 1372 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type + hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x) + { + typedef typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp> + ::__type __type; + return std::__detail::__hyperg<__type>(__a, __b, __c, __x); + } + + + +} +# 3907 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 + + +} +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/math.h" 2 3 + +using std::abs; +using std::acos; +using std::asin; +using std::atan; +using std::atan2; +using std::cos; +using std::sin; +using std::tan; +using std::cosh; +using std::sinh; +using std::tanh; +using std::exp; +using std::frexp; +using std::ldexp; +using std::log; +using std::log10; +using std::modf; +using std::pow; +using std::sqrt; +using std::ceil; +using std::fabs; +using std::floor; +using std::fmod; + + +using std::fpclassify; +using std::isfinite; +using std::isinf; +using std::isnan; +using std::isnormal; +using std::signbit; +using std::isgreater; +using std::isgreaterequal; +using std::isless; +using std::islessequal; +using std::islessgreater; +using std::isunordered; + + + +using std::acosh; +using std::asinh; +using std::atanh; +using std::cbrt; +using std::copysign; +using std::erf; +using std::erfc; +using std::exp2; +using std::expm1; +using std::fdim; +using std::fma; +using std::fmax; +using std::fmin; +using std::hypot; +using std::ilogb; +using std::lgamma; +using std::llrint; +using std::llround; +using std::log1p; +using std::log2; +using std::logb; +using std::lrint; +using std::lround; +using std::nearbyint; +using std::nextafter; +using std::nexttoward; +using std::remainder; +using std::remquo; +using std::rint; +using std::round; +using std::scalbln; +using std::scalbn; +using std::tgamma; +using std::trunc; +# 4578 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h" 1 3 +# 4579 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +# 4582 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +# 4583 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 4653 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + +# 4653 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool signbit(float x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool signbit(double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool signbit(long double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isfinite(float x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isfinite(double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isfinite(long double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isnan(float x); + + + + +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isnan(double x); + +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isnan(long double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isinf(float x); + + + + +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isinf(double x); + +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isinf(long double x); +} +# 4832 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std +{ + template extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) T __pow_helper(T, int); + template extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) T __cmath_power(T, unsigned int); +} + +using std::abs; +using std::fabs; +using std::ceil; +using std::floor; +using std::sqrt; + +using std::pow; + +using std::log; +using std::log10; +using std::fmod; +using std::modf; +using std::exp; +using std::frexp; +using std::ldexp; +using std::asin; +using std::sin; +using std::sinh; +using std::acos; +using std::cos; +using std::cosh; +using std::atan; +using std::atan2; +using std::tan; +using std::tanh; +# 5243 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +# 5252 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int abs(long long int); +# 5272 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int abs(long int a); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float abs(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double abs(double); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float fabs(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float ceil(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float floor(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sqrt(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float pow(float, float); + + + + +template +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) +typename __gnu_cxx::__promote_2<_Tp, _Up>::__type pow(_Tp, _Up); + + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float log(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float log10(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float fmod(float, float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float modf(float, float*); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float exp(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float frexp(float, int*); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float ldexp(float, int); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float asin(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sin(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sinh(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float acos(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cos(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cosh(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float atan(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float atan2(float, float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float tan(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float tanh(float); +# 5399 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +} +# 5505 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float logb(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr int ilogb(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float scalbn(float a, int b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float scalbln(float a, long int b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float exp2(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float expm1(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float log2(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float log1p(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float acosh(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float asinh(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float atanh(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float hypot(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float cbrt(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float erf(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float erfc(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float lgamma(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float tgamma(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float copysign(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float nextafter(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float remainder(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float remquo(float a, float b, int *quo); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float round(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr long int lround(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr long long int llround(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float trunc(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float rint(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr long int lrint(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr long long int llrint(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float nearbyint(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float fdim(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float fma(float a, float b, float c); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float fmax(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float fmin(float a, float b); +} +# 5644 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float exp10(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float rsqrt(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float rcbrt(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sinpi(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cospi(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void sincospi(const float a, float *const sptr, float *const cptr); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void sincos(const float a, float *const sptr, float *const cptr); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float j0(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float j1(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float jn(const int n, const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float y0(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float y1(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float yn(const int n, const float a); + +static inline __attribute__((device)) __attribute__((cudart_builtin)) float cyl_bessel_i0(const float a); + +static inline __attribute__((device)) __attribute__((cudart_builtin)) float cyl_bessel_i1(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfinv(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfcinv(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float normcdfinv(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float normcdf(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfcx(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double copysign(const double a, const float b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double copysign(const float a, const double b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(const unsigned int a, const unsigned int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(const int a, const unsigned int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(const unsigned int a, const int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int min(const long int a, const long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(const unsigned long int a, const unsigned long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(const long int a, const unsigned long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(const unsigned long int a, const long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int min(const long long int a, const long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(const unsigned long long int a, const unsigned long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(const long long int a, const unsigned long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(const unsigned long long int a, const long long int b); +# 5785 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float min(const float a, const float b); +# 5796 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(const double a, const double b); +# 5806 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(const float a, const double b); +# 5816 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(const double a, const float b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(const unsigned int a, const unsigned int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(const int a, const unsigned int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(const unsigned int a, const int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int max(const long int a, const long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(const unsigned long int a, const unsigned long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(const long int a, const unsigned long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(const unsigned long int a, const long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int max(const long long int a, const long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(const unsigned long long int a, const unsigned long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(const long long int a, const unsigned long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(const unsigned long long int a, const long long int b); +# 5915 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float max(const float a, const float b); +# 5926 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const double a, const double b); +# 5936 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const float a, const double b); +# 5946 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const double a, const float b); +# 5958 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern "C"{ +inline __attribute__((device)) void *__nv_aligned_device_malloc(size_t size, size_t align) +{ + __attribute__((device)) void *__nv_aligned_device_malloc_impl(size_t, size_t); + return __nv_aligned_device_malloc_impl(size, align); +} +} +# 6248 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" 1 +# 77 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 78 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 79 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" 2 +# 758 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +static inline __attribute__((host)) __attribute__((device)) float exp10(const float a) +{ + return exp10f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float rsqrt(const float a) +{ + return rsqrtf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float rcbrt(const float a) +{ + return rcbrtf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float sinpi(const float a) +{ + return sinpif(a); +} + +static inline __attribute__((host)) __attribute__((device)) float cospi(const float a) +{ + return cospif(a); +} + +static inline __attribute__((host)) __attribute__((device)) void sincospi(const float a, float *const sptr, float *const cptr) +{ + sincospif(a, sptr, cptr); +} + +static inline __attribute__((host)) __attribute__((device)) void sincos(const float a, float *const sptr, float *const cptr) +{ + sincosf(a, sptr, cptr); +} + +static inline __attribute__((host)) __attribute__((device)) float j0(const float a) +{ + return j0f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float j1(const float a) +{ + return j1f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float jn(const int n, const float a) +{ + return jnf(n, a); +} + +static inline __attribute__((host)) __attribute__((device)) float y0(const float a) +{ + return y0f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float y1(const float a) +{ + return y1f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float yn(const int n, const float a) +{ + return ynf(n, a); +} + +static inline __attribute__((device)) float cyl_bessel_i0(const float a) +{ + return cyl_bessel_i0f(a); +} + +static inline __attribute__((device)) float cyl_bessel_i1(const float a) +{ + return cyl_bessel_i1f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float erfinv(const float a) +{ + return erfinvf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float erfcinv(const float a) +{ + return erfcinvf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float normcdfinv(const float a) +{ + return normcdfinvf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float normcdf(const float a) +{ + return normcdff(a); +} + +static inline __attribute__((host)) __attribute__((device)) float erfcx(const float a) +{ + return erfcxf(a); +} + +static inline __attribute__((host)) __attribute__((device)) double copysign(const double a, const float b) +{ + return copysign(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) double copysign(const float a, const double b) +{ + return copysign(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int min(const unsigned int a, const unsigned int b) +{ + return umin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int min(const int a, const unsigned int b) +{ + return umin(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int min(const unsigned int a, const int b) +{ + return umin(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) long int min(const long int a, const long int b) +{ + long int retval; + + + + + + + if (sizeof(long int) == sizeof(int)) { + + + + retval = static_cast(min(static_cast(a), static_cast(b))); + } else { + retval = static_cast(llmin(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int min(const unsigned long int a, const unsigned long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umin(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmin(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int min(const long int a, const unsigned long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umin(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmin(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int min(const unsigned long int a, const long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umin(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmin(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) long long int min(const long long int a, const long long int b) +{ + return llmin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(const unsigned long long int a, const unsigned long long int b) +{ + return ullmin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(const long long int a, const unsigned long long int b) +{ + return ullmin(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(const unsigned long long int a, const long long int b) +{ + return ullmin(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) float min(const float a, const float b) +{ + return fminf(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double min(const double a, const double b) +{ + return fmin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double min(const float a, const double b) +{ + return fmin(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) double min(const double a, const float b) +{ + return fmin(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int max(const unsigned int a, const unsigned int b) +{ + return umax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int max(const int a, const unsigned int b) +{ + return umax(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int max(const unsigned int a, const int b) +{ + return umax(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) long int max(const long int a, const long int b) +{ + long int retval; + + + + + + if (sizeof(long int) == sizeof(int)) { + + + + retval = static_cast(max(static_cast(a), static_cast(b))); + } else { + retval = static_cast(llmax(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int max(const unsigned long int a, const unsigned long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umax(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmax(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int max(const long int a, const unsigned long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umax(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmax(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int max(const unsigned long int a, const long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umax(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmax(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) long long int max(const long long int a, const long long int b) +{ + return llmax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(const unsigned long long int a, const unsigned long long int b) +{ + return ullmax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(const long long int a, const unsigned long long int b) +{ + return ullmax(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(const unsigned long long int a, const long long int b) +{ + return ullmax(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) float max(const float a, const float b) +{ + return fmaxf(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double max(const double a, const double b) +{ + return fmax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double max(const float a, const double b) +{ + return fmax(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) double max(const double a, const float b) +{ + return fmax(a, static_cast(b)); +} +# 1135 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +inline __attribute__((host)) __attribute__((device)) int min(const int a, const int b) +{ + return (a < b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) unsigned int umin(const unsigned int a, const unsigned int b) +{ + return (a < b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) long long int llmin(const long long int a, const long long int b) +{ + return (a < b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) unsigned long long int ullmin(const unsigned long long int a, + const unsigned long long int b) +{ + return (a < b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) int max(const int a, const int b) +{ + return (a > b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) unsigned int umax(const unsigned int a, const unsigned int b) +{ + return (a > b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) long long int llmax(const long long int a, const long long int b) +{ + return (a > b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) unsigned long long int ullmax(const unsigned long long int a, + const unsigned long long int b) +{ + return (a > b) ? a : b; +} +# 6249 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 304 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 118 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 1 +# 81 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 82 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" 1 +# 83 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +extern "C" +{ +# 106 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __mulhi(int x, int y); +# 116 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __umulhi(unsigned int x, unsigned int y); +# 126 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __mul64hi(long long int x, long long int y); +# 136 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __umul64hi(unsigned long long int x, unsigned long long int y); +# 145 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int_as_float(int x); +# 154 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float_as_int(float x); +# 163 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint_as_float(unsigned int x); +# 172 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float_as_uint(float x); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __syncthreads(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __prof_trigger(int); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __threadfence(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __threadfence_block(void); +__attribute__((device)) __attribute__((cudart_builtin)) + +__attribute__((__noreturn__)) + + + +__attribute__((device_builtin)) void __trap(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __brkpt(); +# 196 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __saturatef(float x); +# 215 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __sad(int x, int y, unsigned int z); +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __usad(unsigned int x, unsigned int y, unsigned int z); +# 243 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __mul24(int x, int y); +# 253 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __umul24(unsigned int x, unsigned int y); +# 269 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float fdividef(float x, float y); +# 289 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdividef(float x, float y); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) double fdivide(double x, double y); +# 303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __sinf(float x) +# 303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 315 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __cosf(float x) +# 315 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 315 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __tanf(float x) +# 328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __tanhf(float x) +# 340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void __sincosf(float x, float *sptr, float *cptr) +# 353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 371 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __expf(float x) +# 371 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 371 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 385 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __exp10f(float x) +# 385 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 385 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 398 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __log2f(float x) +# 398 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 398 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __log10f(float x) +# 411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 428 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __logf(float x) +# 428 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 428 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 443 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __powf(float x, float y) +# 443 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 443 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 453 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rn(float x); +# 463 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rz(float x); +# 473 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_ru(float); +# 483 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rd(float x); +# 493 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rn(float x); +# 503 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rz(float x); +# 513 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_ru(float x); +# 523 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rd(float x); +# 532 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rn(int x); +# 541 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rz(int x); +# 550 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_ru(int x); +# 559 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rd(int x); +# 568 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rn(unsigned int x); +# 577 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rz(unsigned int x); +# 586 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_ru(unsigned int x); +# 595 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rd(unsigned int x); +# 605 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rn(float x); +# 615 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rz(float x); +# 625 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_ru(float x); +# 635 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rd(float x); +# 645 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rn(float x); +# 655 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rz(float x); +# 665 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_ru(float x); +# 675 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rd(float x); +# 684 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rn(long long int x); +# 693 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rz(long long int x); +# 702 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_ru(long long int x); +# 711 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rd(long long int x); +# 720 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rn(unsigned long long int x); +# 729 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rz(unsigned long long int x); +# 738 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_ru(unsigned long long int x); +# 747 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rd(unsigned long long int x); +# 766 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rn(float x, float y); +# 785 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rz(float x, float y); +# 804 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_ru(float x, float y); +# 823 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rd(float x, float y); +# 842 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rn(float x, float y); +# 861 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rz(float x, float y); +# 880 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_ru(float x, float y); +# 899 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rd(float x, float y); +# 917 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rn(float x, float y); +# 935 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rz(float x, float y); +# 953 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_ru(float x, float y); +# 971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rd(float x, float y); +# 1015 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rn(float x, float y, float z); +# 1059 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rz(float x, float y, float z); +# 1103 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_ru(float x, float y, float z); +# 1147 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rd(float x, float y, float z); +# 1164 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rn(float x); +# 1181 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rz(float x); +# 1198 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_ru(float x); +# 1215 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rd(float x); +# 1233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rn(float x); +# 1251 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rz(float x); +# 1269 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_ru(float x); +# 1287 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rd(float x); +# 1305 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frsqrt_rn(float x); +# 1324 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rn(float x, float y); +# 1343 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rz(float x, float y); +# 1362 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_ru(float x, float y); +# 1381 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rd(float x, float y); +# 1390 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __clz(int x); +# 1401 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __ffs(int x); +# 1410 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __popc(unsigned int x); +# 1419 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __brev(unsigned int x); +# 1428 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __clzll(long long int x); +# 1439 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __ffsll(long long int x); +# 1450 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __popcll(unsigned long long int x); +# 1459 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __brevll(unsigned long long int x); +# 1482 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __byte_perm(unsigned int x, unsigned int y, unsigned int s); +# 1494 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __hadd(int x, int y); +# 1507 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __rhadd(int x, int y); +# 1519 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __uhadd(unsigned int x, unsigned int y); +# 1532 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __urhadd(unsigned int x, unsigned int y); +# 1543 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __double2int_rz(double x); +# 1553 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __double2uint_rz(double x); +# 1563 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __double2ll_rz(double x); +# 1573 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __double2ull_rz(double x); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __pm0(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __pm1(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __pm2(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __pm3(void); +# 1603 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabs2(unsigned int a); +# 1614 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsss2(unsigned int a); +# 1625 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vadd2(unsigned int a, unsigned int b); +# 1636 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddss2 (unsigned int a, unsigned int b); +# 1646 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddus2 (unsigned int a, unsigned int b); +# 1657 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgs2(unsigned int a, unsigned int b); +# 1668 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgu2(unsigned int a, unsigned int b); +# 1679 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vhaddu2(unsigned int a, unsigned int b); +# 1690 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpeq2(unsigned int a, unsigned int b); +# 1701 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpges2(unsigned int a, unsigned int b); +# 1712 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgeu2(unsigned int a, unsigned int b); +# 1723 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgts2(unsigned int a, unsigned int b); +# 1734 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgtu2(unsigned int a, unsigned int b); +# 1745 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmples2(unsigned int a, unsigned int b); +# 1756 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpleu2(unsigned int a, unsigned int b); +# 1767 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmplts2(unsigned int a, unsigned int b); +# 1778 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpltu2(unsigned int a, unsigned int b); +# 1789 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpne2(unsigned int a, unsigned int b); +# 1800 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffu2(unsigned int a, unsigned int b); +# 1811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxs2(unsigned int a, unsigned int b); +# 1822 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxu2(unsigned int a, unsigned int b); +# 1833 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmins2(unsigned int a, unsigned int b); +# 1844 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vminu2(unsigned int a, unsigned int b); +# 1855 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vseteq2(unsigned int a, unsigned int b); +# 1866 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetges2(unsigned int a, unsigned int b); +# 1877 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgeu2(unsigned int a, unsigned int b); +# 1888 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgts2(unsigned int a, unsigned int b); +# 1899 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgtu2(unsigned int a, unsigned int b); +# 1910 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetles2(unsigned int a, unsigned int b); +# 1921 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetleu2(unsigned int a, unsigned int b); +# 1932 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetlts2(unsigned int a, unsigned int b); +# 1943 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetltu2(unsigned int a, unsigned int b); +# 1954 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetne2(unsigned int a, unsigned int b); +# 1965 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsadu2(unsigned int a, unsigned int b); +# 1976 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsub2(unsigned int a, unsigned int b); +# 1987 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubss2 (unsigned int a, unsigned int b); +# 1998 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubus2 (unsigned int a, unsigned int b); +# 2008 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vneg2(unsigned int a); +# 2018 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vnegss2(unsigned int a); +# 2029 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffs2(unsigned int a, unsigned int b); +# 2040 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsads2(unsigned int a, unsigned int b); +# 2050 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabs4(unsigned int a); +# 2061 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsss4(unsigned int a); +# 2072 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vadd4(unsigned int a, unsigned int b); +# 2083 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddss4 (unsigned int a, unsigned int b); +# 2093 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddus4 (unsigned int a, unsigned int b); +# 2104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgs4(unsigned int a, unsigned int b); +# 2115 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgu4(unsigned int a, unsigned int b); +# 2126 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vhaddu4(unsigned int a, unsigned int b); +# 2137 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpeq4(unsigned int a, unsigned int b); +# 2148 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpges4(unsigned int a, unsigned int b); +# 2159 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgeu4(unsigned int a, unsigned int b); +# 2170 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgts4(unsigned int a, unsigned int b); +# 2181 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgtu4(unsigned int a, unsigned int b); +# 2192 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmples4(unsigned int a, unsigned int b); +# 2203 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpleu4(unsigned int a, unsigned int b); +# 2214 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmplts4(unsigned int a, unsigned int b); +# 2225 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpltu4(unsigned int a, unsigned int b); +# 2236 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpne4(unsigned int a, unsigned int b); +# 2247 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffu4(unsigned int a, unsigned int b); +# 2258 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxs4(unsigned int a, unsigned int b); +# 2269 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxu4(unsigned int a, unsigned int b); +# 2280 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmins4(unsigned int a, unsigned int b); +# 2291 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vminu4(unsigned int a, unsigned int b); +# 2302 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vseteq4(unsigned int a, unsigned int b); +# 2313 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetles4(unsigned int a, unsigned int b); +# 2324 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetleu4(unsigned int a, unsigned int b); +# 2335 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetlts4(unsigned int a, unsigned int b); +# 2346 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetltu4(unsigned int a, unsigned int b); +# 2357 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetges4(unsigned int a, unsigned int b); +# 2368 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgeu4(unsigned int a, unsigned int b); +# 2379 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgts4(unsigned int a, unsigned int b); +# 2390 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgtu4(unsigned int a, unsigned int b); +# 2401 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetne4(unsigned int a, unsigned int b); +# 2412 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsadu4(unsigned int a, unsigned int b); +# 2423 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsub4(unsigned int a, unsigned int b); +# 2434 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubss4(unsigned int a, unsigned int b); +# 2445 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubus4(unsigned int a, unsigned int b); +# 2455 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vneg4(unsigned int a); +# 2465 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vnegss4(unsigned int a); +# 2476 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffs4(unsigned int a, unsigned int b); +# 2487 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsads4(unsigned int a, unsigned int b); +# 2497 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax_s32_relu(const int a, const int b); +# 2509 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax_s16x2_relu(const unsigned int a, const unsigned int b); +# 2518 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin_s32_relu(const int a, const int b); +# 2530 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin_s16x2_relu(const unsigned int a, const unsigned int b); +# 2539 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax3_s32(const int a, const int b, const int c); +# 2551 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_s16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2560 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_u32(const unsigned int a, const unsigned int b, const unsigned int c); +# 2572 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_u16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2581 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin3_s32(const int a, const int b, const int c); +# 2593 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_s16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2602 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_u32(const unsigned int a, const unsigned int b, const unsigned int c); +# 2614 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_u16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2623 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax3_s32_relu(const int a, const int b, const int c); +# 2635 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c); +# 2644 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin3_s32_relu(const int a, const int b, const int c); +# 2656 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c); +# 2665 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmax_s32(const int a, const int b, const int c); +# 2677 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_s16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2686 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_u32(const unsigned int a, const unsigned int b, const unsigned int c); +# 2698 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_u16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2707 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmin_s32(const int a, const int b, const int c); +# 2719 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_s16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2728 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_u32(const unsigned int a, const unsigned int b, const unsigned int c); +# 2740 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_u16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2750 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmax_s32_relu(const int a, const int b, const int c); +# 2762 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c); +# 2772 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmin_s32_relu(const int a, const int b, const int c); +# 2784 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c); +# 2793 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vibmax_s32(const int a, const int b, bool* const pred); +# 2802 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_u32(const unsigned int a, const unsigned int b, bool* const pred); +# 2811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vibmin_s32(const int a, const int b, bool* const pred); +# 2820 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_u32(const unsigned int a, const unsigned int b, bool* const pred); +# 2834 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_s16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo); +# 2848 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo); +# 2862 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_s16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo); +# 2876 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo); + + + + + + +} +# 2899 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" 1 +# 81 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 82 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" 2 +# 116 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +static __attribute__((host)) __attribute__((device)) short __internal_cast_u2s(unsigned short x) +{ + short res; + + (void)memcpy(&res, &x, sizeof(x)); + + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax_s32_relu(const int a, const int b){ + + + + + + + int ans = max(a, b); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax_s16x2_relu(const unsigned int a, const unsigned int b){ + unsigned int res; + + + + + + + + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + + int ansI_lo = max(aS_lo, bS_lo); + int ansI_hi = max(aS_hi, bS_hi); + + + if(ansI_lo < 0){ ansI_lo = 0; } + if(ansI_hi < 0){ ansI_hi = 0; } + + + unsigned ansU_lo = (unsigned)ansI_lo; + unsigned ansU_hi = (unsigned)ansI_hi; + + + res = ansU_lo | (ansU_hi << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin_s32_relu(const int a, const int b){ + + + + + + + int ans = min(a, b); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin_s16x2_relu(const unsigned int a, const unsigned int b){ + unsigned int res; + + + + + + + + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + + int ansI_lo = min(aS_lo, bS_lo); + int ansI_hi = min(aS_hi, bS_hi); + + + if(ansI_lo < 0){ ansI_lo = 0; } + if(ansI_hi < 0){ ansI_hi = 0; } + + + unsigned ansU_lo = (unsigned)ansI_lo; + unsigned ansU_hi = (unsigned)ansI_hi; + + + res = ansU_lo | (ansU_hi << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax3_s32(const int a, const int b, const int c){ +# 245 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return max(max(a, b), c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_s16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 262 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned int ansU_lo = (unsigned int)max(max(aS_lo, bS_lo), cS_lo); + unsigned int ansU_hi = (unsigned int)max(max(aS_hi, bS_hi), cS_hi); + + + res = (ansU_lo & 0x0000FFFFU) | (ansU_hi << 16); + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_u32(const unsigned int a, const unsigned int b, const unsigned int c){ +# 301 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return max(max(a, b), c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_u16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 317 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + unsigned short ansU_lo = (unsigned short)max(max(aU_lo, bU_lo), cU_lo); + unsigned short ansU_hi = (unsigned short)max(max(aU_hi, bU_hi), cU_hi); + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin3_s32(const int a, const int b, const int c){ +# 347 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return min(min(a, b), c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_s16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 363 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned int ansU_lo = (unsigned int)min(min(aS_lo, bS_lo), cS_lo); + unsigned int ansU_hi = (unsigned int)min(min(aS_hi, bS_hi), cS_hi); + + + res = (ansU_lo & 0x0000FFFFU) | (ansU_hi << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_u32(const unsigned int a, const unsigned int b, const unsigned int c){ +# 403 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return min(min(a, b), c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_u16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 419 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + unsigned short ansU_lo = (unsigned short)min(min(aU_lo, bU_lo), cU_lo); + unsigned short ansU_hi = (unsigned short)min(min(aU_hi, bU_hi), cU_hi); + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax3_s32_relu(const int a, const int b, const int c){ +# 449 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = max(max(a, b), c); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 467 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned ansU_lo = (unsigned)max(0, max(max(aS_lo, bS_lo), cS_lo)); + unsigned ansU_hi = (unsigned)max(0, max(max(aS_hi, bS_hi), cS_hi)); + + + res = ansU_lo | (ansU_hi << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin3_s32_relu(const int a, const int b, const int c){ +# 507 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = min(min(a, b), c); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned res; +# 525 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned ansU_lo = (unsigned)max(0, min(min(aS_lo, bS_lo), cS_lo)); + unsigned ansU_hi = (unsigned)max(0, min(min(aS_hi, bS_hi), cS_hi)); + + + res = ansU_lo | (ansU_hi << 16); + + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmax_s32(const int a, const int b, const int c){ +# 566 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return max(a + b, c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_s16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 582 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + aU_lo += bU_lo; + aU_hi += bU_hi; + + + short sS_lo = __internal_cast_u2s(aU_lo); + short sS_hi = __internal_cast_u2s(aU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned ansU_lo = (unsigned)max(sS_lo, cS_lo); + unsigned ansU_hi = (unsigned)max(sS_hi, cS_hi); + + + res = (ansU_lo & 0x0000FFFFU) | (ansU_hi << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_u32(const unsigned int a, const unsigned int b, const unsigned int c){ +# 622 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return max(a + b, c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_u16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 638 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + unsigned short ansU_lo = (unsigned short)max((unsigned short)(aU_lo + bU_lo), cU_lo); + unsigned short ansU_hi = (unsigned short)max((unsigned short)(aU_hi + bU_hi), cU_hi); + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmin_s32(const int a, const int b, const int c){ +# 668 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return min(a + b, c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_s16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 684 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + aU_lo += bU_lo; + aU_hi += bU_hi; + + + short sS_lo = __internal_cast_u2s(aU_lo); + short sS_hi = __internal_cast_u2s(aU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned ansU_lo = (unsigned)min(sS_lo, cS_lo); + unsigned ansU_hi = (unsigned)min(sS_hi, cS_hi); + + + res = (ansU_lo & 0x0000FFFFU) | (ansU_hi << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_u32(const unsigned int a, const unsigned int b, const unsigned int c){ +# 724 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return min(a + b, c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_u16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 740 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + unsigned short ansU_lo = (unsigned short)min((unsigned short)(aU_lo + bU_lo), cU_lo); + unsigned short ansU_hi = (unsigned short)min((unsigned short)(aU_hi + bU_hi), cU_hi); + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmax_s32_relu(const int a, const int b, const int c){ +# 770 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = max(a + b, c); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 788 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + aU_lo += bU_lo; + aU_hi += bU_hi; + + + short sS_lo = __internal_cast_u2s(aU_lo); + short sS_hi = __internal_cast_u2s(aU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned ansU_lo = (unsigned)max(0, max(sS_lo, cS_lo)); + unsigned ansU_hi = (unsigned)max(0, max(sS_hi, cS_hi)); + + + res = ansU_lo | (ansU_hi << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmin_s32_relu(const int a, const int b, const int c){ +# 828 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = min(a + b, c); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 846 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + aU_lo += bU_lo; + aU_hi += bU_hi; + + + short sS_lo = __internal_cast_u2s(aU_lo); + short sS_hi = __internal_cast_u2s(aU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned ansU_lo = (unsigned)max(0, min(sS_lo, cS_lo)); + unsigned ansU_hi = (unsigned)max(0, min(sS_hi, cS_hi)); + + + res = ansU_lo | (ansU_hi << 16); + + + return res; +} + + + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vibmax_s32(const int a, const int b, bool* const pred){ +# 892 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = max(a, b); + + *pred = (a >= b); + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_u32(const unsigned int a, const unsigned int b, bool* const pred){ +# 913 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned int ans = max(a, b); + + *pred = (a >= b); + return ans; + +} + + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vibmin_s32(const int a, const int b, bool* const pred){ +# 935 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = min(a, b); + + *pred = (a <= b); + return ans; + +} + + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_u32(const unsigned int a, const unsigned int b, bool* const pred){ +# 957 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned int ans = min(a, b); + + *pred = (a <= b); + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_s16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 986 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + + unsigned int ansU_lo = (unsigned int)max(aS_lo, bS_lo); + unsigned int ansU_hi = (unsigned int)max(aS_hi, bS_hi); + + *pred_hi = (aS_hi >= bS_hi); + *pred_lo = (aS_lo >= bS_lo); + + + unsigned int ans = (ansU_lo & 0x0000FFFFU) | (ansU_hi << 16); + + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 1035 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + unsigned short ansU_lo = (unsigned short)max(aU_lo, bU_lo); + unsigned short ansU_hi = (unsigned short)max(aU_hi, bU_hi); + + *pred_hi = (aU_hi >= bU_hi); + *pred_lo = (aU_lo >= bU_lo); + + + unsigned int ans = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_s16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 1077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + + unsigned int ansU_lo = (unsigned int)min(aS_lo, bS_lo); + unsigned int ansU_hi = (unsigned int)min(aS_hi, bS_hi); + + *pred_hi = (aS_hi <= bS_hi); + *pred_lo = (aS_lo <= bS_lo); + + + unsigned int ans = (ansU_lo & 0x0000FFFFU) | (ansU_hi << 16); + + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 1126 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + unsigned short ansU_lo = (unsigned short)min(aU_lo, bU_lo); + unsigned short ansU_hi = (unsigned short)min(aU_hi, bU_hi); + + *pred_hi = (aU_hi <= bU_hi); + *pred_lo = (aU_lo <= bU_lo); + + + unsigned int ans = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + return ans; + +} +# 2900 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" 1 +# 89 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +static __inline__ __attribute__((device)) int atomicAdd(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicAdd(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicSub(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicSub(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicExch(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicExch(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) float atomicExch(float *address, float val) { } + +static __inline__ __attribute__((device)) int atomicMin(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicMin(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicMax(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicMax(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicInc(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicDec(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicAnd(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicAnd(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicOr(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicOr(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicXor(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicXor(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicCAS(int *address, int compare, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicCAS(unsigned int *address, unsigned int compare, unsigned int val) { } +# 156 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) __attribute__((deprecated("__any""() is deprecated in favor of ""__any""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __any(int cond); +extern __attribute__((device)) __attribute__((device_builtin)) __attribute__((deprecated("__all""() is deprecated in favor of ""__all""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __all(int cond); +} +# 169 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +static __inline__ __attribute__((device)) unsigned long long int atomicAdd(unsigned long long int *address, unsigned long long int val) { } + +static __inline__ __attribute__((device)) unsigned long long int atomicExch(unsigned long long int *address, unsigned long long int val) { } + +static __inline__ __attribute__((device)) unsigned long long int atomicCAS(unsigned long long int *address, unsigned long long int compare, unsigned long long int val) { } + +static __inline__ __attribute__((device)) __attribute__((deprecated("__any""() is deprecated in favor of ""__any""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) bool any(bool cond) { } + +static __inline__ __attribute__((device)) __attribute__((deprecated("__all""() is deprecated in favor of ""__all""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) bool all(bool cond) { } +# 2903 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" 1 +# 83 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" 2 + + + + +extern "C" +{ +# 100 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double_as_longlong(double x); +# 109 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __longlong_as_double(long long int x); +# 266 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rn(double x, double y, double z); +# 423 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rz(double x, double y, double z); +# 580 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_ru(double x, double y, double z); +# 737 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rd(double x, double y, double z); +# 749 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rn(double x, double y); +# 761 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rz(double x, double y); +# 773 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_ru(double x, double y); +# 785 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rd(double x, double y); +# 797 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rn(double x, double y); +# 809 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rz(double x, double y); +# 821 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_ru(double x, double y); +# 833 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rd(double x, double y); +# 845 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rn(double x, double y); +# 857 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rz(double x, double y); +# 869 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_ru(double x, double y); +# 881 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rd(double x, double y); +# 890 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rn(double x); +# 899 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rz(double x); +# 908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_ru(double x); +# 917 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rd(double x); +# 926 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rn(double x); +# 935 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_ru(double x); +# 944 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rd(double x); +# 953 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rn(double x); +# 962 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_ru(double x); +# 971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rd(double x); +# 980 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rn(double x); +# 989 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_ru(double x); +# 998 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rd(double x); +# 1007 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rn(double x); +# 1016 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_ru(double x); +# 1025 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rd(double x); + + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) double __int2double_rn(int x); + + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) double __uint2double_rn(unsigned int x); +# 1050 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rn(long long int x); +# 1059 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rz(long long int x); +# 1068 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_ru(long long int x); +# 1077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rd(long long int x); +# 1086 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rn(unsigned long long int x); +# 1095 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rz(unsigned long long int x); +# 1104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_ru(unsigned long long int x); +# 1113 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rd(unsigned long long int x); +# 1122 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2hiint(double x); +# 1131 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2loint(double x); +# 1141 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __hiloint2double(int hi, int lo); +} + + + + + + + +static __inline__ __attribute__((device)) double fma(double a, double b, double c, enum cudaRoundMode mode); + + + +static __inline__ __attribute__((device)) double dmul(double a, double b, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double dadd(double a, double b, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double dsub(double a, double b, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) int double2int(double a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) unsigned int double2uint(double a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) long long int double2ll(double a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) unsigned long long int double2ull(double a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) double ll2double(long long int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double ull2double(unsigned long long int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double int2double(int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double uint2double(unsigned int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double float2double(float a, enum cudaRoundMode mode = cudaRoundNearest); + + + + + + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" 1 +# 83 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" 2 + + + + + + + +static __inline__ __attribute__((device)) double fma(double a, double b, double c, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __fma_rz(a, b, c) : + mode == cudaRoundPosInf ? __fma_ru(a, b, c) : + mode == cudaRoundMinInf ? __fma_rd(a, b, c) : + __fma_rn(a, b, c); +} + +static __inline__ __attribute__((device)) double dmul(double a, double b, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __dmul_rz(a, b) : + mode == cudaRoundPosInf ? __dmul_ru(a, b) : + mode == cudaRoundMinInf ? __dmul_rd(a, b) : + __dmul_rn(a, b); +} + +static __inline__ __attribute__((device)) double dadd(double a, double b, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __dadd_rz(a, b) : + mode == cudaRoundPosInf ? __dadd_ru(a, b) : + mode == cudaRoundMinInf ? __dadd_rd(a, b) : + __dadd_rn(a, b); +} + +static __inline__ __attribute__((device)) double dsub(double a, double b, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __dsub_rz(a, b) : + mode == cudaRoundPosInf ? __dsub_ru(a, b) : + mode == cudaRoundMinInf ? __dsub_rd(a, b) : + __dsub_rn(a, b); +} + +static __inline__ __attribute__((device)) int double2int(double a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __double2int_rn(a) : + mode == cudaRoundPosInf ? __double2int_ru(a) : + mode == cudaRoundMinInf ? __double2int_rd(a) : + __double2int_rz(a); +} + +static __inline__ __attribute__((device)) unsigned int double2uint(double a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __double2uint_rn(a) : + mode == cudaRoundPosInf ? __double2uint_ru(a) : + mode == cudaRoundMinInf ? __double2uint_rd(a) : + __double2uint_rz(a); +} + +static __inline__ __attribute__((device)) long long int double2ll(double a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __double2ll_rn(a) : + mode == cudaRoundPosInf ? __double2ll_ru(a) : + mode == cudaRoundMinInf ? __double2ll_rd(a) : + __double2ll_rz(a); +} + +static __inline__ __attribute__((device)) unsigned long long int double2ull(double a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __double2ull_rn(a) : + mode == cudaRoundPosInf ? __double2ull_ru(a) : + mode == cudaRoundMinInf ? __double2ull_rd(a) : + __double2ull_rz(a); +} + +static __inline__ __attribute__((device)) double ll2double(long long int a, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __ll2double_rz(a) : + mode == cudaRoundPosInf ? __ll2double_ru(a) : + mode == cudaRoundMinInf ? __ll2double_rd(a) : + __ll2double_rn(a); +} + +static __inline__ __attribute__((device)) double ull2double(unsigned long long int a, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __ull2double_rz(a) : + mode == cudaRoundPosInf ? __ull2double_ru(a) : + mode == cudaRoundMinInf ? __ull2double_rd(a) : + __ull2double_rn(a); +} + +static __inline__ __attribute__((device)) double int2double(int a, enum cudaRoundMode mode) +{ + return (double)a; +} + +static __inline__ __attribute__((device)) double uint2double(unsigned int a, enum cudaRoundMode mode) +{ + return (double)a; +} + +static __inline__ __attribute__((device)) double float2double(float a, enum cudaRoundMode mode) +{ + return (double)a; +} +# 1185 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" 2 +# 2904 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_atomic_functions.h" 1 +# 88 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_atomic_functions.h" +static __inline__ __attribute__((device)) float atomicAdd(float *address, float val) { } +# 2905 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" 1 +# 89 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +static __inline__ __attribute__((device)) long long atomicMin(long long *address, long long val) { } + +static __inline__ __attribute__((device)) long long atomicMax(long long *address, long long val) { } + +static __inline__ __attribute__((device)) long long atomicAnd(long long *address, long long val) { } + +static __inline__ __attribute__((device)) long long atomicOr(long long *address, long long val) { } + +static __inline__ __attribute__((device)) long long atomicXor(long long *address, long long val) { } + +static __inline__ __attribute__((device)) unsigned long long atomicMin(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) unsigned long long atomicMax(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) unsigned long long atomicAnd(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) unsigned long long atomicOr(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) unsigned long long atomicXor(unsigned long long *address, unsigned long long val) { } +# 2906 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_35_atomic_functions.h" 1 +# 56 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_35_atomic_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" 1 +# 57 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_35_atomic_functions.h" 2 +# 2907 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" 1 +# 93 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +static __inline__ __attribute__((device)) double atomicAdd(double *address, double val) { } + +static __inline__ __attribute__((device)) +int atomicAdd_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicAdd_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicAdd_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicAdd_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicAdd_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicAdd_system(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +float atomicAdd_block(float *address, float val) { } + +static __inline__ __attribute__((device)) +float atomicAdd_system(float *address, float val) { } + +static __inline__ __attribute__((device)) +double atomicAdd_block(double *address, double val) { } + +static __inline__ __attribute__((device)) +double atomicAdd_system(double *address, double val) { } + +static __inline__ __attribute__((device)) +int atomicSub_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicSub_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicSub_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicSub_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +int atomicExch_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicExch_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicExch_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicExch_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicExch_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicExch_system(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +float atomicExch_block(float *address, float val) { } + +static __inline__ __attribute__((device)) +float atomicExch_system(float *address, float val) { } + +static __inline__ __attribute__((device)) +int atomicMin_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicMin_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +long long atomicMin_block(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +long long atomicMin_system(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicMin_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicMin_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicMin_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicMin_system(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +int atomicMax_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicMax_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +long long atomicMax_block(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +long long atomicMax_system(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicMax_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicMax_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicMax_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicMax_system(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicInc_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicInc_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicDec_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicDec_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +int atomicCAS_block(int *address, int compare, int val) { } + +static __inline__ __attribute__((device)) +int atomicCAS_system(int *address, int compare, int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicCAS_block(unsigned int *address, unsigned int compare, + unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicCAS_system(unsigned int *address, unsigned int compare, + unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long int atomicCAS_block(unsigned long long int *address, + unsigned long long int compare, + unsigned long long int val) { } + +static __inline__ __attribute__((device)) +unsigned long long int atomicCAS_system(unsigned long long int *address, + unsigned long long int compare, + unsigned long long int val) { } + +static __inline__ __attribute__((device)) +int atomicAnd_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicAnd_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +long long atomicAnd_block(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +long long atomicAnd_system(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicAnd_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicAnd_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicAnd_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicAnd_system(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +int atomicOr_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicOr_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +long long atomicOr_block(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +long long atomicOr_system(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicOr_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicOr_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicOr_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicOr_system(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +int atomicXor_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicXor_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +long long atomicXor_block(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +long long atomicXor_system(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicXor_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicXor_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicXor_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicXor_system(unsigned long long *address, unsigned long long val) { } +# 2908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" 1 +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) void __threadfence_system(void); +# 119 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rn(double x, double y); +# 139 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rz(double x, double y); +# 159 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_ru(double x, double y); +# 179 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rd(double x, double y); +# 194 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rn(double x); +# 209 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rz(double x); +# 224 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_ru(double x); +# 239 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rd(double x); +# 254 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rn(double x); +# 269 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rz(double x); +# 284 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_ru(double x); +# 299 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rd(double x); +extern __attribute__((device)) __attribute__((device_builtin)) __attribute__((deprecated("__ballot""() is deprecated in favor of ""__ballot""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __ballot(int); +extern __attribute__((device)) __attribute__((device_builtin)) int __syncthreads_count(int); +extern __attribute__((device)) __attribute__((device_builtin)) int __syncthreads_and(int); +extern __attribute__((device)) __attribute__((device_builtin)) int __syncthreads_or(int); +extern __attribute__((device)) __attribute__((device_builtin)) long long int clock64(void); +# 314 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rn(float x, float y, float z); +# 323 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rd(float x, float y, float z); +# 332 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_ru(float x, float y, float z); +# 341 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rz(float x, float y, float z); +# 354 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double_as_longlong(double x); +# 363 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __longlong_as_double(long long int x); +# 407 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rn(double x, double y, double z); +# 451 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rz(double x, double y, double z); +# 495 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_ru(double x, double y, double z); +# 539 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rd(double x, double y, double z); +# 558 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rn(double x, double y); +# 577 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rz(double x, double y); +# 596 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_ru(double x, double y); +# 615 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rd(double x, double y); +# 634 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rn(double x, double y); +# 653 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rz(double x, double y); +# 672 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_ru(double x, double y); +# 691 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rd(double x, double y); +# 709 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rn(double x, double y); +# 727 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rz(double x, double y); +# 745 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_ru(double x, double y); +# 763 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rd(double x, double y); +# 772 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rn(double x); +# 781 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rz(double x); +# 790 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_ru(double x); +# 799 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rd(double x); +# 809 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rn(double x); +# 819 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_ru(double x); +# 829 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rd(double x); +# 839 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rn(double x); +# 849 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_ru(double x); +# 859 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rd(double x); +# 869 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rn(double x); +# 879 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_ru(double x); +# 889 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rd(double x); +# 899 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rn(double x); +# 909 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_ru(double x); +# 919 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rd(double x); + + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) double __int2double_rn(int x); + + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) double __uint2double_rn(unsigned int x); +# 944 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rn(long long int x); +# 953 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rz(long long int x); +# 962 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_ru(long long int x); +# 971 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rd(long long int x); +# 980 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rn(unsigned long long int x); +# 989 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rz(unsigned long long int x); +# 998 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_ru(unsigned long long int x); +# 1007 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rd(unsigned long long int x); +# 1016 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2hiint(double x); +# 1025 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2loint(double x); +# 1035 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __hiloint2double(int hi, int lo); + + +} + + + + + + +static __inline__ __attribute__((device)) __attribute__((deprecated("__ballot""() is deprecated in favor of ""__ballot""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int ballot(bool pred) { } + +static __inline__ __attribute__((device)) int syncthreads_count(bool pred) { } + +static __inline__ __attribute__((device)) bool syncthreads_and(bool pred) { } + +static __inline__ __attribute__((device)) bool syncthreads_or(bool pred) { } + + + + +static __inline__ __attribute__((device)) unsigned int __isGlobal(const void *ptr) { } +static __inline__ __attribute__((device)) unsigned int __isShared(const void *ptr) { } +static __inline__ __attribute__((device)) unsigned int __isConstant(const void *ptr) { } +static __inline__ __attribute__((device)) unsigned int __isLocal(const void *ptr) { } + +static __inline__ __attribute__((device)) unsigned int __isGridConstant(const void *ptr) { } + +static __inline__ __attribute__((device)) size_t __cvta_generic_to_global(const void *ptr) { } +static __inline__ __attribute__((device)) size_t __cvta_generic_to_shared(const void *ptr) { } +static __inline__ __attribute__((device)) size_t __cvta_generic_to_constant(const void *ptr) { } +static __inline__ __attribute__((device)) size_t __cvta_generic_to_local(const void *ptr) { } + +static __inline__ __attribute__((device)) size_t __cvta_generic_to_grid_constant(const void *ptr) { } + + +static __inline__ __attribute__((device)) void * __cvta_global_to_generic(size_t rawbits) { } +static __inline__ __attribute__((device)) void * __cvta_shared_to_generic(size_t rawbits) { } +static __inline__ __attribute__((device)) void * __cvta_constant_to_generic(size_t rawbits) { } +static __inline__ __attribute__((device)) void * __cvta_local_to_generic(size_t rawbits) { } + +static __inline__ __attribute__((device)) void * __cvta_grid_constant_to_generic(size_t rawbits) { } +# 1090 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +static __inline__ __attribute__((host)) __attribute__((device)) unsigned short __nv_bswap16(unsigned short x) { + + return __builtin_bswap16(x); + + + + + +} +# 1109 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +static __inline__ __attribute__((host)) __attribute__((device)) unsigned int __nv_bswap32(unsigned int x) { + + return __builtin_bswap32(x); + + + + + + +} +# 1129 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +static __inline__ __attribute__((host)) __attribute__((device)) unsigned long long __nv_bswap64(unsigned long long x) { + + return __builtin_bswap64(x); + + + + + + +} +# 2909 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" 1 +# 123 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +static __attribute__((device)) __inline__ unsigned __fns(unsigned mask, unsigned base, int offset) { } +static __attribute__((device)) __inline__ void __barrier_sync(unsigned id) { } +static __attribute__((device)) __inline__ void __barrier_sync_count(unsigned id, unsigned cnt) { } +static __attribute__((device)) __inline__ void __syncwarp(unsigned mask=0xFFFFFFFF) { } +static __attribute__((device)) __inline__ int __all_sync(unsigned mask, int pred) { } +static __attribute__((device)) __inline__ int __any_sync(unsigned mask, int pred) { } +static __attribute__((device)) __inline__ int __uni_sync(unsigned mask, int pred) { } +static __attribute__((device)) __inline__ unsigned __ballot_sync(unsigned mask, int pred) { } +static __attribute__((device)) __inline__ unsigned __activemask() { } +# 140 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __shfl(int var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __shfl(unsigned int var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __shfl_up(int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __shfl_up(unsigned int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __shfl_down(int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __shfl_down(unsigned int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __shfl_xor(int var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __shfl_xor(unsigned int var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) float __shfl(float var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) float __shfl_up(float var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) float __shfl_down(float var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) float __shfl_xor(float var, int laneMask, int width=32) { } + + +static __attribute__((device)) __inline__ int __shfl_sync(unsigned mask, int var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ unsigned int __shfl_sync(unsigned mask, unsigned int var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ int __shfl_up_sync(unsigned mask, int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ unsigned int __shfl_up_sync(unsigned mask, unsigned int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ int __shfl_down_sync(unsigned mask, int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ unsigned int __shfl_down_sync(unsigned mask, unsigned int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ int __shfl_xor_sync(unsigned mask, int var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ unsigned int __shfl_xor_sync(unsigned mask, unsigned int var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ float __shfl_sync(unsigned mask, float var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ float __shfl_up_sync(unsigned mask, float var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ float __shfl_down_sync(unsigned mask, float var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ float __shfl_xor_sync(unsigned mask, float var, int laneMask, int width=32) { } + + + +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long long __shfl(unsigned long long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long long __shfl(long long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long long __shfl_up(long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long long __shfl_up(unsigned long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long long __shfl_down(long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long long __shfl_down(unsigned long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long long __shfl_xor(long long var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long long __shfl_xor(unsigned long long var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) double __shfl(double var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) double __shfl_up(double var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) double __shfl_down(double var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) double __shfl_xor(double var, int laneMask, int width=32) { } + + +static __attribute__((device)) __inline__ long long __shfl_sync(unsigned mask, long long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ unsigned long long __shfl_sync(unsigned mask, unsigned long long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ long long __shfl_up_sync(unsigned mask, long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ unsigned long long __shfl_up_sync(unsigned mask, unsigned long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ long long __shfl_down_sync(unsigned mask, long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ unsigned long long __shfl_down_sync(unsigned mask, unsigned long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ long long __shfl_xor_sync(unsigned mask, long long var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ unsigned long long __shfl_xor_sync(unsigned mask, unsigned long long var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ double __shfl_sync(unsigned mask, double var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ double __shfl_up_sync(unsigned mask, double var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ double __shfl_down_sync(unsigned mask, double var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ double __shfl_xor_sync(unsigned mask, double var, int laneMask, int width=32) { } + + + +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long __shfl(long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long __shfl(unsigned long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long __shfl_up(long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long __shfl_up(unsigned long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long __shfl_down(long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long __shfl_down(unsigned long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long __shfl_xor(long var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long __shfl_xor(unsigned long var, int laneMask, int width=32) { } + + +static __attribute__((device)) __inline__ long __shfl_sync(unsigned mask, long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ unsigned long __shfl_sync(unsigned mask, unsigned long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ long __shfl_up_sync(unsigned mask, long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ unsigned long __shfl_up_sync(unsigned mask, unsigned long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ long __shfl_down_sync(unsigned mask, long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ unsigned long __shfl_down_sync(unsigned mask, unsigned long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ long __shfl_xor_sync(unsigned mask, long var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ unsigned long __shfl_xor_sync(unsigned mask, unsigned long var, int laneMask, int width=32) { } +# 2910 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" 1 +# 91 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ long __ldg(const long *ptr) { } +static __attribute__((device)) __inline__ unsigned long __ldg(const unsigned long *ptr) { } + +static __attribute__((device)) __inline__ char __ldg(const char *ptr) { } +static __attribute__((device)) __inline__ signed char __ldg(const signed char *ptr) { } +static __attribute__((device)) __inline__ short __ldg(const short *ptr) { } +static __attribute__((device)) __inline__ int __ldg(const int *ptr) { } +static __attribute__((device)) __inline__ long long __ldg(const long long *ptr) { } +static __attribute__((device)) __inline__ char2 __ldg(const char2 *ptr) { } +static __attribute__((device)) __inline__ char4 __ldg(const char4 *ptr) { } +static __attribute__((device)) __inline__ short2 __ldg(const short2 *ptr) { } +static __attribute__((device)) __inline__ short4 __ldg(const short4 *ptr) { } +static __attribute__((device)) __inline__ int2 __ldg(const int2 *ptr) { } +static __attribute__((device)) __inline__ int4 __ldg(const int4 *ptr) { } +static __attribute__((device)) __inline__ longlong2 __ldg(const longlong2 *ptr) { } + +static __attribute__((device)) __inline__ unsigned char __ldg(const unsigned char *ptr) { } +static __attribute__((device)) __inline__ unsigned short __ldg(const unsigned short *ptr) { } +static __attribute__((device)) __inline__ unsigned int __ldg(const unsigned int *ptr) { } +static __attribute__((device)) __inline__ unsigned long long __ldg(const unsigned long long *ptr) { } +static __attribute__((device)) __inline__ uchar2 __ldg(const uchar2 *ptr) { } +static __attribute__((device)) __inline__ uchar4 __ldg(const uchar4 *ptr) { } +static __attribute__((device)) __inline__ ushort2 __ldg(const ushort2 *ptr) { } +static __attribute__((device)) __inline__ ushort4 __ldg(const ushort4 *ptr) { } +static __attribute__((device)) __inline__ uint2 __ldg(const uint2 *ptr) { } +static __attribute__((device)) __inline__ uint4 __ldg(const uint4 *ptr) { } +static __attribute__((device)) __inline__ ulonglong2 __ldg(const ulonglong2 *ptr) { } + +static __attribute__((device)) __inline__ float __ldg(const float *ptr) { } +static __attribute__((device)) __inline__ double __ldg(const double *ptr) { } +static __attribute__((device)) __inline__ float2 __ldg(const float2 *ptr) { } +static __attribute__((device)) __inline__ float4 __ldg(const float4 *ptr) { } +static __attribute__((device)) __inline__ double2 __ldg(const double2 *ptr) { } + + + + +static __attribute__((device)) __inline__ long __ldcg(const long *ptr) { } +static __attribute__((device)) __inline__ unsigned long __ldcg(const unsigned long *ptr) { } + +static __attribute__((device)) __inline__ char __ldcg(const char *ptr) { } +static __attribute__((device)) __inline__ signed char __ldcg(const signed char *ptr) { } +static __attribute__((device)) __inline__ short __ldcg(const short *ptr) { } +static __attribute__((device)) __inline__ int __ldcg(const int *ptr) { } +static __attribute__((device)) __inline__ long long __ldcg(const long long *ptr) { } +static __attribute__((device)) __inline__ char2 __ldcg(const char2 *ptr) { } +static __attribute__((device)) __inline__ char4 __ldcg(const char4 *ptr) { } +static __attribute__((device)) __inline__ short2 __ldcg(const short2 *ptr) { } +static __attribute__((device)) __inline__ short4 __ldcg(const short4 *ptr) { } +static __attribute__((device)) __inline__ int2 __ldcg(const int2 *ptr) { } +static __attribute__((device)) __inline__ int4 __ldcg(const int4 *ptr) { } +static __attribute__((device)) __inline__ longlong2 __ldcg(const longlong2 *ptr) { } + +static __attribute__((device)) __inline__ unsigned char __ldcg(const unsigned char *ptr) { } +static __attribute__((device)) __inline__ unsigned short __ldcg(const unsigned short *ptr) { } +static __attribute__((device)) __inline__ unsigned int __ldcg(const unsigned int *ptr) { } +static __attribute__((device)) __inline__ unsigned long long __ldcg(const unsigned long long *ptr) { } +static __attribute__((device)) __inline__ uchar2 __ldcg(const uchar2 *ptr) { } +static __attribute__((device)) __inline__ uchar4 __ldcg(const uchar4 *ptr) { } +static __attribute__((device)) __inline__ ushort2 __ldcg(const ushort2 *ptr) { } +static __attribute__((device)) __inline__ ushort4 __ldcg(const ushort4 *ptr) { } +static __attribute__((device)) __inline__ uint2 __ldcg(const uint2 *ptr) { } +static __attribute__((device)) __inline__ uint4 __ldcg(const uint4 *ptr) { } +static __attribute__((device)) __inline__ ulonglong2 __ldcg(const ulonglong2 *ptr) { } + +static __attribute__((device)) __inline__ float __ldcg(const float *ptr) { } +static __attribute__((device)) __inline__ double __ldcg(const double *ptr) { } +static __attribute__((device)) __inline__ float2 __ldcg(const float2 *ptr) { } +static __attribute__((device)) __inline__ float4 __ldcg(const float4 *ptr) { } +static __attribute__((device)) __inline__ double2 __ldcg(const double2 *ptr) { } + + + +static __attribute__((device)) __inline__ long __ldca(const long *ptr) { } +static __attribute__((device)) __inline__ unsigned long __ldca(const unsigned long *ptr) { } + +static __attribute__((device)) __inline__ char __ldca(const char *ptr) { } +static __attribute__((device)) __inline__ signed char __ldca(const signed char *ptr) { } +static __attribute__((device)) __inline__ short __ldca(const short *ptr) { } +static __attribute__((device)) __inline__ int __ldca(const int *ptr) { } +static __attribute__((device)) __inline__ long long __ldca(const long long *ptr) { } +static __attribute__((device)) __inline__ char2 __ldca(const char2 *ptr) { } +static __attribute__((device)) __inline__ char4 __ldca(const char4 *ptr) { } +static __attribute__((device)) __inline__ short2 __ldca(const short2 *ptr) { } +static __attribute__((device)) __inline__ short4 __ldca(const short4 *ptr) { } +static __attribute__((device)) __inline__ int2 __ldca(const int2 *ptr) { } +static __attribute__((device)) __inline__ int4 __ldca(const int4 *ptr) { } +static __attribute__((device)) __inline__ longlong2 __ldca(const longlong2 *ptr) { } + +static __attribute__((device)) __inline__ unsigned char __ldca(const unsigned char *ptr) { } +static __attribute__((device)) __inline__ unsigned short __ldca(const unsigned short *ptr) { } +static __attribute__((device)) __inline__ unsigned int __ldca(const unsigned int *ptr) { } +static __attribute__((device)) __inline__ unsigned long long __ldca(const unsigned long long *ptr) { } +static __attribute__((device)) __inline__ uchar2 __ldca(const uchar2 *ptr) { } +static __attribute__((device)) __inline__ uchar4 __ldca(const uchar4 *ptr) { } +static __attribute__((device)) __inline__ ushort2 __ldca(const ushort2 *ptr) { } +static __attribute__((device)) __inline__ ushort4 __ldca(const ushort4 *ptr) { } +static __attribute__((device)) __inline__ uint2 __ldca(const uint2 *ptr) { } +static __attribute__((device)) __inline__ uint4 __ldca(const uint4 *ptr) { } +static __attribute__((device)) __inline__ ulonglong2 __ldca(const ulonglong2 *ptr) { } + +static __attribute__((device)) __inline__ float __ldca(const float *ptr) { } +static __attribute__((device)) __inline__ double __ldca(const double *ptr) { } +static __attribute__((device)) __inline__ float2 __ldca(const float2 *ptr) { } +static __attribute__((device)) __inline__ float4 __ldca(const float4 *ptr) { } +static __attribute__((device)) __inline__ double2 __ldca(const double2 *ptr) { } + + + +static __attribute__((device)) __inline__ long __ldcs(const long *ptr) { } +static __attribute__((device)) __inline__ unsigned long __ldcs(const unsigned long *ptr) { } + +static __attribute__((device)) __inline__ char __ldcs(const char *ptr) { } +static __attribute__((device)) __inline__ signed char __ldcs(const signed char *ptr) { } +static __attribute__((device)) __inline__ short __ldcs(const short *ptr) { } +static __attribute__((device)) __inline__ int __ldcs(const int *ptr) { } +static __attribute__((device)) __inline__ long long __ldcs(const long long *ptr) { } +static __attribute__((device)) __inline__ char2 __ldcs(const char2 *ptr) { } +static __attribute__((device)) __inline__ char4 __ldcs(const char4 *ptr) { } +static __attribute__((device)) __inline__ short2 __ldcs(const short2 *ptr) { } +static __attribute__((device)) __inline__ short4 __ldcs(const short4 *ptr) { } +static __attribute__((device)) __inline__ int2 __ldcs(const int2 *ptr) { } +static __attribute__((device)) __inline__ int4 __ldcs(const int4 *ptr) { } +static __attribute__((device)) __inline__ longlong2 __ldcs(const longlong2 *ptr) { } + +static __attribute__((device)) __inline__ unsigned char __ldcs(const unsigned char *ptr) { } +static __attribute__((device)) __inline__ unsigned short __ldcs(const unsigned short *ptr) { } +static __attribute__((device)) __inline__ unsigned int __ldcs(const unsigned int *ptr) { } +static __attribute__((device)) __inline__ unsigned long long __ldcs(const unsigned long long *ptr) { } +static __attribute__((device)) __inline__ uchar2 __ldcs(const uchar2 *ptr) { } +static __attribute__((device)) __inline__ uchar4 __ldcs(const uchar4 *ptr) { } +static __attribute__((device)) __inline__ ushort2 __ldcs(const ushort2 *ptr) { } +static __attribute__((device)) __inline__ ushort4 __ldcs(const ushort4 *ptr) { } +static __attribute__((device)) __inline__ uint2 __ldcs(const uint2 *ptr) { } +static __attribute__((device)) __inline__ uint4 __ldcs(const uint4 *ptr) { } +static __attribute__((device)) __inline__ ulonglong2 __ldcs(const ulonglong2 *ptr) { } + +static __attribute__((device)) __inline__ float __ldcs(const float *ptr) { } +static __attribute__((device)) __inline__ double __ldcs(const double *ptr) { } +static __attribute__((device)) __inline__ float2 __ldcs(const float2 *ptr) { } +static __attribute__((device)) __inline__ float4 __ldcs(const float4 *ptr) { } +static __attribute__((device)) __inline__ double2 __ldcs(const double2 *ptr) { } + + + +static __attribute__((device)) __inline__ long __ldlu(const long *ptr) { } +static __attribute__((device)) __inline__ unsigned long __ldlu(const unsigned long *ptr) { } + +static __attribute__((device)) __inline__ char __ldlu(const char *ptr) { } +static __attribute__((device)) __inline__ signed char __ldlu(const signed char *ptr) { } +static __attribute__((device)) __inline__ short __ldlu(const short *ptr) { } +static __attribute__((device)) __inline__ int __ldlu(const int *ptr) { } +static __attribute__((device)) __inline__ long long __ldlu(const long long *ptr) { } +static __attribute__((device)) __inline__ char2 __ldlu(const char2 *ptr) { } +static __attribute__((device)) __inline__ char4 __ldlu(const char4 *ptr) { } +static __attribute__((device)) __inline__ short2 __ldlu(const short2 *ptr) { } +static __attribute__((device)) __inline__ short4 __ldlu(const short4 *ptr) { } +static __attribute__((device)) __inline__ int2 __ldlu(const int2 *ptr) { } +static __attribute__((device)) __inline__ int4 __ldlu(const int4 *ptr) { } +static __attribute__((device)) __inline__ longlong2 __ldlu(const longlong2 *ptr) { } + +static __attribute__((device)) __inline__ unsigned char __ldlu(const unsigned char *ptr) { } +static __attribute__((device)) __inline__ unsigned short __ldlu(const unsigned short *ptr) { } +static __attribute__((device)) __inline__ unsigned int __ldlu(const unsigned int *ptr) { } +static __attribute__((device)) __inline__ unsigned long long __ldlu(const unsigned long long *ptr) { } +static __attribute__((device)) __inline__ uchar2 __ldlu(const uchar2 *ptr) { } +static __attribute__((device)) __inline__ uchar4 __ldlu(const uchar4 *ptr) { } +static __attribute__((device)) __inline__ ushort2 __ldlu(const ushort2 *ptr) { } +static __attribute__((device)) __inline__ ushort4 __ldlu(const ushort4 *ptr) { } +static __attribute__((device)) __inline__ uint2 __ldlu(const uint2 *ptr) { } +static __attribute__((device)) __inline__ uint4 __ldlu(const uint4 *ptr) { } +static __attribute__((device)) __inline__ ulonglong2 __ldlu(const ulonglong2 *ptr) { } + +static __attribute__((device)) __inline__ float __ldlu(const float *ptr) { } +static __attribute__((device)) __inline__ double __ldlu(const double *ptr) { } +static __attribute__((device)) __inline__ float2 __ldlu(const float2 *ptr) { } +static __attribute__((device)) __inline__ float4 __ldlu(const float4 *ptr) { } +static __attribute__((device)) __inline__ double2 __ldlu(const double2 *ptr) { } + + + +static __attribute__((device)) __inline__ long __ldcv(const long *ptr) { } +static __attribute__((device)) __inline__ unsigned long __ldcv(const unsigned long *ptr) { } + +static __attribute__((device)) __inline__ char __ldcv(const char *ptr) { } +static __attribute__((device)) __inline__ signed char __ldcv(const signed char *ptr) { } +static __attribute__((device)) __inline__ short __ldcv(const short *ptr) { } +static __attribute__((device)) __inline__ int __ldcv(const int *ptr) { } +static __attribute__((device)) __inline__ long long __ldcv(const long long *ptr) { } +static __attribute__((device)) __inline__ char2 __ldcv(const char2 *ptr) { } +static __attribute__((device)) __inline__ char4 __ldcv(const char4 *ptr) { } +static __attribute__((device)) __inline__ short2 __ldcv(const short2 *ptr) { } +static __attribute__((device)) __inline__ short4 __ldcv(const short4 *ptr) { } +static __attribute__((device)) __inline__ int2 __ldcv(const int2 *ptr) { } +static __attribute__((device)) __inline__ int4 __ldcv(const int4 *ptr) { } +static __attribute__((device)) __inline__ longlong2 __ldcv(const longlong2 *ptr) { } + +static __attribute__((device)) __inline__ unsigned char __ldcv(const unsigned char *ptr) { } +static __attribute__((device)) __inline__ unsigned short __ldcv(const unsigned short *ptr) { } +static __attribute__((device)) __inline__ unsigned int __ldcv(const unsigned int *ptr) { } +static __attribute__((device)) __inline__ unsigned long long __ldcv(const unsigned long long *ptr) { } +static __attribute__((device)) __inline__ uchar2 __ldcv(const uchar2 *ptr) { } +static __attribute__((device)) __inline__ uchar4 __ldcv(const uchar4 *ptr) { } +static __attribute__((device)) __inline__ ushort2 __ldcv(const ushort2 *ptr) { } +static __attribute__((device)) __inline__ ushort4 __ldcv(const ushort4 *ptr) { } +static __attribute__((device)) __inline__ uint2 __ldcv(const uint2 *ptr) { } +static __attribute__((device)) __inline__ uint4 __ldcv(const uint4 *ptr) { } +static __attribute__((device)) __inline__ ulonglong2 __ldcv(const ulonglong2 *ptr) { } + +static __attribute__((device)) __inline__ float __ldcv(const float *ptr) { } +static __attribute__((device)) __inline__ double __ldcv(const double *ptr) { } +static __attribute__((device)) __inline__ float2 __ldcv(const float2 *ptr) { } +static __attribute__((device)) __inline__ float4 __ldcv(const float4 *ptr) { } +static __attribute__((device)) __inline__ double2 __ldcv(const double2 *ptr) { } + + + +static __attribute__((device)) __inline__ void __stwb(long *ptr, long value) { } +static __attribute__((device)) __inline__ void __stwb(unsigned long *ptr, unsigned long value) { } + +static __attribute__((device)) __inline__ void __stwb(char *ptr, char value) { } +static __attribute__((device)) __inline__ void __stwb(signed char *ptr, signed char value) { } +static __attribute__((device)) __inline__ void __stwb(short *ptr, short value) { } +static __attribute__((device)) __inline__ void __stwb(int *ptr, int value) { } +static __attribute__((device)) __inline__ void __stwb(long long *ptr, long long value) { } +static __attribute__((device)) __inline__ void __stwb(char2 *ptr, char2 value) { } +static __attribute__((device)) __inline__ void __stwb(char4 *ptr, char4 value) { } +static __attribute__((device)) __inline__ void __stwb(short2 *ptr, short2 value) { } +static __attribute__((device)) __inline__ void __stwb(short4 *ptr, short4 value) { } +static __attribute__((device)) __inline__ void __stwb(int2 *ptr, int2 value) { } +static __attribute__((device)) __inline__ void __stwb(int4 *ptr, int4 value) { } +static __attribute__((device)) __inline__ void __stwb(longlong2 *ptr, longlong2 value) { } + +static __attribute__((device)) __inline__ void __stwb(unsigned char *ptr, unsigned char value) { } +static __attribute__((device)) __inline__ void __stwb(unsigned short *ptr, unsigned short value) { } +static __attribute__((device)) __inline__ void __stwb(unsigned int *ptr, unsigned int value) { } +static __attribute__((device)) __inline__ void __stwb(unsigned long long *ptr, unsigned long long value) { } +static __attribute__((device)) __inline__ void __stwb(uchar2 *ptr, uchar2 value) { } +static __attribute__((device)) __inline__ void __stwb(uchar4 *ptr, uchar4 value) { } +static __attribute__((device)) __inline__ void __stwb(ushort2 *ptr, ushort2 value) { } +static __attribute__((device)) __inline__ void __stwb(ushort4 *ptr, ushort4 value) { } +static __attribute__((device)) __inline__ void __stwb(uint2 *ptr, uint2 value) { } +static __attribute__((device)) __inline__ void __stwb(uint4 *ptr, uint4 value) { } +static __attribute__((device)) __inline__ void __stwb(ulonglong2 *ptr, ulonglong2 value) { } + +static __attribute__((device)) __inline__ void __stwb(float *ptr, float value) { } +static __attribute__((device)) __inline__ void __stwb(double *ptr, double value) { } +static __attribute__((device)) __inline__ void __stwb(float2 *ptr, float2 value) { } +static __attribute__((device)) __inline__ void __stwb(float4 *ptr, float4 value) { } +static __attribute__((device)) __inline__ void __stwb(double2 *ptr, double2 value) { } + + + +static __attribute__((device)) __inline__ void __stcg(long *ptr, long value) { } +static __attribute__((device)) __inline__ void __stcg(unsigned long *ptr, unsigned long value) { } + +static __attribute__((device)) __inline__ void __stcg(char *ptr, char value) { } +static __attribute__((device)) __inline__ void __stcg(signed char *ptr, signed char value) { } +static __attribute__((device)) __inline__ void __stcg(short *ptr, short value) { } +static __attribute__((device)) __inline__ void __stcg(int *ptr, int value) { } +static __attribute__((device)) __inline__ void __stcg(long long *ptr, long long value) { } +static __attribute__((device)) __inline__ void __stcg(char2 *ptr, char2 value) { } +static __attribute__((device)) __inline__ void __stcg(char4 *ptr, char4 value) { } +static __attribute__((device)) __inline__ void __stcg(short2 *ptr, short2 value) { } +static __attribute__((device)) __inline__ void __stcg(short4 *ptr, short4 value) { } +static __attribute__((device)) __inline__ void __stcg(int2 *ptr, int2 value) { } +static __attribute__((device)) __inline__ void __stcg(int4 *ptr, int4 value) { } +static __attribute__((device)) __inline__ void __stcg(longlong2 *ptr, longlong2 value) { } + +static __attribute__((device)) __inline__ void __stcg(unsigned char *ptr, unsigned char value) { } +static __attribute__((device)) __inline__ void __stcg(unsigned short *ptr, unsigned short value) { } +static __attribute__((device)) __inline__ void __stcg(unsigned int *ptr, unsigned int value) { } +static __attribute__((device)) __inline__ void __stcg(unsigned long long *ptr, unsigned long long value) { } +static __attribute__((device)) __inline__ void __stcg(uchar2 *ptr, uchar2 value) { } +static __attribute__((device)) __inline__ void __stcg(uchar4 *ptr, uchar4 value) { } +static __attribute__((device)) __inline__ void __stcg(ushort2 *ptr, ushort2 value) { } +static __attribute__((device)) __inline__ void __stcg(ushort4 *ptr, ushort4 value) { } +static __attribute__((device)) __inline__ void __stcg(uint2 *ptr, uint2 value) { } +static __attribute__((device)) __inline__ void __stcg(uint4 *ptr, uint4 value) { } +static __attribute__((device)) __inline__ void __stcg(ulonglong2 *ptr, ulonglong2 value) { } + +static __attribute__((device)) __inline__ void __stcg(float *ptr, float value) { } +static __attribute__((device)) __inline__ void __stcg(double *ptr, double value) { } +static __attribute__((device)) __inline__ void __stcg(float2 *ptr, float2 value) { } +static __attribute__((device)) __inline__ void __stcg(float4 *ptr, float4 value) { } +static __attribute__((device)) __inline__ void __stcg(double2 *ptr, double2 value) { } + + + +static __attribute__((device)) __inline__ void __stcs(long *ptr, long value) { } +static __attribute__((device)) __inline__ void __stcs(unsigned long *ptr, unsigned long value) { } + +static __attribute__((device)) __inline__ void __stcs(char *ptr, char value) { } +static __attribute__((device)) __inline__ void __stcs(signed char *ptr, signed char value) { } +static __attribute__((device)) __inline__ void __stcs(short *ptr, short value) { } +static __attribute__((device)) __inline__ void __stcs(int *ptr, int value) { } +static __attribute__((device)) __inline__ void __stcs(long long *ptr, long long value) { } +static __attribute__((device)) __inline__ void __stcs(char2 *ptr, char2 value) { } +static __attribute__((device)) __inline__ void __stcs(char4 *ptr, char4 value) { } +static __attribute__((device)) __inline__ void __stcs(short2 *ptr, short2 value) { } +static __attribute__((device)) __inline__ void __stcs(short4 *ptr, short4 value) { } +static __attribute__((device)) __inline__ void __stcs(int2 *ptr, int2 value) { } +static __attribute__((device)) __inline__ void __stcs(int4 *ptr, int4 value) { } +static __attribute__((device)) __inline__ void __stcs(longlong2 *ptr, longlong2 value) { } + +static __attribute__((device)) __inline__ void __stcs(unsigned char *ptr, unsigned char value) { } +static __attribute__((device)) __inline__ void __stcs(unsigned short *ptr, unsigned short value) { } +static __attribute__((device)) __inline__ void __stcs(unsigned int *ptr, unsigned int value) { } +static __attribute__((device)) __inline__ void __stcs(unsigned long long *ptr, unsigned long long value) { } +static __attribute__((device)) __inline__ void __stcs(uchar2 *ptr, uchar2 value) { } +static __attribute__((device)) __inline__ void __stcs(uchar4 *ptr, uchar4 value) { } +static __attribute__((device)) __inline__ void __stcs(ushort2 *ptr, ushort2 value) { } +static __attribute__((device)) __inline__ void __stcs(ushort4 *ptr, ushort4 value) { } +static __attribute__((device)) __inline__ void __stcs(uint2 *ptr, uint2 value) { } +static __attribute__((device)) __inline__ void __stcs(uint4 *ptr, uint4 value) { } +static __attribute__((device)) __inline__ void __stcs(ulonglong2 *ptr, ulonglong2 value) { } + +static __attribute__((device)) __inline__ void __stcs(float *ptr, float value) { } +static __attribute__((device)) __inline__ void __stcs(double *ptr, double value) { } +static __attribute__((device)) __inline__ void __stcs(float2 *ptr, float2 value) { } +static __attribute__((device)) __inline__ void __stcs(float4 *ptr, float4 value) { } +static __attribute__((device)) __inline__ void __stcs(double2 *ptr, double2 value) { } + + + +static __attribute__((device)) __inline__ void __stwt(long *ptr, long value) { } +static __attribute__((device)) __inline__ void __stwt(unsigned long *ptr, unsigned long value) { } + +static __attribute__((device)) __inline__ void __stwt(char *ptr, char value) { } +static __attribute__((device)) __inline__ void __stwt(signed char *ptr, signed char value) { } +static __attribute__((device)) __inline__ void __stwt(short *ptr, short value) { } +static __attribute__((device)) __inline__ void __stwt(int *ptr, int value) { } +static __attribute__((device)) __inline__ void __stwt(long long *ptr, long long value) { } +static __attribute__((device)) __inline__ void __stwt(char2 *ptr, char2 value) { } +static __attribute__((device)) __inline__ void __stwt(char4 *ptr, char4 value) { } +static __attribute__((device)) __inline__ void __stwt(short2 *ptr, short2 value) { } +static __attribute__((device)) __inline__ void __stwt(short4 *ptr, short4 value) { } +static __attribute__((device)) __inline__ void __stwt(int2 *ptr, int2 value) { } +static __attribute__((device)) __inline__ void __stwt(int4 *ptr, int4 value) { } +static __attribute__((device)) __inline__ void __stwt(longlong2 *ptr, longlong2 value) { } + +static __attribute__((device)) __inline__ void __stwt(unsigned char *ptr, unsigned char value) { } +static __attribute__((device)) __inline__ void __stwt(unsigned short *ptr, unsigned short value) { } +static __attribute__((device)) __inline__ void __stwt(unsigned int *ptr, unsigned int value) { } +static __attribute__((device)) __inline__ void __stwt(unsigned long long *ptr, unsigned long long value) { } +static __attribute__((device)) __inline__ void __stwt(uchar2 *ptr, uchar2 value) { } +static __attribute__((device)) __inline__ void __stwt(uchar4 *ptr, uchar4 value) { } +static __attribute__((device)) __inline__ void __stwt(ushort2 *ptr, ushort2 value) { } +static __attribute__((device)) __inline__ void __stwt(ushort4 *ptr, ushort4 value) { } +static __attribute__((device)) __inline__ void __stwt(uint2 *ptr, uint2 value) { } +static __attribute__((device)) __inline__ void __stwt(uint4 *ptr, uint4 value) { } +static __attribute__((device)) __inline__ void __stwt(ulonglong2 *ptr, ulonglong2 value) { } + +static __attribute__((device)) __inline__ void __stwt(float *ptr, float value) { } +static __attribute__((device)) __inline__ void __stwt(double *ptr, double value) { } +static __attribute__((device)) __inline__ void __stwt(float2 *ptr, float2 value) { } +static __attribute__((device)) __inline__ void __stwt(float4 *ptr, float4 value) { } +static __attribute__((device)) __inline__ void __stwt(double2 *ptr, double2 value) { } +# 465 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_l(unsigned int lo, unsigned int hi, unsigned int shift) { } +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_lc(unsigned int lo, unsigned int hi, unsigned int shift) { } +# 490 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_r(unsigned int lo, unsigned int hi, unsigned int shift) { } +# 502 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_rc(unsigned int lo, unsigned int hi, unsigned int shift) { } +# 2911 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_35_intrinsics.h" 1 +# 2912 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" 1 +# 102 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp2a_lo(int srcA, int srcB, int c) { } +# 113 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp2a_lo(unsigned int srcA, unsigned int srcB, unsigned int c) { } +# 125 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp2a_lo(short2 srcA, char4 srcB, int c) { } +# 136 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp2a_lo(ushort2 srcA, uchar4 srcB, unsigned int c) { } +# 148 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp2a_hi(int srcA, int srcB, int c) { } +# 159 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp2a_hi(unsigned int srcA, unsigned int srcB, unsigned int c) { } +# 171 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp2a_hi(short2 srcA, char4 srcB, int c) { } +# 182 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp2a_hi(ushort2 srcA, uchar4 srcB, unsigned int c) { } +# 197 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp4a(int srcA, int srcB, int c) { } +# 206 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp4a(unsigned int srcA, unsigned int srcB, unsigned int c) { } +# 216 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp4a(char4 srcA, char4 srcB, int c) { } +# 225 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp4a(uchar4 srcA, uchar4 srcB, unsigned int c) { } +# 2913 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" 1 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 85 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 87 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" 2 +# 98 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, unsigned value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, int value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, unsigned long value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, long value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, unsigned long long value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, long long value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, float value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, double value) { } + +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, unsigned value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, int value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, unsigned long value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, long value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, unsigned long long value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, long long value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, float value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, double value, int *pred) { } + +static __attribute__((device)) __inline__ void __nanosleep(unsigned int ns) { } + +static __attribute__((device)) __inline__ unsigned short int atomicCAS(unsigned short int *address, unsigned short int compare, unsigned short int val) { } +# 2914 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" 1 +# 81 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 82 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" 2 +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +static __attribute__((device)) __inline__ unsigned __reduce_add_sync(unsigned mask, unsigned value) { } +static __attribute__((device)) __inline__ unsigned __reduce_min_sync(unsigned mask, unsigned value) { } +static __attribute__((device)) __inline__ unsigned __reduce_max_sync(unsigned mask, unsigned value) { } + +static __attribute__((device)) __inline__ int __reduce_add_sync(unsigned mask, int value) { } +static __attribute__((device)) __inline__ int __reduce_min_sync(unsigned mask, int value) { } +static __attribute__((device)) __inline__ int __reduce_max_sync(unsigned mask, int value) { } + +static __attribute__((device)) __inline__ unsigned __reduce_and_sync(unsigned mask, unsigned value) { } +static __attribute__((device)) __inline__ unsigned __reduce_or_sync(unsigned mask, unsigned value) { } +static __attribute__((device)) __inline__ unsigned __reduce_xor_sync(unsigned mask, unsigned value) { } + + + + +extern "C" { +inline __attribute__((device)) void *__nv_associate_access_property(const void *ptr, + unsigned long long property) { + extern __attribute__((device)) void *__nv_associate_access_property_impl(const void *, + unsigned long long); + return __nv_associate_access_property_impl(ptr, property); +} + +inline __attribute__((device)) void __nv_memcpy_async_shared_global_4(void *dst, + const void *src, + unsigned src_size) { + extern __attribute__((device)) void __nv_memcpy_async_shared_global_4_impl(void *, + const void *, + unsigned); + __nv_memcpy_async_shared_global_4_impl(dst, src, src_size); +} + +inline __attribute__((device)) void __nv_memcpy_async_shared_global_8(void *dst, + const void *src, + unsigned src_size) { + extern __attribute__((device)) void __nv_memcpy_async_shared_global_8_impl(void *, + const void *, + unsigned); + __nv_memcpy_async_shared_global_8_impl(dst, src, src_size); +} + +inline __attribute__((device)) void __nv_memcpy_async_shared_global_16(void *dst, + const void *src, + unsigned src_size) { + extern __attribute__((device)) void __nv_memcpy_async_shared_global_16_impl(void *, + const void *, + unsigned); + __nv_memcpy_async_shared_global_16_impl(dst, src, src_size); +} + +} +# 2915 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" 1 +# 79 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 80 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 82 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" 2 +# 92 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +static __attribute__((device)) __inline__ unsigned __isCtaShared(const void *ptr) { } +static __attribute__((device)) __inline__ unsigned __isClusterShared(const void *ptr) { } +static __attribute__((device)) __inline__ void *__cluster_map_shared_rank(const void *ptr, unsigned target_block_rank) { } +static __attribute__((device)) __inline__ unsigned __cluster_query_shared_rank(const void *ptr) { } +static __attribute__((device)) __inline__ uint2 __cluster_map_shared_multicast(const void *ptr, unsigned cluster_cta_mask) { } +static __attribute__((device)) __inline__ unsigned __clusterDimIsSpecified() { } +static __attribute__((device)) __inline__ dim3 __clusterDim() { } +static __attribute__((device)) __inline__ dim3 __clusterRelativeBlockIdx() { } +static __attribute__((device)) __inline__ dim3 __clusterGridDimInClusters() { } +static __attribute__((device)) __inline__ dim3 __clusterIdx() { } +static __attribute__((device)) __inline__ unsigned __clusterRelativeBlockRank() { } +static __attribute__((device)) __inline__ unsigned __clusterSizeInBlocks() { } +static __attribute__((device)) __inline__ void __cluster_barrier_arrive() { } +static __attribute__((device)) __inline__ void __cluster_barrier_arrive_relaxed() { } +static __attribute__((device)) __inline__ void __cluster_barrier_wait() { } +static __attribute__((device)) __inline__ void __threadfence_cluster() { } + +static __attribute__((device)) __inline__ float2 atomicAdd(float2 *__address, float2 val) { } +static __attribute__((device)) __inline__ float2 atomicAdd_block(float2 *__address, float2 val) { } +static __attribute__((device)) __inline__ float2 atomicAdd_system(float2 *__address, float2 val) { } +static __attribute__((device)) __inline__ float4 atomicAdd(float4 *__address, float4 val) { } +static __attribute__((device)) __inline__ float4 atomicAdd_block(float4 *__address, float4 val) { } +static __attribute__((device)) __inline__ float4 atomicAdd_system(float4 *__address, float4 val) { } +# 125 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +extern "C" { + __attribute__((device)) __attribute__((device_builtin)) void __u128AtomicCAS(void *, void *, void *, void *); + __attribute__((device)) __attribute__((device_builtin)) void __u128AtomicCAS_block(void *, void *, void *, void *); + __attribute__((device)) __attribute__((device_builtin)) void __u128AtomicCAS_system(void *, void *, void *, void *); + __attribute__((device)) __attribute__((device_builtin)) void __u128AtomicExch(void *, void *, void *); + __attribute__((device)) __attribute__((device_builtin)) void __u128AtomicExch_block(void *, void *, void *); + __attribute__((device)) __attribute__((device_builtin)) void __u128AtomicExch_system(void *, void *, void *); +} + + + + + + +template +struct __nv_atomic_enable_if { }; + +template +struct __nv_atomic_enable_if { typedef _T __type; }; +# 153 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +template +struct __nv_atomic_triv_cp_helper { + + + + + + + static const bool __val = __is_trivially_copyable(_T); + + + + +}; +# 201 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +template +static __attribute__((device)) __inline__ typename __nv_atomic_enable_if= 16 && __nv_atomic_triv_cp_helper<_T>::__val, _T>::__type +atomicCAS(_T *__address, _T __compare, _T __val) { + union _U {_T __ret; __attribute__((device)) __inline__ _U() {}}; _U __u; + __u128AtomicCAS((void *)(__address), + (void *)(&(const_cast(reinterpret_cast(__compare)))), + (void *)(&(const_cast(reinterpret_cast(__val)))), + (void *)(&(const_cast(reinterpret_cast(__u.__ret))))); + return __u.__ret; +} + +template +static __attribute__((device)) __inline__ typename __nv_atomic_enable_if= 16 && __nv_atomic_triv_cp_helper<_T>::__val, _T>::__type +atomicCAS_block(_T *__address, _T __compare, _T __val) { + union _U {_T __ret; __attribute__((device)) __inline__ _U() {}}; _U __u; + __u128AtomicCAS_block((void *)(__address), + (void *)(&(const_cast(reinterpret_cast(__compare)))), + (void *)(&(const_cast(reinterpret_cast(__val)))), + (void *)(&(const_cast(reinterpret_cast(__u.__ret))))); + return __u.__ret; +} + +template +static __attribute__((device)) __inline__ typename __nv_atomic_enable_if= 16 && __nv_atomic_triv_cp_helper<_T>::__val, _T>::__type +atomicCAS_system(_T *__address, _T __compare, _T __val) { + union _U {_T __ret; __attribute__((device)) __inline__ _U() {}}; _U __u; + __u128AtomicCAS_system((void *)(__address), + (void *)(&(const_cast(reinterpret_cast(__compare)))), + (void *)(&(const_cast(reinterpret_cast(__val)))), + (void *)(&(const_cast(reinterpret_cast(__u.__ret))))); + return __u.__ret; +} + +template +static __attribute__((device)) __inline__ typename __nv_atomic_enable_if= 16 && __nv_atomic_triv_cp_helper<_T>::__val, _T>::__type +atomicExch(_T *__address, _T __val) { + union _U {_T __ret; __attribute__((device)) __inline__ _U() {}}; _U __u; + __u128AtomicExch((void *)(__address), + (void *)(&(const_cast(reinterpret_cast(__val)))), + (void *)(&(const_cast(reinterpret_cast(__u.__ret))))); + return __u.__ret; +} + +template +static __attribute__((device)) __inline__ typename __nv_atomic_enable_if= 16 && __nv_atomic_triv_cp_helper<_T>::__val, _T>::__type +atomicExch_block(_T *__address, _T __val) { + union _U {_T __ret; __attribute__((device)) __inline__ _U() {}}; _U __u; + __u128AtomicExch_block((void *)(__address), + (void *)(&(const_cast(reinterpret_cast(__val)))), + (void *)(&(const_cast(reinterpret_cast(__u.__ret))))); + return __u.__ret; +} + +template +static __attribute__((device)) __inline__ typename __nv_atomic_enable_if= 16 && __nv_atomic_triv_cp_helper<_T>::__val, _T>::__type +atomicExch_system(_T *__address, _T __val) { + union _U {_T __ret; __attribute__((device)) __inline__ _U() {}}; _U __u; + __u128AtomicExch_system((void *)(__address), + (void *)(&(const_cast(reinterpret_cast(__val)))), + (void *)(&(const_cast(reinterpret_cast(__u.__ret))))); + return __u.__ret; +} +# 2916 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" 1 +# 79 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 80 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 82 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" 2 +# 100 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __ffma2_rn(float2 x, float2 y, float2 z) { } +# 112 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __ffma2_rz(float2 x, float2 y, float2 z) { } +# 124 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __ffma2_rd(float2 x, float2 y, float2 z) { } +# 136 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __ffma2_ru(float2 x, float2 y, float2 z) { } +# 149 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __fadd2_rn(float2 x, float2 y) { } +# 161 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __fadd2_rz(float2 x, float2 y) { } +# 173 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __fadd2_rd(float2 x, float2 y) { } +# 185 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __fadd2_ru(float2 x, float2 y) { } +# 198 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __fmul2_rn(float2 x, float2 y) { } +# 210 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __fmul2_rz(float2 x, float2 y) { } +# 222 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __fmul2_rd(float2 x, float2 y) { } +# 234 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __fmul2_ru(float2 x, float2 y) { } +# 2917 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" 1 +# 65 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template struct __nv_itex_trait { }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1Dfetch(T *ptr, cudaTextureObject_t obj, int x) +{ + __nv_tex_surf_handler("__itex1Dfetch", ptr, obj, x); +} + +template +static __attribute__((device)) T tex1Dfetch(cudaTextureObject_t texObject, int x) +{ + T ret; + tex1Dfetch(&ret, texObject, x); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1D(T *ptr, cudaTextureObject_t obj, float x) +{ + __nv_tex_surf_handler("__itex1D", ptr, obj, x); +} + + +template +static __attribute__((device)) T tex1D(cudaTextureObject_t texObject, float x) +{ + T ret; + tex1D(&ret, texObject, x); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2D(T *ptr, cudaTextureObject_t obj, float x, float y) +{ + __nv_tex_surf_handler("__itex2D", ptr, obj, x, y); +} + +template +static __attribute__((device)) T tex2D(cudaTextureObject_t texObject, float x, float y) +{ + T ret; + tex2D(&ret, texObject, x, y); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2D(T *ptr, cudaTextureObject_t obj, float x, float y, + bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2D_sparse", ptr, obj, x, y, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2D(cudaTextureObject_t texObject, float x, float y, bool* isResident) +{ + T ret; + tex2D(&ret, texObject, x, y, isResident); + return ret; +} + + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex3D(T *ptr, cudaTextureObject_t obj, float x, float y, float z) +{ + __nv_tex_surf_handler("__itex3D", ptr, obj, x, y, z); +} + +template +static __attribute__((device)) T tex3D(cudaTextureObject_t texObject, float x, float y, float z) +{ + T ret; + tex3D(&ret, texObject, x, y, z); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex3D(T *ptr, cudaTextureObject_t obj, float x, float y, float z, + bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex3D_sparse", ptr, obj, x, y, z, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex3D(cudaTextureObject_t texObject, float x, float y, float z, bool* isResident) +{ + T ret; + tex3D(&ret, texObject, x, y, z, isResident); + return ret; +} + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DLayered(T *ptr, cudaTextureObject_t obj, float x, int layer) +{ + __nv_tex_surf_handler("__itex1DLayered", ptr, obj, x, layer); +} + +template +static __attribute__((device)) T tex1DLayered(cudaTextureObject_t texObject, float x, int layer) +{ + T ret; + tex1DLayered(&ret, texObject, x, layer); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayered(T *ptr, cudaTextureObject_t obj, float x, float y, int layer) +{ + __nv_tex_surf_handler("__itex2DLayered", ptr, obj, x, y, layer); +} + +template +static __attribute__((device)) T tex2DLayered(cudaTextureObject_t texObject, float x, float y, int layer) +{ + T ret; + tex2DLayered(&ret, texObject, x, y, layer); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayered(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2DLayered_sparse", ptr, obj, x, y, layer, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2DLayered(cudaTextureObject_t texObject, float x, float y, int layer, bool* isResident) +{ + T ret; + tex2DLayered(&ret, texObject, x, y, layer, isResident); + return ret; +} + + + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemap(T *ptr, cudaTextureObject_t obj, float x, float y, float z) +{ + __nv_tex_surf_handler("__itexCubemap", ptr, obj, x, y, z); +} + + +template +static __attribute__((device)) T texCubemap(cudaTextureObject_t texObject, float x, float y, float z) +{ + T ret; + texCubemap(&ret, texObject, x, y, z); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapLayered(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer) +{ + __nv_tex_surf_handler("__itexCubemapLayered", ptr, obj, x, y, z, layer); +} + +template +static __attribute__((device)) T texCubemapLayered(cudaTextureObject_t texObject, float x, float y, float z, int layer) +{ + T ret; + texCubemapLayered(&ret, texObject, x, y, z, layer); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2Dgather(T *ptr, cudaTextureObject_t obj, float x, float y, int comp = 0) +{ + __nv_tex_surf_handler("__itex2Dgather", ptr, obj, x, y, comp); +} + +template +static __attribute__((device)) T tex2Dgather(cudaTextureObject_t to, float x, float y, int comp = 0) +{ + T ret; + tex2Dgather(&ret, to, x, y, comp); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2Dgather(T *ptr, cudaTextureObject_t obj, float x, float y, bool* isResident, int comp = 0) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2Dgather_sparse", ptr, obj, x, y, comp, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2Dgather(cudaTextureObject_t to, float x, float y, bool* isResident, int comp = 0) +{ + T ret; + tex2Dgather(&ret, to, x, y, isResident, comp); + return ret; +} + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DLod(T *ptr, cudaTextureObject_t obj, float x, float level) +{ + __nv_tex_surf_handler("__itex1DLod", ptr, obj, x, level); +} + +template +static __attribute__((device)) T tex1DLod(cudaTextureObject_t texObject, float x, float level) +{ + T ret; + tex1DLod(&ret, texObject, x, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float level) +{ + __nv_tex_surf_handler("__itex2DLod", ptr, obj, x, y, level); +} + +template +static __attribute__((device)) T tex2DLod(cudaTextureObject_t texObject, float x, float y, float level) +{ + T ret; + tex2DLod(&ret, texObject, x, y, level); + return ret; +} + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float level, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2DLod_sparse", ptr, obj, x, y, level, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2DLod(cudaTextureObject_t texObject, float x, float y, float level, bool* isResident) +{ + T ret; + tex2DLod(&ret, texObject, x, y, level, isResident); + return ret; +} + + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex3DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level) +{ + __nv_tex_surf_handler("__itex3DLod", ptr, obj, x, y, z, level); +} + +template +static __attribute__((device)) T tex3DLod(cudaTextureObject_t texObject, float x, float y, float z, float level) +{ + T ret; + tex3DLod(&ret, texObject, x, y, z, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex3DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex3DLod_sparse", ptr, obj, x, y, z, level, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex3DLod(cudaTextureObject_t texObject, float x, float y, float z, float level, bool* isResident) +{ + T ret; + tex3DLod(&ret, texObject, x, y, z, level, isResident); + return ret; +} + + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, int layer, float level) +{ + __nv_tex_surf_handler("__itex1DLayeredLod", ptr, obj, x, layer, level); +} + +template +static __attribute__((device)) T tex1DLayeredLod(cudaTextureObject_t texObject, float x, int layer, float level) +{ + T ret; + tex1DLayeredLod(&ret, texObject, x, layer, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, float level) +{ + __nv_tex_surf_handler("__itex2DLayeredLod", ptr, obj, x, y, layer, level); +} + +template +static __attribute__((device)) T tex2DLayeredLod(cudaTextureObject_t texObject, float x, float y, int layer, float level) +{ + T ret; + tex2DLayeredLod(&ret, texObject, x, y, layer, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, float level, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2DLayeredLod_sparse", ptr, obj, x, y, layer, level, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2DLayeredLod(cudaTextureObject_t texObject, float x, float y, int layer, float level, bool* isResident) +{ + T ret; + tex2DLayeredLod(&ret, texObject, x, y, layer, level, isResident); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level) +{ + __nv_tex_surf_handler("__itexCubemapLod", ptr, obj, x, y, z, level); +} + +template +static __attribute__((device)) T texCubemapLod(cudaTextureObject_t texObject, float x, float y, float z, float level) +{ + T ret; + texCubemapLod(&ret, texObject, x, y, z, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + __nv_tex_surf_handler("__itexCubemapGrad_v2", ptr, obj, x, y, z, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T texCubemapGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + T ret; + texCubemapGrad(&ret, texObject, x, y, z, dPdx, dPdy); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer, float level) +{ + __nv_tex_surf_handler("__itexCubemapLayeredLod", ptr, obj, x, y, z, layer, level); +} + +template +static __attribute__((device)) T texCubemapLayeredLod(cudaTextureObject_t texObject, float x, float y, float z, int layer, float level) +{ + T ret; + texCubemapLayeredLod(&ret, texObject, x, y, z, layer, level); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DGrad(T *ptr, cudaTextureObject_t obj, float x, float dPdx, float dPdy) +{ + __nv_tex_surf_handler("__itex1DGrad", ptr, obj, x, dPdx, dPdy); +} + +template +static __attribute__((device)) T tex1DGrad(cudaTextureObject_t texObject, float x, float dPdx, float dPdy) +{ + T ret; + tex1DGrad(&ret, texObject, x, dPdx, dPdy); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float2 dPdx, float2 dPdy) +{ + __nv_tex_surf_handler("__itex2DGrad_v2", ptr, obj, x, y, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T tex2DGrad(cudaTextureObject_t texObject, float x, float y, float2 dPdx, float2 dPdy) +{ + T ret; + tex2DGrad(&ret, texObject, x, y, dPdx, dPdy); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float2 dPdx, float2 dPdy, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2DGrad_sparse", ptr, obj, x, y, &dPdx, &dPdy, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2DGrad(cudaTextureObject_t texObject, float x, float y, float2 dPdx, float2 dPdy, bool* isResident) +{ + T ret; + tex2DGrad(&ret, texObject, x, y, dPdx, dPdy, isResident); + return ret; +} + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex3DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + __nv_tex_surf_handler("__itex3DGrad_v2", ptr, obj, x, y, z, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T tex3DGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + T ret; + tex3DGrad(&ret, texObject, x, y, z, dPdx, dPdy); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex3DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex3DGrad_sparse", ptr, obj, x, y, z, &dPdx, &dPdy, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex3DGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy, bool* isResident) +{ + T ret; + tex3DGrad(&ret, texObject, x, y, z, dPdx, dPdy, isResident); + return ret; +} + + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DLayeredGrad(T *ptr, cudaTextureObject_t obj, float x, int layer, float dPdx, float dPdy) +{ + __nv_tex_surf_handler("__itex1DLayeredGrad", ptr, obj, x, layer, dPdx, dPdy); +} + +template +static __attribute__((device)) T tex1DLayeredGrad(cudaTextureObject_t texObject, float x, int layer, float dPdx, float dPdy) +{ + T ret; + tex1DLayeredGrad(&ret, texObject, x, layer, dPdx, dPdy); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayeredGrad(T * ptr, cudaTextureObject_t obj, float x, float y, int layer, float2 dPdx, float2 dPdy) +{ + __nv_tex_surf_handler("__itex2DLayeredGrad_v2", ptr, obj, x, y, layer, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T tex2DLayeredGrad(cudaTextureObject_t texObject, float x, float y, int layer, float2 dPdx, float2 dPdy) +{ + T ret; + tex2DLayeredGrad(&ret, texObject, x, y, layer, dPdx, dPdy); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayeredGrad(T * ptr, cudaTextureObject_t obj, float x, float y, int layer, float2 dPdx, float2 dPdy, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2DLayeredGrad_sparse", ptr, obj, x, y, layer, &dPdx, &dPdy, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2DLayeredGrad(cudaTextureObject_t texObject, float x, float y, int layer, float2 dPdx, float2 dPdy, bool* isResident) +{ + T ret; + tex2DLayeredGrad(&ret, texObject, x, y, layer, dPdx, dPdy, isResident); + return ret; +} + + + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapLayeredGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer, float4 dPdx, float4 dPdy) +{ + __nv_tex_surf_handler("__itexCubemapLayeredGrad_v2", ptr, obj, x, y, z, layer, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T texCubemapLayeredGrad(cudaTextureObject_t texObject, float x, float y, float z, int layer, float4 dPdx, float4 dPdy) +{ + T ret; + texCubemapLayeredGrad(&ret, texObject, x, y, z, layer, dPdx, dPdy); + return ret; +} +# 2919 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" 1 +# 58 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template struct __nv_isurf_trait { }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; + +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; + +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; + + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf1Dread(T *ptr, cudaSurfaceObject_t obj, int x, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf1Dread", ptr, obj, x, mode); +} + +template +static __attribute__((device)) T surf1Dread(cudaSurfaceObject_t surfObject, int x, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf1Dread(&ret, surfObject, x, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf2Dread(T *ptr, cudaSurfaceObject_t obj, int x, int y, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf2Dread", ptr, obj, x, y, mode); +} + +template +static __attribute__((device)) T surf2Dread(cudaSurfaceObject_t surfObject, int x, int y, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf2Dread(&ret, surfObject, x, y, boundaryMode); + return ret; +} + + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf3Dread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int z, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf3Dread", ptr, obj, x, y, z, mode); +} + +template +static __attribute__((device)) T surf3Dread(cudaSurfaceObject_t surfObject, int x, int y, int z, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf3Dread(&ret, surfObject, x, y, z, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf1DLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf1DLayeredread", ptr, obj, x, layer, mode); +} + +template +static __attribute__((device)) T surf1DLayeredread(cudaSurfaceObject_t surfObject, int x, int layer, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf1DLayeredread(&ret, surfObject, x, layer, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf2DLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf2DLayeredread", ptr, obj, x, y, layer, mode); +} + +template +static __attribute__((device)) T surf2DLayeredread(cudaSurfaceObject_t surfObject, int x, int y, int layer, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf2DLayeredread(&ret, surfObject, x, y, layer, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surfCubemapread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int face, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurfCubemapread", ptr, obj, x, y, face, mode); +} + +template +static __attribute__((device)) T surfCubemapread(cudaSurfaceObject_t surfObject, int x, int y, int face, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surfCubemapread(&ret, surfObject, x, y, face, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surfCubemapLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int layerface, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurfCubemapLayeredread", ptr, obj, x, y, layerface, mode); +} + +template +static __attribute__((device)) T surfCubemapLayeredread(cudaSurfaceObject_t surfObject, int x, int y, int layerface, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surfCubemapLayeredread(&ret, surfObject, x, y, layerface, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf1Dwrite(T val, cudaSurfaceObject_t obj, int x, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf1Dwrite_v2", &val, obj, x, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf2Dwrite(T val, cudaSurfaceObject_t obj, int x, int y, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf2Dwrite_v2", &val, obj, x, y, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf3Dwrite(T val, cudaSurfaceObject_t obj, int x, int y, int z, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf3Dwrite_v2", &val, obj, x, y, z, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf1DLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf1DLayeredwrite_v2", &val, obj, x, layer, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf2DLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int y, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf2DLayeredwrite_v2", &val, obj, x, y, layer, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surfCubemapwrite(T val, cudaSurfaceObject_t obj, int x, int y, int face, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurfCubemapwrite_v2", &val, obj, x, y, face, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surfCubemapLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int y, int layerface, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurfCubemapLayeredwrite_v2", &val, obj, x, y, layerface, mode); +} +# 2920 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/cudacc_ext.h" 1 +# 2922 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 + + +extern "C" __attribute__((host)) __attribute__((device)) unsigned __cudaPushCallConfiguration(dim3 gridDim, + dim3 blockDim, + size_t sharedMem = 0, + struct CUstream_st *stream = 0); +# 2969 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +enum { + __NV_ATOMIC_RELAXED, + __NV_ATOMIC_CONSUME, + __NV_ATOMIC_ACQUIRE, + __NV_ATOMIC_RELEASE, + __NV_ATOMIC_ACQ_REL, + __NV_ATOMIC_SEQ_CST +}; + +enum { + __NV_THREAD_SCOPE_THREAD, + __NV_THREAD_SCOPE_BLOCK, + __NV_THREAD_SCOPE_CLUSTER, + __NV_THREAD_SCOPE_DEVICE, + __NV_THREAD_SCOPE_SYSTEM +}; +# 119 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/device_launch_parameters.h" 1 +# 68 "/opt/cuda/bin/../targets/x86_64-linux/include/device_launch_parameters.h" +extern "C" { + + +uint3 __attribute__((device_builtin)) extern const threadIdx; +uint3 __attribute__((device_builtin)) extern const blockIdx; +dim3 __attribute__((device_builtin)) extern const blockDim; +dim3 __attribute__((device_builtin)) extern const gridDim; +int __attribute__((device_builtin)) extern const warpSize; + + + + +} +# 120 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 148 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 1 3 +# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 + +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 1 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 + +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + namespace rel_ops + { +# 86 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 + template + inline bool + operator!=(const _Tp& __x, const _Tp& __y) + { return !(__x == __y); } +# 99 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 + template + inline bool + operator>(const _Tp& __x, const _Tp& __y) + { return __y < __x; } +# 112 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 + template + inline bool + operator<=(const _Tp& __x, const _Tp& __y) + { return !(__y < __x); } +# 125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 + template + inline bool + operator>=(const _Tp& __x, const _Tp& __y) + { return !(__x < __y); } + } + + +} +# 69 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 2 3 + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/initializer_list" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/initializer_list" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/initializer_list" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + template + class initializer_list + { + public: + typedef _E value_type; + typedef const _E& reference; + typedef const _E& const_reference; + typedef size_t size_type; + typedef const _E* iterator; + typedef const _E* const_iterator; + + private: + iterator _M_array; + size_type _M_len; + + + constexpr initializer_list(const_iterator __a, size_type __l) + : _M_array(__a), _M_len(__l) { } + + public: + constexpr initializer_list() noexcept + : _M_array(0), _M_len(0) { } + + + constexpr size_type + size() const noexcept { return _M_len; } + + + constexpr const_iterator + begin() const noexcept { return _M_array; } + + + constexpr const_iterator + end() const noexcept { return begin() + size(); } + }; + + + + + + + + template + constexpr const _Tp* + begin(initializer_list<_Tp> __ils) noexcept + { return __ils.begin(); } + + + + + + + + template + constexpr const _Tp* + end(initializer_list<_Tp> __ils) noexcept + { return __ils.end(); } +} +# 74 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 2 3 +# 96 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 97 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template + + inline _Tp + exchange(_Tp& __obj, _Up&& __new_val) + noexcept(__and_, + is_nothrow_assignable<_Tp&, _Up>>::value) + { return std::__exchange(__obj, std::forward<_Up>(__new_val)); } + + + + template + [[nodiscard]] + constexpr add_const_t<_Tp>& + as_const(_Tp& __t) noexcept + { return __t; } + + template + void as_const(const _Tp&&) = delete; +# 230 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 + +} +# 149 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" + +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchKernel( + T *func, + dim3 gridDim, + dim3 blockDim, + void **args, + size_t sharedMem = 0, + cudaStream_t stream = 0 +) +{ + return ::cudaLaunchKernel((const void *)func, gridDim, blockDim, args, sharedMem, stream); +} +# 279 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchKernelEx( + const cudaLaunchConfig_t *config, + void (*kernel)(ExpTypes...), + ActTypes &&... args +) +{ + return [&](ExpTypes... coercedArgs){ + void *pArgs[] = { &coercedArgs... }; + return ::cudaLaunchKernelExC(config, (const void *)kernel, pArgs); + }(std::forward(args)...); +} +# 348 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchKernelEx( + const cudaLaunchConfig_t *config, + const cudaKernel_t kernel, + ActTypes &&... args +) +{ + void *pArgs[] = { &args... }; + return ::cudaLaunchKernelExC(config, (const void *)kernel, pArgs); +} +# 410 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchCooperativeKernel( + T *func, + dim3 gridDim, + dim3 blockDim, + void **args, + size_t sharedMem = 0, + cudaStream_t stream = 0 +) +{ + return ::cudaLaunchCooperativeKernel((const void *)func, gridDim, blockDim, args, sharedMem, stream); +} +# 454 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaEventCreate( + cudaEvent_t *event, + unsigned int flags +) +{ + return ::cudaEventCreateWithFlags(event, flags); +} +# 498 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaGraphInstantiate( + cudaGraphExec_t *pGraphExec, + cudaGraph_t graph, + cudaGraphNode_t *pErrorNode, + char *pLogBuffer, + size_t bufferSize +) +{ + (void)pErrorNode; + (void)pLogBuffer; + (void)bufferSize; + return ::cudaGraphInstantiate(pGraphExec, graph, 0); +} +# 569 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaMallocHost( + void **ptr, + size_t size, + unsigned int flags +) +{ + return ::cudaHostAlloc(ptr, size, flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaHostAlloc( + T **ptr, + size_t size, + unsigned int flags +) +{ + return ::cudaHostAlloc((void**)(void*)ptr, size, flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaHostGetDevicePointer( + T **pDevice, + void *pHost, + unsigned int flags +) +{ + return ::cudaHostGetDevicePointer((void**)(void*)pDevice, pHost, flags); +} +# 698 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocManaged( + T **devPtr, + size_t size, + unsigned int flags = 0x01 +) +{ + return ::cudaMallocManaged((void**)(void*)devPtr, size, flags); +} +# 716 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +cudaError_t cudaMemAdvise( + T *devPtr, + size_t count, + enum cudaMemoryAdvise advice, + struct cudaMemLocation location +) +{ + return ::cudaMemAdvise_v2((const void *)devPtr, count, advice, location); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMemPrefetchAsync( + T *devPtr, + size_t count, + struct cudaMemLocation location, + unsigned int flags, + cudaStream_t stream = 0 +) +{ + return ::cudaMemPrefetchAsync_v2((const void *)devPtr, count, location, flags, stream); +} +# 819 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaStreamAttachMemAsync( + cudaStream_t stream, + T *devPtr, + size_t length = 0, + unsigned int flags = 0x04 +) +{ + return ::cudaStreamAttachMemAsync(stream, (void*)devPtr, length, flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMalloc( + T **devPtr, + size_t size +) +{ + return ::cudaMalloc((void**)(void*)devPtr, size); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocHost( + T **ptr, + size_t size, + unsigned int flags = 0 +) +{ + return cudaMallocHost((void**)(void*)ptr, size, flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocPitch( + T **devPtr, + size_t *pitch, + size_t width, + size_t height +) +{ + return ::cudaMallocPitch((void**)(void*)devPtr, pitch, width, height); +} +# 869 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaMallocAsync( + void **ptr, + size_t size, + cudaMemPool_t memPool, + cudaStream_t stream +) +{ + return ::cudaMallocFromPoolAsync(ptr, size, memPool, stream); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocAsync( + T **ptr, + size_t size, + cudaMemPool_t memPool, + cudaStream_t stream +) +{ + return ::cudaMallocFromPoolAsync((void**)(void*)ptr, size, memPool, stream); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocAsync( + T **ptr, + size_t size, + cudaStream_t stream +) +{ + return ::cudaMallocAsync((void**)(void*)ptr, size, stream); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocFromPoolAsync( + T **ptr, + size_t size, + cudaMemPool_t memPool, + cudaStream_t stream +) +{ + return ::cudaMallocFromPoolAsync((void**)(void*)ptr, size, memPool, stream); +} +# 919 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyBatchAsync( + T **dsts, U **srcs, size_t *sizes, size_t count, struct cudaMemcpyAttributes *attrs, + size_t *attrsIdxs, size_t numAttrs, size_t *failIdx, cudaStream_t hStream +) +{ + return ::cudaMemcpyBatchAsync((void **)dsts, (void **)srcs, sizes, count, attrs, attrsIdxs, numAttrs, failIdx, hStream); +} +# 938 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyBatchAsync( + T **dsts, U **srcs, size_t *sizes, size_t count, struct cudaMemcpyAttributes attr, size_t *failIdx, cudaStream_t hStream +) +{ + size_t attrsIdxs = 0; + return ::cudaMemcpyBatchAsync((void **)dsts, (void **)srcs, sizes, count, &attr, &attrsIdxs, 1, failIdx, hStream); +} +# 984 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyToSymbol( + const T &symbol, + const void *src, + size_t count, + size_t offset = 0, + enum cudaMemcpyKind kind = cudaMemcpyHostToDevice +) +{ + return ::cudaMemcpyToSymbol((const void*)&symbol, src, count, offset, kind); +} +# 1038 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyToSymbolAsync( + const T &symbol, + const void *src, + size_t count, + size_t offset = 0, + enum cudaMemcpyKind kind = cudaMemcpyHostToDevice, + cudaStream_t stream = 0 +) +{ + return ::cudaMemcpyToSymbolAsync((const void*)&symbol, src, count, offset, kind, stream); +} +# 1086 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyFromSymbol( + void *dst, + const T &symbol, + size_t count, + size_t offset = 0, + enum cudaMemcpyKind kind = cudaMemcpyDeviceToHost +) +{ + return ::cudaMemcpyFromSymbol(dst, (const void*)&symbol, count, offset, kind); +} +# 1140 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyFromSymbolAsync( + void *dst, + const T &symbol, + size_t count, + size_t offset = 0, + enum cudaMemcpyKind kind = cudaMemcpyDeviceToHost, + cudaStream_t stream = 0 +) +{ + return ::cudaMemcpyFromSymbolAsync(dst, (const void*)&symbol, count, offset, kind, stream); +} +# 1209 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphAddMemcpyNodeToSymbol( + cudaGraphNode_t *pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t *pDependencies, + size_t numDependencies, + const T &symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphAddMemcpyNodeToSymbol(pGraphNode, graph, pDependencies, numDependencies, (const void*)&symbol, src, count, offset, kind); +} +# 1280 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphAddMemcpyNodeFromSymbol( + cudaGraphNode_t* pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t* pDependencies, + size_t numDependencies, + void* dst, + const T &symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphAddMemcpyNodeFromSymbol(pGraphNode, graph, pDependencies, numDependencies, dst, (const void*)&symbol, count, offset, kind); +} +# 1331 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParamsToSymbol( + cudaGraphNode_t node, + const T &symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphMemcpyNodeSetParamsToSymbol(node, (const void*)&symbol, src, count, offset, kind); +} +# 1379 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParamsFromSymbol( + cudaGraphNode_t node, + void* dst, + const T &symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphMemcpyNodeSetParamsFromSymbol(node, dst, (const void*)&symbol, count, offset, kind); +} +# 1437 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParamsToSymbol( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + const T &symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphExecMemcpyNodeSetParamsToSymbol(hGraphExec, node, (const void*)&symbol, src, count, offset, kind); +} +# 1496 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParamsFromSymbol( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + void* dst, + const T &symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphExecMemcpyNodeSetParamsFromSymbol(hGraphExec, node, dst, (const void*)&symbol, count, offset, kind); +} + + +static __inline__ __attribute__((host)) cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphNode_t *hErrorNode_out, enum cudaGraphExecUpdateResult *updateResult_out) +{ + cudaGraphExecUpdateResultInfo resultInfo; + cudaError_t status = cudaGraphExecUpdate(hGraphExec, hGraph, &resultInfo); + if (hErrorNode_out) { + *hErrorNode_out = resultInfo.errorNode; + } + if (updateResult_out) { + *updateResult_out = resultInfo.result; + } + return status; +} +# 1549 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaUserObjectCreate( + cudaUserObject_t *object_out, + T *objectToWrap, + unsigned int initialRefcount, + unsigned int flags) +{ + return ::cudaUserObjectCreate( + object_out, + objectToWrap, + [](void *vpObj) { delete reinterpret_cast(vpObj); }, + initialRefcount, + flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaUserObjectCreate( + cudaUserObject_t *object_out, + T *objectToWrap, + unsigned int initialRefcount, + cudaUserObjectFlags flags) +{ + return cudaUserObjectCreate(object_out, objectToWrap, initialRefcount, (unsigned int)flags); +} +# 1599 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetSymbolAddress( + void **devPtr, + const T &symbol +) +{ + return ::cudaGetSymbolAddress(devPtr, (const void*)&symbol); +} +# 1631 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetSymbolSize( + size_t *size, + const T &symbol +) +{ + return ::cudaGetSymbolSize(size, (const void*)&symbol); +} +# 1683 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncSetCacheConfig( + T *func, + enum cudaFuncCache cacheConfig +) +{ + return ::cudaFuncSetCacheConfig((const void*)func, cacheConfig); +} + +template +static __inline__ +__attribute__((deprecated)) +__attribute__((host)) cudaError_t cudaFuncSetSharedMemConfig( + T *func, + enum cudaSharedMemConfig config +) +{ + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + + return ::cudaFuncSetSharedMemConfig((const void*)func, config); + +#pragma GCC diagnostic pop + +} +# 1743 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor( + int *numBlocks, + T func, + int blockSize, + size_t dynamicSMemSize) +{ + return ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, (const void*)func, blockSize, dynamicSMemSize, 0x00); +} +# 1796 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags( + int *numBlocks, + T func, + int blockSize, + size_t dynamicSMemSize, + unsigned int flags) +{ + return ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, (const void*)func, blockSize, dynamicSMemSize, flags); +} + + + + +class __cudaOccupancyB2DHelper { + size_t n; +public: + inline __attribute__((host)) __attribute__((device)) __cudaOccupancyB2DHelper(size_t n_) : n(n_) {} + inline __attribute__((host)) __attribute__((device)) size_t operator()(int) + { + return n; + } +}; +# 1866 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) __attribute__((device)) cudaError_t cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags( + int *minGridSize, + int *blockSize, + T func, + UnaryFunction blockSizeToDynamicSMemSize, + int blockSizeLimit = 0, + unsigned int flags = 0) +{ + cudaError_t status; + + + int device; + struct cudaFuncAttributes attr; + + + int maxThreadsPerMultiProcessor; + int warpSize; + int devMaxThreadsPerBlock; + int multiProcessorCount; + int funcMaxThreadsPerBlock; + int occupancyLimit; + int granularity; + + + int maxBlockSize = 0; + int numBlocks = 0; + int maxOccupancy = 0; + + + int blockSizeToTryAligned; + int blockSizeToTry; + int blockSizeLimitAligned; + int occupancyInBlocks; + int occupancyInThreads; + size_t dynamicSMemSize; + + + + + + if (!minGridSize || !blockSize || !func) { + return cudaErrorInvalidValue; + } + + + + + + status = ::cudaGetDevice(&device); + if (status != cudaSuccess) { + return status; + } + + status = cudaDeviceGetAttribute( + &maxThreadsPerMultiProcessor, + cudaDevAttrMaxThreadsPerMultiProcessor, + device); + if (status != cudaSuccess) { + return status; + } + + status = cudaDeviceGetAttribute( + &warpSize, + cudaDevAttrWarpSize, + device); + if (status != cudaSuccess) { + return status; + } + + status = cudaDeviceGetAttribute( + &devMaxThreadsPerBlock, + cudaDevAttrMaxThreadsPerBlock, + device); + if (status != cudaSuccess) { + return status; + } + + status = cudaDeviceGetAttribute( + &multiProcessorCount, + cudaDevAttrMultiProcessorCount, + device); + if (status != cudaSuccess) { + return status; + } + + status = cudaFuncGetAttributes(&attr, func); + if (status != cudaSuccess) { + return status; + } + + funcMaxThreadsPerBlock = attr.maxThreadsPerBlock; + + + + + + occupancyLimit = maxThreadsPerMultiProcessor; + granularity = warpSize; + + if (blockSizeLimit == 0) { + blockSizeLimit = devMaxThreadsPerBlock; + } + + if (devMaxThreadsPerBlock < blockSizeLimit) { + blockSizeLimit = devMaxThreadsPerBlock; + } + + if (funcMaxThreadsPerBlock < blockSizeLimit) { + blockSizeLimit = funcMaxThreadsPerBlock; + } + + blockSizeLimitAligned = ((blockSizeLimit + (granularity - 1)) / granularity) * granularity; + + for (blockSizeToTryAligned = blockSizeLimitAligned; blockSizeToTryAligned > 0; blockSizeToTryAligned -= granularity) { + + + + if (blockSizeLimit < blockSizeToTryAligned) { + blockSizeToTry = blockSizeLimit; + } else { + blockSizeToTry = blockSizeToTryAligned; + } + + dynamicSMemSize = blockSizeToDynamicSMemSize(blockSizeToTry); + + status = cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags( + &occupancyInBlocks, + func, + blockSizeToTry, + dynamicSMemSize, + flags); + + if (status != cudaSuccess) { + return status; + } + + occupancyInThreads = blockSizeToTry * occupancyInBlocks; + + if (occupancyInThreads > maxOccupancy) { + maxBlockSize = blockSizeToTry; + numBlocks = occupancyInBlocks; + maxOccupancy = occupancyInThreads; + } + + + + if (occupancyLimit == maxOccupancy) { + break; + } + } + + + + + + + + *minGridSize = numBlocks * multiProcessorCount; + *blockSize = maxBlockSize; + + return status; +} +# 2062 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) __attribute__((device)) cudaError_t cudaOccupancyMaxPotentialBlockSizeVariableSMem( + int *minGridSize, + int *blockSize, + T func, + UnaryFunction blockSizeToDynamicSMemSize, + int blockSizeLimit = 0) +{ + return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, blockSizeToDynamicSMemSize, blockSizeLimit, 0x00); +} +# 2108 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) __attribute__((device)) cudaError_t cudaOccupancyMaxPotentialBlockSize( + int *minGridSize, + int *blockSize, + T func, + size_t dynamicSMemSize = 0, + int blockSizeLimit = 0) +{ + return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, __cudaOccupancyB2DHelper(dynamicSMemSize), blockSizeLimit, 0x00); +} +# 2147 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock( + size_t *dynamicSmemSize, + T *func, + int numBlocks, + int blockSize) +{ + return ::cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, (const void*)func, numBlocks, blockSize); +} +# 2206 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) __attribute__((device)) cudaError_t cudaOccupancyMaxPotentialBlockSizeWithFlags( + int *minGridSize, + int *blockSize, + T func, + size_t dynamicSMemSize = 0, + int blockSizeLimit = 0, + unsigned int flags = 0) +{ + return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, __cudaOccupancyB2DHelper(dynamicSMemSize), blockSizeLimit, flags); +} +# 2251 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxPotentialClusterSize( + int *clusterSize, + T *func, + const cudaLaunchConfig_t *config) +{ + return ::cudaOccupancyMaxPotentialClusterSize(clusterSize, (const void*)func, config); +} +# 2295 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxActiveClusters( + int *numClusters, + T *func, + const cudaLaunchConfig_t *config) +{ + return ::cudaOccupancyMaxActiveClusters(numClusters, (const void*)func, config); +} +# 2336 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncGetAttributes( + struct cudaFuncAttributes *attr, + T *entry +) +{ + return ::cudaFuncGetAttributes(attr, (const void*)entry); +} +# 2402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncSetAttribute( + T *func, + enum cudaFuncAttribute attr, + int value +) +{ + return ::cudaFuncSetAttribute((const void*)func, attr, value); +} +# 2435 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncGetName( + const char **name, + T *func +) +{ + return ::cudaFuncGetName(name, (const void *)func); +} +# 2458 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetKernel( + cudaKernel_t *kernelPtr, + T *func +) +{ + return ::cudaGetKernel(kernelPtr, (const void *)func); +} +# 2496 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLibraryGetGlobal(T **dptr, size_t *bytes, cudaLibrary_t library, const char *name) +{ + return ::cudaLibraryGetGlobal((void**)(void*)dptr, bytes, library, name); +} +# 2530 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLibraryGetManaged(T **dptr, size_t *bytes, cudaLibrary_t library, const char *name) +{ + return ::cudaLibraryGetManaged((void**)(void*)dptr, bytes, library, name); +} +# 2560 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLibraryGetUnifiedFunction(T **fptr, cudaLibrary_t library, const char *symbol) +{ + return ::cudaLibraryGetUnifiedFunction((void**)(void*)fptr, library, symbol); +} +# 2576 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +#pragma GCC diagnostic pop +# 0 "" 2 +# 1 "CMakeCUDACompilerId.cu" +# 477 "CMakeCUDACompilerId.cu" +char const* info_compiler = "INFO" ":" "compiler[" "NVIDIA" "]"; + +char const* info_simulate = "INFO" ":" "simulate[" "GNU" "]"; +# 790 "CMakeCUDACompilerId.cu" +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + ('0' + (((12) / 10000000)%10)), ('0' + (((12) / 1000000)%10)), ('0' + (((12) / 100000)%10)), ('0' + (((12) / 10000)%10)), ('0' + (((12) / 1000)%10)), ('0' + (((12) / 100)%10)), ('0' + (((12) / 10)%10)), ('0' + ((12) % 10)), + + '.', ('0' + (((8) / 10000000)%10)), ('0' + (((8) / 1000000)%10)), ('0' + (((8) / 100000)%10)), ('0' + (((8) / 10000)%10)), ('0' + (((8) / 1000)%10)), ('0' + (((8) / 100)%10)), ('0' + (((8) / 10)%10)), ('0' + ((8) % 10)), + + '.', ('0' + (((93) / 10000000)%10)), ('0' + (((93) / 1000000)%10)), ('0' + (((93) / 100000)%10)), ('0' + (((93) / 10000)%10)), ('0' + (((93) / 1000)%10)), ('0' + (((93) / 100)%10)), ('0' + (((93) / 10)%10)), ('0' + ((93) % 10)), + + + + + + ']','\0'}; +# 819 "CMakeCUDACompilerId.cu" +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + ('0' + (((14) / 10000000)%10)), ('0' + (((14) / 1000000)%10)), ('0' + (((14) / 100000)%10)), ('0' + (((14) / 10000)%10)), ('0' + (((14) / 1000)%10)), ('0' + (((14) / 100)%10)), ('0' + (((14) / 10)%10)), ('0' + ((14) % 10)), + + '.', ('0' + (((2) / 10000000)%10)), ('0' + (((2) / 1000000)%10)), ('0' + (((2) / 100000)%10)), ('0' + (((2) / 10000)%10)), ('0' + (((2) / 1000)%10)), ('0' + (((2) / 100)%10)), ('0' + (((2) / 10)%10)), ('0' + ((2) % 10)), + + + + + + + + ']','\0'}; + + + + + + +char const* info_platform = "INFO" ":" "platform[" "Linux" "]"; +char const* info_arch = "INFO" ":" "arch[" "]"; + + + + +char const* info_host_compiler = "INFO" ":" "host_compiler[" "GNU" "]"; + + + + +char const info_host_compiler_version[] = { + 'I', 'N', 'F', 'O', ':','h','o','s','t','_', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + ('0' + (((14) / 10000000)%10)), ('0' + (((14) / 1000000)%10)), ('0' + (((14) / 100000)%10)), ('0' + (((14) / 10000)%10)), ('0' + (((14) / 1000)%10)), ('0' + (((14) / 100)%10)), ('0' + (((14) / 10)%10)), ('0' + ((14) % 10)), + + '.', ('0' + (((2) / 10000000)%10)), ('0' + (((2) / 1000000)%10)), ('0' + (((2) / 100000)%10)), ('0' + (((2) / 10000)%10)), ('0' + (((2) / 1000)%10)), ('0' + (((2) / 100)%10)), ('0' + (((2) / 10)%10)), ('0' + ((2) % 10)), + + '.', ('0' + (((1) / 10000000)%10)), ('0' + (((1) / 1000000)%10)), ('0' + (((1) / 100000)%10)), ('0' + (((1) / 10000)%10)), ('0' + (((1) / 1000)%10)), ('0' + (((1) / 100)%10)), ('0' + (((1) / 10)%10)), ('0' + ((1) % 10)), + + + + + + ']','\0'}; +# 882 "CMakeCUDACompilerId.cu" +const char* info_language_standard_default = "INFO" ":" "standard_default[" + + + + + + + + "17" + + + + + + + +"]"; + +const char* info_language_extensions_default = "INFO" ":" "extensions_default[" + + + "ON" + + + +"]"; + + + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; + + require += info_version[argc]; + + + require += info_simulate[argc]; + + + require += info_simulate_version[argc]; + + + require += info_host_compiler[argc]; + + + require += info_host_compiler_version[argc]; + + require += info_language_standard_default[argc]; + require += info_language_extensions_default[argc]; + (void)argv; + return require; +} diff --git a/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.c b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.c new file mode 100644 index 0000000..4b1ecad --- /dev/null +++ b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.c @@ -0,0 +1,51 @@ +# 1 "CMakeCUDACompilerId.cu" +# 477 "CMakeCUDACompilerId.cu" +extern const char *info_compiler; + +extern const char *info_simulate; +# 790 "CMakeCUDACompilerId.cu" +static const char info_version[50]; +# 819 "CMakeCUDACompilerId.cu" +static const char info_simulate_version[41]; +# 839 "CMakeCUDACompilerId.cu" +extern const char *info_platform; +extern const char *info_arch; + + + + +extern const char *info_host_compiler; + + + + +static const char info_host_compiler_version[55]; +# 882 "CMakeCUDACompilerId.cu" +extern const char *info_language_standard_default; +# 900 "CMakeCUDACompilerId.cu" +extern const char *info_language_extensions_default; +# 477 "CMakeCUDACompilerId.cu" +const char *info_compiler = ((const char *)"INFO:compiler[NVIDIA]"); + +const char *info_simulate = ((const char *)"INFO:simulate[GNU]"); +# 790 "CMakeCUDACompilerId.cu" +static const char info_version[50] = {((char)73),((char)78),((char)70),((char)79),((char)58),((char)99),((char)111),((char)109),((char)112),((char)105),((char)108),((char)101),((char)114),((char)95),((char)118),((char)101),((char)114),((char)115),((char)105),((char)111),((char)110),((char)91),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)49),((char)50),((char)46),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)56),((char)46),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)57),((char)51),((char)93),((char)0)}; +# 819 "CMakeCUDACompilerId.cu" +static const char info_simulate_version[41] = {((char)73),((char)78),((char)70),((char)79),((char)58),((char)115),((char)105),((char)109),((char)117),((char)108),((char)97),((char)116),((char)101),((char)95),((char)118),((char)101),((char)114),((char)115),((char)105),((char)111),((char)110),((char)91),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)49),((char)52),((char)46),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)50),((char)93),((char)0)}; +# 839 "CMakeCUDACompilerId.cu" +const char *info_platform = ((const char *)"INFO:platform[Linux]"); +const char *info_arch = ((const char *)"INFO:arch[]"); + + + + +const char *info_host_compiler = ((const char *)"INFO:host_compiler[GNU]"); + + + + +static const char info_host_compiler_version[55] = {((char)73),((char)78),((char)70),((char)79),((char)58),((char)104),((char)111),((char)115),((char)116),((char)95),((char)99),((char)111),((char)109),((char)112),((char)105),((char)108),((char)101),((char)114),((char)95),((char)118),((char)101),((char)114),((char)115),((char)105),((char)111),((char)110),((char)91),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)49),((char)52),((char)46),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)50),((char)46),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)49),((char)93),((char)0)}; +# 882 "CMakeCUDACompilerId.cu" +const char *info_language_standard_default = ((const char *)"INFO:standard_default[17]"); +# 900 "CMakeCUDACompilerId.cu" +const char *info_language_extensions_default = ((const char *)"INFO:extensions_default[ON]"); diff --git a/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.cpp b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.cpp new file mode 100644 index 0000000..b1e8272 --- /dev/null +++ b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.cpp @@ -0,0 +1,36281 @@ +# 1 "CMakeCUDACompilerId.cu" +#pragma GCC diagnostic ignored "-Wunused-local-typedefs" +# 1 +#pragma GCC diagnostic push +# 1 +#pragma GCC diagnostic ignored "-Wunused-variable" +# 1 +#pragma GCC diagnostic ignored "-Wunused-function" +# 1 +static char __nv_inited_managed_rt = 0; static void **__nv_fatbinhandle_for_managed_rt; static void __nv_save_fatbinhandle_for_managed_rt(void **in){__nv_fatbinhandle_for_managed_rt = in;} static char __nv_init_managed_rt_with_module(void **); static inline void __nv_init_managed_rt(void) { __nv_inited_managed_rt = (__nv_inited_managed_rt ? __nv_inited_managed_rt : __nv_init_managed_rt_with_module(__nv_fatbinhandle_for_managed_rt));} +# 1 +#pragma GCC diagnostic pop +# 1 +#pragma GCC diagnostic ignored "-Wunused-variable" + +# 1 +#define __nv_is_extended_device_lambda_closure_type(X) false +#define __nv_is_extended_host_device_lambda_closure_type(X) false +#define __nv_is_extended_device_lambda_with_preserved_return_type(X) false +#if defined(__nv_is_extended_device_lambda_closure_type) && defined(__nv_is_extended_host_device_lambda_closure_type)&& defined(__nv_is_extended_device_lambda_with_preserved_return_type) +#endif + +# 1 +# 61 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +#pragma GCC diagnostic push +# 64 +#pragma GCC diagnostic ignored "-Wunused-function" +# 31 "/usr/include/bits/types.h" 3 +typedef unsigned char __u_char; +# 32 +typedef unsigned short __u_short; +# 33 +typedef unsigned __u_int; +# 34 +typedef unsigned long __u_long; +# 37 +typedef signed char __int8_t; +# 38 +typedef unsigned char __uint8_t; +# 39 +typedef signed short __int16_t; +# 40 +typedef unsigned short __uint16_t; +# 41 +typedef signed int __int32_t; +# 42 +typedef unsigned __uint32_t; +# 44 +typedef signed long __int64_t; +# 45 +typedef unsigned long __uint64_t; +# 52 +typedef __int8_t __int_least8_t; +# 53 +typedef __uint8_t __uint_least8_t; +# 54 +typedef __int16_t __int_least16_t; +# 55 +typedef __uint16_t __uint_least16_t; +# 56 +typedef __int32_t __int_least32_t; +# 57 +typedef __uint32_t __uint_least32_t; +# 58 +typedef __int64_t __int_least64_t; +# 59 +typedef __uint64_t __uint_least64_t; +# 63 +typedef long __quad_t; +# 64 +typedef unsigned long __u_quad_t; +# 72 +typedef long __intmax_t; +# 73 +typedef unsigned long __uintmax_t; +# 145 "/usr/include/bits/types.h" 3 +typedef unsigned long __dev_t; +# 146 +typedef unsigned __uid_t; +# 147 +typedef unsigned __gid_t; +# 148 +typedef unsigned long __ino_t; +# 149 +typedef unsigned long __ino64_t; +# 150 +typedef unsigned __mode_t; +# 151 +typedef unsigned long __nlink_t; +# 152 +typedef long __off_t; +# 153 +typedef long __off64_t; +# 154 +typedef int __pid_t; +# 155 +typedef struct { int __val[2]; } __fsid_t; +# 156 +typedef long __clock_t; +# 157 +typedef unsigned long __rlim_t; +# 158 +typedef unsigned long __rlim64_t; +# 159 +typedef unsigned __id_t; +# 160 +typedef long __time_t; +# 161 +typedef unsigned __useconds_t; +# 162 +typedef long __suseconds_t; +# 163 +typedef long __suseconds64_t; +# 165 +typedef int __daddr_t; +# 166 +typedef int __key_t; +# 169 +typedef int __clockid_t; +# 172 +typedef void *__timer_t; +# 175 +typedef long __blksize_t; +# 180 +typedef long __blkcnt_t; +# 181 +typedef long __blkcnt64_t; +# 184 +typedef unsigned long __fsblkcnt_t; +# 185 +typedef unsigned long __fsblkcnt64_t; +# 188 +typedef unsigned long __fsfilcnt_t; +# 189 +typedef unsigned long __fsfilcnt64_t; +# 192 +typedef long __fsword_t; +# 194 +typedef long __ssize_t; +# 197 +typedef long __syscall_slong_t; +# 199 +typedef unsigned long __syscall_ulong_t; +# 203 +typedef __off64_t __loff_t; +# 204 +typedef char *__caddr_t; +# 207 +typedef long __intptr_t; +# 210 +typedef unsigned __socklen_t; +# 215 +typedef int __sig_atomic_t; +# 28 "/usr/include/ctype.h" 3 +extern "C" { +# 47 "/usr/include/ctype.h" 3 +enum { +# 48 +_ISupper = ((0 < 8) ? (1 << 0) << 8 : ((1 << 0) >> 8)), +# 49 +_ISlower = ((1 < 8) ? (1 << 1) << 8 : ((1 << 1) >> 8)), +# 50 +_ISalpha = ((2 < 8) ? (1 << 2) << 8 : ((1 << 2) >> 8)), +# 51 +_ISdigit = ((3 < 8) ? (1 << 3) << 8 : ((1 << 3) >> 8)), +# 52 +_ISxdigit = ((4 < 8) ? (1 << 4) << 8 : ((1 << 4) >> 8)), +# 53 +_ISspace = ((5 < 8) ? (1 << 5) << 8 : ((1 << 5) >> 8)), +# 54 +_ISprint = ((6 < 8) ? (1 << 6) << 8 : ((1 << 6) >> 8)), +# 55 +_ISgraph = ((7 < 8) ? (1 << 7) << 8 : ((1 << 7) >> 8)), +# 56 +_ISblank = ((8 < 8) ? (1 << 8) << 8 : ((1 << 8) >> 8)), +# 57 +_IScntrl, +# 58 +_ISpunct = ((10 < 8) ? (1 << 10) << 8 : ((1 << 10) >> 8)), +# 59 +_ISalnum = ((11 < 8) ? (1 << 11) << 8 : ((1 << 11) >> 8)) +# 60 +}; +# 79 "/usr/include/ctype.h" 3 +extern const unsigned short **__ctype_b_loc() noexcept(true) +# 80 + __attribute((const)); +# 81 +extern const __int32_t **__ctype_tolower_loc() noexcept(true) +# 82 + __attribute((const)); +# 83 +extern const __int32_t **__ctype_toupper_loc() noexcept(true) +# 84 + __attribute((const)); +# 108 "/usr/include/ctype.h" 3 +extern int isalnum(int) noexcept(true); +# 109 +extern int isalpha(int) noexcept(true); +# 110 +extern int iscntrl(int) noexcept(true); +# 111 +extern int isdigit(int) noexcept(true); +# 112 +extern int islower(int) noexcept(true); +# 113 +extern int isgraph(int) noexcept(true); +# 114 +extern int isprint(int) noexcept(true); +# 115 +extern int ispunct(int) noexcept(true); +# 116 +extern int isspace(int) noexcept(true); +# 117 +extern int isupper(int) noexcept(true); +# 118 +extern int isxdigit(int) noexcept(true); +# 122 +extern int tolower(int __c) noexcept(true); +# 125 +extern int toupper(int __c) noexcept(true); +# 130 +extern int isblank(int) noexcept(true); +# 135 +extern int isctype(int __c, int __mask) noexcept(true); +# 142 +extern int isascii(int __c) noexcept(true); +# 146 +extern int toascii(int __c) noexcept(true); +# 150 +extern int _toupper(int) noexcept(true); +# 151 +extern int _tolower(int) noexcept(true); +# 27 "/usr/include/bits/types/__locale_t.h" 3 +struct __locale_struct { +# 30 +struct __locale_data *__locales[13]; +# 33 +const unsigned short *__ctype_b; +# 34 +const int *__ctype_tolower; +# 35 +const int *__ctype_toupper; +# 38 +const char *__names[13]; +# 39 +}; +# 41 +typedef __locale_struct *__locale_t; +# 24 "/usr/include/bits/types/locale_t.h" 3 +typedef __locale_t locale_t; +# 251 "/usr/include/ctype.h" 3 +extern int isalnum_l(int, locale_t) noexcept(true); +# 252 +extern int isalpha_l(int, locale_t) noexcept(true); +# 253 +extern int iscntrl_l(int, locale_t) noexcept(true); +# 254 +extern int isdigit_l(int, locale_t) noexcept(true); +# 255 +extern int islower_l(int, locale_t) noexcept(true); +# 256 +extern int isgraph_l(int, locale_t) noexcept(true); +# 257 +extern int isprint_l(int, locale_t) noexcept(true); +# 258 +extern int ispunct_l(int, locale_t) noexcept(true); +# 259 +extern int isspace_l(int, locale_t) noexcept(true); +# 260 +extern int isupper_l(int, locale_t) noexcept(true); +# 261 +extern int isxdigit_l(int, locale_t) noexcept(true); +# 263 +extern int isblank_l(int, locale_t) noexcept(true); +# 267 +extern int __tolower_l(int __c, locale_t __l) noexcept(true); +# 268 +extern int tolower_l(int __c, locale_t __l) noexcept(true); +# 271 +extern int __toupper_l(int __c, locale_t __l) noexcept(true); +# 272 +extern int toupper_l(int __c, locale_t __l) noexcept(true); +# 327 "/usr/include/ctype.h" 3 +} +# 68 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" +#if 0 +# 68 +enum cudaRoundMode { +# 70 +cudaRoundNearest, +# 71 +cudaRoundZero, +# 72 +cudaRoundPosInf, +# 73 +cudaRoundMinInf +# 74 +}; +#endif +# 104 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 104 +struct char1 { +# 106 +signed char x; +# 107 +}; +#endif +# 109 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 109 +struct uchar1 { +# 111 +unsigned char x; +# 112 +}; +#endif +# 115 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 115 +struct __attribute((aligned(2))) char2 { +# 117 +signed char x, y; +# 118 +}; +#endif +# 120 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 120 +struct __attribute((aligned(2))) uchar2 { +# 122 +unsigned char x, y; +# 123 +}; +#endif +# 125 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 125 +struct char3 { +# 127 +signed char x, y, z; +# 128 +}; +#endif +# 130 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 130 +struct uchar3 { +# 132 +unsigned char x, y, z; +# 133 +}; +#endif +# 135 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 135 +struct __attribute((aligned(4))) char4 { +# 137 +signed char x, y, z, w; +# 138 +}; +#endif +# 140 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 140 +struct __attribute((aligned(4))) uchar4 { +# 142 +unsigned char x, y, z, w; +# 143 +}; +#endif +# 145 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 145 +struct short1 { +# 147 +short x; +# 148 +}; +#endif +# 150 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 150 +struct ushort1 { +# 152 +unsigned short x; +# 153 +}; +#endif +# 155 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 155 +struct __attribute((aligned(4))) short2 { +# 157 +short x, y; +# 158 +}; +#endif +# 160 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 160 +struct __attribute((aligned(4))) ushort2 { +# 162 +unsigned short x, y; +# 163 +}; +#endif +# 165 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 165 +struct short3 { +# 167 +short x, y, z; +# 168 +}; +#endif +# 170 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 170 +struct ushort3 { +# 172 +unsigned short x, y, z; +# 173 +}; +#endif +# 175 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 175 +struct __attribute((aligned(8))) short4 { short x; short y; short z; short w; }; +#endif +# 176 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 176 +struct __attribute((aligned(8))) ushort4 { unsigned short x; unsigned short y; unsigned short z; unsigned short w; }; +#endif +# 178 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 178 +struct int1 { +# 180 +int x; +# 181 +}; +#endif +# 183 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 183 +struct uint1 { +# 185 +unsigned x; +# 186 +}; +#endif +# 188 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 188 +struct __attribute((aligned(8))) int2 { int x; int y; }; +#endif +# 189 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 189 +struct __attribute((aligned(8))) uint2 { unsigned x; unsigned y; }; +#endif +# 191 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 191 +struct int3 { +# 193 +int x, y, z; +# 194 +}; +#endif +# 196 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 196 +struct uint3 { +# 198 +unsigned x, y, z; +# 199 +}; +#endif +# 201 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 201 +struct __attribute((aligned(16))) int4 { +# 203 +int x, y, z, w; +# 204 +}; +#endif +# 206 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 206 +struct __attribute((aligned(16))) uint4 { +# 208 +unsigned x, y, z, w; +# 209 +}; +#endif +# 211 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 211 +struct long1 { +# 213 +long x; +# 214 +}; +#endif +# 216 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 216 +struct ulong1 { +# 218 +unsigned long x; +# 219 +}; +#endif +# 226 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 226 +struct __attribute((aligned((2) * sizeof(long)))) long2 { +# 228 +long x, y; +# 229 +}; +#endif +# 231 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 231 +struct __attribute((aligned((2) * sizeof(unsigned long)))) ulong2 { +# 233 +unsigned long x, y; +# 234 +}; +#endif +# 238 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 238 +struct long3 { +# 240 +long x, y, z; +# 241 +}; +#endif +# 243 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 243 +struct ulong3 { +# 245 +unsigned long x, y, z; +# 246 +}; +#endif +# 248 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 248 +struct __attribute((aligned(16))) long4 { +# 250 +long x, y, z, w; +# 251 +}; +#endif +# 253 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 253 +struct __attribute((aligned(16))) ulong4 { +# 255 +unsigned long x, y, z, w; +# 256 +}; +#endif +# 258 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 258 +struct float1 { +# 260 +float x; +# 261 +}; +#endif +# 280 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 280 +struct __attribute((aligned(8))) float2 { float x; float y; }; +#endif +# 285 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 285 +struct float3 { +# 287 +float x, y, z; +# 288 +}; +#endif +# 290 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 290 +struct __attribute((aligned(16))) float4 { +# 292 +float x, y, z, w; +# 293 +}; +#endif +# 295 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 295 +struct longlong1 { +# 297 +long long x; +# 298 +}; +#endif +# 300 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 300 +struct ulonglong1 { +# 302 +unsigned long long x; +# 303 +}; +#endif +# 305 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 305 +struct __attribute((aligned(16))) longlong2 { +# 307 +long long x, y; +# 308 +}; +#endif +# 310 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 310 +struct __attribute((aligned(16))) ulonglong2 { +# 312 +unsigned long long x, y; +# 313 +}; +#endif +# 315 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 315 +struct longlong3 { +# 317 +long long x, y, z; +# 318 +}; +#endif +# 320 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 320 +struct ulonglong3 { +# 322 +unsigned long long x, y, z; +# 323 +}; +#endif +# 325 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 325 +struct __attribute((aligned(16))) longlong4 { +# 327 +long long x, y, z, w; +# 328 +}; +#endif +# 330 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 330 +struct __attribute((aligned(16))) ulonglong4 { +# 332 +unsigned long long x, y, z, w; +# 333 +}; +#endif +# 335 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 335 +struct double1 { +# 337 +double x; +# 338 +}; +#endif +# 340 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 340 +struct __attribute((aligned(16))) double2 { +# 342 +double x, y; +# 343 +}; +#endif +# 345 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 345 +struct double3 { +# 347 +double x, y, z; +# 348 +}; +#endif +# 350 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 350 +struct __attribute((aligned(16))) double4 { +# 352 +double x, y, z, w; +# 353 +}; +#endif +# 367 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef char1 +# 367 +char1; +#endif +# 368 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef uchar1 +# 368 +uchar1; +#endif +# 369 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef char2 +# 369 +char2; +#endif +# 370 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef uchar2 +# 370 +uchar2; +#endif +# 371 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef char3 +# 371 +char3; +#endif +# 372 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef uchar3 +# 372 +uchar3; +#endif +# 373 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef char4 +# 373 +char4; +#endif +# 374 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef uchar4 +# 374 +uchar4; +#endif +# 375 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef short1 +# 375 +short1; +#endif +# 376 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ushort1 +# 376 +ushort1; +#endif +# 377 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef short2 +# 377 +short2; +#endif +# 378 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ushort2 +# 378 +ushort2; +#endif +# 379 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef short3 +# 379 +short3; +#endif +# 380 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ushort3 +# 380 +ushort3; +#endif +# 381 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef short4 +# 381 +short4; +#endif +# 382 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ushort4 +# 382 +ushort4; +#endif +# 383 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef int1 +# 383 +int1; +#endif +# 384 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef uint1 +# 384 +uint1; +#endif +# 385 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef int2 +# 385 +int2; +#endif +# 386 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef uint2 +# 386 +uint2; +#endif +# 387 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef int3 +# 387 +int3; +#endif +# 388 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef uint3 +# 388 +uint3; +#endif +# 389 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef int4 +# 389 +int4; +#endif +# 390 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef uint4 +# 390 +uint4; +#endif +# 391 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef long1 +# 391 +long1; +#endif +# 392 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ulong1 +# 392 +ulong1; +#endif +# 393 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef long2 +# 393 +long2; +#endif +# 394 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ulong2 +# 394 +ulong2; +#endif +# 395 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef long3 +# 395 +long3; +#endif +# 396 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ulong3 +# 396 +ulong3; +#endif +# 397 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef long4 +# 397 +long4; +#endif +# 398 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ulong4 +# 398 +ulong4; +#endif +# 399 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef float1 +# 399 +float1; +#endif +# 400 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef float2 +# 400 +float2; +#endif +# 401 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef float3 +# 401 +float3; +#endif +# 402 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef float4 +# 402 +float4; +#endif +# 403 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef longlong1 +# 403 +longlong1; +#endif +# 404 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ulonglong1 +# 404 +ulonglong1; +#endif +# 405 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef longlong2 +# 405 +longlong2; +#endif +# 406 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ulonglong2 +# 406 +ulonglong2; +#endif +# 407 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef longlong3 +# 407 +longlong3; +#endif +# 408 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ulonglong3 +# 408 +ulonglong3; +#endif +# 409 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef longlong4 +# 409 +longlong4; +#endif +# 410 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ulonglong4 +# 410 +ulonglong4; +#endif +# 411 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef double1 +# 411 +double1; +#endif +# 412 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef double2 +# 412 +double2; +#endif +# 413 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef double3 +# 413 +double3; +#endif +# 414 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef double4 +# 414 +double4; +#endif +# 426 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 426 +struct dim3 { +# 428 +unsigned x, y, z; +# 440 +}; +#endif +# 442 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef dim3 +# 442 +dim3; +#endif +# 23 "/usr/include/bits/pthread_stack_min-dynamic.h" 3 +extern "C" { +# 24 +extern long __sysconf(int __name) noexcept(true); +# 25 +} +# 145 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 +typedef long ptrdiff_t; +# 214 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 +typedef unsigned long size_t; +#if !defined(__CUDA_INCLUDE_COMPILER_INTERNAL_HEADERS__) +#define __CUDA_INCLUDE_COMPILER_INTERNAL_HEADERS__ +#endif +#include "crt/host_runtime.h" +# 436 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 +typedef +# 425 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 +struct { +# 426 +long long __max_align_ll __attribute((__aligned__(__alignof__(long long)))); +# 427 +long double __max_align_ld __attribute((__aligned__(__alignof__(long double)))); +# 436 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 +} max_align_t; +# 443 +typedef __decltype((nullptr)) nullptr_t; +# 205 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 205 +enum cudaError { +# 212 +cudaSuccess, +# 218 +cudaErrorInvalidValue, +# 224 +cudaErrorMemoryAllocation, +# 230 +cudaErrorInitializationError, +# 237 +cudaErrorCudartUnloading, +# 244 +cudaErrorProfilerDisabled, +# 252 +cudaErrorProfilerNotInitialized, +# 259 +cudaErrorProfilerAlreadyStarted, +# 266 +cudaErrorProfilerAlreadyStopped, +# 274 +cudaErrorInvalidConfiguration, +# 280 +cudaErrorInvalidPitchValue = 12, +# 286 +cudaErrorInvalidSymbol, +# 294 +cudaErrorInvalidHostPointer = 16, +# 302 +cudaErrorInvalidDevicePointer, +# 307 +cudaErrorInvalidTexture, +# 313 +cudaErrorInvalidTextureBinding, +# 320 +cudaErrorInvalidChannelDescriptor, +# 326 +cudaErrorInvalidMemcpyDirection, +# 336 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorAddressOfConstant, +# 345 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorTextureFetchFailed, +# 354 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorTextureNotBound, +# 363 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorSynchronizationError, +# 368 +cudaErrorInvalidFilterSetting, +# 374 +cudaErrorInvalidNormSetting, +# 382 +cudaErrorMixedDeviceExecution, +# 390 +cudaErrorNotYetImplemented = 31, +# 399 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorMemoryValueTooLarge, +# 405 +cudaErrorStubLibrary = 34, +# 412 +cudaErrorInsufficientDriver, +# 419 +cudaErrorCallRequiresNewerDriver, +# 425 +cudaErrorInvalidSurface, +# 431 +cudaErrorDuplicateVariableName = 43, +# 437 +cudaErrorDuplicateTextureName, +# 443 +cudaErrorDuplicateSurfaceName, +# 453 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorDevicesUnavailable, +# 466 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorIncompatibleDriverContext = 49, +# 472 +cudaErrorMissingConfiguration = 52, +# 481 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorPriorLaunchFailure, +# 487 +cudaErrorLaunchMaxDepthExceeded = 65, +# 495 +cudaErrorLaunchFileScopedTex, +# 503 +cudaErrorLaunchFileScopedSurf, +# 519 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorSyncDepthExceeded, +# 531 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorLaunchPendingCountExceeded, +# 537 +cudaErrorInvalidDeviceFunction = 98, +# 543 +cudaErrorNoDevice = 100, +# 550 +cudaErrorInvalidDevice, +# 555 +cudaErrorDeviceNotLicensed, +# 564 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorSoftwareValidityNotEstablished, +# 569 +cudaErrorStartupFailure = 127, +# 574 +cudaErrorInvalidKernelImage = 200, +# 584 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorDeviceUninitialized, +# 589 +cudaErrorMapBufferObjectFailed = 205, +# 594 +cudaErrorUnmapBufferObjectFailed, +# 600 +cudaErrorArrayIsMapped, +# 605 +cudaErrorAlreadyMapped, +# 613 +cudaErrorNoKernelImageForDevice, +# 618 +cudaErrorAlreadyAcquired, +# 623 +cudaErrorNotMapped, +# 629 +cudaErrorNotMappedAsArray, +# 635 +cudaErrorNotMappedAsPointer, +# 641 +cudaErrorECCUncorrectable, +# 647 +cudaErrorUnsupportedLimit, +# 653 +cudaErrorDeviceAlreadyInUse, +# 659 +cudaErrorPeerAccessUnsupported, +# 665 +cudaErrorInvalidPtx, +# 670 +cudaErrorInvalidGraphicsContext, +# 676 +cudaErrorNvlinkUncorrectable, +# 683 +cudaErrorJitCompilerNotFound, +# 690 +cudaErrorUnsupportedPtxVersion, +# 697 +cudaErrorJitCompilationDisabled, +# 702 +cudaErrorUnsupportedExecAffinity, +# 708 +cudaErrorUnsupportedDevSideSync, +# 719 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorContained, +# 724 +cudaErrorInvalidSource = 300, +# 729 +cudaErrorFileNotFound, +# 734 +cudaErrorSharedObjectSymbolNotFound, +# 739 +cudaErrorSharedObjectInitFailed, +# 744 +cudaErrorOperatingSystem, +# 751 +cudaErrorInvalidResourceHandle = 400, +# 757 +cudaErrorIllegalState, +# 765 +cudaErrorLossyQuery, +# 772 +cudaErrorSymbolNotFound = 500, +# 780 +cudaErrorNotReady = 600, +# 788 +cudaErrorIllegalAddress = 700, +# 797 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorLaunchOutOfResources, +# 808 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorLaunchTimeout, +# 814 +cudaErrorLaunchIncompatibleTexturing, +# 821 +cudaErrorPeerAccessAlreadyEnabled, +# 828 +cudaErrorPeerAccessNotEnabled, +# 841 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorSetOnActiveProcess = 708, +# 848 +cudaErrorContextIsDestroyed, +# 855 +cudaErrorAssert, +# 862 +cudaErrorTooManyPeers, +# 868 +cudaErrorHostMemoryAlreadyRegistered, +# 874 +cudaErrorHostMemoryNotRegistered, +# 883 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorHardwareStackError, +# 891 +cudaErrorIllegalInstruction, +# 900 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorMisalignedAddress, +# 911 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorInvalidAddressSpace, +# 919 +cudaErrorInvalidPc, +# 930 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorLaunchFailure, +# 939 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorCooperativeLaunchTooLarge, +# 947 +cudaErrorTensorMemoryLeak, +# 952 +cudaErrorNotPermitted = 800, +# 958 +cudaErrorNotSupported, +# 967 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorSystemNotReady, +# 974 +cudaErrorSystemDriverMismatch, +# 983 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorCompatNotSupportedOnDevice, +# 988 +cudaErrorMpsConnectionFailed, +# 993 +cudaErrorMpsRpcFailure, +# 999 +cudaErrorMpsServerNotReady, +# 1004 +cudaErrorMpsMaxClientsReached, +# 1009 +cudaErrorMpsMaxConnectionsReached, +# 1014 +cudaErrorMpsClientTerminated, +# 1019 +cudaErrorCdpNotSupported, +# 1024 +cudaErrorCdpVersionMismatch, +# 1029 +cudaErrorStreamCaptureUnsupported = 900, +# 1035 +cudaErrorStreamCaptureInvalidated, +# 1041 +cudaErrorStreamCaptureMerge, +# 1046 +cudaErrorStreamCaptureUnmatched, +# 1052 +cudaErrorStreamCaptureUnjoined, +# 1059 +cudaErrorStreamCaptureIsolation, +# 1065 +cudaErrorStreamCaptureImplicit, +# 1071 +cudaErrorCapturedEvent, +# 1078 +cudaErrorStreamCaptureWrongThread, +# 1083 +cudaErrorTimeout, +# 1089 +cudaErrorGraphExecUpdateFailure, +# 1099 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorExternalDevice, +# 1105 +cudaErrorInvalidClusterSize, +# 1111 +cudaErrorFunctionNotLoaded, +# 1117 +cudaErrorInvalidResourceType, +# 1123 +cudaErrorInvalidResourceConfiguration, +# 1128 +cudaErrorUnknown = 999, +# 1136 +cudaErrorApiFailureBase = 10000 +# 1137 +}; +#endif +# 1142 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1142 +enum cudaChannelFormatKind { +# 1144 +cudaChannelFormatKindSigned, +# 1145 +cudaChannelFormatKindUnsigned, +# 1146 +cudaChannelFormatKindFloat, +# 1147 +cudaChannelFormatKindNone, +# 1148 +cudaChannelFormatKindNV12, +# 1149 +cudaChannelFormatKindUnsignedNormalized8X1, +# 1150 +cudaChannelFormatKindUnsignedNormalized8X2, +# 1151 +cudaChannelFormatKindUnsignedNormalized8X4, +# 1152 +cudaChannelFormatKindUnsignedNormalized16X1, +# 1153 +cudaChannelFormatKindUnsignedNormalized16X2, +# 1154 +cudaChannelFormatKindUnsignedNormalized16X4, +# 1155 +cudaChannelFormatKindSignedNormalized8X1, +# 1156 +cudaChannelFormatKindSignedNormalized8X2, +# 1157 +cudaChannelFormatKindSignedNormalized8X4, +# 1158 +cudaChannelFormatKindSignedNormalized16X1, +# 1159 +cudaChannelFormatKindSignedNormalized16X2, +# 1160 +cudaChannelFormatKindSignedNormalized16X4, +# 1161 +cudaChannelFormatKindUnsignedBlockCompressed1, +# 1162 +cudaChannelFormatKindUnsignedBlockCompressed1SRGB, +# 1163 +cudaChannelFormatKindUnsignedBlockCompressed2, +# 1164 +cudaChannelFormatKindUnsignedBlockCompressed2SRGB, +# 1165 +cudaChannelFormatKindUnsignedBlockCompressed3, +# 1166 +cudaChannelFormatKindUnsignedBlockCompressed3SRGB, +# 1167 +cudaChannelFormatKindUnsignedBlockCompressed4, +# 1168 +cudaChannelFormatKindSignedBlockCompressed4, +# 1169 +cudaChannelFormatKindUnsignedBlockCompressed5, +# 1170 +cudaChannelFormatKindSignedBlockCompressed5, +# 1171 +cudaChannelFormatKindUnsignedBlockCompressed6H, +# 1172 +cudaChannelFormatKindSignedBlockCompressed6H, +# 1173 +cudaChannelFormatKindUnsignedBlockCompressed7, +# 1174 +cudaChannelFormatKindUnsignedBlockCompressed7SRGB, +# 1175 +cudaChannelFormatKindUnsignedNormalized1010102 +# 1177 +}; +#endif +# 1182 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1182 +struct cudaChannelFormatDesc { +# 1184 +int x; +# 1185 +int y; +# 1186 +int z; +# 1187 +int w; +# 1188 +cudaChannelFormatKind f; +# 1189 +}; +#endif +# 1194 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef struct cudaArray *cudaArray_t; +# 1199 +typedef const cudaArray *cudaArray_const_t; +# 1201 +struct cudaArray; +# 1206 +typedef struct cudaMipmappedArray *cudaMipmappedArray_t; +# 1211 +typedef const cudaMipmappedArray *cudaMipmappedArray_const_t; +# 1213 +struct cudaMipmappedArray; +# 1223 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1223 +struct cudaArraySparseProperties { +# 1224 +struct { +# 1225 +unsigned width; +# 1226 +unsigned height; +# 1227 +unsigned depth; +# 1228 +} tileExtent; +# 1229 +unsigned miptailFirstLevel; +# 1230 +unsigned long long miptailSize; +# 1231 +unsigned flags; +# 1232 +unsigned reserved[4]; +# 1233 +}; +#endif +# 1238 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1238 +struct cudaArrayMemoryRequirements { +# 1239 +size_t size; +# 1240 +size_t alignment; +# 1241 +unsigned reserved[4]; +# 1242 +}; +#endif +# 1247 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1247 +enum cudaMemoryType { +# 1249 +cudaMemoryTypeUnregistered, +# 1250 +cudaMemoryTypeHost, +# 1251 +cudaMemoryTypeDevice, +# 1252 +cudaMemoryTypeManaged +# 1253 +}; +#endif +# 1258 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1258 +enum cudaMemcpyKind { +# 1260 +cudaMemcpyHostToHost, +# 1261 +cudaMemcpyHostToDevice, +# 1262 +cudaMemcpyDeviceToHost, +# 1263 +cudaMemcpyDeviceToDevice, +# 1264 +cudaMemcpyDefault +# 1265 +}; +#endif +# 1272 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1272 +struct cudaPitchedPtr { +# 1274 +void *ptr; +# 1275 +size_t pitch; +# 1276 +size_t xsize; +# 1277 +size_t ysize; +# 1278 +}; +#endif +# 1285 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1285 +struct cudaExtent { +# 1287 +size_t width; +# 1288 +size_t height; +# 1289 +size_t depth; +# 1290 +}; +#endif +# 1297 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1297 +struct cudaPos { +# 1299 +size_t x; +# 1300 +size_t y; +# 1301 +size_t z; +# 1302 +}; +#endif +# 1307 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1307 +struct cudaMemcpy3DParms { +# 1309 +cudaArray_t srcArray; +# 1310 +cudaPos srcPos; +# 1311 +cudaPitchedPtr srcPtr; +# 1313 +cudaArray_t dstArray; +# 1314 +cudaPos dstPos; +# 1315 +cudaPitchedPtr dstPtr; +# 1317 +cudaExtent extent; +# 1318 +cudaMemcpyKind kind; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 1319 +}; +#endif +# 1324 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1324 +struct cudaMemcpyNodeParams { +# 1325 +int flags; +# 1326 +int reserved[3]; +# 1327 +cudaMemcpy3DParms copyParams; +# 1328 +}; +#endif +# 1333 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1333 +struct cudaMemcpy3DPeerParms { +# 1335 +cudaArray_t srcArray; +# 1336 +cudaPos srcPos; +# 1337 +cudaPitchedPtr srcPtr; +# 1338 +int srcDevice; +# 1340 +cudaArray_t dstArray; +# 1341 +cudaPos dstPos; +# 1342 +cudaPitchedPtr dstPtr; +# 1343 +int dstDevice; +# 1345 +cudaExtent extent; +# 1346 +}; +#endif +# 1351 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1351 +struct cudaMemsetParams { +# 1352 +void *dst; +# 1353 +size_t pitch; +# 1354 +unsigned value; +# 1355 +unsigned elementSize; +# 1356 +size_t width; +# 1357 +size_t height; +# 1358 +}; +#endif +# 1363 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1363 +struct cudaMemsetParamsV2 { +# 1364 +void *dst; +# 1365 +size_t pitch; +# 1366 +unsigned value; +# 1367 +unsigned elementSize; +# 1368 +size_t width; +# 1369 +size_t height; +# 1370 +}; +#endif +# 1375 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1375 +enum cudaAccessProperty { +# 1376 +cudaAccessPropertyNormal, +# 1377 +cudaAccessPropertyStreaming, +# 1378 +cudaAccessPropertyPersisting +# 1379 +}; +#endif +# 1392 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1392 +struct cudaAccessPolicyWindow { +# 1393 +void *base_ptr; +# 1394 +size_t num_bytes; +# 1395 +float hitRatio; +# 1396 +cudaAccessProperty hitProp; +# 1397 +cudaAccessProperty missProp; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 1398 +}; +#endif +# 1410 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef void (*cudaHostFn_t)(void * userData); +# 1415 +#if 0 +# 1415 +struct cudaHostNodeParams { +# 1416 +cudaHostFn_t fn; +# 1417 +void *userData; +# 1418 +}; +#endif +# 1423 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1423 +struct cudaHostNodeParamsV2 { +# 1424 +cudaHostFn_t fn; +# 1425 +void *userData; +# 1426 +}; +#endif +# 1431 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1431 +enum cudaStreamCaptureStatus { +# 1432 +cudaStreamCaptureStatusNone, +# 1433 +cudaStreamCaptureStatusActive, +# 1434 +cudaStreamCaptureStatusInvalidated +# 1436 +}; +#endif +# 1442 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1442 +enum cudaStreamCaptureMode { +# 1443 +cudaStreamCaptureModeGlobal, +# 1444 +cudaStreamCaptureModeThreadLocal, +# 1445 +cudaStreamCaptureModeRelaxed +# 1446 +}; +#endif +# 1448 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1448 +enum cudaSynchronizationPolicy { +# 1449 +cudaSyncPolicyAuto = 1, +# 1450 +cudaSyncPolicySpin, +# 1451 +cudaSyncPolicyYield, +# 1452 +cudaSyncPolicyBlockingSync +# 1453 +}; +#endif +# 1458 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1458 +enum cudaClusterSchedulingPolicy { +# 1459 +cudaClusterSchedulingPolicyDefault, +# 1460 +cudaClusterSchedulingPolicySpread, +# 1461 +cudaClusterSchedulingPolicyLoadBalancing +# 1462 +}; +#endif +# 1467 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1467 +enum cudaStreamUpdateCaptureDependenciesFlags { +# 1468 +cudaStreamAddCaptureDependencies, +# 1469 +cudaStreamSetCaptureDependencies +# 1470 +}; +#endif +# 1475 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1475 +enum cudaUserObjectFlags { +# 1476 +cudaUserObjectNoDestructorSync = 1 +# 1477 +}; +#endif +# 1482 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1482 +enum cudaUserObjectRetainFlags { +# 1483 +cudaGraphUserObjectMove = 1 +# 1484 +}; +#endif +# 1489 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct cudaGraphicsResource; +# 1494 +#if 0 +# 1494 +enum cudaGraphicsRegisterFlags { +# 1496 +cudaGraphicsRegisterFlagsNone, +# 1497 +cudaGraphicsRegisterFlagsReadOnly, +# 1498 +cudaGraphicsRegisterFlagsWriteDiscard, +# 1499 +cudaGraphicsRegisterFlagsSurfaceLoadStore = 4, +# 1500 +cudaGraphicsRegisterFlagsTextureGather = 8 +# 1501 +}; +#endif +# 1506 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1506 +enum cudaGraphicsMapFlags { +# 1508 +cudaGraphicsMapFlagsNone, +# 1509 +cudaGraphicsMapFlagsReadOnly, +# 1510 +cudaGraphicsMapFlagsWriteDiscard +# 1511 +}; +#endif +# 1516 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1516 +enum cudaGraphicsCubeFace { +# 1518 +cudaGraphicsCubeFacePositiveX, +# 1519 +cudaGraphicsCubeFaceNegativeX, +# 1520 +cudaGraphicsCubeFacePositiveY, +# 1521 +cudaGraphicsCubeFaceNegativeY, +# 1522 +cudaGraphicsCubeFacePositiveZ, +# 1523 +cudaGraphicsCubeFaceNegativeZ +# 1524 +}; +#endif +# 1529 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1529 +enum cudaResourceType { +# 1531 +cudaResourceTypeArray, +# 1532 +cudaResourceTypeMipmappedArray, +# 1533 +cudaResourceTypeLinear, +# 1534 +cudaResourceTypePitch2D +# 1535 +}; +#endif +# 1540 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1540 +enum cudaResourceViewFormat { +# 1542 +cudaResViewFormatNone, +# 1543 +cudaResViewFormatUnsignedChar1, +# 1544 +cudaResViewFormatUnsignedChar2, +# 1545 +cudaResViewFormatUnsignedChar4, +# 1546 +cudaResViewFormatSignedChar1, +# 1547 +cudaResViewFormatSignedChar2, +# 1548 +cudaResViewFormatSignedChar4, +# 1549 +cudaResViewFormatUnsignedShort1, +# 1550 +cudaResViewFormatUnsignedShort2, +# 1551 +cudaResViewFormatUnsignedShort4, +# 1552 +cudaResViewFormatSignedShort1, +# 1553 +cudaResViewFormatSignedShort2, +# 1554 +cudaResViewFormatSignedShort4, +# 1555 +cudaResViewFormatUnsignedInt1, +# 1556 +cudaResViewFormatUnsignedInt2, +# 1557 +cudaResViewFormatUnsignedInt4, +# 1558 +cudaResViewFormatSignedInt1, +# 1559 +cudaResViewFormatSignedInt2, +# 1560 +cudaResViewFormatSignedInt4, +# 1561 +cudaResViewFormatHalf1, +# 1562 +cudaResViewFormatHalf2, +# 1563 +cudaResViewFormatHalf4, +# 1564 +cudaResViewFormatFloat1, +# 1565 +cudaResViewFormatFloat2, +# 1566 +cudaResViewFormatFloat4, +# 1567 +cudaResViewFormatUnsignedBlockCompressed1, +# 1568 +cudaResViewFormatUnsignedBlockCompressed2, +# 1569 +cudaResViewFormatUnsignedBlockCompressed3, +# 1570 +cudaResViewFormatUnsignedBlockCompressed4, +# 1571 +cudaResViewFormatSignedBlockCompressed4, +# 1572 +cudaResViewFormatUnsignedBlockCompressed5, +# 1573 +cudaResViewFormatSignedBlockCompressed5, +# 1574 +cudaResViewFormatUnsignedBlockCompressed6H, +# 1575 +cudaResViewFormatSignedBlockCompressed6H, +# 1576 +cudaResViewFormatUnsignedBlockCompressed7 +# 1577 +}; +#endif +# 1582 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1582 +struct cudaResourceDesc { +# 1583 +cudaResourceType resType; +# 1585 +union { +# 1586 +struct { +# 1587 +cudaArray_t array; +# 1588 +} array; +# 1589 +struct { +# 1590 +cudaMipmappedArray_t mipmap; +# 1591 +} mipmap; +# 1592 +struct { +# 1593 +void *devPtr; +# 1594 +cudaChannelFormatDesc desc; +# 1595 +size_t sizeInBytes; +# 1596 +} linear; +# 1597 +struct { +# 1598 +void *devPtr; +# 1599 +cudaChannelFormatDesc desc; +# 1600 +size_t width; +# 1601 +size_t height; +# 1602 +size_t pitchInBytes; +# 1603 +} pitch2D; +# 1604 +} res; +# 1605 +}; +#endif +# 1610 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1610 +struct cudaResourceViewDesc { +# 1612 +cudaResourceViewFormat format; +# 1613 +size_t width; +# 1614 +size_t height; +# 1615 +size_t depth; +# 1616 +unsigned firstMipmapLevel; +# 1617 +unsigned lastMipmapLevel; +# 1618 +unsigned firstLayer; +# 1619 +unsigned lastLayer; +# 1620 +}; +#endif +# 1625 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1625 +struct cudaPointerAttributes { +# 1631 +cudaMemoryType type; +# 1642 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +int device; +# 1648 +void *devicePointer; +# 1657 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +void *hostPointer; +# 1658 +}; +#endif +# 1663 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1663 +struct cudaFuncAttributes { +# 1670 +size_t sharedSizeBytes; +# 1676 +size_t constSizeBytes; +# 1681 +size_t localSizeBytes; +# 1688 +int maxThreadsPerBlock; +# 1693 +int numRegs; +# 1700 +int ptxVersion; +# 1707 +int binaryVersion; +# 1713 +int cacheModeCA; +# 1720 +int maxDynamicSharedSizeBytes; +# 1729 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +int preferredShmemCarveout; +# 1735 +int clusterDimMustBeSet; +# 1746 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +int requiredClusterWidth; +# 1747 +int requiredClusterHeight; +# 1748 +int requiredClusterDepth; +# 1754 +int clusterSchedulingPolicyPreference; +# 1776 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +int nonPortableClusterSizeAllowed; +# 1781 +int reserved[16]; +# 1782 +}; +#endif +# 1787 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1787 +enum cudaFuncAttribute { +# 1789 +cudaFuncAttributeMaxDynamicSharedMemorySize = 8, +# 1790 +cudaFuncAttributePreferredSharedMemoryCarveout, +# 1791 +cudaFuncAttributeClusterDimMustBeSet, +# 1792 +cudaFuncAttributeRequiredClusterWidth, +# 1793 +cudaFuncAttributeRequiredClusterHeight, +# 1794 +cudaFuncAttributeRequiredClusterDepth, +# 1795 +cudaFuncAttributeNonPortableClusterSizeAllowed, +# 1796 +cudaFuncAttributeClusterSchedulingPolicyPreference, +# 1797 +cudaFuncAttributeMax +# 1798 +}; +#endif +# 1803 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1803 +enum cudaFuncCache { +# 1805 +cudaFuncCachePreferNone, +# 1806 +cudaFuncCachePreferShared, +# 1807 +cudaFuncCachePreferL1, +# 1808 +cudaFuncCachePreferEqual +# 1809 +}; +#endif +# 1815 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1815 +enum cudaSharedMemConfig { +# 1817 +cudaSharedMemBankSizeDefault, +# 1818 +cudaSharedMemBankSizeFourByte, +# 1819 +cudaSharedMemBankSizeEightByte +# 1820 +}; +#endif +# 1825 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1825 +enum cudaSharedCarveout { +# 1826 +cudaSharedmemCarveoutDefault = (-1), +# 1827 +cudaSharedmemCarveoutMaxShared = 100, +# 1828 +cudaSharedmemCarveoutMaxL1 = 0 +# 1829 +}; +#endif +# 1834 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1834 +enum cudaComputeMode { +# 1836 +cudaComputeModeDefault, +# 1837 +cudaComputeModeExclusive, +# 1838 +cudaComputeModeProhibited, +# 1839 +cudaComputeModeExclusiveProcess +# 1840 +}; +#endif +# 1845 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1845 +enum cudaLimit { +# 1847 +cudaLimitStackSize, +# 1848 +cudaLimitPrintfFifoSize, +# 1849 +cudaLimitMallocHeapSize, +# 1850 +cudaLimitDevRuntimeSyncDepth, +# 1851 +cudaLimitDevRuntimePendingLaunchCount, +# 1852 +cudaLimitMaxL2FetchGranularity, +# 1853 +cudaLimitPersistingL2CacheSize +# 1854 +}; +#endif +# 1859 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1859 +enum cudaMemoryAdvise { +# 1861 +cudaMemAdviseSetReadMostly = 1, +# 1862 +cudaMemAdviseUnsetReadMostly, +# 1863 +cudaMemAdviseSetPreferredLocation, +# 1864 +cudaMemAdviseUnsetPreferredLocation, +# 1865 +cudaMemAdviseSetAccessedBy, +# 1866 +cudaMemAdviseUnsetAccessedBy +# 1867 +}; +#endif +# 1872 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1872 +enum cudaMemRangeAttribute { +# 1874 +cudaMemRangeAttributeReadMostly = 1, +# 1875 +cudaMemRangeAttributePreferredLocation, +# 1876 +cudaMemRangeAttributeAccessedBy, +# 1877 +cudaMemRangeAttributeLastPrefetchLocation, +# 1878 +cudaMemRangeAttributePreferredLocationType, +# 1879 +cudaMemRangeAttributePreferredLocationId, +# 1880 +cudaMemRangeAttributeLastPrefetchLocationType, +# 1881 +cudaMemRangeAttributeLastPrefetchLocationId +# 1882 +}; +#endif +# 1887 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1887 +enum cudaFlushGPUDirectRDMAWritesOptions { +# 1888 +cudaFlushGPUDirectRDMAWritesOptionHost = (1 << 0), +# 1889 +cudaFlushGPUDirectRDMAWritesOptionMemOps +# 1890 +}; +#endif +# 1895 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1895 +enum cudaGPUDirectRDMAWritesOrdering { +# 1896 +cudaGPUDirectRDMAWritesOrderingNone, +# 1897 +cudaGPUDirectRDMAWritesOrderingOwner = 100, +# 1898 +cudaGPUDirectRDMAWritesOrderingAllDevices = 200 +# 1899 +}; +#endif +# 1904 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1904 +enum cudaFlushGPUDirectRDMAWritesScope { +# 1905 +cudaFlushGPUDirectRDMAWritesToOwner = 100, +# 1906 +cudaFlushGPUDirectRDMAWritesToAllDevices = 200 +# 1907 +}; +#endif +# 1912 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1912 +enum cudaFlushGPUDirectRDMAWritesTarget { +# 1913 +cudaFlushGPUDirectRDMAWritesTargetCurrentDevice +# 1914 +}; +#endif +# 1920 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1920 +enum cudaDeviceAttr { +# 1922 +cudaDevAttrMaxThreadsPerBlock = 1, +# 1923 +cudaDevAttrMaxBlockDimX, +# 1924 +cudaDevAttrMaxBlockDimY, +# 1925 +cudaDevAttrMaxBlockDimZ, +# 1926 +cudaDevAttrMaxGridDimX, +# 1927 +cudaDevAttrMaxGridDimY, +# 1928 +cudaDevAttrMaxGridDimZ, +# 1929 +cudaDevAttrMaxSharedMemoryPerBlock, +# 1930 +cudaDevAttrTotalConstantMemory, +# 1931 +cudaDevAttrWarpSize, +# 1932 +cudaDevAttrMaxPitch, +# 1933 +cudaDevAttrMaxRegistersPerBlock, +# 1934 +cudaDevAttrClockRate, +# 1935 +cudaDevAttrTextureAlignment, +# 1936 +cudaDevAttrGpuOverlap, +# 1937 +cudaDevAttrMultiProcessorCount, +# 1938 +cudaDevAttrKernelExecTimeout, +# 1939 +cudaDevAttrIntegrated, +# 1940 +cudaDevAttrCanMapHostMemory, +# 1941 +cudaDevAttrComputeMode, +# 1942 +cudaDevAttrMaxTexture1DWidth, +# 1943 +cudaDevAttrMaxTexture2DWidth, +# 1944 +cudaDevAttrMaxTexture2DHeight, +# 1945 +cudaDevAttrMaxTexture3DWidth, +# 1946 +cudaDevAttrMaxTexture3DHeight, +# 1947 +cudaDevAttrMaxTexture3DDepth, +# 1948 +cudaDevAttrMaxTexture2DLayeredWidth, +# 1949 +cudaDevAttrMaxTexture2DLayeredHeight, +# 1950 +cudaDevAttrMaxTexture2DLayeredLayers, +# 1951 +cudaDevAttrSurfaceAlignment, +# 1952 +cudaDevAttrConcurrentKernels, +# 1953 +cudaDevAttrEccEnabled, +# 1954 +cudaDevAttrPciBusId, +# 1955 +cudaDevAttrPciDeviceId, +# 1956 +cudaDevAttrTccDriver, +# 1957 +cudaDevAttrMemoryClockRate, +# 1958 +cudaDevAttrGlobalMemoryBusWidth, +# 1959 +cudaDevAttrL2CacheSize, +# 1960 +cudaDevAttrMaxThreadsPerMultiProcessor, +# 1961 +cudaDevAttrAsyncEngineCount, +# 1962 +cudaDevAttrUnifiedAddressing, +# 1963 +cudaDevAttrMaxTexture1DLayeredWidth, +# 1964 +cudaDevAttrMaxTexture1DLayeredLayers, +# 1965 +cudaDevAttrMaxTexture2DGatherWidth = 45, +# 1966 +cudaDevAttrMaxTexture2DGatherHeight, +# 1967 +cudaDevAttrMaxTexture3DWidthAlt, +# 1968 +cudaDevAttrMaxTexture3DHeightAlt, +# 1969 +cudaDevAttrMaxTexture3DDepthAlt, +# 1970 +cudaDevAttrPciDomainId, +# 1971 +cudaDevAttrTexturePitchAlignment, +# 1972 +cudaDevAttrMaxTextureCubemapWidth, +# 1973 +cudaDevAttrMaxTextureCubemapLayeredWidth, +# 1974 +cudaDevAttrMaxTextureCubemapLayeredLayers, +# 1975 +cudaDevAttrMaxSurface1DWidth, +# 1976 +cudaDevAttrMaxSurface2DWidth, +# 1977 +cudaDevAttrMaxSurface2DHeight, +# 1978 +cudaDevAttrMaxSurface3DWidth, +# 1979 +cudaDevAttrMaxSurface3DHeight, +# 1980 +cudaDevAttrMaxSurface3DDepth, +# 1981 +cudaDevAttrMaxSurface1DLayeredWidth, +# 1982 +cudaDevAttrMaxSurface1DLayeredLayers, +# 1983 +cudaDevAttrMaxSurface2DLayeredWidth, +# 1984 +cudaDevAttrMaxSurface2DLayeredHeight, +# 1985 +cudaDevAttrMaxSurface2DLayeredLayers, +# 1986 +cudaDevAttrMaxSurfaceCubemapWidth, +# 1987 +cudaDevAttrMaxSurfaceCubemapLayeredWidth, +# 1988 +cudaDevAttrMaxSurfaceCubemapLayeredLayers, +# 1989 +cudaDevAttrMaxTexture1DLinearWidth, +# 1990 +cudaDevAttrMaxTexture2DLinearWidth, +# 1991 +cudaDevAttrMaxTexture2DLinearHeight, +# 1992 +cudaDevAttrMaxTexture2DLinearPitch, +# 1993 +cudaDevAttrMaxTexture2DMipmappedWidth, +# 1994 +cudaDevAttrMaxTexture2DMipmappedHeight, +# 1995 +cudaDevAttrComputeCapabilityMajor, +# 1996 +cudaDevAttrComputeCapabilityMinor, +# 1997 +cudaDevAttrMaxTexture1DMipmappedWidth, +# 1998 +cudaDevAttrStreamPrioritiesSupported, +# 1999 +cudaDevAttrGlobalL1CacheSupported, +# 2000 +cudaDevAttrLocalL1CacheSupported, +# 2001 +cudaDevAttrMaxSharedMemoryPerMultiprocessor, +# 2002 +cudaDevAttrMaxRegistersPerMultiprocessor, +# 2003 +cudaDevAttrManagedMemory, +# 2004 +cudaDevAttrIsMultiGpuBoard, +# 2005 +cudaDevAttrMultiGpuBoardGroupID, +# 2006 +cudaDevAttrHostNativeAtomicSupported, +# 2007 +cudaDevAttrSingleToDoublePrecisionPerfRatio, +# 2008 +cudaDevAttrPageableMemoryAccess, +# 2009 +cudaDevAttrConcurrentManagedAccess, +# 2010 +cudaDevAttrComputePreemptionSupported, +# 2011 +cudaDevAttrCanUseHostPointerForRegisteredMem, +# 2012 +cudaDevAttrReserved92, +# 2013 +cudaDevAttrReserved93, +# 2014 +cudaDevAttrReserved94, +# 2015 +cudaDevAttrCooperativeLaunch, +# 2016 +cudaDevAttrCooperativeMultiDeviceLaunch, +# 2017 +cudaDevAttrMaxSharedMemoryPerBlockOptin, +# 2018 +cudaDevAttrCanFlushRemoteWrites, +# 2019 +cudaDevAttrHostRegisterSupported, +# 2020 +cudaDevAttrPageableMemoryAccessUsesHostPageTables, +# 2021 +cudaDevAttrDirectManagedMemAccessFromHost, +# 2022 +cudaDevAttrMaxBlocksPerMultiprocessor = 106, +# 2023 +cudaDevAttrMaxPersistingL2CacheSize = 108, +# 2024 +cudaDevAttrMaxAccessPolicyWindowSize, +# 2025 +cudaDevAttrReservedSharedMemoryPerBlock = 111, +# 2026 +cudaDevAttrSparseCudaArraySupported, +# 2027 +cudaDevAttrHostRegisterReadOnlySupported, +# 2028 +cudaDevAttrTimelineSemaphoreInteropSupported, +# 2029 +cudaDevAttrMaxTimelineSemaphoreInteropSupported = 114, +# 2030 +cudaDevAttrMemoryPoolsSupported, +# 2031 +cudaDevAttrGPUDirectRDMASupported, +# 2032 +cudaDevAttrGPUDirectRDMAFlushWritesOptions, +# 2033 +cudaDevAttrGPUDirectRDMAWritesOrdering, +# 2034 +cudaDevAttrMemoryPoolSupportedHandleTypes, +# 2035 +cudaDevAttrClusterLaunch, +# 2036 +cudaDevAttrDeferredMappingCudaArraySupported, +# 2037 +cudaDevAttrReserved122, +# 2038 +cudaDevAttrReserved123, +# 2039 +cudaDevAttrReserved124, +# 2040 +cudaDevAttrIpcEventSupport, +# 2041 +cudaDevAttrMemSyncDomainCount, +# 2042 +cudaDevAttrReserved127, +# 2043 +cudaDevAttrReserved128, +# 2044 +cudaDevAttrReserved129, +# 2045 +cudaDevAttrNumaConfig, +# 2046 +cudaDevAttrNumaId, +# 2047 +cudaDevAttrReserved132, +# 2048 +cudaDevAttrMpsEnabled, +# 2049 +cudaDevAttrHostNumaId, +# 2050 +cudaDevAttrD3D12CigSupported, +# 2051 +cudaDevAttrGpuPciDeviceId = 139, +# 2052 +cudaDevAttrGpuPciSubsystemId, +# 2053 +cudaDevAttrHostNumaMultinodeIpcSupported = 143, +# 2054 +cudaDevAttrMax +# 2055 +}; +#endif +# 2060 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2060 +enum cudaMemPoolAttr { +# 2070 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaMemPoolReuseFollowEventDependencies = 1, +# 2077 +cudaMemPoolReuseAllowOpportunistic, +# 2085 +cudaMemPoolReuseAllowInternalDependencies, +# 2096 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaMemPoolAttrReleaseThreshold, +# 2102 +cudaMemPoolAttrReservedMemCurrent, +# 2109 +cudaMemPoolAttrReservedMemHigh, +# 2115 +cudaMemPoolAttrUsedMemCurrent, +# 2122 +cudaMemPoolAttrUsedMemHigh +# 2123 +}; +#endif +# 2128 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2128 +enum cudaMemLocationType { +# 2129 +cudaMemLocationTypeInvalid, +# 2130 +cudaMemLocationTypeDevice, +# 2131 +cudaMemLocationTypeHost, +# 2132 +cudaMemLocationTypeHostNuma, +# 2133 +cudaMemLocationTypeHostNumaCurrent +# 2134 +}; +#endif +# 2142 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2142 +struct cudaMemLocation { +# 2143 +cudaMemLocationType type; +# 2144 +int id; +# 2145 +}; +#endif +# 2150 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2150 +enum cudaMemAccessFlags { +# 2151 +cudaMemAccessFlagsProtNone, +# 2152 +cudaMemAccessFlagsProtRead, +# 2153 +cudaMemAccessFlagsProtReadWrite = 3 +# 2154 +}; +#endif +# 2159 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2159 +struct cudaMemAccessDesc { +# 2160 +cudaMemLocation location; +# 2161 +cudaMemAccessFlags flags; +# 2162 +}; +#endif +# 2167 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2167 +enum cudaMemAllocationType { +# 2168 +cudaMemAllocationTypeInvalid, +# 2172 +cudaMemAllocationTypePinned, +# 2173 +cudaMemAllocationTypeMax = 2147483647 +# 2174 +}; +#endif +# 2179 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2179 +enum cudaMemAllocationHandleType { +# 2180 +cudaMemHandleTypeNone, +# 2181 +cudaMemHandleTypePosixFileDescriptor, +# 2182 +cudaMemHandleTypeWin32, +# 2183 +cudaMemHandleTypeWin32Kmt = 4, +# 2184 +cudaMemHandleTypeFabric = 8 +# 2185 +}; +#endif +# 2196 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2196 +struct cudaMemPoolProps { +# 2197 +cudaMemAllocationType allocType; +# 2198 +cudaMemAllocationHandleType handleTypes; +# 2199 +cudaMemLocation location; +# 2206 +void *win32SecurityAttributes; +# 2207 +size_t maxSize; +# 2208 +unsigned short usage; +# 2209 +unsigned char reserved[54]; +# 2210 +}; +#endif +# 2215 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2215 +struct cudaMemPoolPtrExportData { +# 2216 +unsigned char reserved[64]; +# 2217 +}; +#endif +# 2222 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2222 +struct cudaMemAllocNodeParams { +# 2227 +cudaMemPoolProps poolProps; +# 2228 +const cudaMemAccessDesc *accessDescs; +# 2229 +size_t accessDescCount; +# 2230 +size_t bytesize; +# 2231 +void *dptr; +# 2232 +}; +#endif +# 2237 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2237 +struct cudaMemAllocNodeParamsV2 { +# 2242 +cudaMemPoolProps poolProps; +# 2243 +const cudaMemAccessDesc *accessDescs; +# 2244 +size_t accessDescCount; +# 2245 +size_t bytesize; +# 2246 +void *dptr; +# 2247 +}; +#endif +# 2252 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2252 +struct cudaMemFreeNodeParams { +# 2253 +void *dptr; +# 2254 +}; +#endif +# 2259 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2259 +enum cudaGraphMemAttributeType { +# 2264 +cudaGraphMemAttrUsedMemCurrent, +# 2271 +cudaGraphMemAttrUsedMemHigh, +# 2278 +cudaGraphMemAttrReservedMemCurrent, +# 2285 +cudaGraphMemAttrReservedMemHigh +# 2286 +}; +#endif +# 2291 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2291 +enum cudaMemcpyFlags { +# 2292 +cudaMemcpyFlagDefault, +# 2297 +cudaMemcpyFlagPreferOverlapWithCompute +# 2298 +}; +#endif +# 2300 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2300 +enum cudaMemcpySrcAccessOrder { +# 2304 +cudaMemcpySrcAccessOrderInvalid, +# 2309 +cudaMemcpySrcAccessOrderStream, +# 2320 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaMemcpySrcAccessOrderDuringApiCall, +# 2329 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaMemcpySrcAccessOrderAny, +# 2331 +cudaMemcpySrcAccessOrderMax = 2147483647 +# 2332 +}; +#endif +# 2337 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2337 +struct cudaMemcpyAttributes { +# 2338 +cudaMemcpySrcAccessOrder srcAccessOrder; +# 2339 +cudaMemLocation srcLocHint; +# 2340 +cudaMemLocation dstLocHint; +# 2341 +unsigned flags; +# 2342 +}; +#endif +# 2347 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2347 +enum cudaMemcpy3DOperandType { +# 2348 +cudaMemcpyOperandTypePointer = 1, +# 2349 +cudaMemcpyOperandTypeArray, +# 2350 +cudaMemcpyOperandTypeMax = 2147483647 +# 2351 +}; +#endif +# 2356 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2356 +struct cudaOffset3D { +# 2357 +size_t x; +# 2358 +size_t y; +# 2359 +size_t z; +# 2360 +}; +#endif +# 2365 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2365 +struct cudaMemcpy3DOperand { +# 2366 +cudaMemcpy3DOperandType type; +# 2367 +union { +# 2371 +struct { +# 2372 +void *ptr; +# 2373 +size_t rowLength; +# 2374 +size_t layerHeight; +# 2375 +cudaMemLocation locHint; +# 2376 +} ptr; +# 2381 +struct { +# 2382 +cudaArray_t array; +# 2383 +cudaOffset3D offset; +# 2384 +} array; +# 2385 +} op; +# 2386 +}; +#endif +# 2388 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2388 +struct cudaMemcpy3DBatchOp { +# 2389 +cudaMemcpy3DOperand src; +# 2390 +cudaMemcpy3DOperand dst; +# 2391 +cudaExtent extent; +# 2392 +cudaMemcpySrcAccessOrder srcAccessOrder; +# 2393 +unsigned flags; +# 2394 +}; +#endif +# 2400 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2400 +enum cudaDeviceP2PAttr { +# 2401 +cudaDevP2PAttrPerformanceRank = 1, +# 2402 +cudaDevP2PAttrAccessSupported, +# 2403 +cudaDevP2PAttrNativeAtomicSupported, +# 2404 +cudaDevP2PAttrCudaArrayAccessSupported +# 2405 +}; +#endif +# 2412 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2412 +struct CUuuid_st { +# 2413 +char bytes[16]; +# 2414 +}; +#endif +# 2415 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef CUuuid_st +# 2415 +CUuuid; +#endif +# 2417 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef CUuuid_st +# 2417 +cudaUUID_t; +#endif +# 2422 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2422 +struct cudaDeviceProp { +# 2424 +char name[256]; +# 2425 +cudaUUID_t uuid; +# 2426 +char luid[8]; +# 2427 +unsigned luidDeviceNodeMask; +# 2428 +size_t totalGlobalMem; +# 2429 +size_t sharedMemPerBlock; +# 2430 +int regsPerBlock; +# 2431 +int warpSize; +# 2432 +size_t memPitch; +# 2433 +int maxThreadsPerBlock; +# 2434 +int maxThreadsDim[3]; +# 2435 +int maxGridSize[3]; +# 2436 +int clockRate; +# 2437 +size_t totalConstMem; +# 2438 +int major; +# 2439 +int minor; +# 2440 +size_t textureAlignment; +# 2441 +size_t texturePitchAlignment; +# 2442 +int deviceOverlap; +# 2443 +int multiProcessorCount; +# 2444 +int kernelExecTimeoutEnabled; +# 2445 +int integrated; +# 2446 +int canMapHostMemory; +# 2447 +int computeMode; +# 2448 +int maxTexture1D; +# 2449 +int maxTexture1DMipmap; +# 2450 +int maxTexture1DLinear; +# 2451 +int maxTexture2D[2]; +# 2452 +int maxTexture2DMipmap[2]; +# 2453 +int maxTexture2DLinear[3]; +# 2454 +int maxTexture2DGather[2]; +# 2455 +int maxTexture3D[3]; +# 2456 +int maxTexture3DAlt[3]; +# 2457 +int maxTextureCubemap; +# 2458 +int maxTexture1DLayered[2]; +# 2459 +int maxTexture2DLayered[3]; +# 2460 +int maxTextureCubemapLayered[2]; +# 2461 +int maxSurface1D; +# 2462 +int maxSurface2D[2]; +# 2463 +int maxSurface3D[3]; +# 2464 +int maxSurface1DLayered[2]; +# 2465 +int maxSurface2DLayered[3]; +# 2466 +int maxSurfaceCubemap; +# 2467 +int maxSurfaceCubemapLayered[2]; +# 2468 +size_t surfaceAlignment; +# 2469 +int concurrentKernels; +# 2470 +int ECCEnabled; +# 2471 +int pciBusID; +# 2472 +int pciDeviceID; +# 2473 +int pciDomainID; +# 2474 +int tccDriver; +# 2475 +int asyncEngineCount; +# 2476 +int unifiedAddressing; +# 2477 +int memoryClockRate; +# 2478 +int memoryBusWidth; +# 2479 +int l2CacheSize; +# 2480 +int persistingL2CacheMaxSize; +# 2481 +int maxThreadsPerMultiProcessor; +# 2482 +int streamPrioritiesSupported; +# 2483 +int globalL1CacheSupported; +# 2484 +int localL1CacheSupported; +# 2485 +size_t sharedMemPerMultiprocessor; +# 2486 +int regsPerMultiprocessor; +# 2487 +int managedMemory; +# 2488 +int isMultiGpuBoard; +# 2489 +int multiGpuBoardGroupID; +# 2490 +int hostNativeAtomicSupported; +# 2491 +int singleToDoublePrecisionPerfRatio; +# 2492 +int pageableMemoryAccess; +# 2493 +int concurrentManagedAccess; +# 2494 +int computePreemptionSupported; +# 2495 +int canUseHostPointerForRegisteredMem; +# 2496 +int cooperativeLaunch; +# 2497 +int cooperativeMultiDeviceLaunch; +# 2498 +size_t sharedMemPerBlockOptin; +# 2499 +int pageableMemoryAccessUsesHostPageTables; +# 2500 +int directManagedMemAccessFromHost; +# 2501 +int maxBlocksPerMultiProcessor; +# 2502 +int accessPolicyMaxWindowSize; +# 2503 +size_t reservedSharedMemPerBlock; +# 2504 +int hostRegisterSupported; +# 2505 +int sparseCudaArraySupported; +# 2506 +int hostRegisterReadOnlySupported; +# 2507 +int timelineSemaphoreInteropSupported; +# 2508 +int memoryPoolsSupported; +# 2509 +int gpuDirectRDMASupported; +# 2510 +unsigned gpuDirectRDMAFlushWritesOptions; +# 2511 +int gpuDirectRDMAWritesOrdering; +# 2512 +unsigned memoryPoolSupportedHandleTypes; +# 2513 +int deferredMappingCudaArraySupported; +# 2514 +int ipcEventSupported; +# 2515 +int clusterLaunch; +# 2516 +int unifiedFunctionPointers; +# 2517 +int reserved[63]; +# 2518 +}; +#endif +# 2531 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 2528 +struct cudaIpcEventHandle_st { +# 2530 +char reserved[64]; +# 2531 +} cudaIpcEventHandle_t; +#endif +# 2539 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 2536 +struct cudaIpcMemHandle_st { +# 2538 +char reserved[64]; +# 2539 +} cudaIpcMemHandle_t; +#endif +# 2547 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 2544 +struct cudaMemFabricHandle_st { +# 2546 +char reserved[64]; +# 2547 +} cudaMemFabricHandle_t; +#endif +# 2552 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2552 +enum cudaExternalMemoryHandleType { +# 2556 +cudaExternalMemoryHandleTypeOpaqueFd = 1, +# 2560 +cudaExternalMemoryHandleTypeOpaqueWin32, +# 2564 +cudaExternalMemoryHandleTypeOpaqueWin32Kmt, +# 2568 +cudaExternalMemoryHandleTypeD3D12Heap, +# 2572 +cudaExternalMemoryHandleTypeD3D12Resource, +# 2576 +cudaExternalMemoryHandleTypeD3D11Resource, +# 2580 +cudaExternalMemoryHandleTypeD3D11ResourceKmt, +# 2584 +cudaExternalMemoryHandleTypeNvSciBuf +# 2585 +}; +#endif +# 2627 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2627 +struct cudaExternalMemoryHandleDesc { +# 2631 +cudaExternalMemoryHandleType type; +# 2632 +union { +# 2638 +int fd; +# 2654 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct { +# 2658 +void *handle; +# 2663 +const void *name; +# 2664 +} win32; +# 2669 +const void *nvSciBufObject; +# 2670 +} handle; +# 2674 +unsigned long long size; +# 2678 +unsigned flags; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 2679 +}; +#endif +# 2684 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2684 +struct cudaExternalMemoryBufferDesc { +# 2688 +unsigned long long offset; +# 2692 +unsigned long long size; +# 2696 +unsigned flags; +# 2697 +}; +#endif +# 2702 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2702 +struct cudaExternalMemoryMipmappedArrayDesc { +# 2707 +unsigned long long offset; +# 2711 +cudaChannelFormatDesc formatDesc; +# 2715 +cudaExtent extent; +# 2720 +unsigned flags; +# 2724 +unsigned numLevels; +# 2725 +}; +#endif +# 2730 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2730 +enum cudaExternalSemaphoreHandleType { +# 2734 +cudaExternalSemaphoreHandleTypeOpaqueFd = 1, +# 2738 +cudaExternalSemaphoreHandleTypeOpaqueWin32, +# 2742 +cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt, +# 2746 +cudaExternalSemaphoreHandleTypeD3D12Fence, +# 2750 +cudaExternalSemaphoreHandleTypeD3D11Fence, +# 2754 +cudaExternalSemaphoreHandleTypeNvSciSync, +# 2758 +cudaExternalSemaphoreHandleTypeKeyedMutex, +# 2762 +cudaExternalSemaphoreHandleTypeKeyedMutexKmt, +# 2766 +cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd, +# 2770 +cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32 +# 2771 +}; +#endif +# 2776 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2776 +struct cudaExternalSemaphoreHandleDesc { +# 2780 +cudaExternalSemaphoreHandleType type; +# 2781 +union { +# 2788 +int fd; +# 2804 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct { +# 2808 +void *handle; +# 2813 +const void *name; +# 2814 +} win32; +# 2818 +const void *nvSciSyncObj; +# 2819 +} handle; +# 2823 +unsigned flags; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 2824 +}; +#endif +# 2829 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2829 +struct cudaExternalSemaphoreSignalParams_v1 { +# 2830 +struct { +# 2834 +struct { +# 2838 +unsigned long long value; +# 2839 +} fence; +# 2840 +union { +# 2845 +void *fence; +# 2846 +unsigned long long reserved; +# 2847 +} nvSciSync; +# 2851 +struct { +# 2855 +unsigned long long key; +# 2856 +} keyedMutex; +# 2857 +} params; +# 2868 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +unsigned flags; +# 2869 +}; +#endif +# 2874 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2874 +struct cudaExternalSemaphoreWaitParams_v1 { +# 2875 +struct { +# 2879 +struct { +# 2883 +unsigned long long value; +# 2884 +} fence; +# 2885 +union { +# 2890 +void *fence; +# 2891 +unsigned long long reserved; +# 2892 +} nvSciSync; +# 2896 +struct { +# 2900 +unsigned long long key; +# 2904 +unsigned timeoutMs; +# 2905 +} keyedMutex; +# 2906 +} params; +# 2917 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +unsigned flags; +# 2918 +}; +#endif +# 2923 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2923 +struct cudaExternalSemaphoreSignalParams { +# 2924 +struct { +# 2928 +struct { +# 2932 +unsigned long long value; +# 2933 +} fence; +# 2934 +union { +# 2939 +void *fence; +# 2940 +unsigned long long reserved; +# 2941 +} nvSciSync; +# 2945 +struct { +# 2949 +unsigned long long key; +# 2950 +} keyedMutex; +# 2951 +unsigned reserved[12]; +# 2952 +} params; +# 2963 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +unsigned flags; +# 2964 +unsigned reserved[16]; +# 2965 +}; +#endif +# 2970 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2970 +struct cudaExternalSemaphoreWaitParams { +# 2971 +struct { +# 2975 +struct { +# 2979 +unsigned long long value; +# 2980 +} fence; +# 2981 +union { +# 2986 +void *fence; +# 2987 +unsigned long long reserved; +# 2988 +} nvSciSync; +# 2992 +struct { +# 2996 +unsigned long long key; +# 3000 +unsigned timeoutMs; +# 3001 +} keyedMutex; +# 3002 +unsigned reserved[10]; +# 3003 +} params; +# 3014 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +unsigned flags; +# 3015 +unsigned reserved[16]; +# 3016 +}; +#endif +# 3027 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef cudaError +# 3027 +cudaError_t; +#endif +# 3032 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUstream_st * +# 3032 +cudaStream_t; +#endif +# 3037 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUevent_st * +# 3037 +cudaEvent_t; +#endif +# 3042 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef cudaGraphicsResource * +# 3042 +cudaGraphicsResource_t; +#endif +# 3047 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUexternalMemory_st * +# 3047 +cudaExternalMemory_t; +#endif +# 3052 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUexternalSemaphore_st * +# 3052 +cudaExternalSemaphore_t; +#endif +# 3057 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUgraph_st * +# 3057 +cudaGraph_t; +#endif +# 3062 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUgraphNode_st * +# 3062 +cudaGraphNode_t; +#endif +# 3067 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUuserObject_st * +# 3067 +cudaUserObject_t; +#endif +# 3072 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef unsigned long long +# 3072 +cudaGraphConditionalHandle; +#endif +# 3077 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUfunc_st * +# 3077 +cudaFunction_t; +#endif +# 3082 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUkern_st * +# 3082 +cudaKernel_t; +#endif +# 3087 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3087 +enum cudaJitOption { +# 3094 +cudaJitMaxRegisters, +# 3108 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaJitThreadsPerBlock, +# 3116 +cudaJitWallTime, +# 3125 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaJitInfoLogBuffer, +# 3134 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaJitInfoLogBufferSizeBytes, +# 3143 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaJitErrorLogBuffer, +# 3152 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaJitErrorLogBufferSizeBytes, +# 3160 +cudaJitOptimizationLevel, +# 3168 +cudaJitFallbackStrategy = 10, +# 3176 +cudaJitGenerateDebugInfo, +# 3183 +cudaJitLogVerbose, +# 3190 +cudaJitGenerateLineInfo, +# 3198 +cudaJitCacheMode, +# 3205 +cudaJitPositionIndependentCode = 30, +# 3218 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaJitMinCtaPerSm, +# 3231 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaJitMaxThreadsPerBlock, +# 3241 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaJitOverrideDirectiveValues +# 3242 +}; +#endif +# 3248 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3248 +enum cudaLibraryOption { +# 3250 +cudaLibraryHostUniversalFunctionAndDataTable, +# 3261 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaLibraryBinaryIsPreserved +# 3262 +}; +#endif +# 3264 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3264 +struct cudalibraryHostUniversalFunctionAndDataTable { +# 3266 +void *functionTable; +# 3267 +size_t functionWindowSize; +# 3268 +void *dataTable; +# 3269 +size_t dataWindowSize; +# 3270 +}; +#endif +# 3275 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3275 +enum cudaJit_CacheMode { +# 3277 +cudaJitCacheOptionNone, +# 3278 +cudaJitCacheOptionCG, +# 3279 +cudaJitCacheOptionCA +# 3280 +}; +#endif +# 3285 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3285 +enum cudaJit_Fallback { +# 3287 +cudaPreferPtx, +# 3289 +cudaPreferBinary +# 3290 +}; +#endif +# 3295 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUlib_st * +# 3295 +cudaLibrary_t; +#endif +# 3300 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUmemPoolHandle_st * +# 3300 +cudaMemPool_t; +#endif +# 3305 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3305 +enum cudaCGScope { +# 3306 +cudaCGScopeInvalid, +# 3307 +cudaCGScopeGrid, +# 3308 +cudaCGScopeMultiGrid +# 3309 +}; +#endif +# 3314 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3314 +struct cudaLaunchParams { +# 3316 +void *func; +# 3317 +dim3 gridDim; +# 3318 +dim3 blockDim; +# 3319 +void **args; +# 3320 +size_t sharedMem; +# 3321 +cudaStream_t stream; +# 3322 +}; +#endif +# 3327 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3327 +struct cudaKernelNodeParams { +# 3328 +void *func; +# 3329 +dim3 gridDim; +# 3330 +dim3 blockDim; +# 3331 +unsigned sharedMemBytes; +# 3332 +void **kernelParams; +# 3333 +void **extra; +# 3334 +}; +#endif +# 3339 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3339 +struct cudaKernelNodeParamsV2 { +# 3340 +void *func; +# 3342 +dim3 gridDim; +# 3343 +dim3 blockDim; +# 3349 +unsigned sharedMemBytes; +# 3350 +void **kernelParams; +# 3351 +void **extra; +# 3352 +}; +#endif +# 3357 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3357 +struct cudaExternalSemaphoreSignalNodeParams { +# 3358 +cudaExternalSemaphore_t *extSemArray; +# 3359 +const cudaExternalSemaphoreSignalParams *paramsArray; +# 3360 +unsigned numExtSems; +# 3361 +}; +#endif +# 3366 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3366 +struct cudaExternalSemaphoreSignalNodeParamsV2 { +# 3367 +cudaExternalSemaphore_t *extSemArray; +# 3368 +const cudaExternalSemaphoreSignalParams *paramsArray; +# 3369 +unsigned numExtSems; +# 3370 +}; +#endif +# 3375 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3375 +struct cudaExternalSemaphoreWaitNodeParams { +# 3376 +cudaExternalSemaphore_t *extSemArray; +# 3377 +const cudaExternalSemaphoreWaitParams *paramsArray; +# 3378 +unsigned numExtSems; +# 3379 +}; +#endif +# 3384 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3384 +struct cudaExternalSemaphoreWaitNodeParamsV2 { +# 3385 +cudaExternalSemaphore_t *extSemArray; +# 3386 +const cudaExternalSemaphoreWaitParams *paramsArray; +# 3387 +unsigned numExtSems; +# 3388 +}; +#endif +# 3390 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3390 +enum cudaGraphConditionalHandleFlags { +# 3391 +cudaGraphCondAssignDefault = 1 +# 3392 +}; +#endif +# 3397 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3397 +enum cudaGraphConditionalNodeType { +# 3398 +cudaGraphCondTypeIf, +# 3399 +cudaGraphCondTypeWhile, +# 3400 +cudaGraphCondTypeSwitch +# 3401 +}; +#endif +# 3406 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3406 +struct cudaConditionalNodeParams { +# 3407 +cudaGraphConditionalHandle handle; +# 3410 +cudaGraphConditionalNodeType type; +# 3411 +unsigned size; +# 3413 +cudaGraph_t *phGraph_out; +# 3432 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +}; +#endif +# 3437 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3437 +enum cudaGraphNodeType { +# 3438 +cudaGraphNodeTypeKernel, +# 3439 +cudaGraphNodeTypeMemcpy, +# 3440 +cudaGraphNodeTypeMemset, +# 3441 +cudaGraphNodeTypeHost, +# 3442 +cudaGraphNodeTypeGraph, +# 3443 +cudaGraphNodeTypeEmpty, +# 3444 +cudaGraphNodeTypeWaitEvent, +# 3445 +cudaGraphNodeTypeEventRecord, +# 3446 +cudaGraphNodeTypeExtSemaphoreSignal, +# 3447 +cudaGraphNodeTypeExtSemaphoreWait, +# 3448 +cudaGraphNodeTypeMemAlloc, +# 3449 +cudaGraphNodeTypeMemFree, +# 3450 +cudaGraphNodeTypeConditional = 13, +# 3467 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaGraphNodeTypeCount +# 3468 +}; +#endif +# 3473 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3473 +struct cudaChildGraphNodeParams { +# 3474 +cudaGraph_t graph; +# 3476 +}; +#endif +# 3481 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3481 +struct cudaEventRecordNodeParams { +# 3482 +cudaEvent_t event; +# 3483 +}; +#endif +# 3488 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3488 +struct cudaEventWaitNodeParams { +# 3489 +cudaEvent_t event; +# 3490 +}; +#endif +# 3495 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3495 +struct cudaGraphNodeParams { +# 3496 +cudaGraphNodeType type; +# 3497 +int reserved0[3]; +# 3499 +union { +# 3500 +long long reserved1[29]; +# 3501 +cudaKernelNodeParamsV2 kernel; +# 3502 +cudaMemcpyNodeParams memcpy; +# 3503 +cudaMemsetParamsV2 memset; +# 3504 +cudaHostNodeParamsV2 host; +# 3505 +cudaChildGraphNodeParams graph; +# 3506 +cudaEventWaitNodeParams eventWait; +# 3507 +cudaEventRecordNodeParams eventRecord; +# 3508 +cudaExternalSemaphoreSignalNodeParamsV2 extSemSignal; +# 3509 +cudaExternalSemaphoreWaitNodeParamsV2 extSemWait; +# 3510 +cudaMemAllocNodeParamsV2 alloc; +# 3511 +cudaMemFreeNodeParams free; +# 3512 +cudaConditionalNodeParams conditional; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 3513 +}; +# 3515 +long long reserved2; +# 3516 +}; +#endif +# 3528 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 3521 +enum cudaGraphDependencyType_enum { +# 3522 +cudaGraphDependencyTypeDefault, +# 3523 +cudaGraphDependencyTypeProgrammatic +# 3528 +} cudaGraphDependencyType; +#endif +# 3558 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 3535 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct cudaGraphEdgeData_st { +# 3536 +unsigned char from_port; +# 3546 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +unsigned char to_port; +# 3553 +unsigned char type; +# 3556 +unsigned char reserved[5]; +# 3558 +} cudaGraphEdgeData; +#endif +# 3579 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef struct CUgraphExec_st *cudaGraphExec_t; +# 3584 +#if 0 +# 3584 +enum cudaGraphExecUpdateResult { +# 3585 +cudaGraphExecUpdateSuccess, +# 3586 +cudaGraphExecUpdateError, +# 3587 +cudaGraphExecUpdateErrorTopologyChanged, +# 3588 +cudaGraphExecUpdateErrorNodeTypeChanged, +# 3589 +cudaGraphExecUpdateErrorFunctionChanged, +# 3590 +cudaGraphExecUpdateErrorParametersChanged, +# 3591 +cudaGraphExecUpdateErrorNotSupported, +# 3592 +cudaGraphExecUpdateErrorUnsupportedFunctionChange, +# 3593 +cudaGraphExecUpdateErrorAttributesChanged +# 3594 +}; +#endif +# 3606 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 3599 +enum cudaGraphInstantiateResult { +# 3600 +cudaGraphInstantiateSuccess, +# 3601 +cudaGraphInstantiateError, +# 3602 +cudaGraphInstantiateInvalidStructure, +# 3603 +cudaGraphInstantiateNodeOperationNotSupported, +# 3604 +cudaGraphInstantiateMultipleDevicesNotSupported, +# 3605 +cudaGraphInstantiateConditionalHandleUnused +# 3606 +} cudaGraphInstantiateResult; +#endif +# 3617 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 3611 +struct cudaGraphInstantiateParams_st { +# 3613 +unsigned long long flags; +# 3614 +cudaStream_t uploadStream; +# 3615 +cudaGraphNode_t errNode_out; +# 3616 +cudaGraphInstantiateResult result_out; +# 3617 +} cudaGraphInstantiateParams; +#endif +# 3639 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 3622 +struct cudaGraphExecUpdateResultInfo_st { +# 3626 +cudaGraphExecUpdateResult result; +# 3633 +cudaGraphNode_t errorNode; +# 3638 +cudaGraphNode_t errorFromNode; +# 3639 +} cudaGraphExecUpdateResultInfo; +#endif +# 3644 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef struct CUgraphDeviceUpdatableNode_st *cudaGraphDeviceNode_t; +# 3649 +#if 0 +# 3649 +enum cudaGraphKernelNodeField { +# 3651 +cudaGraphKernelNodeFieldInvalid, +# 3652 +cudaGraphKernelNodeFieldGridDim, +# 3653 +cudaGraphKernelNodeFieldParam, +# 3654 +cudaGraphKernelNodeFieldEnabled +# 3655 +}; +#endif +# 3660 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3660 +struct cudaGraphKernelNodeUpdate { +# 3661 +cudaGraphDeviceNode_t node; +# 3662 +cudaGraphKernelNodeField field; +# 3663 +union { +# 3665 +dim3 gridDim; +# 3670 +struct { +# 3671 +const void *pValue; +# 3672 +size_t offset; +# 3673 +size_t size; +# 3674 +} param; +# 3675 +unsigned isEnabled; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 3676 +} updateData; +# 3677 +}; +#endif +# 3683 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3683 +enum cudaGetDriverEntryPointFlags { +# 3684 +cudaEnableDefault, +# 3685 +cudaEnableLegacyStream, +# 3686 +cudaEnablePerThreadDefaultStream +# 3687 +}; +#endif +# 3692 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3692 +enum cudaDriverEntryPointQueryResult { +# 3693 +cudaDriverEntryPointSuccess, +# 3694 +cudaDriverEntryPointSymbolNotFound, +# 3695 +cudaDriverEntryPointVersionNotSufficent +# 3696 +}; +#endif +# 3701 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3701 +enum cudaGraphDebugDotFlags { +# 3702 +cudaGraphDebugDotFlagsVerbose = (1 << 0), +# 3703 +cudaGraphDebugDotFlagsKernelNodeParams = (1 << 2), +# 3704 +cudaGraphDebugDotFlagsMemcpyNodeParams = (1 << 3), +# 3705 +cudaGraphDebugDotFlagsMemsetNodeParams = (1 << 4), +# 3706 +cudaGraphDebugDotFlagsHostNodeParams = (1 << 5), +# 3707 +cudaGraphDebugDotFlagsEventNodeParams = (1 << 6), +# 3708 +cudaGraphDebugDotFlagsExtSemasSignalNodeParams = (1 << 7), +# 3709 +cudaGraphDebugDotFlagsExtSemasWaitNodeParams = (1 << 8), +# 3710 +cudaGraphDebugDotFlagsKernelNodeAttributes = (1 << 9), +# 3711 +cudaGraphDebugDotFlagsHandles = (1 << 10), +# 3712 +cudaGraphDebugDotFlagsConditionalNodeParams = (1 << 15) +# 3713 +}; +#endif +# 3718 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3718 +enum cudaGraphInstantiateFlags { +# 3719 +cudaGraphInstantiateFlagAutoFreeOnLaunch = 1, +# 3720 +cudaGraphInstantiateFlagUpload, +# 3723 +cudaGraphInstantiateFlagDeviceLaunch = 4, +# 3726 +cudaGraphInstantiateFlagUseNodePriority = 8 +# 3728 +}; +#endif +# 3749 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 3746 +enum cudaLaunchMemSyncDomain { +# 3747 +cudaLaunchMemSyncDomainDefault, +# 3748 +cudaLaunchMemSyncDomainRemote +# 3749 +} cudaLaunchMemSyncDomain; +#endif +# 3765 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 3762 +struct cudaLaunchMemSyncDomainMap_st { +# 3763 +unsigned char default_; +# 3764 +unsigned char remote; +# 3765 +} cudaLaunchMemSyncDomainMap; +#endif +# 3917 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 3770 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +enum cudaLaunchAttributeID { +# 3771 +cudaLaunchAttributeIgnore, +# 3772 +cudaLaunchAttributeAccessPolicyWindow, +# 3774 +cudaLaunchAttributeCooperative, +# 3776 +cudaLaunchAttributeSynchronizationPolicy, +# 3777 +cudaLaunchAttributeClusterDimension, +# 3779 +cudaLaunchAttributeClusterSchedulingPolicyPreference, +# 3781 +cudaLaunchAttributeProgrammaticStreamSerialization, +# 3792 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaLaunchAttributeProgrammaticEvent, +# 3818 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaLaunchAttributePriority, +# 3820 +cudaLaunchAttributeMemSyncDomainMap, +# 3822 +cudaLaunchAttributeMemSyncDomain, +# 3824 +cudaLaunchAttributePreferredClusterDimension, +# 3860 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaLaunchAttributeLaunchCompletionEvent, +# 3882 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaLaunchAttributeDeviceUpdatableKernelNode, +# 3910 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaLaunchAttributePreferredSharedMemoryCarveout +# 3917 +} cudaLaunchAttributeID; +#endif +# 4013 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 3922 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +union cudaLaunchAttributeValue { +# 3923 +char pad[64]; +# 3924 +cudaAccessPolicyWindow accessPolicyWindow; +# 3925 +int cooperative; +# 3927 +cudaSynchronizationPolicy syncPolicy; +# 3941 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct { +# 3942 +unsigned x; +# 3943 +unsigned y; +# 3944 +unsigned z; +# 3945 +} clusterDim; +# 3946 +cudaClusterSchedulingPolicy clusterSchedulingPolicyPreference; +# 3949 +int programmaticStreamSerializationAllowed; +# 3960 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct { +# 3961 +cudaEvent_t event; +# 3962 +int flags; +# 3963 +int triggerAtBlockStart; +# 3964 +} programmaticEvent; +# 3965 +int priority; +# 3966 +cudaLaunchMemSyncDomainMap memSyncDomainMap; +# 3969 +cudaLaunchMemSyncDomain memSyncDomain; +# 3984 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct { +# 3985 +unsigned x; +# 3986 +unsigned y; +# 3987 +unsigned z; +# 3988 +} preferredClusterDim; +# 3997 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct { +# 3998 +cudaEvent_t event; +# 3999 +int flags; +# 4000 +} launchCompletionEvent; +# 4008 +struct { +# 4009 +int deviceUpdatable; +# 4010 +cudaGraphDeviceNode_t devNode; +# 4011 +} deviceUpdatableKernelNode; +# 4012 +unsigned sharedMemCarveout; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 4013 +} cudaLaunchAttributeValue; +#endif +# 4022 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 4018 +struct cudaLaunchAttribute_st { +# 4019 +cudaLaunchAttributeID id; +# 4020 +char pad[(8) - sizeof(cudaLaunchAttributeID)]; +# 4021 +cudaLaunchAttributeValue val; +# 4022 +} cudaLaunchAttribute; +#endif +# 4034 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 4027 +struct cudaLaunchConfig_st { +# 4028 +dim3 gridDim; +# 4029 +dim3 blockDim; +# 4030 +size_t dynamicSmemBytes; +# 4031 +cudaStream_t stream; +# 4032 +cudaLaunchAttribute *attrs; +# 4033 +unsigned numAttrs; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 4034 +} cudaLaunchConfig_t; +#endif +# 4061 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 4061 +enum cudaDeviceNumaConfig { +# 4062 +cudaDeviceNumaConfigNone, +# 4063 +cudaDeviceNumaConfigNumaNode +# 4064 +}; +#endif +# 4069 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef struct cudaAsyncCallbackEntry *cudaAsyncCallbackHandle_t; +# 4071 +struct cudaAsyncCallbackEntry; +# 4078 +#if 0 +typedef +# 4076 +enum cudaAsyncNotificationType_enum { +# 4077 +cudaAsyncNotificationTypeOverBudget = 1 +# 4078 +} cudaAsyncNotificationType; +#endif +# 4091 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 4083 +struct cudaAsyncNotificationInfo { +# 4085 +cudaAsyncNotificationType type; +# 4086 +union { +# 4087 +struct { +# 4088 +unsigned long long bytesOverBudget; +# 4089 +} overBudget; +# 4090 +} info; +# 4091 +} cudaAsyncNotificationInfo_t; +#endif +# 4093 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef void (*cudaAsyncCallback)(cudaAsyncNotificationInfo_t *, void *, cudaAsyncCallbackHandle_t); +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_types.h" +#if 0 +# 86 +enum cudaSurfaceBoundaryMode { +# 88 +cudaBoundaryModeZero, +# 89 +cudaBoundaryModeClamp, +# 90 +cudaBoundaryModeTrap +# 91 +}; +#endif +# 96 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_types.h" +#if 0 +# 96 +enum cudaSurfaceFormatMode { +# 98 +cudaFormatModeForced, +# 99 +cudaFormatModeAuto +# 100 +}; +#endif +# 105 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_types.h" +#if 0 +typedef unsigned long long +# 105 +cudaSurfaceObject_t; +#endif +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_types.h" +#if 0 +# 86 +enum cudaTextureAddressMode { +# 88 +cudaAddressModeWrap, +# 89 +cudaAddressModeClamp, +# 90 +cudaAddressModeMirror, +# 91 +cudaAddressModeBorder +# 92 +}; +#endif +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_types.h" +#if 0 +# 97 +enum cudaTextureFilterMode { +# 99 +cudaFilterModePoint, +# 100 +cudaFilterModeLinear +# 101 +}; +#endif +# 106 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_types.h" +#if 0 +# 106 +enum cudaTextureReadMode { +# 108 +cudaReadModeElementType, +# 109 +cudaReadModeNormalizedFloat +# 110 +}; +#endif +# 115 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_types.h" +#if 0 +# 115 +struct cudaTextureDesc { +# 120 +cudaTextureAddressMode addressMode[3]; +# 124 +cudaTextureFilterMode filterMode; +# 128 +cudaTextureReadMode readMode; +# 132 +int sRGB; +# 136 +float borderColor[4]; +# 140 +int normalizedCoords; +# 144 +unsigned maxAnisotropy; +# 148 +cudaTextureFilterMode mipmapFilterMode; +# 152 +float mipmapLevelBias; +# 156 +float minMipmapLevelClamp; +# 160 +float maxMipmapLevelClamp; +# 164 +int disableTrilinearOptimization; +# 168 +int seamlessCubemap; +# 169 +}; +#endif +# 174 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_types.h" +#if 0 +typedef unsigned long long +# 174 +cudaTextureObject_t; +#endif +# 94 "/opt/cuda/bin/../targets/x86_64-linux/include/library_types.h" +typedef +# 57 +enum cudaDataType_t { +# 59 +CUDA_R_16F = 2, +# 60 +CUDA_C_16F = 6, +# 61 +CUDA_R_16BF = 14, +# 62 +CUDA_C_16BF, +# 63 +CUDA_R_32F = 0, +# 64 +CUDA_C_32F = 4, +# 65 +CUDA_R_64F = 1, +# 66 +CUDA_C_64F = 5, +# 67 +CUDA_R_4I = 16, +# 68 +CUDA_C_4I, +# 69 +CUDA_R_4U, +# 70 +CUDA_C_4U, +# 71 +CUDA_R_8I = 3, +# 72 +CUDA_C_8I = 7, +# 73 +CUDA_R_8U, +# 74 +CUDA_C_8U, +# 75 +CUDA_R_16I = 20, +# 76 +CUDA_C_16I, +# 77 +CUDA_R_16U, +# 78 +CUDA_C_16U, +# 79 +CUDA_R_32I = 10, +# 80 +CUDA_C_32I, +# 81 +CUDA_R_32U, +# 82 +CUDA_C_32U, +# 83 +CUDA_R_64I = 24, +# 84 +CUDA_C_64I, +# 85 +CUDA_R_64U, +# 86 +CUDA_C_64U, +# 87 +CUDA_R_8F_E4M3, +# 88 +CUDA_R_8F_UE4M3 = CUDA_R_8F_E4M3, +# 89 +CUDA_R_8F_E5M2, +# 90 +CUDA_R_8F_UE8M0, +# 91 +CUDA_R_6F_E2M3, +# 92 +CUDA_R_6F_E3M2, +# 93 +CUDA_R_4F_E2M1 +# 94 +} cudaDataType; +# 102 +typedef +# 97 +enum libraryPropertyType_t { +# 99 +MAJOR_VERSION, +# 100 +MINOR_VERSION, +# 101 +PATCH_LEVEL +# 102 +} libraryPropertyType; +# 308 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std { +# 310 +typedef unsigned long size_t; +# 311 +typedef long ptrdiff_t; +# 314 +typedef __decltype((nullptr)) nullptr_t; +# 317 +#pragma GCC visibility push ( default ) +# 320 +__attribute((__noreturn__, __always_inline__)) inline void +# 321 +__terminate() noexcept +# 322 +{ +# 323 +void terminate() noexcept __attribute((__noreturn__, __cold__)); +# 324 +terminate(); +# 325 +} +#pragma GCC visibility pop +} +# 341 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std { +# 343 +inline namespace __cxx11 __attribute((__abi_tag__("cxx11"))) { } +# 344 +} +# 345 +namespace __gnu_cxx { +# 347 +inline namespace __cxx11 __attribute((__abi_tag__("cxx11"))) { } +# 348 +} +# 534 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std { +# 536 +#pragma GCC visibility push ( default ) +# 541 +__attribute((__always_inline__)) constexpr bool +# 543 +__is_constant_evaluated() noexcept +# 544 +{ +# 550 +return __builtin_is_constant_evaluated(); +# 554 +} +#pragma GCC visibility pop +} +# 573 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std { +# 575 +#pragma GCC visibility push ( default ) +# 577 +__attribute((__noreturn__)) void +# 579 +__glibcxx_assert_fail(const char * __file, int __line, const char * __function, const char * __condition) noexcept; +# 583 +#pragma GCC visibility pop +} +# 604 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std { +# 606 +__attribute((__always_inline__, __visibility__("default"))) inline void +# 608 +__glibcxx_assert_fail() +# 609 +{ } +# 610 +} +# 828 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace __gnu_cxx { +# 830 +typedef __decltype(((0.0bf16))) __bfloat16_t; +# 831 +} +# 34 "/usr/include/stdlib.h" 3 +extern "C" { +# 63 "/usr/include/stdlib.h" 3 +typedef +# 60 +struct { +# 61 +int quot; +# 62 +int rem; +# 63 +} div_t; +# 71 +typedef +# 68 +struct { +# 69 +long quot; +# 70 +long rem; +# 71 +} ldiv_t; +# 81 +__extension__ typedef +# 78 +struct { +# 79 +long long quot; +# 80 +long long rem; +# 81 +} lldiv_t; +# 98 "/usr/include/stdlib.h" 3 +extern size_t __ctype_get_mb_cur_max() noexcept(true); +# 102 +extern double atof(const char * __nptr) noexcept(true) +# 103 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 105 +extern int atoi(const char * __nptr) noexcept(true) +# 106 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 108 +extern long atol(const char * __nptr) noexcept(true) +# 109 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 113 +__extension__ extern long long atoll(const char * __nptr) noexcept(true) +# 114 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 118 +extern double strtod(const char *__restrict__ __nptr, char **__restrict__ __endptr) noexcept(true) +# 120 + __attribute((__nonnull__(1))); +# 124 +extern float strtof(const char *__restrict__ __nptr, char **__restrict__ __endptr) noexcept(true) +# 125 + __attribute((__nonnull__(1))); +# 127 +extern long double strtold(const char *__restrict__ __nptr, char **__restrict__ __endptr) noexcept(true) +# 129 + __attribute((__nonnull__(1))); +# 141 "/usr/include/stdlib.h" 3 +extern _Float32 strtof32(const char *__restrict__ __nptr, char **__restrict__ __endptr) noexcept(true) +# 143 + __attribute((__nonnull__(1))); +# 147 +extern _Float64 strtof64(const char *__restrict__ __nptr, char **__restrict__ __endptr) noexcept(true) +# 149 + __attribute((__nonnull__(1))); +# 153 +extern _Float128 strtof128(const char *__restrict__ __nptr, char **__restrict__ __endptr) noexcept(true) +# 155 + __attribute((__nonnull__(1))); +# 159 +extern _Float32x strtof32x(const char *__restrict__ __nptr, char **__restrict__ __endptr) noexcept(true) +# 161 + __attribute((__nonnull__(1))); +# 165 +extern _Float64x strtof64x(const char *__restrict__ __nptr, char **__restrict__ __endptr) noexcept(true) +# 167 + __attribute((__nonnull__(1))); +# 177 "/usr/include/stdlib.h" 3 +extern long strtol(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtol") +# 179 + __attribute((__nonnull__(1))); +# 181 +extern unsigned long strtoul(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtoul") +# 183 + __attribute((__nonnull__(1))); +# 188 +__extension__ extern long long strtoq(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtoll") +# 190 + __attribute((__nonnull__(1))); +# 193 +__extension__ extern unsigned long long strtouq(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtoull") +# 195 + __attribute((__nonnull__(1))); +# 201 +__extension__ extern long long strtoll(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtoll") +# 203 + __attribute((__nonnull__(1))); +# 206 +__extension__ extern unsigned long long strtoull(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtoull") +# 208 + __attribute((__nonnull__(1))); +# 215 +extern long strtol(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtol") +# 218 + __attribute((__nonnull__(1))); +# 219 +extern unsigned long strtoul(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtoul") +# 223 + __attribute((__nonnull__(1))); +# 226 +__extension__ extern long long strtoq(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtoll") +# 229 + __attribute((__nonnull__(1))); +# 231 +__extension__ extern unsigned long long strtouq(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtoull") +# 235 + __attribute((__nonnull__(1))); +# 238 +__extension__ extern long long strtoll(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtoll") +# 241 + __attribute((__nonnull__(1))); +# 243 +__extension__ extern unsigned long long strtoull(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtoull") +# 247 + __attribute((__nonnull__(1))); +# 278 "/usr/include/stdlib.h" 3 +extern int strfromd(char * __dest, size_t __size, const char * __format, double __f) noexcept(true) +# 280 + __attribute((__nonnull__(3))); +# 282 +extern int strfromf(char * __dest, size_t __size, const char * __format, float __f) noexcept(true) +# 284 + __attribute((__nonnull__(3))); +# 286 +extern int strfroml(char * __dest, size_t __size, const char * __format, long double __f) noexcept(true) +# 288 + __attribute((__nonnull__(3))); +# 298 "/usr/include/stdlib.h" 3 +extern int strfromf32(char * __dest, size_t __size, const char * __format, _Float32 __f) noexcept(true) +# 300 + __attribute((__nonnull__(3))); +# 304 +extern int strfromf64(char * __dest, size_t __size, const char * __format, _Float64 __f) noexcept(true) +# 306 + __attribute((__nonnull__(3))); +# 310 +extern int strfromf128(char * __dest, size_t __size, const char * __format, _Float128 __f) noexcept(true) +# 312 + __attribute((__nonnull__(3))); +# 316 +extern int strfromf32x(char * __dest, size_t __size, const char * __format, _Float32x __f) noexcept(true) +# 318 + __attribute((__nonnull__(3))); +# 322 +extern int strfromf64x(char * __dest, size_t __size, const char * __format, _Float64x __f) noexcept(true) +# 324 + __attribute((__nonnull__(3))); +# 340 "/usr/include/stdlib.h" 3 +extern long strtol_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base, locale_t __loc) noexcept(true) __asm__("__isoc23_strtol_l") +# 342 + __attribute((__nonnull__(1, 4))); +# 344 +extern unsigned long strtoul_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base, locale_t __loc) noexcept(true) __asm__("__isoc23_strtoul_l") +# 347 + __attribute((__nonnull__(1, 4))); +# 350 +__extension__ extern long long strtoll_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base, locale_t __loc) noexcept(true) __asm__("__isoc23_strtoll_l") +# 353 + __attribute((__nonnull__(1, 4))); +# 356 +__extension__ extern unsigned long long strtoull_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base, locale_t __loc) noexcept(true) __asm__("__isoc23_strtoull_l") +# 359 + __attribute((__nonnull__(1, 4))); +# 365 +extern long strtol_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base, locale_t __loc) noexcept(true) __asm__("__isoc23_strtol_l") +# 369 + __attribute((__nonnull__(1, 4))); +# 370 +extern unsigned long strtoul_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base, locale_t __loc) noexcept(true) __asm__("__isoc23_strtoul_l") +# 375 + __attribute((__nonnull__(1, 4))); +# 377 +__extension__ extern long long strtoll_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base, locale_t __loc) noexcept(true) __asm__("__isoc23_strtoll_l") +# 382 + __attribute((__nonnull__(1, 4))); +# 384 +__extension__ extern unsigned long long strtoull_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base, locale_t __loc) noexcept(true) __asm__("__isoc23_strtoull_l") +# 389 + __attribute((__nonnull__(1, 4))); +# 415 "/usr/include/stdlib.h" 3 +extern double strtod_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 417 + __attribute((__nonnull__(1, 3))); +# 419 +extern float strtof_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 421 + __attribute((__nonnull__(1, 3))); +# 423 +extern long double strtold_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 426 + __attribute((__nonnull__(1, 3))); +# 436 "/usr/include/stdlib.h" 3 +extern _Float32 strtof32_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 439 + __attribute((__nonnull__(1, 3))); +# 443 +extern _Float64 strtof64_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 446 + __attribute((__nonnull__(1, 3))); +# 450 +extern _Float128 strtof128_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 453 + __attribute((__nonnull__(1, 3))); +# 457 +extern _Float32x strtof32x_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 460 + __attribute((__nonnull__(1, 3))); +# 464 +extern _Float64x strtof64x_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 467 + __attribute((__nonnull__(1, 3))); +# 505 "/usr/include/stdlib.h" 3 +extern char *l64a(long __n) noexcept(true); +# 508 +extern long a64l(const char * __s) noexcept(true) +# 509 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 27 "/usr/include/sys/types.h" 3 +extern "C" { +# 33 +typedef __u_char u_char; +# 34 +typedef __u_short u_short; +# 35 +typedef __u_int u_int; +# 36 +typedef __u_long u_long; +# 37 +typedef __quad_t quad_t; +# 38 +typedef __u_quad_t u_quad_t; +# 39 +typedef __fsid_t fsid_t; +# 42 +typedef __loff_t loff_t; +# 47 +typedef __ino_t ino_t; +# 54 +typedef __ino64_t ino64_t; +# 59 +typedef __dev_t dev_t; +# 64 +typedef __gid_t gid_t; +# 69 +typedef __mode_t mode_t; +# 74 +typedef __nlink_t nlink_t; +# 79 +typedef __uid_t uid_t; +# 85 +typedef __off_t off_t; +# 92 +typedef __off64_t off64_t; +# 97 +typedef __pid_t pid_t; +# 103 +typedef __id_t id_t; +# 108 +typedef __ssize_t ssize_t; +# 114 +typedef __daddr_t daddr_t; +# 115 +typedef __caddr_t caddr_t; +# 121 +typedef __key_t key_t; +# 7 "/usr/include/bits/types/clock_t.h" 3 +typedef __clock_t clock_t; +# 7 "/usr/include/bits/types/clockid_t.h" 3 +typedef __clockid_t clockid_t; +# 10 "/usr/include/bits/types/time_t.h" 3 +typedef __time_t time_t; +# 7 "/usr/include/bits/types/timer_t.h" 3 +typedef __timer_t timer_t; +# 134 "/usr/include/sys/types.h" 3 +typedef __useconds_t useconds_t; +# 138 +typedef __suseconds_t suseconds_t; +# 148 "/usr/include/sys/types.h" 3 +typedef unsigned long ulong; +# 149 +typedef unsigned short ushort; +# 150 +typedef unsigned uint; +# 24 "/usr/include/bits/stdint-intn.h" 3 +typedef __int8_t int8_t; +# 25 +typedef __int16_t int16_t; +# 26 +typedef __int32_t int32_t; +# 27 +typedef __int64_t int64_t; +# 158 "/usr/include/sys/types.h" 3 +typedef __uint8_t u_int8_t; +# 159 +typedef __uint16_t u_int16_t; +# 160 +typedef __uint32_t u_int32_t; +# 161 +typedef __uint64_t u_int64_t; +# 164 +typedef long register_t __attribute((__mode__(__word__))); +# 34 "/usr/include/bits/byteswap.h" 3 +static inline __uint16_t __bswap_16(__uint16_t __bsx) +# 35 +{ +# 37 +return __builtin_bswap16(__bsx); +# 41 +} +# 49 +static inline __uint32_t __bswap_32(__uint32_t __bsx) +# 50 +{ +# 52 +return __builtin_bswap32(__bsx); +# 56 +} +# 70 "/usr/include/bits/byteswap.h" 3 +__extension__ static inline __uint64_t __bswap_64(__uint64_t __bsx) +# 71 +{ +# 73 +return __builtin_bswap64(__bsx); +# 77 +} +# 33 "/usr/include/bits/uintn-identity.h" 3 +static inline __uint16_t __uint16_identity(__uint16_t __x) +# 34 +{ +# 35 +return __x; +# 36 +} +# 39 +static inline __uint32_t __uint32_identity(__uint32_t __x) +# 40 +{ +# 41 +return __x; +# 42 +} +# 45 +static inline __uint64_t __uint64_identity(__uint64_t __x) +# 46 +{ +# 47 +return __x; +# 48 +} +# 8 "/usr/include/bits/types/__sigset_t.h" 3 +typedef +# 6 +struct { +# 7 +unsigned long __val[(1024) / ((8) * sizeof(unsigned long))]; +# 8 +} __sigset_t; +# 7 "/usr/include/bits/types/sigset_t.h" 3 +typedef __sigset_t sigset_t; +# 8 "/usr/include/bits/types/struct_timeval.h" 3 +struct timeval { +# 14 +__time_t tv_sec; +# 15 +__suseconds_t tv_usec; +# 17 +}; +# 11 "/usr/include/bits/types/struct_timespec.h" 3 +struct timespec { +# 16 +__time_t tv_sec; +# 21 +__syscall_slong_t tv_nsec; +# 31 "/usr/include/bits/types/struct_timespec.h" 3 +}; +# 49 "/usr/include/sys/select.h" 3 +typedef long __fd_mask; +# 70 "/usr/include/sys/select.h" 3 +typedef +# 60 +struct { +# 64 +__fd_mask fds_bits[1024 / (8 * ((int)sizeof(__fd_mask)))]; +# 70 +} fd_set; +# 77 +typedef __fd_mask fd_mask; +# 91 "/usr/include/sys/select.h" 3 +extern "C" { +# 102 "/usr/include/sys/select.h" 3 +extern int select(int __nfds, fd_set *__restrict__ __readfds, fd_set *__restrict__ __writefds, fd_set *__restrict__ __exceptfds, timeval *__restrict__ __timeout); +# 127 "/usr/include/sys/select.h" 3 +extern int pselect(int __nfds, fd_set *__restrict__ __readfds, fd_set *__restrict__ __writefds, fd_set *__restrict__ __exceptfds, const timespec *__restrict__ __timeout, const __sigset_t *__restrict__ __sigmask); +# 153 "/usr/include/sys/select.h" 3 +} +# 185 "/usr/include/sys/types.h" 3 +typedef __blksize_t blksize_t; +# 192 +typedef __blkcnt_t blkcnt_t; +# 196 +typedef __fsblkcnt_t fsblkcnt_t; +# 200 +typedef __fsfilcnt_t fsfilcnt_t; +# 219 "/usr/include/sys/types.h" 3 +typedef __blkcnt64_t blkcnt64_t; +# 220 +typedef __fsblkcnt64_t fsblkcnt64_t; +# 221 +typedef __fsfilcnt64_t fsfilcnt64_t; +# 33 "/usr/include/bits/atomic_wide_counter.h" 3 +typedef +# 26 +union { +# 27 +__extension__ unsigned long long __value64; +# 29 +struct { +# 30 +unsigned __low; +# 31 +unsigned __high; +# 32 +} __value32; +# 33 +} __atomic_wide_counter; +# 55 "/usr/include/bits/thread-shared-types.h" 3 +typedef +# 51 +struct __pthread_internal_list { +# 53 +__pthread_internal_list *__prev; +# 54 +__pthread_internal_list *__next; +# 55 +} __pthread_list_t; +# 60 +typedef +# 57 +struct __pthread_internal_slist { +# 59 +__pthread_internal_slist *__next; +# 60 +} __pthread_slist_t; +# 22 "/usr/include/bits/struct_mutex.h" 3 +struct __pthread_mutex_s { +# 24 +int __lock; +# 25 +unsigned __count; +# 26 +int __owner; +# 28 +unsigned __nusers; +# 32 +int __kind; +# 34 +short __spins; +# 35 +short __elision; +# 36 +__pthread_list_t __list; +# 53 "/usr/include/bits/struct_mutex.h" 3 +}; +# 23 "/usr/include/bits/struct_rwlock.h" 3 +struct __pthread_rwlock_arch_t { +# 25 +unsigned __readers; +# 26 +unsigned __writers; +# 27 +unsigned __wrphase_futex; +# 28 +unsigned __writers_futex; +# 29 +unsigned __pad3; +# 30 +unsigned __pad4; +# 32 +int __cur_writer; +# 33 +int __shared; +# 34 +signed char __rwelision; +# 39 +unsigned char __pad1[7]; +# 42 +unsigned long __pad2; +# 45 +unsigned __flags; +# 55 "/usr/include/bits/struct_rwlock.h" 3 +}; +# 94 "/usr/include/bits/thread-shared-types.h" 3 +struct __pthread_cond_s { +# 96 +__atomic_wide_counter __wseq; +# 97 +__atomic_wide_counter __g1_start; +# 98 +unsigned __g_size[2]; +# 99 +unsigned __g1_orig_size; +# 100 +unsigned __wrefs; +# 101 +unsigned __g_signals[2]; +# 102 +unsigned __unused_initialized_1; +# 103 +unsigned __unused_initialized_2; +# 104 +}; +# 106 +typedef unsigned __tss_t; +# 107 +typedef unsigned long __thrd_t; +# 112 +typedef +# 110 +struct { +# 111 +int __data; +# 112 +} __once_flag; +# 27 "/usr/include/bits/pthreadtypes.h" 3 +typedef unsigned long pthread_t; +# 36 +typedef +# 33 +union { +# 34 +char __size[4]; +# 35 +int __align; +# 36 +} pthread_mutexattr_t; +# 45 +typedef +# 42 +union { +# 43 +char __size[4]; +# 44 +int __align; +# 45 +} pthread_condattr_t; +# 49 +typedef unsigned pthread_key_t; +# 53 +typedef int pthread_once_t; +# 56 +union pthread_attr_t { +# 58 +char __size[56]; +# 59 +long __align; +# 60 +}; +# 62 +typedef pthread_attr_t pthread_attr_t; +# 72 +typedef +# 68 +union { +# 69 +__pthread_mutex_s __data; +# 70 +char __size[40]; +# 71 +long __align; +# 72 +} pthread_mutex_t; +# 80 +typedef +# 76 +union { +# 77 +__pthread_cond_s __data; +# 78 +char __size[48]; +# 79 +__extension__ long long __align; +# 80 +} pthread_cond_t; +# 91 +typedef +# 87 +union { +# 88 +__pthread_rwlock_arch_t __data; +# 89 +char __size[56]; +# 90 +long __align; +# 91 +} pthread_rwlock_t; +# 97 +typedef +# 94 +union { +# 95 +char __size[8]; +# 96 +long __align; +# 97 +} pthread_rwlockattr_t; +# 103 +typedef volatile int pthread_spinlock_t; +# 112 +typedef +# 109 +union { +# 110 +char __size[32]; +# 111 +long __align; +# 112 +} pthread_barrier_t; +# 118 +typedef +# 115 +union { +# 116 +char __size[4]; +# 117 +int __align; +# 118 +} pthread_barrierattr_t; +# 230 "/usr/include/sys/types.h" 3 +} +# 521 "/usr/include/stdlib.h" 3 +extern long random() noexcept(true); +# 524 +extern void srandom(unsigned __seed) noexcept(true); +# 530 +extern char *initstate(unsigned __seed, char * __statebuf, size_t __statelen) noexcept(true) +# 531 + __attribute((__nonnull__(2))); +# 535 +extern char *setstate(char * __statebuf) noexcept(true) __attribute((__nonnull__(1))); +# 543 +struct random_data { +# 545 +int32_t *fptr; +# 546 +int32_t *rptr; +# 547 +int32_t *state; +# 548 +int rand_type; +# 549 +int rand_deg; +# 550 +int rand_sep; +# 551 +int32_t *end_ptr; +# 552 +}; +# 554 +extern int random_r(random_data *__restrict__ __buf, int32_t *__restrict__ __result) noexcept(true) +# 555 + __attribute((__nonnull__(1, 2))); +# 557 +extern int srandom_r(unsigned __seed, random_data * __buf) noexcept(true) +# 558 + __attribute((__nonnull__(2))); +# 560 +extern int initstate_r(unsigned __seed, char *__restrict__ __statebuf, size_t __statelen, random_data *__restrict__ __buf) noexcept(true) +# 563 + __attribute((__nonnull__(2, 4))); +# 565 +extern int setstate_r(char *__restrict__ __statebuf, random_data *__restrict__ __buf) noexcept(true) +# 567 + __attribute((__nonnull__(1, 2))); +# 573 +extern int rand() noexcept(true); +# 575 +extern void srand(unsigned __seed) noexcept(true); +# 579 +extern int rand_r(unsigned * __seed) noexcept(true); +# 587 +extern double drand48() noexcept(true); +# 588 +extern double erand48(unsigned short __xsubi[3]) noexcept(true) __attribute((__nonnull__(1))); +# 591 +extern long lrand48() noexcept(true); +# 592 +extern long nrand48(unsigned short __xsubi[3]) noexcept(true) +# 593 + __attribute((__nonnull__(1))); +# 596 +extern long mrand48() noexcept(true); +# 597 +extern long jrand48(unsigned short __xsubi[3]) noexcept(true) +# 598 + __attribute((__nonnull__(1))); +# 601 +extern void srand48(long __seedval) noexcept(true); +# 602 +extern unsigned short *seed48(unsigned short __seed16v[3]) noexcept(true) +# 603 + __attribute((__nonnull__(1))); +# 604 +extern void lcong48(unsigned short __param[7]) noexcept(true) __attribute((__nonnull__(1))); +# 610 +struct drand48_data { +# 612 +unsigned short __x[3]; +# 613 +unsigned short __old_x[3]; +# 614 +unsigned short __c; +# 615 +unsigned short __init; +# 616 +__extension__ unsigned long long __a; +# 618 +}; +# 621 +extern int drand48_r(drand48_data *__restrict__ __buffer, double *__restrict__ __result) noexcept(true) +# 622 + __attribute((__nonnull__(1, 2))); +# 623 +extern int erand48_r(unsigned short __xsubi[3], drand48_data *__restrict__ __buffer, double *__restrict__ __result) noexcept(true) +# 625 + __attribute((__nonnull__(1, 2))); +# 628 +extern int lrand48_r(drand48_data *__restrict__ __buffer, long *__restrict__ __result) noexcept(true) +# 630 + __attribute((__nonnull__(1, 2))); +# 631 +extern int nrand48_r(unsigned short __xsubi[3], drand48_data *__restrict__ __buffer, long *__restrict__ __result) noexcept(true) +# 634 + __attribute((__nonnull__(1, 2))); +# 637 +extern int mrand48_r(drand48_data *__restrict__ __buffer, long *__restrict__ __result) noexcept(true) +# 639 + __attribute((__nonnull__(1, 2))); +# 640 +extern int jrand48_r(unsigned short __xsubi[3], drand48_data *__restrict__ __buffer, long *__restrict__ __result) noexcept(true) +# 643 + __attribute((__nonnull__(1, 2))); +# 646 +extern int srand48_r(long __seedval, drand48_data * __buffer) noexcept(true) +# 647 + __attribute((__nonnull__(2))); +# 649 +extern int seed48_r(unsigned short __seed16v[3], drand48_data * __buffer) noexcept(true) +# 650 + __attribute((__nonnull__(1, 2))); +# 652 +extern int lcong48_r(unsigned short __param[7], drand48_data * __buffer) noexcept(true) +# 654 + __attribute((__nonnull__(1, 2))); +# 657 +extern __uint32_t arc4random() noexcept(true); +# 661 +extern void arc4random_buf(void * __buf, size_t __size) noexcept(true) +# 662 + __attribute((__nonnull__(1))); +# 666 +extern __uint32_t arc4random_uniform(__uint32_t __upper_bound) noexcept(true); +# 672 +extern void *malloc(size_t __size) noexcept(true) __attribute((__malloc__)) +# 673 + __attribute((__alloc_size__(1))); +# 675 +extern void *calloc(size_t __nmemb, size_t __size) noexcept(true) +# 676 + __attribute((__malloc__)) __attribute((__alloc_size__(1, 2))); +# 683 +extern void *realloc(void * __ptr, size_t __size) noexcept(true) +# 684 + __attribute((__warn_unused_result__)) __attribute((__alloc_size__(2))); +# 687 +extern void free(void * __ptr) noexcept(true); +# 695 +extern void *reallocarray(void * __ptr, size_t __nmemb, size_t __size) noexcept(true) +# 696 + __attribute((__warn_unused_result__)) +# 697 + __attribute((__alloc_size__(2, 3))) +# 698 + __attribute((__malloc__(__builtin_free, 1))); +# 701 +extern void *reallocarray(void * __ptr, size_t __nmemb, size_t __size) noexcept(true) +# 702 + __attribute((__malloc__(reallocarray, 1))); +# 26 "/usr/include/alloca.h" 3 +extern "C" { +# 32 +extern void *alloca(size_t __size) noexcept(true); +# 38 +} +# 712 "/usr/include/stdlib.h" 3 +extern void *valloc(size_t __size) noexcept(true) __attribute((__malloc__)) +# 713 + __attribute((__alloc_size__(1))); +# 718 +extern int posix_memalign(void ** __memptr, size_t __alignment, size_t __size) noexcept(true) +# 719 + __attribute((__nonnull__(1))); +# 724 +extern void *aligned_alloc(size_t __alignment, size_t __size) noexcept(true) +# 725 + __attribute((__malloc__)) __attribute((__alloc_align__(1 ))) +# 726 + __attribute((__alloc_size__(2))); +# 730 +extern void abort() noexcept(true) __attribute((__noreturn__)) __attribute((__cold__)); +# 734 +extern int atexit(void (* __func)(void)) noexcept(true) __attribute((__nonnull__(1))); +# 739 +extern "C++" int at_quick_exit(void (* __func)(void)) noexcept(true) __asm__("at_quick_exit") +# 740 + __attribute((__nonnull__(1))); +# 749 "/usr/include/stdlib.h" 3 +extern int on_exit(void (* __func)(int __status, void * __arg), void * __arg) noexcept(true) +# 750 + __attribute((__nonnull__(1))); +# 756 +extern void exit(int __status) noexcept(true) __attribute((__noreturn__)); +# 762 +extern void quick_exit(int __status) noexcept(true) __attribute((__noreturn__)); +# 768 +extern void _Exit(int __status) noexcept(true) __attribute((__noreturn__)); +# 773 +extern char *getenv(const char * __name) noexcept(true) __attribute((__nonnull__(1))); +# 778 +extern char *secure_getenv(const char * __name) noexcept(true) +# 779 + __attribute((__nonnull__(1))); +# 786 +extern int putenv(char * __string) noexcept(true) __attribute((__nonnull__(1))); +# 792 +extern int setenv(const char * __name, const char * __value, int __replace) noexcept(true) +# 793 + __attribute((__nonnull__(2))); +# 796 +extern int unsetenv(const char * __name) noexcept(true) __attribute((__nonnull__(1))); +# 803 +extern int clearenv() noexcept(true); +# 814 "/usr/include/stdlib.h" 3 +extern char *mktemp(char * __template) noexcept(true) __attribute((__nonnull__(1))); +# 827 "/usr/include/stdlib.h" 3 +extern int mkstemp(char * __template) __attribute((__nonnull__(1))); +# 837 "/usr/include/stdlib.h" 3 +extern int mkstemp64(char * __template) __attribute((__nonnull__(1))); +# 849 "/usr/include/stdlib.h" 3 +extern int mkstemps(char * __template, int __suffixlen) __attribute((__nonnull__(1))); +# 859 "/usr/include/stdlib.h" 3 +extern int mkstemps64(char * __template, int __suffixlen) +# 860 + __attribute((__nonnull__(1))); +# 870 "/usr/include/stdlib.h" 3 +extern char *mkdtemp(char * __template) noexcept(true) __attribute((__nonnull__(1))); +# 881 "/usr/include/stdlib.h" 3 +extern int mkostemp(char * __template, int __flags) __attribute((__nonnull__(1))); +# 891 "/usr/include/stdlib.h" 3 +extern int mkostemp64(char * __template, int __flags) __attribute((__nonnull__(1))); +# 901 "/usr/include/stdlib.h" 3 +extern int mkostemps(char * __template, int __suffixlen, int __flags) +# 902 + __attribute((__nonnull__(1))); +# 913 "/usr/include/stdlib.h" 3 +extern int mkostemps64(char * __template, int __suffixlen, int __flags) +# 914 + __attribute((__nonnull__(1))); +# 923 "/usr/include/stdlib.h" 3 +extern int system(const char * __command); +# 929 +extern char *canonicalize_file_name(const char * __name) noexcept(true) +# 930 + __attribute((__nonnull__(1))) __attribute((__malloc__)) +# 931 + __attribute((__malloc__(__builtin_free, 1))); +# 940 "/usr/include/stdlib.h" 3 +extern char *realpath(const char *__restrict__ __name, char *__restrict__ __resolved) noexcept(true); +# 948 +typedef int (*__compar_fn_t)(const void *, const void *); +# 951 +typedef __compar_fn_t comparison_fn_t; +# 955 +typedef int (*__compar_d_fn_t)(const void *, const void *, void *); +# 960 +extern void *bsearch(const void * __key, const void * __base, size_t __nmemb, size_t __size, __compar_fn_t __compar) +# 962 + __attribute((__nonnull__(1, 2, 5))); +# 970 +extern void qsort(void * __base, size_t __nmemb, size_t __size, __compar_fn_t __compar) +# 971 + __attribute((__nonnull__(1, 4))); +# 973 +extern void qsort_r(void * __base, size_t __nmemb, size_t __size, __compar_d_fn_t __compar, void * __arg) +# 975 + __attribute((__nonnull__(1, 4))); +# 980 +extern int abs(int __x) noexcept(true) __attribute((const)); +# 981 +extern long labs(long __x) noexcept(true) __attribute((const)); +# 984 +__extension__ extern long long llabs(long long __x) noexcept(true) +# 985 + __attribute((const)); +# 992 +extern div_t div(int __numer, int __denom) noexcept(true) +# 993 + __attribute((const)); +# 994 +extern ldiv_t ldiv(long __numer, long __denom) noexcept(true) +# 995 + __attribute((const)); +# 998 +__extension__ extern lldiv_t lldiv(long long __numer, long long __denom) noexcept(true) +# 1000 + __attribute((const)); +# 1012 "/usr/include/stdlib.h" 3 +extern char *ecvt(double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign) noexcept(true) +# 1013 + __attribute((__nonnull__(3, 4))); +# 1018 +extern char *fcvt(double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign) noexcept(true) +# 1019 + __attribute((__nonnull__(3, 4))); +# 1024 +extern char *gcvt(double __value, int __ndigit, char * __buf) noexcept(true) +# 1025 + __attribute((__nonnull__(3))); +# 1030 +extern char *qecvt(long double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign) noexcept(true) +# 1032 + __attribute((__nonnull__(3, 4))); +# 1033 +extern char *qfcvt(long double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign) noexcept(true) +# 1035 + __attribute((__nonnull__(3, 4))); +# 1036 +extern char *qgcvt(long double __value, int __ndigit, char * __buf) noexcept(true) +# 1037 + __attribute((__nonnull__(3))); +# 1042 +extern int ecvt_r(double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign, char *__restrict__ __buf, size_t __len) noexcept(true) +# 1044 + __attribute((__nonnull__(3, 4, 5))); +# 1045 +extern int fcvt_r(double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign, char *__restrict__ __buf, size_t __len) noexcept(true) +# 1047 + __attribute((__nonnull__(3, 4, 5))); +# 1049 +extern int qecvt_r(long double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign, char *__restrict__ __buf, size_t __len) noexcept(true) +# 1052 + __attribute((__nonnull__(3, 4, 5))); +# 1053 +extern int qfcvt_r(long double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign, char *__restrict__ __buf, size_t __len) noexcept(true) +# 1056 + __attribute((__nonnull__(3, 4, 5))); +# 1062 +extern int mblen(const char * __s, size_t __n) noexcept(true); +# 1065 +extern int mbtowc(wchar_t *__restrict__ __pwc, const char *__restrict__ __s, size_t __n) noexcept(true); +# 1069 +extern int wctomb(char * __s, wchar_t __wchar) noexcept(true); +# 1073 +extern size_t mbstowcs(wchar_t *__restrict__ __pwcs, const char *__restrict__ __s, size_t __n) noexcept(true) +# 1075 + __attribute((__access__(__read_only__ , 2 ))); +# 1077 +extern size_t wcstombs(char *__restrict__ __s, const wchar_t *__restrict__ __pwcs, size_t __n) noexcept(true) +# 1080 + __attribute((__access__(__write_only__ , 1 , 3 ))) +# 1081 + __attribute((__access__(__read_only__ , 2 ))); +# 1088 +extern int rpmatch(const char * __response) noexcept(true) __attribute((__nonnull__(1))); +# 1099 "/usr/include/stdlib.h" 3 +extern int getsubopt(char **__restrict__ __optionp, char *const *__restrict__ __tokens, char **__restrict__ __valuep) noexcept(true) +# 1102 + __attribute((__nonnull__(1, 2, 3))); +# 1110 +extern int posix_openpt(int __oflag); +# 1118 +extern int grantpt(int __fd) noexcept(true); +# 1122 +extern int unlockpt(int __fd) noexcept(true); +# 1127 +extern char *ptsname(int __fd) noexcept(true); +# 1134 +extern int ptsname_r(int __fd, char * __buf, size_t __buflen) noexcept(true) +# 1135 + __attribute((__nonnull__(2))) __attribute((__access__(__write_only__ , 2 , 3 ))); +# 1138 +extern int getpt(); +# 1145 +extern int getloadavg(double __loadavg[], int __nelem) noexcept(true) +# 1146 + __attribute((__nonnull__(1))); +# 1167 "/usr/include/stdlib.h" 3 +} +# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 +extern "C++" { +# 48 +namespace std __attribute((__visibility__("default"))) { +# 52 +using ::abs; +# 56 +inline long abs(long __i) { return __builtin_labs(__i); } +# 61 +inline long long abs(long long __x) { return __builtin_llabs(__x); } +# 71 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 +constexpr double abs(double __x) +# 72 +{ return __builtin_fabs(__x); } +# 75 +constexpr float abs(float __x) +# 76 +{ return __builtin_fabsf(__x); } +# 79 +constexpr long double abs(long double __x) +# 80 +{ return __builtin_fabsl(__x); } +# 85 +__extension__ constexpr __int128 abs(__int128 __x) { return (__x >= (0)) ? __x : (-__x); } +# 137 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 +__extension__ constexpr __float128 abs(__float128 __x) +# 138 +{ +# 142 +return __builtin_fabsf128(__x); +# 147 +} +# 151 +} +# 152 +} +# 125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +extern "C++" { +# 127 +namespace std __attribute((__visibility__("default"))) { +# 131 +using ::div_t; +# 132 +using ::ldiv_t; +# 134 +using ::abort; +# 136 +using ::aligned_alloc; +# 138 +using ::atexit; +# 141 +using ::at_quick_exit; +# 144 +using ::atof; +# 145 +using ::atoi; +# 146 +using ::atol; +# 147 +using ::bsearch; +# 148 +using ::calloc; +# 149 +using ::div; +# 150 +using ::exit; +# 151 +using ::free; +# 152 +using ::getenv; +# 153 +using ::labs; +# 154 +using ::ldiv; +# 155 +using ::malloc; +# 157 +using ::mblen; +# 158 +using ::mbstowcs; +# 159 +using ::mbtowc; +# 161 +using ::qsort; +# 164 +using ::quick_exit; +# 167 +using ::rand; +# 168 +using ::realloc; +# 169 +using ::srand; +# 170 +using ::strtod; +# 171 +using ::strtol; +# 172 +using ::strtoul; +# 173 +using ::system; +# 175 +using ::wcstombs; +# 176 +using ::wctomb; +# 181 +inline ldiv_t div(long __i, long __j) noexcept { return ldiv(__i, __j); } +# 186 +} +# 199 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +namespace __gnu_cxx __attribute((__visibility__("default"))) { +# 204 +using ::lldiv_t; +# 210 +using ::_Exit; +# 214 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wlong-long" +using ::llabs; +# 219 +inline lldiv_t div(long long __n, long long __d) +# 220 +{ lldiv_t __q; (__q.quot) = (__n / __d); (__q.rem) = (__n % __d); return __q; } +# 222 +using ::lldiv; +#pragma GCC diagnostic pop +# 234 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +using ::atoll; +# 235 +using ::strtoll; +# 236 +using ::strtoull; +# 238 +using ::strtof; +# 239 +using ::strtold; +# 242 +} +# 244 +namespace std { +# 247 +using __gnu_cxx::lldiv_t; +# 249 +using __gnu_cxx::_Exit; +# 251 +using __gnu_cxx::llabs; +# 252 +using __gnu_cxx::div; +# 253 +using __gnu_cxx::lldiv; +# 255 +using __gnu_cxx::atoll; +# 256 +using __gnu_cxx::strtof; +# 257 +using __gnu_cxx::strtoll; +# 258 +using __gnu_cxx::strtoull; +# 259 +using __gnu_cxx::strtold; +# 260 +} +# 278 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +} +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h" 3 +using std::abort; +# 39 +using std::atexit; +# 40 +using std::exit; +# 43 +using std::at_quick_exit; +# 46 +using std::quick_exit; +# 49 +using std::_Exit; +# 57 +using std::abs; +# 58 +using std::atof; +# 59 +using std::atoi; +# 60 +using std::atol; +# 61 +using std::bsearch; +# 62 +using std::calloc; +# 63 +using std::div; +# 64 +using std::free; +# 65 +using std::getenv; +# 66 +using std::labs; +# 67 +using std::ldiv; +# 68 +using std::malloc; +# 70 +using std::mblen; +# 71 +using std::mbstowcs; +# 72 +using std::mbtowc; +# 74 +using std::qsort; +# 75 +using std::rand; +# 76 +using std::realloc; +# 77 +using std::srand; +# 78 +using std::strtod; +# 79 +using std::strtol; +# 80 +using std::strtoul; +# 81 +using std::system; +# 83 +using std::wcstombs; +# 84 +using std::wctomb; +# 184 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern "C" { +# 191 +__attribute__((unused)) extern cudaError_t __cudaDeviceSynchronizeDeprecationAvoidance(); +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) extern cudaError_t __cudaCDP2DeviceGetAttribute(int * value, cudaDeviceAttr attr, int device); +# 245 +__attribute__((unused)) extern cudaError_t __cudaCDP2DeviceGetLimit(size_t * pValue, cudaLimit limit); +# 246 +__attribute__((unused)) extern cudaError_t __cudaCDP2DeviceGetCacheConfig(cudaFuncCache * pCacheConfig); +# 247 +__attribute__((unused)) extern cudaError_t __cudaCDP2DeviceGetSharedMemConfig(cudaSharedMemConfig * pConfig); +# 248 +__attribute__((unused)) extern cudaError_t __cudaCDP2GetLastError(); +# 249 +__attribute__((unused)) extern cudaError_t __cudaCDP2PeekAtLastError(); +# 250 +__attribute__((unused)) extern const char *__cudaCDP2GetErrorString(cudaError_t error); +# 251 +__attribute__((unused)) extern const char *__cudaCDP2GetErrorName(cudaError_t error); +# 252 +__attribute__((unused)) extern cudaError_t __cudaCDP2GetDeviceCount(int * count); +# 253 +__attribute__((unused)) extern cudaError_t __cudaCDP2GetDevice(int * device); +# 254 +__attribute__((unused)) extern cudaError_t __cudaCDP2StreamCreateWithFlags(cudaStream_t * pStream, unsigned flags); +# 255 +__attribute__((unused)) extern cudaError_t __cudaCDP2StreamDestroy(cudaStream_t stream); +# 256 +__attribute__((unused)) extern cudaError_t __cudaCDP2StreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned flags); +# 257 +__attribute__((unused)) extern cudaError_t __cudaCDP2StreamWaitEvent_ptsz(cudaStream_t stream, cudaEvent_t event, unsigned flags); +# 258 +__attribute__((unused)) extern cudaError_t __cudaCDP2EventCreateWithFlags(cudaEvent_t * event, unsigned flags); +# 259 +__attribute__((unused)) extern cudaError_t __cudaCDP2EventRecord(cudaEvent_t event, cudaStream_t stream); +# 260 +__attribute__((unused)) extern cudaError_t __cudaCDP2EventRecord_ptsz(cudaEvent_t event, cudaStream_t stream); +# 261 +__attribute__((unused)) extern cudaError_t __cudaCDP2EventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned flags); +# 262 +__attribute__((unused)) extern cudaError_t __cudaCDP2EventRecordWithFlags_ptsz(cudaEvent_t event, cudaStream_t stream, unsigned flags); +# 263 +__attribute__((unused)) extern cudaError_t __cudaCDP2EventDestroy(cudaEvent_t event); +# 264 +__attribute__((unused)) extern cudaError_t __cudaCDP2FuncGetAttributes(cudaFuncAttributes * attr, const void * func); +# 265 +__attribute__((unused)) extern cudaError_t __cudaCDP2Free(void * devPtr); +# 266 +__attribute__((unused)) extern cudaError_t __cudaCDP2Malloc(void ** devPtr, size_t size); +# 267 +__attribute__((unused)) extern cudaError_t __cudaCDP2MemcpyAsync(void * dst, const void * src, size_t count, cudaMemcpyKind kind, cudaStream_t stream); +# 268 +__attribute__((unused)) extern cudaError_t __cudaCDP2MemcpyAsync_ptsz(void * dst, const void * src, size_t count, cudaMemcpyKind kind, cudaStream_t stream); +# 269 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memcpy2DAsync(void * dst, size_t dpitch, const void * src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream); +# 270 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memcpy2DAsync_ptsz(void * dst, size_t dpitch, const void * src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream); +# 271 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memcpy3DAsync(const cudaMemcpy3DParms * p, cudaStream_t stream); +# 272 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memcpy3DAsync_ptsz(const cudaMemcpy3DParms * p, cudaStream_t stream); +# 273 +__attribute__((unused)) extern cudaError_t __cudaCDP2MemsetAsync(void * devPtr, int value, size_t count, cudaStream_t stream); +# 274 +__attribute__((unused)) extern cudaError_t __cudaCDP2MemsetAsync_ptsz(void * devPtr, int value, size_t count, cudaStream_t stream); +# 275 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memset2DAsync(void * devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream); +# 276 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memset2DAsync_ptsz(void * devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream); +# 277 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream); +# 278 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memset3DAsync_ptsz(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream); +# 279 +__attribute__((unused)) extern cudaError_t __cudaCDP2RuntimeGetVersion(int * runtimeVersion); +# 280 +__attribute__((unused)) extern void *__cudaCDP2GetParameterBuffer(size_t alignment, size_t size); +# 281 +__attribute__((unused)) extern void *__cudaCDP2GetParameterBufferV2(void * func, dim3 gridDimension, dim3 blockDimension, unsigned sharedMemSize); +# 282 +__attribute__((unused)) extern cudaError_t __cudaCDP2LaunchDevice_ptsz(void * func, void * parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned sharedMemSize, cudaStream_t stream); +# 283 +__attribute__((unused)) extern cudaError_t __cudaCDP2LaunchDeviceV2_ptsz(void * parameterBuffer, cudaStream_t stream); +# 284 +__attribute__((unused)) extern cudaError_t __cudaCDP2LaunchDevice(void * func, void * parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned sharedMemSize, cudaStream_t stream); +# 285 +__attribute__((unused)) extern cudaError_t __cudaCDP2LaunchDeviceV2(void * parameterBuffer, cudaStream_t stream); +# 286 +__attribute__((unused)) extern cudaError_t __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessor(int * numBlocks, const void * func, int blockSize, size_t dynamicSmemSize); +# 287 +__attribute__((unused)) extern cudaError_t __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int * numBlocks, const void * func, int blockSize, size_t dynamicSmemSize, unsigned flags); +# 290 +extern cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream); +# 311 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline cudaGraphExec_t cudaGetCurrentGraphExec() +# 312 +{int volatile ___ = 1; +# 316 +::exit(___);} +#if 0 +# 312 +{ +# 313 +unsigned long long current_graph_exec; +# 314 +__asm__("mov.u64 %0, %%current_graph_exec;" : "=l" (current_graph_exec) :); +# 315 +return (cudaGraphExec_t)current_graph_exec; +# 316 +} +#endif +# 346 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) extern cudaError_t cudaGraphKernelNodeSetParam(cudaGraphDeviceNode_t node, size_t offset, const void * value, size_t size); +# 374 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) extern cudaError_t cudaGraphKernelNodeSetEnabled(cudaGraphDeviceNode_t node, bool enable); +# 401 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) extern cudaError_t cudaGraphKernelNodeSetGridDim(cudaGraphDeviceNode_t node, dim3 gridDim); +# 430 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) extern cudaError_t cudaGraphKernelNodeUpdatesApply(const cudaGraphKernelNodeUpdate * updates, size_t updateCount); +# 448 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline void cudaTriggerProgrammaticLaunchCompletion() +# 449 +{int volatile ___ = 1; +# 451 +::exit(___);} +#if 0 +# 449 +{ +# 450 +__asm__ volatile("griddepcontrol.launch_dependents;" : :); +# 451 +} +#endif +# 464 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline void cudaGridDependencySynchronize() +# 465 +{int volatile ___ = 1; +# 467 +::exit(___);} +#if 0 +# 465 +{ +# 466 +__asm__ volatile("griddepcontrol.wait;" : : : "memory"); +# 467 +} +#endif +# 479 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) extern void cudaGraphSetConditional(cudaGraphConditionalHandle handle, unsigned value); +# 482 +__attribute__((unused)) extern unsigned long long cudaCGGetIntrinsicHandle(cudaCGScope scope); +# 483 +__attribute__((unused)) extern cudaError_t cudaCGSynchronize(unsigned long long handle, unsigned flags); +# 484 +__attribute__((unused)) extern cudaError_t cudaCGSynchronizeGrid(unsigned long long handle, unsigned flags); +# 485 +__attribute__((unused)) extern cudaError_t cudaCGGetSize(unsigned * numThreads, unsigned * numGrids, unsigned long long handle); +# 486 +__attribute__((unused)) extern cudaError_t cudaCGGetRank(unsigned * threadRank, unsigned * gridRank, unsigned long long handle); +# 714 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline void *cudaGetParameterBuffer(size_t alignment, size_t size) +# 715 +{int volatile ___ = 1;(void)alignment;(void)size; +# 717 +::exit(___);} +#if 0 +# 715 +{ +# 716 +return __cudaCDP2GetParameterBuffer(alignment, size); +# 717 +} +#endif +# 724 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline void *cudaGetParameterBufferV2(void *func, dim3 gridDimension, dim3 blockDimension, unsigned sharedMemSize) +# 725 +{int volatile ___ = 1;(void)func;(void)gridDimension;(void)blockDimension;(void)sharedMemSize; +# 727 +::exit(___);} +#if 0 +# 725 +{ +# 726 +return __cudaCDP2GetParameterBufferV2(func, gridDimension, blockDimension, sharedMemSize); +# 727 +} +#endif +# 734 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline cudaError_t cudaLaunchDevice_ptsz(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned sharedMemSize, cudaStream_t stream) +# 735 +{int volatile ___ = 1;(void)func;(void)parameterBuffer;(void)gridDimension;(void)blockDimension;(void)sharedMemSize;(void)stream; +# 737 +::exit(___);} +#if 0 +# 735 +{ +# 736 +return __cudaCDP2LaunchDevice_ptsz(func, parameterBuffer, gridDimension, blockDimension, sharedMemSize, stream); +# 737 +} +#endif +# 739 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline cudaError_t cudaLaunchDeviceV2_ptsz(void *parameterBuffer, cudaStream_t stream) +# 740 +{int volatile ___ = 1;(void)parameterBuffer;(void)stream; +# 742 +::exit(___);} +#if 0 +# 740 +{ +# 741 +return __cudaCDP2LaunchDeviceV2_ptsz(parameterBuffer, stream); +# 742 +} +#endif +# 800 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline cudaError_t cudaLaunchDevice(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned sharedMemSize, cudaStream_t stream) +# 801 +{int volatile ___ = 1;(void)func;(void)parameterBuffer;(void)gridDimension;(void)blockDimension;(void)sharedMemSize;(void)stream; +# 803 +::exit(___);} +#if 0 +# 801 +{ +# 802 +return __cudaCDP2LaunchDevice(func, parameterBuffer, gridDimension, blockDimension, sharedMemSize, stream); +# 803 +} +#endif +# 805 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline cudaError_t cudaLaunchDeviceV2(void *parameterBuffer, cudaStream_t stream) +# 806 +{int volatile ___ = 1;(void)parameterBuffer;(void)stream; +# 808 +::exit(___);} +#if 0 +# 806 +{ +# 807 +return __cudaCDP2LaunchDeviceV2(parameterBuffer, stream); +# 808 +} +#endif +# 862 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +} +# 868 +template< class T> static inline cudaError_t cudaMalloc(T ** devPtr, size_t size); +# 869 +template< class T> static inline cudaError_t cudaFuncGetAttributes(cudaFuncAttributes * attr, T * entry); +# 870 +template< class T> static inline cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int * numBlocks, T func, int blockSize, size_t dynamicSmemSize); +# 871 +template< class T> static inline cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int * numBlocks, T func, int blockSize, size_t dynamicSmemSize, unsigned flags); +# 901 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +template< class T> __attribute__((unused)) static inline cudaError_t +# 902 +cudaGraphKernelNodeSetParam(cudaGraphDeviceNode_t node, size_t offset, const T &value) +# 903 +{int volatile ___ = 1;(void)node;(void)offset;(void)value; +# 905 +::exit(___);} +#if 0 +# 903 +{ +# 904 +return cudaGraphKernelNodeSetParam(node, offset, &value, sizeof(T)); +# 905 +} +#endif +# 287 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern "C" { +# 334 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceReset(); +# 356 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceSynchronize(); +# 442 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceSetLimit(cudaLimit limit, size_t value); +# 478 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetLimit(size_t * pValue, cudaLimit limit); +# 501 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t * maxWidthInElements, const cudaChannelFormatDesc * fmtDesc, int device); +# 535 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetCacheConfig(cudaFuncCache * pCacheConfig); +# 572 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetStreamPriorityRange(int * leastPriority, int * greatestPriority); +# 616 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig); +# 643 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetByPCIBusId(int * device, const char * pciBusId); +# 673 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetPCIBusId(char * pciBusId, int len, int device); +# 724 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t * handle, cudaEvent_t event); +# 768 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaIpcOpenEventHandle(cudaEvent_t * event, cudaIpcEventHandle_t handle); +# 813 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t * handle, void * devPtr); +# 880 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaIpcOpenMemHandle(void ** devPtr, cudaIpcMemHandle_t handle, unsigned flags); +# 919 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaIpcCloseMemHandle(void * devPtr); +# 951 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope); +# 989 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void * userData, cudaAsyncCallbackHandle_t * callback); +# 1012 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback); +# 1059 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaDeviceGetSharedMemConfig(cudaSharedMemConfig * pConfig); +# 1105 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config); +# 1146 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaThreadExit(); +# 1172 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaThreadSynchronize(); +# 1221 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaThreadSetLimit(cudaLimit limit, size_t value); +# 1254 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaThreadGetLimit(size_t * pValue, cudaLimit limit); +# 1290 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaThreadGetCacheConfig(cudaFuncCache * pCacheConfig); +# 1337 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaThreadSetCacheConfig(cudaFuncCache cacheConfig); +# 1402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetLastError(); +# 1453 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaPeekAtLastError(); +# 1469 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern const char *cudaGetErrorName(cudaError_t error); +# 1485 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern const char *cudaGetErrorString(cudaError_t error); +# 1514 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetDeviceCount(int * count); +# 1818 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetDeviceProperties_v2(cudaDeviceProp * prop, int device); +# 2024 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetAttribute(int * value, cudaDeviceAttr attr, int device); +# 2042 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t * memPool, int device); +# 2066 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool); +# 2086 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetMemPool(cudaMemPool_t * memPool, int device); +# 2148 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetNvSciSyncAttributes(void * nvSciSyncAttrList, int device, int flags); +# 2188 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetP2PAttribute(int * value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice); +# 2210 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaChooseDevice(int * device, const cudaDeviceProp * prop); +# 2239 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaInitDevice(int device, unsigned deviceFlags, unsigned flags); +# 2285 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaSetDevice(int device); +# 2307 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetDevice(int * device); +# 2338 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaSetValidDevices(int * device_arr, int len); +# 2408 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaSetDeviceFlags(unsigned flags); +# 2453 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetDeviceFlags(unsigned * flags); +# 2497 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamCreate(cudaStream_t * pStream); +# 2533 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamCreateWithFlags(cudaStream_t * pStream, unsigned flags); +# 2585 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamCreateWithPriority(cudaStream_t * pStream, unsigned flags, int priority); +# 2613 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int * priority); +# 2639 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned * flags); +# 2676 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamGetId(cudaStream_t hStream, unsigned long long * streamId); +# 2702 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamGetDevice(cudaStream_t hStream, int * device); +# 2717 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaCtxResetPersistingL2Cache(); +# 2737 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src); +# 2758 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamGetAttribute(cudaStream_t hStream, cudaLaunchAttributeID attr, cudaLaunchAttributeValue * value_out); +# 2782 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamSetAttribute(cudaStream_t hStream, cudaLaunchAttributeID attr, const cudaLaunchAttributeValue * value); +# 2816 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamDestroy(cudaStream_t stream); +# 2847 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned flags = 0); +# 2855 +typedef void (*cudaStreamCallback_t)(cudaStream_t stream, cudaError_t status, void * userData); +# 2922 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void * userData, unsigned flags); +# 2946 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamSynchronize(cudaStream_t stream); +# 2971 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamQuery(cudaStream_t stream); +# 3055 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamAttachMemAsync(cudaStream_t stream, void * devPtr, size_t length = 0, unsigned flags = 4); +# 3094 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode); +# 3135 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t * dependencies, const cudaGraphEdgeData * dependencyData, size_t numDependencies, cudaStreamCaptureMode mode); +# 3186 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode * mode); +# 3215 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t * pGraph); +# 3253 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus * pCaptureStatus); +# 3303 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamGetCaptureInfo_v2(cudaStream_t stream, cudaStreamCaptureStatus * captureStatus_out, unsigned long long * id_out = 0, cudaGraph_t * graph_out = 0, const cudaGraphNode_t ** dependencies_out = 0, size_t * numDependencies_out = 0); +# 3362 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamGetCaptureInfo_v3(cudaStream_t stream, cudaStreamCaptureStatus * captureStatus_out, unsigned long long * id_out = 0, cudaGraph_t * graph_out = 0, const cudaGraphNode_t ** dependencies_out = 0, const cudaGraphEdgeData ** edgeData_out = 0, size_t * numDependencies_out = 0); +# 3402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t * dependencies, size_t numDependencies, unsigned flags = 0); +# 3437 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamUpdateCaptureDependencies_v2(cudaStream_t stream, cudaGraphNode_t * dependencies, const cudaGraphEdgeData * dependencyData, size_t numDependencies, unsigned flags = 0); +# 3474 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaEventCreate(cudaEvent_t * event); +# 3511 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaEventCreateWithFlags(cudaEvent_t * event, unsigned flags); +# 3552 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream = 0); +# 3600 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream = 0, unsigned flags = 0); +# 3633 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaEventQuery(cudaEvent_t event); +# 3664 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaEventSynchronize(cudaEvent_t event); +# 3694 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaEventDestroy(cudaEvent_t event); +# 3739 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaEventElapsedTime(float * ms, cudaEvent_t start, cudaEvent_t end); +# 3787 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaEventElapsedTime_v2(float * ms, cudaEvent_t start, cudaEvent_t end); +# 3968 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaImportExternalMemory(cudaExternalMemory_t * extMem_out, const cudaExternalMemoryHandleDesc * memHandleDesc); +# 4023 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaExternalMemoryGetMappedBuffer(void ** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc * bufferDesc); +# 4083 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t * mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc * mipmapDesc); +# 4107 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem); +# 4261 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t * extSem_out, const cudaExternalSemaphoreHandleDesc * semHandleDesc); +# 4344 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaSignalExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t * extSemArray, const cudaExternalSemaphoreSignalParams * paramsArray, unsigned numExtSems, cudaStream_t stream = 0); +# 4420 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaWaitExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t * extSemArray, const cudaExternalSemaphoreWaitParams * paramsArray, unsigned numExtSems, cudaStream_t stream = 0); +# 4443 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem); +# 4511 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLaunchKernel(const void * func, dim3 gridDim, dim3 blockDim, void ** args, size_t sharedMem, cudaStream_t stream); +# 4574 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLaunchKernelExC(const cudaLaunchConfig_t * config, const void * func, void ** args); +# 4632 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLaunchCooperativeKernel(const void * func, dim3 gridDim, dim3 blockDim, void ** args, size_t sharedMem, cudaStream_t stream); +# 4733 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaLaunchCooperativeKernelMultiDevice(cudaLaunchParams * launchParamsList, unsigned numDevices, unsigned flags = 0); +# 4783 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaFuncSetCacheConfig(const void * func, cudaFuncCache cacheConfig); +# 4818 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaFuncGetAttributes(cudaFuncAttributes * attr, const void * func); +# 4877 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaFuncSetAttribute(const void * func, cudaFuncAttribute attr, int value); +# 4903 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaFuncGetName(const char ** name, const void * func); +# 4926 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaFuncGetParamInfo(const void * func, size_t paramIndex, size_t * paramOffset, size_t * paramSize); +# 4950 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaSetDoubleForDevice(double * d); +# 4974 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaSetDoubleForHost(double * d); +# 5040 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void * userData); +# 5114 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaFuncSetSharedMemConfig(const void * func, cudaSharedMemConfig config); +# 5171 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int * numBlocks, const void * func, int blockSize, size_t dynamicSMemSize); +# 5201 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t * dynamicSmemSize, const void * func, int numBlocks, int blockSize); +# 5247 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int * numBlocks, const void * func, int blockSize, size_t dynamicSMemSize, unsigned flags); +# 5283 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaOccupancyMaxPotentialClusterSize(int * clusterSize, const void * func, const cudaLaunchConfig_t * launchConfig); +# 5323 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaOccupancyMaxActiveClusters(int * numClusters, const void * func, const cudaLaunchConfig_t * launchConfig); +# 5443 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMallocManaged(void ** devPtr, size_t size, unsigned flags = 1); +# 5476 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMalloc(void ** devPtr, size_t size); +# 5513 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMallocHost(void ** ptr, size_t size); +# 5556 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMallocPitch(void ** devPtr, size_t * pitch, size_t width, size_t height); +# 5608 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMallocArray(cudaArray_t * array, const cudaChannelFormatDesc * desc, size_t width, size_t height = 0, unsigned flags = 0); +# 5647 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaFree(void * devPtr); +# 5670 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaFreeHost(void * ptr); +# 5693 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaFreeArray(cudaArray_t array); +# 5716 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray); +# 5782 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaHostAlloc(void ** pHost, size_t size, unsigned flags); +# 5879 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaHostRegister(void * ptr, size_t size, unsigned flags); +# 5902 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaHostUnregister(void * ptr); +# 5947 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaHostGetDevicePointer(void ** pDevice, void * pHost, unsigned flags); +# 5969 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaHostGetFlags(unsigned * pFlags, void * pHost); +# 6008 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMalloc3D(cudaPitchedPtr * pitchedDevPtr, cudaExtent extent); +# 6153 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMalloc3DArray(cudaArray_t * array, const cudaChannelFormatDesc * desc, cudaExtent extent, unsigned flags = 0); +# 6298 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMallocMipmappedArray(cudaMipmappedArray_t * mipmappedArray, const cudaChannelFormatDesc * desc, cudaExtent extent, unsigned numLevels, unsigned flags = 0); +# 6331 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t * levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned level); +# 6436 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy3D(const cudaMemcpy3DParms * p); +# 6468 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms * p); +# 6586 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy3DAsync(const cudaMemcpy3DParms * p, cudaStream_t stream = 0); +# 6613 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms * p, cudaStream_t stream = 0); +# 6647 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemGetInfo(size_t * free, size_t * total); +# 6673 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaArrayGetInfo(cudaChannelFormatDesc * desc, cudaExtent * extent, unsigned * flags, cudaArray_t array); +# 6702 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaArrayGetPlane(cudaArray_t * pPlaneArray, cudaArray_t hArray, unsigned planeIdx); +# 6725 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements * memoryRequirements, cudaArray_t array, int device); +# 6749 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements * memoryRequirements, cudaMipmappedArray_t mipmap, int device); +# 6777 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaArrayGetSparseProperties(cudaArraySparseProperties * sparseProperties, cudaArray_t array); +# 6807 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties * sparseProperties, cudaMipmappedArray_t mipmap); +# 6852 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy(void * dst, const void * src, size_t count, cudaMemcpyKind kind); +# 6887 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpyPeer(void * dst, int dstDevice, const void * src, int srcDevice, size_t count); +# 6936 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy2D(void * dst, size_t dpitch, const void * src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind); +# 6986 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void * src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind); +# 7036 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy2DFromArray(void * dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind); +# 7083 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind = cudaMemcpyDeviceToDevice); +# 7126 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpyToSymbol(const void * symbol, const void * src, size_t count, size_t offset = 0, cudaMemcpyKind kind = cudaMemcpyHostToDevice); +# 7170 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpyFromSymbol(void * dst, const void * symbol, size_t count, size_t offset = 0, cudaMemcpyKind kind = cudaMemcpyDeviceToHost); +# 7227 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpyAsync(void * dst, const void * src, size_t count, cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7262 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpyPeerAsync(void * dst, int dstDevice, const void * src, int srcDevice, size_t count, cudaStream_t stream = 0); +# 7334 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpyBatchAsync(void ** dsts, void ** srcs, size_t * sizes, size_t count, cudaMemcpyAttributes * attrs, size_t * attrsIdxs, size_t numAttrs, size_t * failIdx, cudaStream_t stream); +# 7402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp * opList, size_t * failIdx, unsigned long long flags, cudaStream_t stream); +# 7465 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy2DAsync(void * dst, size_t dpitch, const void * src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7523 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void * src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7580 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy2DFromArrayAsync(void * dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7631 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpyToSymbolAsync(const void * symbol, const void * src, size_t count, size_t offset, cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7682 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpyFromSymbolAsync(void * dst, const void * symbol, size_t count, size_t offset, cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7711 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemset(void * devPtr, int value, size_t count); +# 7745 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemset2D(void * devPtr, size_t pitch, int value, size_t width, size_t height); +# 7791 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent); +# 7827 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemsetAsync(void * devPtr, int value, size_t count, cudaStream_t stream = 0); +# 7868 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemset2DAsync(void * devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream = 0); +# 7921 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream = 0); +# 7949 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetSymbolAddress(void ** devPtr, const void * symbol); +# 7976 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetSymbolSize(size_t * size, const void * symbol); +# 8048 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPrefetchAsync(const void * devPtr, size_t count, int dstDevice, cudaStream_t stream = 0); +# 8129 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPrefetchAsync_v2(const void * devPtr, size_t count, cudaMemLocation location, unsigned flags, cudaStream_t stream = 0); +# 8243 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemAdvise(const void * devPtr, size_t count, cudaMemoryAdvise advice, int device); +# 8366 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemAdvise_v2(const void * devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location); +# 8448 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemRangeGetAttribute(void * data, size_t dataSize, cudaMemRangeAttribute attribute, const void * devPtr, size_t count); +# 8491 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemRangeGetAttributes(void ** data, size_t * dataSizes, cudaMemRangeAttribute * attributes, size_t numAttributes, const void * devPtr, size_t count); +# 8551 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void * src, size_t count, cudaMemcpyKind kind); +# 8593 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaMemcpyFromArray(void * dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind); +# 8636 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind = cudaMemcpyDeviceToDevice); +# 8687 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void * src, size_t count, cudaMemcpyKind kind, cudaStream_t stream = 0); +# 8737 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaMemcpyFromArrayAsync(void * dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream = 0); +# 8806 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMallocAsync(void ** devPtr, size_t size, cudaStream_t hStream); +# 8832 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaFreeAsync(void * devPtr, cudaStream_t hStream); +# 8857 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep); +# 8901 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void * value); +# 8949 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void * value); +# 8964 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc * descList, size_t count); +# 8977 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolGetAccess(cudaMemAccessFlags * flags, cudaMemPool_t memPool, cudaMemLocation * location); +# 9021 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolCreate(cudaMemPool_t * memPool, const cudaMemPoolProps * poolProps); +# 9043 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool); +# 9079 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMallocFromPoolAsync(void ** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream); +# 9104 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolExportToShareableHandle(void * shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned flags); +# 9131 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolImportFromShareableHandle(cudaMemPool_t * memPool, void * shareableHandle, cudaMemAllocationHandleType handleType, unsigned flags); +# 9154 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolExportPointer(cudaMemPoolPtrExportData * exportData, void * ptr); +# 9183 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolImportPointer(void ** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData * exportData); +# 9336 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaPointerGetAttributes(cudaPointerAttributes * attributes, const void * ptr); +# 9377 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceCanAccessPeer(int * canAccessPeer, int device, int peerDevice); +# 9419 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned flags); +# 9441 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceDisablePeerAccess(int peerDevice); +# 9505 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource); +# 9540 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned flags); +# 9579 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t * resources, cudaStream_t stream = 0); +# 9614 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t * resources, cudaStream_t stream = 0); +# 9646 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsResourceGetMappedPointer(void ** devPtr, size_t * size, cudaGraphicsResource_t resource); +# 9684 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t * array, cudaGraphicsResource_t resource, unsigned arrayIndex, unsigned mipLevel); +# 9713 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t * mipmappedArray, cudaGraphicsResource_t resource); +# 9748 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetChannelDesc(cudaChannelFormatDesc * desc, cudaArray_const_t array); +# 9778 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f); +# 10003 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaCreateTextureObject(cudaTextureObject_t * pTexObject, const cudaResourceDesc * pResDesc, const cudaTextureDesc * pTexDesc, const cudaResourceViewDesc * pResViewDesc); +# 10023 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject); +# 10043 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetTextureObjectResourceDesc(cudaResourceDesc * pResDesc, cudaTextureObject_t texObject); +# 10063 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetTextureObjectTextureDesc(cudaTextureDesc * pTexDesc, cudaTextureObject_t texObject); +# 10084 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc * pResViewDesc, cudaTextureObject_t texObject); +# 10129 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t * pSurfObject, const cudaResourceDesc * pResDesc); +# 10149 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject); +# 10168 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetSurfaceObjectResourceDesc(cudaResourceDesc * pResDesc, cudaSurfaceObject_t surfObject); +# 10202 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDriverGetVersion(int * driverVersion); +# 10231 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaRuntimeGetVersion(int * runtimeVersion); +# 10278 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphCreate(cudaGraph_t * pGraph, unsigned flags); +# 10377 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddKernelNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, const cudaKernelNodeParams * pNodeParams); +# 10410 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams * pNodeParams); +# 10437 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams * pNodeParams); +# 10457 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hSrc, cudaGraphNode_t hDst); +# 10480 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaLaunchAttributeID attr, cudaLaunchAttributeValue * value_out); +# 10504 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaLaunchAttributeID attr, const cudaLaunchAttributeValue * value); +# 10555 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddMemcpyNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, const cudaMemcpy3DParms * pCopyParams); +# 10614 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddMemcpyNodeToSymbol(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, const void * symbol, const void * src, size_t count, size_t offset, cudaMemcpyKind kind); +# 10683 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddMemcpyNodeFromSymbol(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, void * dst, const void * symbol, size_t count, size_t offset, cudaMemcpyKind kind); +# 10751 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddMemcpyNode1D(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, void * dst, const void * src, size_t count, cudaMemcpyKind kind); +# 10783 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms * pNodeParams); +# 10810 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms * pNodeParams); +# 10849 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemcpyNodeSetParamsToSymbol(cudaGraphNode_t node, const void * symbol, const void * src, size_t count, size_t offset, cudaMemcpyKind kind); +# 10895 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemcpyNodeSetParamsFromSymbol(cudaGraphNode_t node, void * dst, const void * symbol, size_t count, size_t offset, cudaMemcpyKind kind); +# 10941 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void * dst, const void * src, size_t count, cudaMemcpyKind kind); +# 10989 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddMemsetNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, const cudaMemsetParams * pMemsetParams); +# 11012 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams * pNodeParams); +# 11036 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams * pNodeParams); +# 11078 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddHostNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, const cudaHostNodeParams * pNodeParams); +# 11101 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams * pNodeParams); +# 11125 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams * pNodeParams); +# 11166 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddChildGraphNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, cudaGraph_t childGraph); +# 11193 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t * pGraph); +# 11231 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies); +# 11275 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddEventRecordNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, cudaEvent_t event); +# 11302 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t * event_out); +# 11330 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event); +# 11377 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddEventWaitNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, cudaEvent_t event); +# 11404 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t * event_out); +# 11432 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event); +# 11482 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams * nodeParams); +# 11515 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams * params_out); +# 11543 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams * nodeParams); +# 11593 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams * nodeParams); +# 11626 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams * params_out); +# 11654 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams * nodeParams); +# 11732 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddMemAllocNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, cudaMemAllocNodeParams * nodeParams); +# 11759 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams * params_out); +# 11820 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddMemFreeNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, void * dptr); +# 11844 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void * dptr_out); +# 11872 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGraphMemTrim(int device); +# 11909 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void * value); +# 11943 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void * value); +# 11971 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphClone(cudaGraph_t * pGraphClone, cudaGraph_t originalGraph); +# 11999 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t * pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph); +# 12030 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType * pType); +# 12061 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t * nodes, size_t * numNodes); +# 12092 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t * pRootNodes, size_t * pNumRootNodes); +# 12126 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t * from, cudaGraphNode_t * to, size_t * numEdges); +# 12166 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphGetEdges_v2(cudaGraph_t graph, cudaGraphNode_t * from, cudaGraphNode_t * to, cudaGraphEdgeData * edgeData, size_t * numEdges); +# 12197 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t * pDependencies, size_t * pNumDependencies); +# 12234 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeGetDependencies_v2(cudaGraphNode_t node, cudaGraphNode_t * pDependencies, cudaGraphEdgeData * edgeData, size_t * pNumDependencies); +# 12266 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t * pDependentNodes, size_t * pNumDependentNodes); +# 12304 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeGetDependentNodes_v2(cudaGraphNode_t node, cudaGraphNode_t * pDependentNodes, cudaGraphEdgeData * edgeData, size_t * pNumDependentNodes); +# 12335 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t * from, const cudaGraphNode_t * to, size_t numDependencies); +# 12367 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t * from, const cudaGraphNode_t * to, const cudaGraphEdgeData * edgeData, size_t numDependencies); +# 12398 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t * from, const cudaGraphNode_t * to, size_t numDependencies); +# 12433 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphRemoveDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t * from, const cudaGraphNode_t * to, const cudaGraphEdgeData * edgeData, size_t numDependencies); +# 12463 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node); +# 12534 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphInstantiate(cudaGraphExec_t * pGraphExec, cudaGraph_t graph, unsigned long long flags = 0); +# 12607 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t * pGraphExec, cudaGraph_t graph, unsigned long long flags = 0); +# 12714 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphInstantiateWithParams(cudaGraphExec_t * pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams * instantiateParams); +# 12739 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long * flags); +# 12799 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams * pNodeParams); +# 12850 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms * pNodeParams); +# 12905 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecMemcpyNodeSetParamsToSymbol(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const void * symbol, const void * src, size_t count, size_t offset, cudaMemcpyKind kind); +# 12968 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecMemcpyNodeSetParamsFromSymbol(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void * dst, const void * symbol, size_t count, size_t offset, cudaMemcpyKind kind); +# 13029 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void * dst, const void * src, size_t count, cudaMemcpyKind kind); +# 13088 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams * pNodeParams); +# 13128 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams * pNodeParams); +# 13175 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph); +# 13220 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event); +# 13265 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event); +# 13313 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams * nodeParams); +# 13361 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams * nodeParams); +# 13401 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned isEnabled); +# 13435 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned * isEnabled); +# 13529 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo * resultInfo); +# 13554 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream); +# 13585 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream); +# 13608 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec); +# 13629 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphDestroy(cudaGraph_t graph); +# 13648 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char * path, unsigned flags); +# 13684 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaUserObjectCreate(cudaUserObject_t * object_out, void * ptr, cudaHostFn_t destroy, unsigned initialRefcount, unsigned flags); +# 13708 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned count = 1); +# 13736 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned count = 1); +# 13764 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned count = 1, unsigned flags = 0); +# 13789 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned count = 1); +# 13831 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, cudaGraphNodeParams * nodeParams); +# 13875 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddNode_v2(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, const cudaGraphEdgeData * dependencyData, size_t numDependencies, cudaGraphNodeParams * nodeParams); +# 13904 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams * nodeParams); +# 13953 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams * nodeParams); +# 13980 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle * pHandle_out, cudaGraph_t graph, unsigned defaultLaunchValue = 0, unsigned flags = 0); +# 14061 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetDriverEntryPoint(const char * symbol, void ** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult * driverStatus = 0); +# 14137 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetDriverEntryPointByVersion(const char * symbol, void ** funcPtr, unsigned cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult * driverStatus = 0); +# 14212 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLibraryLoadData(cudaLibrary_t * library, const void * code, cudaJitOption * jitOptions, void ** jitOptionsValues, unsigned numJitOptions, cudaLibraryOption * libraryOptions, void ** libraryOptionValues, unsigned numLibraryOptions); +# 14272 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLibraryLoadFromFile(cudaLibrary_t * library, const char * fileName, cudaJitOption * jitOptions, void ** jitOptionsValues, unsigned numJitOptions, cudaLibraryOption * libraryOptions, void ** libraryOptionValues, unsigned numLibraryOptions); +# 14293 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLibraryUnload(cudaLibrary_t library); +# 14318 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLibraryGetKernel(cudaKernel_t * pKernel, cudaLibrary_t library, const char * name); +# 14352 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLibraryGetGlobal(void ** dptr, size_t * bytes, cudaLibrary_t library, const char * name); +# 14385 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLibraryGetManaged(void ** dptr, size_t * bytes, cudaLibrary_t library, const char * name); +# 14412 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLibraryGetUnifiedFunction(void ** fptr, cudaLibrary_t library, const char * symbol); +# 14434 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLibraryGetKernelCount(unsigned * count, cudaLibrary_t lib); +# 14456 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLibraryEnumerateKernels(cudaKernel_t * kernels, unsigned numKernels, cudaLibrary_t lib); +# 14525 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device); +# 14530 +extern cudaError_t cudaGetExportTable(const void ** ppExportTable, const cudaUUID_t * pExportTableId); +# 14716 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetFuncBySymbol(cudaFunction_t * functionPtr, const void * symbolPtr); +# 14740 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetKernel(cudaKernel_t * kernelPtr, const void * entryFuncAddr); +# 14918 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +} +# 120 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" +template< class T> inline cudaChannelFormatDesc cudaCreateChannelDesc() +# 121 +{ +# 122 +return cudaCreateChannelDesc(0, 0, 0, 0, cudaChannelFormatKindNone); +# 123 +} +# 125 +static inline cudaChannelFormatDesc cudaCreateChannelDescHalf() +# 126 +{ +# 127 +int e = (((int)sizeof(unsigned short)) * 8); +# 129 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +# 130 +} +# 132 +static inline cudaChannelFormatDesc cudaCreateChannelDescHalf1() +# 133 +{ +# 134 +int e = (((int)sizeof(unsigned short)) * 8); +# 136 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +# 137 +} +# 139 +static inline cudaChannelFormatDesc cudaCreateChannelDescHalf2() +# 140 +{ +# 141 +int e = (((int)sizeof(unsigned short)) * 8); +# 143 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindFloat); +# 144 +} +# 146 +static inline cudaChannelFormatDesc cudaCreateChannelDescHalf4() +# 147 +{ +# 148 +int e = (((int)sizeof(unsigned short)) * 8); +# 150 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindFloat); +# 151 +} +# 153 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< char> () +# 154 +{ +# 155 +int e = (((int)sizeof(char)) * 8); +# 160 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 162 +} +# 164 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< signed char> () +# 165 +{ +# 166 +int e = (((int)sizeof(signed char)) * 8); +# 168 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 169 +} +# 171 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< unsigned char> () +# 172 +{ +# 173 +int e = (((int)sizeof(unsigned char)) * 8); +# 175 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +# 176 +} +# 178 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< char1> () +# 179 +{ +# 180 +int e = (((int)sizeof(signed char)) * 8); +# 182 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 183 +} +# 185 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< uchar1> () +# 186 +{ +# 187 +int e = (((int)sizeof(unsigned char)) * 8); +# 189 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +# 190 +} +# 192 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< char2> () +# 193 +{ +# 194 +int e = (((int)sizeof(signed char)) * 8); +# 196 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +# 197 +} +# 199 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< uchar2> () +# 200 +{ +# 201 +int e = (((int)sizeof(unsigned char)) * 8); +# 203 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +# 204 +} +# 206 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< char4> () +# 207 +{ +# 208 +int e = (((int)sizeof(signed char)) * 8); +# 210 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +# 211 +} +# 213 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< uchar4> () +# 214 +{ +# 215 +int e = (((int)sizeof(unsigned char)) * 8); +# 217 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +# 218 +} +# 220 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< short> () +# 221 +{ +# 222 +int e = (((int)sizeof(short)) * 8); +# 224 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 225 +} +# 227 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< unsigned short> () +# 228 +{ +# 229 +int e = (((int)sizeof(unsigned short)) * 8); +# 231 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +# 232 +} +# 234 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< short1> () +# 235 +{ +# 236 +int e = (((int)sizeof(short)) * 8); +# 238 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 239 +} +# 241 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< ushort1> () +# 242 +{ +# 243 +int e = (((int)sizeof(unsigned short)) * 8); +# 245 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +# 246 +} +# 248 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< short2> () +# 249 +{ +# 250 +int e = (((int)sizeof(short)) * 8); +# 252 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +# 253 +} +# 255 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< ushort2> () +# 256 +{ +# 257 +int e = (((int)sizeof(unsigned short)) * 8); +# 259 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +# 260 +} +# 262 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< short4> () +# 263 +{ +# 264 +int e = (((int)sizeof(short)) * 8); +# 266 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +# 267 +} +# 269 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< ushort4> () +# 270 +{ +# 271 +int e = (((int)sizeof(unsigned short)) * 8); +# 273 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +# 274 +} +# 276 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< int> () +# 277 +{ +# 278 +int e = (((int)sizeof(int)) * 8); +# 280 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 281 +} +# 283 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< unsigned> () +# 284 +{ +# 285 +int e = (((int)sizeof(unsigned)) * 8); +# 287 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +# 288 +} +# 290 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< int1> () +# 291 +{ +# 292 +int e = (((int)sizeof(int)) * 8); +# 294 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 295 +} +# 297 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< uint1> () +# 298 +{ +# 299 +int e = (((int)sizeof(unsigned)) * 8); +# 301 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +# 302 +} +# 304 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< int2> () +# 305 +{ +# 306 +int e = (((int)sizeof(int)) * 8); +# 308 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +# 309 +} +# 311 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< uint2> () +# 312 +{ +# 313 +int e = (((int)sizeof(unsigned)) * 8); +# 315 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +# 316 +} +# 318 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< int4> () +# 319 +{ +# 320 +int e = (((int)sizeof(int)) * 8); +# 322 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +# 323 +} +# 325 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< uint4> () +# 326 +{ +# 327 +int e = (((int)sizeof(unsigned)) * 8); +# 329 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +# 330 +} +# 392 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< float> () +# 393 +{ +# 394 +int e = (((int)sizeof(float)) * 8); +# 396 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +# 397 +} +# 399 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< float1> () +# 400 +{ +# 401 +int e = (((int)sizeof(float)) * 8); +# 403 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +# 404 +} +# 406 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< float2> () +# 407 +{ +# 408 +int e = (((int)sizeof(float)) * 8); +# 410 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindFloat); +# 411 +} +# 413 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< float4> () +# 414 +{ +# 415 +int e = (((int)sizeof(float)) * 8); +# 417 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindFloat); +# 418 +} +# 420 +static inline cudaChannelFormatDesc cudaCreateChannelDescNV12() +# 421 +{ +# 422 +int e = (((int)sizeof(char)) * 8); +# 424 +return cudaCreateChannelDesc(e, e, e, 0, cudaChannelFormatKindNV12); +# 425 +} +# 427 +template< cudaChannelFormatKind > inline cudaChannelFormatDesc cudaCreateChannelDesc() +# 428 +{ +# 429 +return cudaCreateChannelDesc(0, 0, 0, 0, cudaChannelFormatKindNone); +# 430 +} +# 433 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedNormalized8X1> () +# 434 +{ +# 435 +return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindSignedNormalized8X1); +# 436 +} +# 438 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedNormalized8X2> () +# 439 +{ +# 440 +return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindSignedNormalized8X2); +# 441 +} +# 443 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedNormalized8X4> () +# 444 +{ +# 445 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindSignedNormalized8X4); +# 446 +} +# 449 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedNormalized8X1> () +# 450 +{ +# 451 +return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindUnsignedNormalized8X1); +# 452 +} +# 454 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedNormalized8X2> () +# 455 +{ +# 456 +return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindUnsignedNormalized8X2); +# 457 +} +# 459 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedNormalized8X4> () +# 460 +{ +# 461 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedNormalized8X4); +# 462 +} +# 465 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedNormalized16X1> () +# 466 +{ +# 467 +return cudaCreateChannelDesc(16, 0, 0, 0, cudaChannelFormatKindSignedNormalized16X1); +# 468 +} +# 470 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedNormalized16X2> () +# 471 +{ +# 472 +return cudaCreateChannelDesc(16, 16, 0, 0, cudaChannelFormatKindSignedNormalized16X2); +# 473 +} +# 475 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedNormalized16X4> () +# 476 +{ +# 477 +return cudaCreateChannelDesc(16, 16, 16, 16, cudaChannelFormatKindSignedNormalized16X4); +# 478 +} +# 481 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedNormalized16X1> () +# 482 +{ +# 483 +return cudaCreateChannelDesc(16, 0, 0, 0, cudaChannelFormatKindUnsignedNormalized16X1); +# 484 +} +# 486 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedNormalized16X2> () +# 487 +{ +# 488 +return cudaCreateChannelDesc(16, 16, 0, 0, cudaChannelFormatKindUnsignedNormalized16X2); +# 489 +} +# 491 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedNormalized16X4> () +# 492 +{ +# 493 +return cudaCreateChannelDesc(16, 16, 16, 16, cudaChannelFormatKindUnsignedNormalized16X4); +# 494 +} +# 497 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindNV12> () +# 498 +{ +# 499 +return cudaCreateChannelDesc(8, 8, 8, 0, cudaChannelFormatKindNV12); +# 500 +} +# 503 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedNormalized1010102> () +# 504 +{ +# 505 +return cudaCreateChannelDesc(10, 10, 10, 2, cudaChannelFormatKindUnsignedNormalized1010102); +# 506 +} +# 509 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed1> () +# 510 +{ +# 511 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed1); +# 512 +} +# 515 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed1SRGB> () +# 516 +{ +# 517 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed1SRGB); +# 518 +} +# 521 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed2> () +# 522 +{ +# 523 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed2); +# 524 +} +# 527 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed2SRGB> () +# 528 +{ +# 529 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed2SRGB); +# 530 +} +# 533 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed3> () +# 534 +{ +# 535 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed3); +# 536 +} +# 539 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed3SRGB> () +# 540 +{ +# 541 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed3SRGB); +# 542 +} +# 545 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed4> () +# 546 +{ +# 547 +return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindUnsignedBlockCompressed4); +# 548 +} +# 551 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedBlockCompressed4> () +# 552 +{ +# 553 +return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindSignedBlockCompressed4); +# 554 +} +# 557 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed5> () +# 558 +{ +# 559 +return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindUnsignedBlockCompressed5); +# 560 +} +# 563 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedBlockCompressed5> () +# 564 +{ +# 565 +return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindSignedBlockCompressed5); +# 566 +} +# 569 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed6H> () +# 570 +{ +# 571 +return cudaCreateChannelDesc(16, 16, 16, 0, cudaChannelFormatKindUnsignedBlockCompressed6H); +# 572 +} +# 575 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedBlockCompressed6H> () +# 576 +{ +# 577 +return cudaCreateChannelDesc(16, 16, 16, 0, cudaChannelFormatKindSignedBlockCompressed6H); +# 578 +} +# 581 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed7> () +# 582 +{ +# 583 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed7); +# 584 +} +# 587 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed7SRGB> () +# 588 +{ +# 589 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed7SRGB); +# 590 +} +# 79 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static inline cudaPitchedPtr make_cudaPitchedPtr(void *d, size_t p, size_t xsz, size_t ysz) +# 80 +{ +# 81 +cudaPitchedPtr s; +# 83 +(s.ptr) = d; +# 84 +(s.pitch) = p; +# 85 +(s.xsize) = xsz; +# 86 +(s.ysize) = ysz; +# 88 +return s; +# 89 +} +# 106 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static inline cudaPos make_cudaPos(size_t x, size_t y, size_t z) +# 107 +{ +# 108 +cudaPos p; +# 110 +(p.x) = x; +# 111 +(p.y) = y; +# 112 +(p.z) = z; +# 114 +return p; +# 115 +} +# 132 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static inline cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) +# 133 +{ +# 134 +cudaExtent e; +# 136 +(e.width) = w; +# 137 +(e.height) = h; +# 138 +(e.depth) = d; +# 140 +return e; +# 141 +} +# 77 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.h" +static inline char1 make_char1(signed char x); +# 79 +static inline uchar1 make_uchar1(unsigned char x); +# 81 +static inline char2 make_char2(signed char x, signed char y); +# 83 +static inline uchar2 make_uchar2(unsigned char x, unsigned char y); +# 85 +static inline char3 make_char3(signed char x, signed char y, signed char z); +# 87 +static inline uchar3 make_uchar3(unsigned char x, unsigned char y, unsigned char z); +# 89 +static inline char4 make_char4(signed char x, signed char y, signed char z, signed char w); +# 91 +static inline uchar4 make_uchar4(unsigned char x, unsigned char y, unsigned char z, unsigned char w); +# 93 +static inline short1 make_short1(short x); +# 95 +static inline ushort1 make_ushort1(unsigned short x); +# 97 +static inline short2 make_short2(short x, short y); +# 99 +static inline ushort2 make_ushort2(unsigned short x, unsigned short y); +# 101 +static inline short3 make_short3(short x, short y, short z); +# 103 +static inline ushort3 make_ushort3(unsigned short x, unsigned short y, unsigned short z); +# 105 +static inline short4 make_short4(short x, short y, short z, short w); +# 107 +static inline ushort4 make_ushort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w); +# 109 +static inline int1 make_int1(int x); +# 111 +static inline uint1 make_uint1(unsigned x); +# 113 +static inline int2 make_int2(int x, int y); +# 115 +static inline uint2 make_uint2(unsigned x, unsigned y); +# 117 +static inline int3 make_int3(int x, int y, int z); +# 119 +static inline uint3 make_uint3(unsigned x, unsigned y, unsigned z); +# 121 +static inline int4 make_int4(int x, int y, int z, int w); +# 123 +static inline uint4 make_uint4(unsigned x, unsigned y, unsigned z, unsigned w); +# 125 +static inline long1 make_long1(long x); +# 127 +static inline ulong1 make_ulong1(unsigned long x); +# 129 +static inline long2 make_long2(long x, long y); +# 131 +static inline ulong2 make_ulong2(unsigned long x, unsigned long y); +# 133 +static inline long3 make_long3(long x, long y, long z); +# 135 +static inline ulong3 make_ulong3(unsigned long x, unsigned long y, unsigned long z); +# 137 +static inline long4 make_long4(long x, long y, long z, long w); +# 139 +static inline ulong4 make_ulong4(unsigned long x, unsigned long y, unsigned long z, unsigned long w); +# 141 +static inline float1 make_float1(float x); +# 143 +static inline float2 make_float2(float x, float y); +# 145 +static inline float3 make_float3(float x, float y, float z); +# 147 +static inline float4 make_float4(float x, float y, float z, float w); +# 149 +static inline longlong1 make_longlong1(long long x); +# 151 +static inline ulonglong1 make_ulonglong1(unsigned long long x); +# 153 +static inline longlong2 make_longlong2(long long x, long long y); +# 155 +static inline ulonglong2 make_ulonglong2(unsigned long long x, unsigned long long y); +# 157 +static inline longlong3 make_longlong3(long long x, long long y, long long z); +# 159 +static inline ulonglong3 make_ulonglong3(unsigned long long x, unsigned long long y, unsigned long long z); +# 161 +static inline longlong4 make_longlong4(long long x, long long y, long long z, long long w); +# 163 +static inline ulonglong4 make_ulonglong4(unsigned long long x, unsigned long long y, unsigned long long z, unsigned long long w); +# 165 +static inline double1 make_double1(double x); +# 167 +static inline double2 make_double2(double x, double y); +# 169 +static inline double3 make_double3(double x, double y, double z); +# 171 +static inline double4 make_double4(double x, double y, double z, double w); +# 73 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.hpp" +static inline char1 make_char1(signed char x) +# 74 +{ +# 75 +char1 t; (t.x) = x; return t; +# 76 +} +# 78 +static inline uchar1 make_uchar1(unsigned char x) +# 79 +{ +# 80 +uchar1 t; (t.x) = x; return t; +# 81 +} +# 83 +static inline char2 make_char2(signed char x, signed char y) +# 84 +{ +# 85 +char2 t; (t.x) = x; (t.y) = y; return t; +# 86 +} +# 88 +static inline uchar2 make_uchar2(unsigned char x, unsigned char y) +# 89 +{ +# 90 +uchar2 t; (t.x) = x; (t.y) = y; return t; +# 91 +} +# 93 +static inline char3 make_char3(signed char x, signed char y, signed char z) +# 94 +{ +# 95 +char3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 96 +} +# 98 +static inline uchar3 make_uchar3(unsigned char x, unsigned char y, unsigned char z) +# 99 +{ +# 100 +uchar3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 101 +} +# 103 +static inline char4 make_char4(signed char x, signed char y, signed char z, signed char w) +# 104 +{ +# 105 +char4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 106 +} +# 108 +static inline uchar4 make_uchar4(unsigned char x, unsigned char y, unsigned char z, unsigned char w) +# 109 +{ +# 110 +uchar4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 111 +} +# 113 +static inline short1 make_short1(short x) +# 114 +{ +# 115 +short1 t; (t.x) = x; return t; +# 116 +} +# 118 +static inline ushort1 make_ushort1(unsigned short x) +# 119 +{ +# 120 +ushort1 t; (t.x) = x; return t; +# 121 +} +# 123 +static inline short2 make_short2(short x, short y) +# 124 +{ +# 125 +short2 t; (t.x) = x; (t.y) = y; return t; +# 126 +} +# 128 +static inline ushort2 make_ushort2(unsigned short x, unsigned short y) +# 129 +{ +# 130 +ushort2 t; (t.x) = x; (t.y) = y; return t; +# 131 +} +# 133 +static inline short3 make_short3(short x, short y, short z) +# 134 +{ +# 135 +short3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 136 +} +# 138 +static inline ushort3 make_ushort3(unsigned short x, unsigned short y, unsigned short z) +# 139 +{ +# 140 +ushort3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 141 +} +# 143 +static inline short4 make_short4(short x, short y, short z, short w) +# 144 +{ +# 145 +short4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 146 +} +# 148 +static inline ushort4 make_ushort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w) +# 149 +{ +# 150 +ushort4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 151 +} +# 153 +static inline int1 make_int1(int x) +# 154 +{ +# 155 +int1 t; (t.x) = x; return t; +# 156 +} +# 158 +static inline uint1 make_uint1(unsigned x) +# 159 +{ +# 160 +uint1 t; (t.x) = x; return t; +# 161 +} +# 163 +static inline int2 make_int2(int x, int y) +# 164 +{ +# 165 +int2 t; (t.x) = x; (t.y) = y; return t; +# 166 +} +# 168 +static inline uint2 make_uint2(unsigned x, unsigned y) +# 169 +{ +# 170 +uint2 t; (t.x) = x; (t.y) = y; return t; +# 171 +} +# 173 +static inline int3 make_int3(int x, int y, int z) +# 174 +{ +# 175 +int3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 176 +} +# 178 +static inline uint3 make_uint3(unsigned x, unsigned y, unsigned z) +# 179 +{ +# 180 +uint3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 181 +} +# 183 +static inline int4 make_int4(int x, int y, int z, int w) +# 184 +{ +# 185 +int4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 186 +} +# 188 +static inline uint4 make_uint4(unsigned x, unsigned y, unsigned z, unsigned w) +# 189 +{ +# 190 +uint4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 191 +} +# 193 +static inline long1 make_long1(long x) +# 194 +{ +# 195 +long1 t; (t.x) = x; return t; +# 196 +} +# 198 +static inline ulong1 make_ulong1(unsigned long x) +# 199 +{ +# 200 +ulong1 t; (t.x) = x; return t; +# 201 +} +# 203 +static inline long2 make_long2(long x, long y) +# 204 +{ +# 205 +long2 t; (t.x) = x; (t.y) = y; return t; +# 206 +} +# 208 +static inline ulong2 make_ulong2(unsigned long x, unsigned long y) +# 209 +{ +# 210 +ulong2 t; (t.x) = x; (t.y) = y; return t; +# 211 +} +# 213 +static inline long3 make_long3(long x, long y, long z) +# 214 +{ +# 215 +long3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 216 +} +# 218 +static inline ulong3 make_ulong3(unsigned long x, unsigned long y, unsigned long z) +# 219 +{ +# 220 +ulong3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 221 +} +# 223 +static inline long4 make_long4(long x, long y, long z, long w) +# 224 +{ +# 225 +long4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 226 +} +# 228 +static inline ulong4 make_ulong4(unsigned long x, unsigned long y, unsigned long z, unsigned long w) +# 229 +{ +# 230 +ulong4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 231 +} +# 233 +static inline float1 make_float1(float x) +# 234 +{ +# 235 +float1 t; (t.x) = x; return t; +# 236 +} +# 238 +static inline float2 make_float2(float x, float y) +# 239 +{ +# 240 +float2 t; (t.x) = x; (t.y) = y; return t; +# 241 +} +# 243 +static inline float3 make_float3(float x, float y, float z) +# 244 +{ +# 245 +float3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 246 +} +# 248 +static inline float4 make_float4(float x, float y, float z, float w) +# 249 +{ +# 250 +float4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 251 +} +# 253 +static inline longlong1 make_longlong1(long long x) +# 254 +{ +# 255 +longlong1 t; (t.x) = x; return t; +# 256 +} +# 258 +static inline ulonglong1 make_ulonglong1(unsigned long long x) +# 259 +{ +# 260 +ulonglong1 t; (t.x) = x; return t; +# 261 +} +# 263 +static inline longlong2 make_longlong2(long long x, long long y) +# 264 +{ +# 265 +longlong2 t; (t.x) = x; (t.y) = y; return t; +# 266 +} +# 268 +static inline ulonglong2 make_ulonglong2(unsigned long long x, unsigned long long y) +# 269 +{ +# 270 +ulonglong2 t; (t.x) = x; (t.y) = y; return t; +# 271 +} +# 273 +static inline longlong3 make_longlong3(long long x, long long y, long long z) +# 274 +{ +# 275 +longlong3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 276 +} +# 278 +static inline ulonglong3 make_ulonglong3(unsigned long long x, unsigned long long y, unsigned long long z) +# 279 +{ +# 280 +ulonglong3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 281 +} +# 283 +static inline longlong4 make_longlong4(long long x, long long y, long long z, long long w) +# 284 +{ +# 285 +longlong4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 286 +} +# 288 +static inline ulonglong4 make_ulonglong4(unsigned long long x, unsigned long long y, unsigned long long z, unsigned long long w) +# 289 +{ +# 290 +ulonglong4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 291 +} +# 293 +static inline double1 make_double1(double x) +# 294 +{ +# 295 +double1 t; (t.x) = x; return t; +# 296 +} +# 298 +static inline double2 make_double2(double x, double y) +# 299 +{ +# 300 +double2 t; (t.x) = x; (t.y) = y; return t; +# 301 +} +# 303 +static inline double3 make_double3(double x, double y, double z) +# 304 +{ +# 305 +double3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 306 +} +# 308 +static inline double4 make_double4(double x, double y, double z, double w) +# 309 +{ +# 310 +double4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 311 +} +# 28 "/usr/include/string.h" 3 +extern "C" { +# 43 "/usr/include/string.h" 3 +extern void *memcpy(void *__restrict__ __dest, const void *__restrict__ __src, size_t __n) noexcept(true) +# 44 + __attribute((__nonnull__(1, 2))); +# 47 +extern void *memmove(void * __dest, const void * __src, size_t __n) noexcept(true) +# 48 + __attribute((__nonnull__(1, 2))); +# 54 +extern void *memccpy(void *__restrict__ __dest, const void *__restrict__ __src, int __c, size_t __n) noexcept(true) +# 56 + __attribute((__nonnull__(1, 2))) __attribute((__access__(__write_only__ , 1 , 4 ))); +# 61 +extern void *memset(void * __s, int __c, size_t __n) noexcept(true) __attribute((__nonnull__(1))); +# 64 +extern int memcmp(const void * __s1, const void * __s2, size_t __n) noexcept(true) +# 65 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 80 "/usr/include/string.h" 3 +extern int __memcmpeq(const void * __s1, const void * __s2, size_t __n) noexcept(true) +# 81 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 85 +extern "C++" { +# 87 +extern void *memchr(void * __s, int __c, size_t __n) noexcept(true) __asm__("memchr") +# 88 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 89 +extern const void *memchr(const void * __s, int __c, size_t __n) noexcept(true) __asm__("memchr") +# 90 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 105 "/usr/include/string.h" 3 +} +# 115 "/usr/include/string.h" 3 +extern "C++" void *rawmemchr(void * __s, int __c) noexcept(true) __asm__("rawmemchr") +# 116 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 117 +extern "C++" const void *rawmemchr(const void * __s, int __c) noexcept(true) __asm__("rawmemchr") +# 118 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 126 +extern "C++" void *memrchr(void * __s, int __c, size_t __n) noexcept(true) __asm__("memrchr") +# 127 + __attribute((__pure__)) __attribute((__nonnull__(1))) +# 128 + __attribute((__access__(__read_only__ , 1 , 3 ))); +# 129 +extern "C++" const void *memrchr(const void * __s, int __c, size_t __n) noexcept(true) __asm__("memrchr") +# 130 + __attribute((__pure__)) __attribute((__nonnull__(1))) +# 131 + __attribute((__access__(__read_only__ , 1 , 3 ))); +# 141 "/usr/include/string.h" 3 +extern char *strcpy(char *__restrict__ __dest, const char *__restrict__ __src) noexcept(true) +# 142 + __attribute((__nonnull__(1, 2))); +# 144 +extern char *strncpy(char *__restrict__ __dest, const char *__restrict__ __src, size_t __n) noexcept(true) +# 146 + __attribute((__nonnull__(1, 2))); +# 149 +extern char *strcat(char *__restrict__ __dest, const char *__restrict__ __src) noexcept(true) +# 150 + __attribute((__nonnull__(1, 2))); +# 152 +extern char *strncat(char *__restrict__ __dest, const char *__restrict__ __src, size_t __n) noexcept(true) +# 153 + __attribute((__nonnull__(1, 2))); +# 156 +extern int strcmp(const char * __s1, const char * __s2) noexcept(true) +# 157 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 159 +extern int strncmp(const char * __s1, const char * __s2, size_t __n) noexcept(true) +# 160 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 163 +extern int strcoll(const char * __s1, const char * __s2) noexcept(true) +# 164 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 166 +extern size_t strxfrm(char *__restrict__ __dest, const char *__restrict__ __src, size_t __n) noexcept(true) +# 168 + __attribute((__nonnull__(2))) __attribute((__access__(__write_only__ , 1 , 3 ))); +# 175 +extern int strcoll_l(const char * __s1, const char * __s2, locale_t __l) noexcept(true) +# 176 + __attribute((__pure__)) __attribute((__nonnull__(1, 2, 3))); +# 179 +extern size_t strxfrm_l(char * __dest, const char * __src, size_t __n, locale_t __l) noexcept(true) +# 180 + __attribute((__nonnull__(2, 4))) +# 181 + __attribute((__access__(__write_only__ , 1 , 3 ))); +# 187 +extern char *strdup(const char * __s) noexcept(true) +# 188 + __attribute((__malloc__)) __attribute((__nonnull__(1))); +# 195 +extern char *strndup(const char * __string, size_t __n) noexcept(true) +# 196 + __attribute((__malloc__)) __attribute((__nonnull__(1))); +# 224 "/usr/include/string.h" 3 +extern "C++" { +# 226 +extern char *strchr(char * __s, int __c) noexcept(true) __asm__("strchr") +# 227 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 228 +extern const char *strchr(const char * __s, int __c) noexcept(true) __asm__("strchr") +# 229 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 244 "/usr/include/string.h" 3 +} +# 251 +extern "C++" { +# 253 +extern char *strrchr(char * __s, int __c) noexcept(true) __asm__("strrchr") +# 254 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 255 +extern const char *strrchr(const char * __s, int __c) noexcept(true) __asm__("strrchr") +# 256 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 271 "/usr/include/string.h" 3 +} +# 281 "/usr/include/string.h" 3 +extern "C++" char *strchrnul(char * __s, int __c) noexcept(true) __asm__("strchrnul") +# 282 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 283 +extern "C++" const char *strchrnul(const char * __s, int __c) noexcept(true) __asm__("strchrnul") +# 284 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 293 "/usr/include/string.h" 3 +extern size_t strcspn(const char * __s, const char * __reject) noexcept(true) +# 294 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 297 +extern size_t strspn(const char * __s, const char * __accept) noexcept(true) +# 298 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 301 +extern "C++" { +# 303 +extern char *strpbrk(char * __s, const char * __accept) noexcept(true) __asm__("strpbrk") +# 304 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 305 +extern const char *strpbrk(const char * __s, const char * __accept) noexcept(true) __asm__("strpbrk") +# 306 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 321 "/usr/include/string.h" 3 +} +# 328 +extern "C++" { +# 330 +extern char *strstr(char * __haystack, const char * __needle) noexcept(true) __asm__("strstr") +# 331 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 332 +extern const char *strstr(const char * __haystack, const char * __needle) noexcept(true) __asm__("strstr") +# 333 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 348 "/usr/include/string.h" 3 +} +# 356 +extern char *strtok(char *__restrict__ __s, const char *__restrict__ __delim) noexcept(true) +# 357 + __attribute((__nonnull__(2))); +# 361 +extern char *__strtok_r(char *__restrict__ __s, const char *__restrict__ __delim, char **__restrict__ __save_ptr) noexcept(true) +# 364 + __attribute((__nonnull__(2, 3))); +# 366 +extern char *strtok_r(char *__restrict__ __s, const char *__restrict__ __delim, char **__restrict__ __save_ptr) noexcept(true) +# 368 + __attribute((__nonnull__(2, 3))); +# 374 +extern "C++" char *strcasestr(char * __haystack, const char * __needle) noexcept(true) __asm__("strcasestr") +# 375 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 376 +extern "C++" const char *strcasestr(const char * __haystack, const char * __needle) noexcept(true) __asm__("strcasestr") +# 378 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 389 "/usr/include/string.h" 3 +extern void *memmem(const void * __haystack, size_t __haystacklen, const void * __needle, size_t __needlelen) noexcept(true) +# 391 + __attribute((__pure__)) __attribute((__nonnull__(1, 3))) +# 392 + __attribute((__access__(__read_only__ , 1 , 2 ))) +# 393 + __attribute((__access__(__read_only__ , 3 , 4 ))); +# 397 +extern void *__mempcpy(void *__restrict__ __dest, const void *__restrict__ __src, size_t __n) noexcept(true) +# 399 + __attribute((__nonnull__(1, 2))); +# 400 +extern void *mempcpy(void *__restrict__ __dest, const void *__restrict__ __src, size_t __n) noexcept(true) +# 402 + __attribute((__nonnull__(1, 2))); +# 407 +extern size_t strlen(const char * __s) noexcept(true) +# 408 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 413 +extern size_t strnlen(const char * __string, size_t __maxlen) noexcept(true) +# 414 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 419 +extern char *strerror(int __errnum) noexcept(true); +# 444 "/usr/include/string.h" 3 +extern char *strerror_r(int __errnum, char * __buf, size_t __buflen) noexcept(true) +# 445 + __attribute((__nonnull__(2))) __attribute((__access__(__write_only__ , 2 , 3 ))); +# 450 +extern const char *strerrordesc_np(int __err) noexcept(true); +# 452 +extern const char *strerrorname_np(int __err) noexcept(true); +# 458 +extern char *strerror_l(int __errnum, locale_t __l) noexcept(true); +# 30 "/usr/include/strings.h" 3 +extern "C" { +# 34 +extern int bcmp(const void * __s1, const void * __s2, size_t __n) noexcept(true) +# 35 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 38 +extern void bcopy(const void * __src, void * __dest, size_t __n) noexcept(true) +# 39 + __attribute((__nonnull__(1, 2))); +# 42 +extern void bzero(void * __s, size_t __n) noexcept(true) __attribute((__nonnull__(1))); +# 46 +extern "C++" { +# 48 +extern char *index(char * __s, int __c) noexcept(true) __asm__("index") +# 49 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 50 +extern const char *index(const char * __s, int __c) noexcept(true) __asm__("index") +# 51 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 66 "/usr/include/strings.h" 3 +} +# 74 +extern "C++" { +# 76 +extern char *rindex(char * __s, int __c) noexcept(true) __asm__("rindex") +# 77 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 78 +extern const char *rindex(const char * __s, int __c) noexcept(true) __asm__("rindex") +# 79 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 94 "/usr/include/strings.h" 3 +} +# 104 "/usr/include/strings.h" 3 +extern int ffs(int __i) noexcept(true) __attribute((const)); +# 110 +extern int ffsl(long __l) noexcept(true) __attribute((const)); +# 111 +__extension__ extern int ffsll(long long __ll) noexcept(true) +# 112 + __attribute((const)); +# 116 +extern int strcasecmp(const char * __s1, const char * __s2) noexcept(true) +# 117 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 120 +extern int strncasecmp(const char * __s1, const char * __s2, size_t __n) noexcept(true) +# 121 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 128 +extern int strcasecmp_l(const char * __s1, const char * __s2, locale_t __loc) noexcept(true) +# 129 + __attribute((__pure__)) __attribute((__nonnull__(1, 2, 3))); +# 133 +extern int strncasecmp_l(const char * __s1, const char * __s2, size_t __n, locale_t __loc) noexcept(true) +# 135 + __attribute((__pure__)) __attribute((__nonnull__(1, 2, 4))); +# 138 +} +# 466 "/usr/include/string.h" 3 +extern void explicit_bzero(void * __s, size_t __n) noexcept(true) __attribute((__nonnull__(1))) +# 467 + __attribute((__access__(__write_only__ , 1 , 2 ))); +# 471 +extern char *strsep(char **__restrict__ __stringp, const char *__restrict__ __delim) noexcept(true) +# 473 + __attribute((__nonnull__(1, 2))); +# 478 +extern char *strsignal(int __sig) noexcept(true); +# 482 +extern const char *sigabbrev_np(int __sig) noexcept(true); +# 485 +extern const char *sigdescr_np(int __sig) noexcept(true); +# 489 +extern char *__stpcpy(char *__restrict__ __dest, const char *__restrict__ __src) noexcept(true) +# 490 + __attribute((__nonnull__(1, 2))); +# 491 +extern char *stpcpy(char *__restrict__ __dest, const char *__restrict__ __src) noexcept(true) +# 492 + __attribute((__nonnull__(1, 2))); +# 496 +extern char *__stpncpy(char *__restrict__ __dest, const char *__restrict__ __src, size_t __n) noexcept(true) +# 498 + __attribute((__nonnull__(1, 2))); +# 499 +extern char *stpncpy(char *__restrict__ __dest, const char *__restrict__ __src, size_t __n) noexcept(true) +# 501 + __attribute((__nonnull__(1, 2))); +# 506 +extern size_t strlcpy(char *__restrict__ __dest, const char *__restrict__ __src, size_t __n) noexcept(true) +# 508 + __attribute((__nonnull__(1, 2))) __attribute((__access__(__write_only__ , 1 , 3 ))); +# 512 +extern size_t strlcat(char *__restrict__ __dest, const char *__restrict__ __src, size_t __n) noexcept(true) +# 514 + __attribute((__nonnull__(1, 2))) __attribute((__access__(__read_write__ , 1 , 3 ))); +# 519 +extern int strverscmp(const char * __s1, const char * __s2) noexcept(true) +# 520 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 523 +extern char *strfry(char * __string) noexcept(true) __attribute((__nonnull__(1))); +# 526 +extern void *memfrob(void * __s, size_t __n) noexcept(true) __attribute((__nonnull__(1))) +# 527 + __attribute((__access__(__read_write__ , 1 , 2 ))); +# 535 +extern "C++" char *basename(char * __filename) noexcept(true) __asm__("basename") +# 536 + __attribute((__nonnull__(1))); +# 537 +extern "C++" const char *basename(const char * __filename) noexcept(true) __asm__("basename") +# 538 + __attribute((__nonnull__(1))); +# 552 "/usr/include/string.h" 3 +} +# 26 "/usr/include/bits/timex.h" 3 +struct timex { +# 58 "/usr/include/bits/timex.h" 3 +unsigned modes; +# 59 +__syscall_slong_t offset; +# 60 +__syscall_slong_t freq; +# 61 +__syscall_slong_t maxerror; +# 62 +__syscall_slong_t esterror; +# 63 +int status; +# 64 +__syscall_slong_t constant; +# 65 +__syscall_slong_t precision; +# 66 +__syscall_slong_t tolerance; +# 67 +timeval time; +# 68 +__syscall_slong_t tick; +# 69 +__syscall_slong_t ppsfreq; +# 70 +__syscall_slong_t jitter; +# 71 +int shift; +# 72 +__syscall_slong_t stabil; +# 73 +__syscall_slong_t jitcnt; +# 74 +__syscall_slong_t calcnt; +# 75 +__syscall_slong_t errcnt; +# 76 +__syscall_slong_t stbcnt; +# 78 +int tai; +# 81 +int: 32; int: 32; int: 32; int: 32; +# 82 +int: 32; int: 32; int: 32; int: 32; +# 83 +int: 32; int: 32; int: 32; +# 85 +}; +# 75 "/usr/include/bits/time.h" 3 +extern "C" { +# 78 +extern int clock_adjtime(__clockid_t __clock_id, timex * __utx) noexcept(true) __attribute((__nonnull__(2))); +# 90 "/usr/include/bits/time.h" 3 +} +# 7 "/usr/include/bits/types/struct_tm.h" 3 +struct tm { +# 9 +int tm_sec; +# 10 +int tm_min; +# 11 +int tm_hour; +# 12 +int tm_mday; +# 13 +int tm_mon; +# 14 +int tm_year; +# 15 +int tm_wday; +# 16 +int tm_yday; +# 17 +int tm_isdst; +# 20 +long tm_gmtoff; +# 21 +const char *tm_zone; +# 26 +}; +# 8 "/usr/include/bits/types/struct_itimerspec.h" 3 +struct itimerspec { +# 10 +timespec it_interval; +# 11 +timespec it_value; +# 12 +}; +# 49 "/usr/include/time.h" 3 +struct sigevent; +# 68 "/usr/include/time.h" 3 +extern "C" { +# 72 +extern clock_t clock() noexcept(true); +# 76 +extern time_t time(time_t * __timer) noexcept(true); +# 79 +extern double difftime(time_t __time1, time_t __time0); +# 82 +extern time_t mktime(tm * __tp) noexcept(true); +# 99 "/usr/include/time.h" 3 +extern size_t strftime(char *__restrict__ __s, size_t __maxsize, const char *__restrict__ __format, const tm *__restrict__ __tp) noexcept(true) +# 102 + __attribute((__nonnull__(1, 3, 4))); +# 107 +extern char *strptime(const char *__restrict__ __s, const char *__restrict__ __fmt, tm * __tp) noexcept(true); +# 116 +extern size_t strftime_l(char *__restrict__ __s, size_t __maxsize, const char *__restrict__ __format, const tm *__restrict__ __tp, locale_t __loc) noexcept(true); +# 123 +extern char *strptime_l(const char *__restrict__ __s, const char *__restrict__ __fmt, tm * __tp, locale_t __loc) noexcept(true); +# 132 +extern tm *gmtime(const time_t * __timer) noexcept(true); +# 136 +extern tm *localtime(const time_t * __timer) noexcept(true); +# 154 "/usr/include/time.h" 3 +extern tm *gmtime_r(const time_t *__restrict__ __timer, tm *__restrict__ __tp) noexcept(true); +# 159 +extern tm *localtime_r(const time_t *__restrict__ __timer, tm *__restrict__ __tp) noexcept(true); +# 179 "/usr/include/time.h" 3 +extern char *asctime(const tm * __tp) noexcept(true); +# 183 +extern char *ctime(const time_t * __timer) noexcept(true); +# 197 "/usr/include/time.h" 3 +extern char *asctime_r(const tm *__restrict__ __tp, char *__restrict__ __buf) noexcept(true); +# 202 +extern char *ctime_r(const time_t *__restrict__ __timer, char *__restrict__ __buf) noexcept(true); +# 217 "/usr/include/time.h" 3 +extern char *__tzname[2]; +# 218 +extern int __daylight; +# 219 +extern long __timezone; +# 224 +extern char *tzname[2]; +# 228 +extern void tzset() noexcept(true); +# 232 +extern int daylight; +# 233 +extern long timezone; +# 246 "/usr/include/time.h" 3 +extern time_t timegm(tm * __tp) noexcept(true); +# 263 "/usr/include/time.h" 3 +extern time_t timelocal(tm * __tp) noexcept(true); +# 271 +extern int dysize(int __year) noexcept(true) __attribute((const)); +# 281 "/usr/include/time.h" 3 +extern int nanosleep(const timespec * __requested_time, timespec * __remaining); +# 285 +extern int clock_getres(clockid_t __clock_id, timespec * __res) noexcept(true); +# 288 +extern int clock_gettime(clockid_t __clock_id, timespec * __tp) noexcept(true) +# 289 + __attribute((__nonnull__(2))); +# 292 +extern int clock_settime(clockid_t __clock_id, const timespec * __tp) noexcept(true) +# 293 + __attribute((__nonnull__(2))); +# 323 "/usr/include/time.h" 3 +extern int clock_nanosleep(clockid_t __clock_id, int __flags, const timespec * __req, timespec * __rem); +# 338 "/usr/include/time.h" 3 +extern int clock_getcpuclockid(pid_t __pid, clockid_t * __clock_id) noexcept(true); +# 343 +extern int timer_create(clockid_t __clock_id, sigevent *__restrict__ __evp, timer_t *__restrict__ __timerid) noexcept(true); +# 348 +extern int timer_delete(timer_t __timerid) noexcept(true); +# 352 +extern int timer_settime(timer_t __timerid, int __flags, const itimerspec *__restrict__ __value, itimerspec *__restrict__ __ovalue) noexcept(true); +# 357 +extern int timer_gettime(timer_t __timerid, itimerspec * __value) noexcept(true); +# 376 "/usr/include/time.h" 3 +extern int timer_getoverrun(timer_t __timerid) noexcept(true); +# 383 +extern int timespec_get(timespec * __ts, int __base) noexcept(true) +# 384 + __attribute((__nonnull__(1))); +# 399 "/usr/include/time.h" 3 +extern int timespec_getres(timespec * __ts, int __base) noexcept(true); +# 425 "/usr/include/time.h" 3 +extern int getdate_err; +# 434 "/usr/include/time.h" 3 +extern tm *getdate(const char * __string); +# 448 "/usr/include/time.h" 3 +extern int getdate_r(const char *__restrict__ __string, tm *__restrict__ __resbufp); +# 452 +} +# 88 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern "C" { +# 91 +extern clock_t clock() noexcept(true); +# 96 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern void *memset(void *, int, size_t) noexcept(true); +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern void *memcpy(void *, const void *, size_t) noexcept(true); +# 99 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +} +# 126 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern "C" { +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int abs(int a) noexcept(true); +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern long labs(long a) noexcept(true); +# 255 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern long long llabs(long long a) noexcept(true); +# 283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double fabs(double x) noexcept(true); +# 306 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float fabsf(float x) noexcept(true); +# 317 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern inline int min(const int a, const int b); +# 324 +extern inline unsigned umin(const unsigned a, const unsigned b); +# 331 +extern inline long long llmin(const long long a, const long long b); +# 338 +extern inline unsigned long long ullmin(const unsigned long long a, const unsigned long long b); +# 359 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float fminf(float x, float y) noexcept(true); +# 379 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double fmin(double x, double y) noexcept(true); +# 392 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern inline int max(const int a, const int b); +# 400 +extern inline unsigned umax(const unsigned a, const unsigned b); +# 407 +extern inline long long llmax(const long long a, const long long b); +# 414 +extern inline unsigned long long ullmax(const unsigned long long a, const unsigned long long b); +# 435 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float fmaxf(float x, float y) noexcept(true); +# 455 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double fmax(double, double) noexcept(true); +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double sin(double x) noexcept(true); +# 495 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double cos(double x) noexcept(true); +# 511 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern void sincos(double x, double * sptr, double * cptr) noexcept(true); +# 524 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern void sincosf(float x, float * sptr, float * cptr) noexcept(true); +# 547 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double tan(double x) noexcept(true); +# 571 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double sqrt(double x) noexcept(true); +# 597 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double rsqrt(double x); +# 621 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float rsqrtf(float x); +# 648 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double log2(double x) noexcept(true); +# 677 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double exp2(double x) noexcept(true); +# 706 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float exp2f(float x) noexcept(true); +# 737 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double exp10(double x) noexcept(true); +# 764 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float exp10f(float x) noexcept(true); +# 798 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double expm1(double x) noexcept(true); +# 831 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float expm1f(float x) noexcept(true); +# 858 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float log2f(float x) noexcept(true); +# 883 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double log10(double x) noexcept(true); +# 909 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double log(double x) noexcept(true); +# 936 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double log1p(double x) noexcept(true); +# 966 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float log1pf(float x) noexcept(true); +# 992 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double floor(double x) noexcept(true); +# 1021 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double exp(double x) noexcept(true); +# 1040 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double cosh(double x) noexcept(true); +# 1060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double sinh(double x) noexcept(true); +# 1080 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double tanh(double x) noexcept(true); +# 1104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double acosh(double x) noexcept(true); +# 1131 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float acoshf(float x) noexcept(true); +# 1155 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double asinh(double x) noexcept(true); +# 1179 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float asinhf(float x) noexcept(true); +# 1204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double atanh(double x) noexcept(true); +# 1229 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float atanhf(float x) noexcept(true); +# 1247 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double ldexp(double x, int exp) noexcept(true); +# 1262 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float ldexpf(float x, int exp) noexcept(true); +# 1283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double logb(double x) noexcept(true); +# 1307 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float logbf(float x) noexcept(true); +# 1331 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int ilogb(double x) noexcept(true); +# 1355 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int ilogbf(float x) noexcept(true); +# 1383 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double scalbn(double x, int n) noexcept(true); +# 1411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float scalbnf(float x, int n) noexcept(true); +# 1439 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double scalbln(double x, long n) noexcept(true); +# 1467 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float scalblnf(float x, long n) noexcept(true); +# 1499 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double frexp(double x, int * nptr) noexcept(true); +# 1528 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float frexpf(float x, int * nptr) noexcept(true); +# 1551 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double round(double x) noexcept(true); +# 1577 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float roundf(float x) noexcept(true); +# 1595 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern long lround(double x) noexcept(true); +# 1613 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern long lroundf(float x) noexcept(true); +# 1631 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern long long llround(double x) noexcept(true); +# 1649 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern long long llroundf(float x) noexcept(true); +# 1719 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float rintf(float x) noexcept(true); +# 1736 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern long lrint(double x) noexcept(true); +# 1753 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern long lrintf(float x) noexcept(true); +# 1770 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern long long llrint(double x) noexcept(true); +# 1787 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern long long llrintf(float x) noexcept(true); +# 1811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double nearbyint(double x) noexcept(true); +# 1835 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float nearbyintf(float x) noexcept(true); +# 1859 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double ceil(double x) noexcept(true); +# 1882 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double trunc(double x) noexcept(true); +# 1908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float truncf(float x) noexcept(true); +# 1930 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double fdim(double x, double y) noexcept(true); +# 1951 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float fdimf(float x, float y) noexcept(true); +# 2034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double atan2(double y, double x) noexcept(true); +# 2060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double atan(double x) noexcept(true); +# 2077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double acos(double x) noexcept(true); +# 2099 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double asin(double x) noexcept(true); +# 2130 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double hypot(double x, double y) noexcept(true); +# 2187 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float hypotf(float x, float y) noexcept(true); +# 2459 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double cbrt(double x) noexcept(true); +# 2486 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float cbrtf(float x) noexcept(true); +# 2512 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double rcbrt(double x); +# 2533 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float rcbrtf(float x); +# 2556 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double sinpi(double x) noexcept(true); +# 2579 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float sinpif(float x) noexcept(true); +# 2601 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double cospi(double x) noexcept(true); +# 2623 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float cospif(float x) noexcept(true); +# 2636 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern void sincospi(double x, double * sptr, double * cptr); +# 2649 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern void sincospif(float x, float * sptr, float * cptr); +# 2735 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double pow(double x, double y) noexcept(true); +# 2759 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double modf(double x, double * iptr) noexcept(true); +# 2786 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double fmod(double x, double y) noexcept(true); +# 2816 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double remainder(double x, double y) noexcept(true); +# 2849 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float remainderf(float x, float y) noexcept(true); +# 2887 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double remquo(double x, double y, int * quo) noexcept(true); +# 2925 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float remquof(float x, float y, int * quo) noexcept(true); +# 2946 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double j0(double x) noexcept(true); +# 2968 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float j0f(float x) noexcept(true); +# 2995 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double j1(double x) noexcept(true); +# 3022 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float j1f(float x) noexcept(true); +# 3045 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double jn(int n, double x) noexcept(true); +# 3068 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float jnf(int n, float x) noexcept(true); +# 3095 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double y0(double x) noexcept(true); +# 3122 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float y0f(float x) noexcept(true); +# 3149 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double y1(double x) noexcept(true); +# 3176 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float y1f(float x) noexcept(true); +# 3204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double yn(int n, double x) noexcept(true); +# 3232 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float ynf(int n, float x) noexcept(true); +# 3328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double erf(double x) noexcept(true); +# 3353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float erff(float x) noexcept(true); +# 3383 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double erfinv(double x); +# 3406 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float erfinvf(float x); +# 3430 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double erfc(double x) noexcept(true); +# 3453 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float erfcf(float x) noexcept(true); +# 3485 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double lgamma(double x) noexcept(true); +# 3513 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double erfcinv(double x); +# 3534 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float erfcinvf(float x); +# 3556 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double normcdfinv(double x); +# 3578 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float normcdfinvf(float x); +# 3597 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double normcdf(double x); +# 3616 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float normcdff(float x); +# 3636 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double erfcx(double x); +# 3656 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float erfcxf(float x); +# 3689 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float lgammaf(float x) noexcept(true); +# 3718 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double tgamma(double x) noexcept(true); +# 3747 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float tgammaf(float x) noexcept(true); +# 3761 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double copysign(double x, double y) noexcept(true); +# 3775 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float copysignf(float x, float y) noexcept(true); +# 3794 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double nextafter(double x, double y) noexcept(true); +# 3813 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float nextafterf(float x, float y) noexcept(true); +# 3829 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double nan(const char * tagp) noexcept(true); +# 3845 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float nanf(const char * tagp) noexcept(true); +# 3852 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __isinff(float) noexcept(true); +# 3853 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __isnanf(float) noexcept(true); +# 3863 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __finite(double) noexcept(true); +# 3864 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __finitef(float) noexcept(true); +# 3865 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __signbit(double) noexcept(true); +# 3866 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __isnan(double) noexcept(true); +# 3867 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __isinf(double) noexcept(true); +# 3870 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __signbitf(float) noexcept(true); +# 3921 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double fma(double x, double y, double z) noexcept(true); +# 3971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float fmaf(float x, float y, float z) noexcept(true); +# 3982 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __signbitl(long double) noexcept(true); +# 3988 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __finitel(long double) noexcept(true); +# 3989 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __isinfl(long double) noexcept(true); +# 3990 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __isnanl(long double) noexcept(true); +# 4034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float acosf(float x) noexcept(true); +# 4056 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float asinf(float x) noexcept(true); +# 4083 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float atanf(float x) noexcept(true); +# 4163 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float atan2f(float y, float x) noexcept(true); +# 4182 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float cosf(float x) noexcept(true); +# 4202 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float sinf(float x) noexcept(true); +# 4222 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float tanf(float x) noexcept(true); +# 4241 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float coshf(float x) noexcept(true); +# 4261 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float sinhf(float x) noexcept(true); +# 4281 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float tanhf(float x) noexcept(true); +# 4304 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float logf(float x) noexcept(true); +# 4334 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float expf(float x) noexcept(true); +# 4357 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float log10f(float x) noexcept(true); +# 4380 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float modff(float x, float * iptr) noexcept(true); +# 4463 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float powf(float x, float y) noexcept(true); +# 4487 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float sqrtf(float x) noexcept(true); +# 4510 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float ceilf(float x) noexcept(true); +# 4533 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float floorf(float x) noexcept(true); +# 4559 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float fmodf(float x, float y) noexcept(true); +# 4574 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +} +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +extern "C++" { +# 70 +namespace std __attribute((__visibility__("default"))) { +# 74 +struct __true_type { }; +# 75 +struct __false_type { }; +# 77 +template< bool > +# 78 +struct __truth_type { +# 79 +typedef __false_type __type; }; +# 82 +template<> struct __truth_type< true> { +# 83 +typedef __true_type __type; }; +# 87 +template< class _Sp, class _Tp> +# 88 +struct __traitor { +# 90 +enum { __value = ((bool)_Sp::__value) || ((bool)_Tp::__value)}; +# 91 +typedef typename __truth_type< __value> ::__type __type; +# 92 +}; +# 95 +template< class , class > +# 96 +struct __are_same { +# 98 +enum { __value}; +# 99 +typedef __false_type __type; +# 100 +}; +# 102 +template< class _Tp> +# 103 +struct __are_same< _Tp, _Tp> { +# 105 +enum { __value = 1}; +# 106 +typedef __true_type __type; +# 107 +}; +# 110 +template< class _Tp> +# 111 +struct __is_void { +# 113 +enum { __value}; +# 114 +typedef __false_type __type; +# 115 +}; +# 118 +template<> struct __is_void< void> { +# 120 +enum { __value = 1}; +# 121 +typedef __true_type __type; +# 122 +}; +# 127 +template< class _Tp> +# 128 +struct __is_integer { +# 130 +enum { __value}; +# 131 +typedef __false_type __type; +# 132 +}; +# 139 +template<> struct __is_integer< bool> { +# 141 +enum { __value = 1}; +# 142 +typedef __true_type __type; +# 143 +}; +# 146 +template<> struct __is_integer< char> { +# 148 +enum { __value = 1}; +# 149 +typedef __true_type __type; +# 150 +}; +# 153 +template<> struct __is_integer< signed char> { +# 155 +enum { __value = 1}; +# 156 +typedef __true_type __type; +# 157 +}; +# 160 +template<> struct __is_integer< unsigned char> { +# 162 +enum { __value = 1}; +# 163 +typedef __true_type __type; +# 164 +}; +# 168 +template<> struct __is_integer< wchar_t> { +# 170 +enum { __value = 1}; +# 171 +typedef __true_type __type; +# 172 +}; +# 186 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +template<> struct __is_integer< char16_t> { +# 188 +enum { __value = 1}; +# 189 +typedef __true_type __type; +# 190 +}; +# 193 +template<> struct __is_integer< char32_t> { +# 195 +enum { __value = 1}; +# 196 +typedef __true_type __type; +# 197 +}; +# 201 +template<> struct __is_integer< short> { +# 203 +enum { __value = 1}; +# 204 +typedef __true_type __type; +# 205 +}; +# 208 +template<> struct __is_integer< unsigned short> { +# 210 +enum { __value = 1}; +# 211 +typedef __true_type __type; +# 212 +}; +# 215 +template<> struct __is_integer< int> { +# 217 +enum { __value = 1}; +# 218 +typedef __true_type __type; +# 219 +}; +# 222 +template<> struct __is_integer< unsigned> { +# 224 +enum { __value = 1}; +# 225 +typedef __true_type __type; +# 226 +}; +# 229 +template<> struct __is_integer< long> { +# 231 +enum { __value = 1}; +# 232 +typedef __true_type __type; +# 233 +}; +# 236 +template<> struct __is_integer< unsigned long> { +# 238 +enum { __value = 1}; +# 239 +typedef __true_type __type; +# 240 +}; +# 243 +template<> struct __is_integer< long long> { +# 245 +enum { __value = 1}; +# 246 +typedef __true_type __type; +# 247 +}; +# 250 +template<> struct __is_integer< unsigned long long> { +# 252 +enum { __value = 1}; +# 253 +typedef __true_type __type; +# 254 +}; +# 273 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +template<> struct __is_integer< __int128> { enum { __value = 1}; typedef __true_type __type; }; template<> struct __is_integer< unsigned __int128> { enum { __value = 1}; typedef __true_type __type; }; +# 290 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +template< class _Tp> +# 291 +struct __is_floating { +# 293 +enum { __value}; +# 294 +typedef __false_type __type; +# 295 +}; +# 299 +template<> struct __is_floating< float> { +# 301 +enum { __value = 1}; +# 302 +typedef __true_type __type; +# 303 +}; +# 306 +template<> struct __is_floating< double> { +# 308 +enum { __value = 1}; +# 309 +typedef __true_type __type; +# 310 +}; +# 313 +template<> struct __is_floating< long double> { +# 315 +enum { __value = 1}; +# 316 +typedef __true_type __type; +# 317 +}; +# 367 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +template< class _Tp> +# 368 +struct __is_pointer { +# 370 +enum { __value}; +# 371 +typedef __false_type __type; +# 372 +}; +# 374 +template< class _Tp> +# 375 +struct __is_pointer< _Tp *> { +# 377 +enum { __value = 1}; +# 378 +typedef __true_type __type; +# 379 +}; +# 384 +template< class _Tp> +# 385 +struct __is_arithmetic : public __traitor< __is_integer< _Tp> , __is_floating< _Tp> > { +# 387 +}; +# 392 +template< class _Tp> +# 393 +struct __is_scalar : public __traitor< __is_arithmetic< _Tp> , __is_pointer< _Tp> > { +# 395 +}; +# 400 +template< class _Tp> +# 401 +struct __is_char { +# 403 +enum { __value}; +# 404 +typedef __false_type __type; +# 405 +}; +# 408 +template<> struct __is_char< char> { +# 410 +enum { __value = 1}; +# 411 +typedef __true_type __type; +# 412 +}; +# 416 +template<> struct __is_char< wchar_t> { +# 418 +enum { __value = 1}; +# 419 +typedef __true_type __type; +# 420 +}; +# 423 +template< class _Tp> +# 424 +struct __is_byte { +# 426 +enum { __value}; +# 427 +typedef __false_type __type; +# 428 +}; +# 431 +template<> struct __is_byte< char> { +# 433 +enum { __value = 1}; +# 434 +typedef __true_type __type; +# 435 +}; +# 438 +template<> struct __is_byte< signed char> { +# 440 +enum { __value = 1}; +# 441 +typedef __true_type __type; +# 442 +}; +# 445 +template<> struct __is_byte< unsigned char> { +# 447 +enum { __value = 1}; +# 448 +typedef __true_type __type; +# 449 +}; +# 452 +enum class byte: unsigned char; +# 455 +template<> struct __is_byte< byte> { +# 457 +enum { __value = 1}; +# 458 +typedef __true_type __type; +# 459 +}; +# 471 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +template< class > struct iterator_traits; +# 474 +template< class _Tp> +# 475 +struct __is_nonvolatile_trivially_copyable { +# 477 +enum { __value = __is_trivially_copyable(_Tp)}; +# 478 +}; +# 483 +template< class _Tp> +# 484 +struct __is_nonvolatile_trivially_copyable< volatile _Tp> { +# 486 +enum { __value}; +# 487 +}; +# 490 +template< class _OutputIter, class _InputIter> +# 491 +struct __memcpyable { +# 493 +enum { __value}; +# 494 +}; +# 496 +template< class _Tp> +# 497 +struct __memcpyable< _Tp *, _Tp *> : public __is_nonvolatile_trivially_copyable< _Tp> { +# 499 +}; +# 501 +template< class _Tp> +# 502 +struct __memcpyable< _Tp *, const _Tp *> : public __is_nonvolatile_trivially_copyable< _Tp> { +# 504 +}; +# 511 +template< class _Iter1, class _Iter2> +# 512 +struct __memcmpable { +# 514 +enum { __value}; +# 515 +}; +# 518 +template< class _Tp> +# 519 +struct __memcmpable< _Tp *, _Tp *> : public __is_nonvolatile_trivially_copyable< _Tp> { +# 521 +}; +# 523 +template< class _Tp> +# 524 +struct __memcmpable< const _Tp *, _Tp *> : public __is_nonvolatile_trivially_copyable< _Tp> { +# 526 +}; +# 528 +template< class _Tp> +# 529 +struct __memcmpable< _Tp *, const _Tp *> : public __is_nonvolatile_trivially_copyable< _Tp> { +# 531 +}; +# 539 +template< class _Tp, bool _TreatAsBytes = __is_byte< _Tp> ::__value> +# 546 +struct __is_memcmp_ordered { +# 548 +static const bool __value = (((_Tp)(-1)) > ((_Tp)1)); +# 549 +}; +# 551 +template< class _Tp> +# 552 +struct __is_memcmp_ordered< _Tp, false> { +# 554 +static const bool __value = false; +# 555 +}; +# 558 +template< class _Tp, class _Up, bool = sizeof(_Tp) == sizeof(_Up)> +# 559 +struct __is_memcmp_ordered_with { +# 561 +static const bool __value = (__is_memcmp_ordered< _Tp> ::__value && __is_memcmp_ordered< _Up> ::__value); +# 563 +}; +# 565 +template< class _Tp, class _Up> +# 566 +struct __is_memcmp_ordered_with< _Tp, _Up, false> { +# 568 +static const bool __value = false; +# 569 +}; +# 581 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +template<> struct __is_memcmp_ordered_with< byte, byte, true> { +# 582 +static constexpr inline bool __value = true; }; +# 584 +template< class _Tp, bool _SameSize> +# 585 +struct __is_memcmp_ordered_with< _Tp, byte, _SameSize> { +# 586 +static constexpr inline bool __value = false; }; +# 588 +template< class _Up, bool _SameSize> +# 589 +struct __is_memcmp_ordered_with< byte, _Up, _SameSize> { +# 590 +static constexpr inline bool __value = false; }; +# 596 +template< class _Tp> +# 597 +struct __is_move_iterator { +# 599 +enum { __value}; +# 600 +typedef __false_type __type; +# 601 +}; +# 605 +template< class _Iterator> inline _Iterator +# 608 +__miter_base(_Iterator __it) +# 609 +{ return __it; } +# 612 +} +# 613 +} +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 +extern "C++" { +# 39 +namespace __gnu_cxx __attribute((__visibility__("default"))) { +# 44 +template< bool , class > +# 45 +struct __enable_if { +# 46 +}; +# 48 +template< class _Tp> +# 49 +struct __enable_if< true, _Tp> { +# 50 +typedef _Tp __type; }; +# 54 +template< bool _Cond, class _Iftrue, class _Iffalse> +# 55 +struct __conditional_type { +# 56 +typedef _Iftrue __type; }; +# 58 +template< class _Iftrue, class _Iffalse> +# 59 +struct __conditional_type< false, _Iftrue, _Iffalse> { +# 60 +typedef _Iffalse __type; }; +# 64 +template< class _Tp> +# 65 +struct __add_unsigned { +# 68 +private: typedef __enable_if< std::__is_integer< _Tp> ::__value, _Tp> __if_type; +# 71 +public: typedef typename __enable_if< std::__is_integer< _Tp> ::__value, _Tp> ::__type __type; +# 72 +}; +# 75 +template<> struct __add_unsigned< char> { +# 76 +typedef unsigned char __type; }; +# 79 +template<> struct __add_unsigned< signed char> { +# 80 +typedef unsigned char __type; }; +# 83 +template<> struct __add_unsigned< short> { +# 84 +typedef unsigned short __type; }; +# 87 +template<> struct __add_unsigned< int> { +# 88 +typedef unsigned __type; }; +# 91 +template<> struct __add_unsigned< long> { +# 92 +typedef unsigned long __type; }; +# 95 +template<> struct __add_unsigned< long long> { +# 96 +typedef unsigned long long __type; }; +# 100 +template<> struct __add_unsigned< bool> ; +# 103 +template<> struct __add_unsigned< wchar_t> ; +# 107 +template< class _Tp> +# 108 +struct __remove_unsigned { +# 111 +private: typedef __enable_if< std::__is_integer< _Tp> ::__value, _Tp> __if_type; +# 114 +public: typedef typename __enable_if< std::__is_integer< _Tp> ::__value, _Tp> ::__type __type; +# 115 +}; +# 118 +template<> struct __remove_unsigned< char> { +# 119 +typedef signed char __type; }; +# 122 +template<> struct __remove_unsigned< unsigned char> { +# 123 +typedef signed char __type; }; +# 126 +template<> struct __remove_unsigned< unsigned short> { +# 127 +typedef short __type; }; +# 130 +template<> struct __remove_unsigned< unsigned> { +# 131 +typedef int __type; }; +# 134 +template<> struct __remove_unsigned< unsigned long> { +# 135 +typedef long __type; }; +# 138 +template<> struct __remove_unsigned< unsigned long long> { +# 139 +typedef long long __type; }; +# 143 +template<> struct __remove_unsigned< bool> ; +# 146 +template<> struct __remove_unsigned< wchar_t> ; +# 150 +template< class _Type> constexpr bool +# 153 +__is_null_pointer(_Type *__ptr) +# 154 +{ return __ptr == 0; } +# 156 +template< class _Type> constexpr bool +# 159 +__is_null_pointer(_Type) +# 160 +{ return false; } +# 164 +constexpr bool __is_null_pointer(std::nullptr_t) +# 165 +{ return true; } +# 170 +template< class _Tp, bool = std::template __is_integer< _Tp> ::__value> +# 171 +struct __promote { +# 172 +typedef double __type; }; +# 177 +template< class _Tp> +# 178 +struct __promote< _Tp, false> { +# 179 +}; +# 182 +template<> struct __promote< long double> { +# 183 +typedef long double __type; }; +# 186 +template<> struct __promote< double> { +# 187 +typedef double __type; }; +# 190 +template<> struct __promote< float> { +# 191 +typedef float __type; }; +# 225 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 +template< class ..._Tp> using __promoted_t = __decltype(((((typename __promote< _Tp> ::__type)0) + ... ))); +# 230 +template< class _Tp, class _Up> using __promote_2 = __promote< __promoted_t< _Tp, _Up> > ; +# 233 +template< class _Tp, class _Up, class _Vp> using __promote_3 = __promote< __promoted_t< _Tp, _Up, _Vp> > ; +# 236 +template< class _Tp, class _Up, class _Vp, class _Wp> using __promote_4 = __promote< __promoted_t< _Tp, _Up, _Vp, _Wp> > ; +# 270 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 +} +# 271 +} +# 34 "/usr/include/math.h" 3 +extern "C" { +# 167 "/usr/include/math.h" 3 +typedef float float_t; +# 168 +typedef double double_t; +# 256 "/usr/include/math.h" 3 +enum { +# 257 +FP_INT_UPWARD, +# 260 +FP_INT_DOWNWARD, +# 263 +FP_INT_TOWARDZERO, +# 266 +FP_INT_TONEARESTFROMZERO, +# 269 +FP_INT_TONEAREST +# 272 +}; +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 +extern int __fpclassify(double __value) noexcept(true) +# 21 + __attribute((const)); +# 24 +extern int __signbit(double __value) noexcept(true) +# 25 + __attribute((const)); +# 29 +extern int __isinf(double __value) noexcept(true) +# 30 + __attribute((const)); +# 33 +extern int __finite(double __value) noexcept(true) +# 34 + __attribute((const)); +# 37 +extern int __isnan(double __value) noexcept(true) +# 38 + __attribute((const)); +# 41 +extern int __iseqsig(double __x, double __y) noexcept(true); +# 44 +extern int __issignaling(double __value) noexcept(true) +# 45 + __attribute((const)); +# 53 "/usr/include/bits/mathcalls.h" 3 +extern double acos(double __x) noexcept(true); extern double __acos(double __x) noexcept(true); +# 55 +extern double asin(double __x) noexcept(true); extern double __asin(double __x) noexcept(true); +# 57 +extern double atan(double __x) noexcept(true); extern double __atan(double __x) noexcept(true); +# 59 +extern double atan2(double __y, double __x) noexcept(true); extern double __atan2(double __y, double __x) noexcept(true); +# 62 +extern double cos(double __x) noexcept(true); extern double __cos(double __x) noexcept(true); +# 64 +extern double sin(double __x) noexcept(true); extern double __sin(double __x) noexcept(true); +# 66 +extern double tan(double __x) noexcept(true); extern double __tan(double __x) noexcept(true); +# 70 +extern double acospi(double __x) noexcept(true); extern double __acospi(double __x) noexcept(true); +# 72 +extern double asinpi(double __x) noexcept(true); extern double __asinpi(double __x) noexcept(true); +# 74 +extern double atanpi(double __x) noexcept(true); extern double __atanpi(double __x) noexcept(true); +# 76 +extern double atan2pi(double __y, double __x) noexcept(true); extern double __atan2pi(double __y, double __x) noexcept(true); +# 79 +extern double cospi(double __x) noexcept(true); extern double __cospi(double __x) noexcept(true); +# 81 +extern double sinpi(double __x) noexcept(true); extern double __sinpi(double __x) noexcept(true); +# 83 +extern double tanpi(double __x) noexcept(true); extern double __tanpi(double __x) noexcept(true); +# 89 +extern double cosh(double __x) noexcept(true); extern double __cosh(double __x) noexcept(true); +# 91 +extern double sinh(double __x) noexcept(true); extern double __sinh(double __x) noexcept(true); +# 93 +extern double tanh(double __x) noexcept(true); extern double __tanh(double __x) noexcept(true); +# 97 +extern void sincos(double __x, double * __sinx, double * __cosx) noexcept(true); extern void __sincos(double __x, double * __sinx, double * __cosx) noexcept(true); +# 103 +extern double acosh(double __x) noexcept(true); extern double __acosh(double __x) noexcept(true); +# 105 +extern double asinh(double __x) noexcept(true); extern double __asinh(double __x) noexcept(true); +# 107 +extern double atanh(double __x) noexcept(true); extern double __atanh(double __x) noexcept(true); +# 113 +extern double exp(double __x) noexcept(true); extern double __exp(double __x) noexcept(true); +# 116 +extern double frexp(double __x, int * __exponent) noexcept(true); extern double __frexp(double __x, int * __exponent) noexcept(true); +# 119 +extern double ldexp(double __x, int __exponent) noexcept(true); extern double __ldexp(double __x, int __exponent) noexcept(true); +# 122 +extern double log(double __x) noexcept(true); extern double __log(double __x) noexcept(true); +# 125 +extern double log10(double __x) noexcept(true); extern double __log10(double __x) noexcept(true); +# 128 +extern double modf(double __x, double * __iptr) noexcept(true); extern double __modf(double __x, double * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 132 +extern double exp10(double __x) noexcept(true); extern double __exp10(double __x) noexcept(true); +# 135 +extern double exp2m1(double __x) noexcept(true); extern double __exp2m1(double __x) noexcept(true); +# 138 +extern double exp10m1(double __x) noexcept(true); extern double __exp10m1(double __x) noexcept(true); +# 141 +extern double log2p1(double __x) noexcept(true); extern double __log2p1(double __x) noexcept(true); +# 144 +extern double log10p1(double __x) noexcept(true); extern double __log10p1(double __x) noexcept(true); +# 147 +extern double logp1(double __x) noexcept(true); extern double __logp1(double __x) noexcept(true); +# 152 +extern double expm1(double __x) noexcept(true); extern double __expm1(double __x) noexcept(true); +# 155 +extern double log1p(double __x) noexcept(true); extern double __log1p(double __x) noexcept(true); +# 158 +extern double logb(double __x) noexcept(true); extern double __logb(double __x) noexcept(true); +# 163 +extern double exp2(double __x) noexcept(true); extern double __exp2(double __x) noexcept(true); +# 166 +extern double log2(double __x) noexcept(true); extern double __log2(double __x) noexcept(true); +# 173 +extern double pow(double __x, double __y) noexcept(true); extern double __pow(double __x, double __y) noexcept(true); +# 176 +extern double sqrt(double __x) noexcept(true); extern double __sqrt(double __x) noexcept(true); +# 180 +extern double hypot(double __x, double __y) noexcept(true); extern double __hypot(double __x, double __y) noexcept(true); +# 185 +extern double cbrt(double __x) noexcept(true); extern double __cbrt(double __x) noexcept(true); +# 192 +extern double ceil(double __x) noexcept(true) __attribute((const)); +# 195 +extern double fabs(double __x) noexcept(true) __attribute((const)); +# 198 +extern double floor(double __x) noexcept(true) __attribute((const)); +# 201 +extern double fmod(double __x, double __y) noexcept(true); extern double __fmod(double __x, double __y) noexcept(true); +# 216 "/usr/include/bits/mathcalls.h" 3 +extern int finite(double __value) noexcept(true) +# 217 + __attribute((const)); +# 220 +extern double drem(double __x, double __y) noexcept(true); extern double __drem(double __x, double __y) noexcept(true); +# 224 +extern double significand(double __x) noexcept(true); extern double __significand(double __x) noexcept(true); +# 231 +extern double copysign(double __x, double __y) noexcept(true) __attribute((const)); +# 236 +extern double nan(const char * __tagb) noexcept(true); extern double __nan(const char * __tagb) noexcept(true); +# 253 "/usr/include/bits/mathcalls.h" 3 +extern double j0(double) noexcept(true); extern double __j0(double) noexcept(true); +# 254 +extern double j1(double) noexcept(true); extern double __j1(double) noexcept(true); +# 255 +extern double jn(int, double) noexcept(true); extern double __jn(int, double) noexcept(true); +# 256 +extern double y0(double) noexcept(true); extern double __y0(double) noexcept(true); +# 257 +extern double y1(double) noexcept(true); extern double __y1(double) noexcept(true); +# 258 +extern double yn(int, double) noexcept(true); extern double __yn(int, double) noexcept(true); +# 264 +extern double erf(double) noexcept(true); extern double __erf(double) noexcept(true); +# 265 +extern double erfc(double) noexcept(true); extern double __erfc(double) noexcept(true); +# 266 +extern double lgamma(double) noexcept(true); extern double __lgamma(double) noexcept(true); +# 271 +extern double tgamma(double) noexcept(true); extern double __tgamma(double) noexcept(true); +# 277 +extern double gamma(double) noexcept(true); extern double __gamma(double) noexcept(true); +# 285 +extern double lgamma_r(double, int * __signgamp) noexcept(true); extern double __lgamma_r(double, int * __signgamp) noexcept(true); +# 292 +extern double rint(double __x) noexcept(true); extern double __rint(double __x) noexcept(true); +# 295 +extern double nextafter(double __x, double __y) noexcept(true); extern double __nextafter(double __x, double __y) noexcept(true); +# 297 +extern double nexttoward(double __x, long double __y) noexcept(true); extern double __nexttoward(double __x, long double __y) noexcept(true); +# 302 +extern double nextdown(double __x) noexcept(true); extern double __nextdown(double __x) noexcept(true); +# 304 +extern double nextup(double __x) noexcept(true); extern double __nextup(double __x) noexcept(true); +# 308 +extern double remainder(double __x, double __y) noexcept(true); extern double __remainder(double __x, double __y) noexcept(true); +# 312 +extern double scalbn(double __x, int __n) noexcept(true); extern double __scalbn(double __x, int __n) noexcept(true); +# 316 +extern int ilogb(double __x) noexcept(true); extern int __ilogb(double __x) noexcept(true); +# 321 +extern long llogb(double __x) noexcept(true); extern long __llogb(double __x) noexcept(true); +# 326 +extern double scalbln(double __x, long __n) noexcept(true); extern double __scalbln(double __x, long __n) noexcept(true); +# 330 +extern double nearbyint(double __x) noexcept(true); extern double __nearbyint(double __x) noexcept(true); +# 334 +extern double round(double __x) noexcept(true) __attribute((const)); +# 338 +extern double trunc(double __x) noexcept(true) __attribute((const)); +# 343 +extern double remquo(double __x, double __y, int * __quo) noexcept(true); extern double __remquo(double __x, double __y, int * __quo) noexcept(true); +# 350 +extern long lrint(double __x) noexcept(true); extern long __lrint(double __x) noexcept(true); +# 352 +__extension__ extern long long llrint(double __x) noexcept(true); extern long long __llrint(double __x) noexcept(true); +# 356 +extern long lround(double __x) noexcept(true); extern long __lround(double __x) noexcept(true); +# 358 +__extension__ extern long long llround(double __x) noexcept(true); extern long long __llround(double __x) noexcept(true); +# 362 +extern double fdim(double __x, double __y) noexcept(true); extern double __fdim(double __x, double __y) noexcept(true); +# 366 +extern double fmax(double __x, double __y) noexcept(true) __attribute((const)); +# 369 +extern double fmin(double __x, double __y) noexcept(true) __attribute((const)); +# 373 +extern double fma(double __x, double __y, double __z) noexcept(true); extern double __fma(double __x, double __y, double __z) noexcept(true); +# 378 +extern double roundeven(double __x) noexcept(true) __attribute((const)); +# 382 +extern __intmax_t fromfp(double __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfp(double __x, int __round, unsigned __width) noexcept(true); +# 387 +extern __uintmax_t ufromfp(double __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfp(double __x, int __round, unsigned __width) noexcept(true); +# 393 +extern __intmax_t fromfpx(double __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpx(double __x, int __round, unsigned __width) noexcept(true); +# 399 +extern __uintmax_t ufromfpx(double __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpx(double __x, int __round, unsigned __width) noexcept(true); +# 403 +extern int canonicalize(double * __cx, const double * __x) noexcept(true); +# 410 +extern double fmaxmag(double __x, double __y) noexcept(true) __attribute((const)); +# 413 +extern double fminmag(double __x, double __y) noexcept(true) __attribute((const)); +# 418 +extern double fmaximum(double __x, double __y) noexcept(true) __attribute((const)); +# 421 +extern double fminimum(double __x, double __y) noexcept(true) __attribute((const)); +# 424 +extern double fmaximum_num(double __x, double __y) noexcept(true) __attribute((const)); +# 427 +extern double fminimum_num(double __x, double __y) noexcept(true) __attribute((const)); +# 430 +extern double fmaximum_mag(double __x, double __y) noexcept(true) __attribute((const)); +# 433 +extern double fminimum_mag(double __x, double __y) noexcept(true) __attribute((const)); +# 436 +extern double fmaximum_mag_num(double __x, double __y) noexcept(true) __attribute((const)); +# 439 +extern double fminimum_mag_num(double __x, double __y) noexcept(true) __attribute((const)); +# 444 +extern int totalorder(const double * __x, const double * __y) noexcept(true) +# 446 + __attribute((__pure__)); +# 449 +extern int totalordermag(const double * __x, const double * __y) noexcept(true) +# 451 + __attribute((__pure__)); +# 454 +extern double getpayload(const double * __x) noexcept(true); extern double __getpayload(const double * __x) noexcept(true); +# 457 +extern int setpayload(double * __x, double __payload) noexcept(true); +# 460 +extern int setpayloadsig(double * __x, double __payload) noexcept(true); +# 468 +extern double scalb(double __x, double __n) noexcept(true); extern double __scalb(double __x, double __n) noexcept(true); +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 +extern int __fpclassifyf(float __value) noexcept(true) +# 21 + __attribute((const)); +# 24 +extern int __signbitf(float __value) noexcept(true) +# 25 + __attribute((const)); +# 29 +extern int __isinff(float __value) noexcept(true) +# 30 + __attribute((const)); +# 33 +extern int __finitef(float __value) noexcept(true) +# 34 + __attribute((const)); +# 37 +extern int __isnanf(float __value) noexcept(true) +# 38 + __attribute((const)); +# 41 +extern int __iseqsigf(float __x, float __y) noexcept(true); +# 44 +extern int __issignalingf(float __value) noexcept(true) +# 45 + __attribute((const)); +# 53 "/usr/include/bits/mathcalls.h" 3 +extern float acosf(float __x) noexcept(true); extern float __acosf(float __x) noexcept(true); +# 55 +extern float asinf(float __x) noexcept(true); extern float __asinf(float __x) noexcept(true); +# 57 +extern float atanf(float __x) noexcept(true); extern float __atanf(float __x) noexcept(true); +# 59 +extern float atan2f(float __y, float __x) noexcept(true); extern float __atan2f(float __y, float __x) noexcept(true); +# 62 +extern float cosf(float __x) noexcept(true); +# 64 +extern float sinf(float __x) noexcept(true); +# 66 +extern float tanf(float __x) noexcept(true); +# 70 +extern float acospif(float __x) noexcept(true); extern float __acospif(float __x) noexcept(true); +# 72 +extern float asinpif(float __x) noexcept(true); extern float __asinpif(float __x) noexcept(true); +# 74 +extern float atanpif(float __x) noexcept(true); extern float __atanpif(float __x) noexcept(true); +# 76 +extern float atan2pif(float __y, float __x) noexcept(true); extern float __atan2pif(float __y, float __x) noexcept(true); +# 79 +extern float cospif(float __x) noexcept(true); extern float __cospif(float __x) noexcept(true); +# 81 +extern float sinpif(float __x) noexcept(true); extern float __sinpif(float __x) noexcept(true); +# 83 +extern float tanpif(float __x) noexcept(true); extern float __tanpif(float __x) noexcept(true); +# 89 +extern float coshf(float __x) noexcept(true); extern float __coshf(float __x) noexcept(true); +# 91 +extern float sinhf(float __x) noexcept(true); extern float __sinhf(float __x) noexcept(true); +# 93 +extern float tanhf(float __x) noexcept(true); +# 97 +extern void sincosf(float __x, float * __sinx, float * __cosx) noexcept(true); +# 103 +extern float acoshf(float __x) noexcept(true); extern float __acoshf(float __x) noexcept(true); +# 105 +extern float asinhf(float __x) noexcept(true); extern float __asinhf(float __x) noexcept(true); +# 107 +extern float atanhf(float __x) noexcept(true); extern float __atanhf(float __x) noexcept(true); +# 113 +extern float expf(float __x) noexcept(true); +# 116 +extern float frexpf(float __x, int * __exponent) noexcept(true); extern float __frexpf(float __x, int * __exponent) noexcept(true); +# 119 +extern float ldexpf(float __x, int __exponent) noexcept(true); extern float __ldexpf(float __x, int __exponent) noexcept(true); +# 122 +extern float logf(float __x) noexcept(true); +# 125 +extern float log10f(float __x) noexcept(true); +# 128 +extern float modff(float __x, float * __iptr) noexcept(true); extern float __modff(float __x, float * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 132 +extern float exp10f(float __x) noexcept(true); +# 135 +extern float exp2m1f(float __x) noexcept(true); extern float __exp2m1f(float __x) noexcept(true); +# 138 +extern float exp10m1f(float __x) noexcept(true); extern float __exp10m1f(float __x) noexcept(true); +# 141 +extern float log2p1f(float __x) noexcept(true); extern float __log2p1f(float __x) noexcept(true); +# 144 +extern float log10p1f(float __x) noexcept(true); extern float __log10p1f(float __x) noexcept(true); +# 147 +extern float logp1f(float __x) noexcept(true); extern float __logp1f(float __x) noexcept(true); +# 152 +extern float expm1f(float __x) noexcept(true); extern float __expm1f(float __x) noexcept(true); +# 155 +extern float log1pf(float __x) noexcept(true); extern float __log1pf(float __x) noexcept(true); +# 158 +extern float logbf(float __x) noexcept(true); extern float __logbf(float __x) noexcept(true); +# 163 +extern float exp2f(float __x) noexcept(true); extern float __exp2f(float __x) noexcept(true); +# 166 +extern float log2f(float __x) noexcept(true); +# 173 +extern float powf(float __x, float __y) noexcept(true); +# 176 +extern float sqrtf(float __x) noexcept(true); extern float __sqrtf(float __x) noexcept(true); +# 180 +extern float hypotf(float __x, float __y) noexcept(true); extern float __hypotf(float __x, float __y) noexcept(true); +# 185 +extern float cbrtf(float __x) noexcept(true); extern float __cbrtf(float __x) noexcept(true); +# 192 +extern float ceilf(float __x) noexcept(true) __attribute((const)); +# 195 +extern float fabsf(float __x) noexcept(true) __attribute((const)); +# 198 +extern float floorf(float __x) noexcept(true) __attribute((const)); +# 201 +extern float fmodf(float __x, float __y) noexcept(true); extern float __fmodf(float __x, float __y) noexcept(true); +# 210 "/usr/include/bits/mathcalls.h" 3 +extern int isinff(float __value) noexcept(true) +# 211 + __attribute((const)); +# 216 +extern int finitef(float __value) noexcept(true) +# 217 + __attribute((const)); +# 220 +extern float dremf(float __x, float __y) noexcept(true); extern float __dremf(float __x, float __y) noexcept(true); +# 224 +extern float significandf(float __x) noexcept(true); extern float __significandf(float __x) noexcept(true); +# 231 +extern float copysignf(float __x, float __y) noexcept(true) __attribute((const)); +# 236 +extern float nanf(const char * __tagb) noexcept(true); extern float __nanf(const char * __tagb) noexcept(true); +# 246 "/usr/include/bits/mathcalls.h" 3 +extern int isnanf(float __value) noexcept(true) +# 247 + __attribute((const)); +# 253 +extern float j0f(float) noexcept(true); extern float __j0f(float) noexcept(true); +# 254 +extern float j1f(float) noexcept(true); extern float __j1f(float) noexcept(true); +# 255 +extern float jnf(int, float) noexcept(true); extern float __jnf(int, float) noexcept(true); +# 256 +extern float y0f(float) noexcept(true); extern float __y0f(float) noexcept(true); +# 257 +extern float y1f(float) noexcept(true); extern float __y1f(float) noexcept(true); +# 258 +extern float ynf(int, float) noexcept(true); extern float __ynf(int, float) noexcept(true); +# 264 +extern float erff(float) noexcept(true); extern float __erff(float) noexcept(true); +# 265 +extern float erfcf(float) noexcept(true); extern float __erfcf(float) noexcept(true); +# 266 +extern float lgammaf(float) noexcept(true); extern float __lgammaf(float) noexcept(true); +# 271 +extern float tgammaf(float) noexcept(true); extern float __tgammaf(float) noexcept(true); +# 277 +extern float gammaf(float) noexcept(true); extern float __gammaf(float) noexcept(true); +# 285 +extern float lgammaf_r(float, int * __signgamp) noexcept(true); extern float __lgammaf_r(float, int * __signgamp) noexcept(true); +# 292 +extern float rintf(float __x) noexcept(true); extern float __rintf(float __x) noexcept(true); +# 295 +extern float nextafterf(float __x, float __y) noexcept(true); extern float __nextafterf(float __x, float __y) noexcept(true); +# 297 +extern float nexttowardf(float __x, long double __y) noexcept(true); extern float __nexttowardf(float __x, long double __y) noexcept(true); +# 302 +extern float nextdownf(float __x) noexcept(true); extern float __nextdownf(float __x) noexcept(true); +# 304 +extern float nextupf(float __x) noexcept(true); extern float __nextupf(float __x) noexcept(true); +# 308 +extern float remainderf(float __x, float __y) noexcept(true); extern float __remainderf(float __x, float __y) noexcept(true); +# 312 +extern float scalbnf(float __x, int __n) noexcept(true); extern float __scalbnf(float __x, int __n) noexcept(true); +# 316 +extern int ilogbf(float __x) noexcept(true); extern int __ilogbf(float __x) noexcept(true); +# 321 +extern long llogbf(float __x) noexcept(true); extern long __llogbf(float __x) noexcept(true); +# 326 +extern float scalblnf(float __x, long __n) noexcept(true); extern float __scalblnf(float __x, long __n) noexcept(true); +# 330 +extern float nearbyintf(float __x) noexcept(true); extern float __nearbyintf(float __x) noexcept(true); +# 334 +extern float roundf(float __x) noexcept(true) __attribute((const)); +# 338 +extern float truncf(float __x) noexcept(true) __attribute((const)); +# 343 +extern float remquof(float __x, float __y, int * __quo) noexcept(true); extern float __remquof(float __x, float __y, int * __quo) noexcept(true); +# 350 +extern long lrintf(float __x) noexcept(true); extern long __lrintf(float __x) noexcept(true); +# 352 +__extension__ extern long long llrintf(float __x) noexcept(true); extern long long __llrintf(float __x) noexcept(true); +# 356 +extern long lroundf(float __x) noexcept(true); extern long __lroundf(float __x) noexcept(true); +# 358 +__extension__ extern long long llroundf(float __x) noexcept(true); extern long long __llroundf(float __x) noexcept(true); +# 362 +extern float fdimf(float __x, float __y) noexcept(true); extern float __fdimf(float __x, float __y) noexcept(true); +# 366 +extern float fmaxf(float __x, float __y) noexcept(true) __attribute((const)); +# 369 +extern float fminf(float __x, float __y) noexcept(true) __attribute((const)); +# 373 +extern float fmaf(float __x, float __y, float __z) noexcept(true); extern float __fmaf(float __x, float __y, float __z) noexcept(true); +# 378 +extern float roundevenf(float __x) noexcept(true) __attribute((const)); +# 382 +extern __intmax_t fromfpf(float __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpf(float __x, int __round, unsigned __width) noexcept(true); +# 387 +extern __uintmax_t ufromfpf(float __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpf(float __x, int __round, unsigned __width) noexcept(true); +# 393 +extern __intmax_t fromfpxf(float __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpxf(float __x, int __round, unsigned __width) noexcept(true); +# 399 +extern __uintmax_t ufromfpxf(float __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpxf(float __x, int __round, unsigned __width) noexcept(true); +# 403 +extern int canonicalizef(float * __cx, const float * __x) noexcept(true); +# 410 +extern float fmaxmagf(float __x, float __y) noexcept(true) __attribute((const)); +# 413 +extern float fminmagf(float __x, float __y) noexcept(true) __attribute((const)); +# 418 +extern float fmaximumf(float __x, float __y) noexcept(true) __attribute((const)); +# 421 +extern float fminimumf(float __x, float __y) noexcept(true) __attribute((const)); +# 424 +extern float fmaximum_numf(float __x, float __y) noexcept(true) __attribute((const)); +# 427 +extern float fminimum_numf(float __x, float __y) noexcept(true) __attribute((const)); +# 430 +extern float fmaximum_magf(float __x, float __y) noexcept(true) __attribute((const)); +# 433 +extern float fminimum_magf(float __x, float __y) noexcept(true) __attribute((const)); +# 436 +extern float fmaximum_mag_numf(float __x, float __y) noexcept(true) __attribute((const)); +# 439 +extern float fminimum_mag_numf(float __x, float __y) noexcept(true) __attribute((const)); +# 444 +extern int totalorderf(const float * __x, const float * __y) noexcept(true) +# 446 + __attribute((__pure__)); +# 449 +extern int totalordermagf(const float * __x, const float * __y) noexcept(true) +# 451 + __attribute((__pure__)); +# 454 +extern float getpayloadf(const float * __x) noexcept(true); extern float __getpayloadf(const float * __x) noexcept(true); +# 457 +extern int setpayloadf(float * __x, float __payload) noexcept(true); +# 460 +extern int setpayloadsigf(float * __x, float __payload) noexcept(true); +# 468 +extern float scalbf(float __x, float __n) noexcept(true); extern float __scalbf(float __x, float __n) noexcept(true); +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 +extern int __fpclassifyl(long double __value) noexcept(true) +# 21 + __attribute((const)); +# 24 +extern int __signbitl(long double __value) noexcept(true) +# 25 + __attribute((const)); +# 29 +extern int __isinfl(long double __value) noexcept(true) +# 30 + __attribute((const)); +# 33 +extern int __finitel(long double __value) noexcept(true) +# 34 + __attribute((const)); +# 37 +extern int __isnanl(long double __value) noexcept(true) +# 38 + __attribute((const)); +# 41 +extern int __iseqsigl(long double __x, long double __y) noexcept(true); +# 44 +extern int __issignalingl(long double __value) noexcept(true) +# 45 + __attribute((const)); +# 53 "/usr/include/bits/mathcalls.h" 3 +extern long double acosl(long double __x) noexcept(true); extern long double __acosl(long double __x) noexcept(true); +# 55 +extern long double asinl(long double __x) noexcept(true); extern long double __asinl(long double __x) noexcept(true); +# 57 +extern long double atanl(long double __x) noexcept(true); extern long double __atanl(long double __x) noexcept(true); +# 59 +extern long double atan2l(long double __y, long double __x) noexcept(true); extern long double __atan2l(long double __y, long double __x) noexcept(true); +# 62 +extern long double cosl(long double __x) noexcept(true); extern long double __cosl(long double __x) noexcept(true); +# 64 +extern long double sinl(long double __x) noexcept(true); extern long double __sinl(long double __x) noexcept(true); +# 66 +extern long double tanl(long double __x) noexcept(true); extern long double __tanl(long double __x) noexcept(true); +# 70 +extern long double acospil(long double __x) noexcept(true); extern long double __acospil(long double __x) noexcept(true); +# 72 +extern long double asinpil(long double __x) noexcept(true); extern long double __asinpil(long double __x) noexcept(true); +# 74 +extern long double atanpil(long double __x) noexcept(true); extern long double __atanpil(long double __x) noexcept(true); +# 76 +extern long double atan2pil(long double __y, long double __x) noexcept(true); extern long double __atan2pil(long double __y, long double __x) noexcept(true); +# 79 +extern long double cospil(long double __x) noexcept(true); extern long double __cospil(long double __x) noexcept(true); +# 81 +extern long double sinpil(long double __x) noexcept(true); extern long double __sinpil(long double __x) noexcept(true); +# 83 +extern long double tanpil(long double __x) noexcept(true); extern long double __tanpil(long double __x) noexcept(true); +# 89 +extern long double coshl(long double __x) noexcept(true); extern long double __coshl(long double __x) noexcept(true); +# 91 +extern long double sinhl(long double __x) noexcept(true); extern long double __sinhl(long double __x) noexcept(true); +# 93 +extern long double tanhl(long double __x) noexcept(true); extern long double __tanhl(long double __x) noexcept(true); +# 97 +extern void sincosl(long double __x, long double * __sinx, long double * __cosx) noexcept(true); extern void __sincosl(long double __x, long double * __sinx, long double * __cosx) noexcept(true); +# 103 +extern long double acoshl(long double __x) noexcept(true); extern long double __acoshl(long double __x) noexcept(true); +# 105 +extern long double asinhl(long double __x) noexcept(true); extern long double __asinhl(long double __x) noexcept(true); +# 107 +extern long double atanhl(long double __x) noexcept(true); extern long double __atanhl(long double __x) noexcept(true); +# 113 +extern long double expl(long double __x) noexcept(true); extern long double __expl(long double __x) noexcept(true); +# 116 +extern long double frexpl(long double __x, int * __exponent) noexcept(true); extern long double __frexpl(long double __x, int * __exponent) noexcept(true); +# 119 +extern long double ldexpl(long double __x, int __exponent) noexcept(true); extern long double __ldexpl(long double __x, int __exponent) noexcept(true); +# 122 +extern long double logl(long double __x) noexcept(true); extern long double __logl(long double __x) noexcept(true); +# 125 +extern long double log10l(long double __x) noexcept(true); extern long double __log10l(long double __x) noexcept(true); +# 128 +extern long double modfl(long double __x, long double * __iptr) noexcept(true); extern long double __modfl(long double __x, long double * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 132 +extern long double exp10l(long double __x) noexcept(true); extern long double __exp10l(long double __x) noexcept(true); +# 135 +extern long double exp2m1l(long double __x) noexcept(true); extern long double __exp2m1l(long double __x) noexcept(true); +# 138 +extern long double exp10m1l(long double __x) noexcept(true); extern long double __exp10m1l(long double __x) noexcept(true); +# 141 +extern long double log2p1l(long double __x) noexcept(true); extern long double __log2p1l(long double __x) noexcept(true); +# 144 +extern long double log10p1l(long double __x) noexcept(true); extern long double __log10p1l(long double __x) noexcept(true); +# 147 +extern long double logp1l(long double __x) noexcept(true); extern long double __logp1l(long double __x) noexcept(true); +# 152 +extern long double expm1l(long double __x) noexcept(true); extern long double __expm1l(long double __x) noexcept(true); +# 155 +extern long double log1pl(long double __x) noexcept(true); extern long double __log1pl(long double __x) noexcept(true); +# 158 +extern long double logbl(long double __x) noexcept(true); extern long double __logbl(long double __x) noexcept(true); +# 163 +extern long double exp2l(long double __x) noexcept(true); extern long double __exp2l(long double __x) noexcept(true); +# 166 +extern long double log2l(long double __x) noexcept(true); extern long double __log2l(long double __x) noexcept(true); +# 173 +extern long double powl(long double __x, long double __y) noexcept(true); extern long double __powl(long double __x, long double __y) noexcept(true); +# 176 +extern long double sqrtl(long double __x) noexcept(true); extern long double __sqrtl(long double __x) noexcept(true); +# 180 +extern long double hypotl(long double __x, long double __y) noexcept(true); extern long double __hypotl(long double __x, long double __y) noexcept(true); +# 185 +extern long double cbrtl(long double __x) noexcept(true); extern long double __cbrtl(long double __x) noexcept(true); +# 192 +extern long double ceill(long double __x) noexcept(true) __attribute((const)); +# 195 +extern long double fabsl(long double __x) noexcept(true) __attribute((const)); +# 198 +extern long double floorl(long double __x) noexcept(true) __attribute((const)); +# 201 +extern long double fmodl(long double __x, long double __y) noexcept(true); extern long double __fmodl(long double __x, long double __y) noexcept(true); +# 210 "/usr/include/bits/mathcalls.h" 3 +extern int isinfl(long double __value) noexcept(true) +# 211 + __attribute((const)); +# 216 +extern int finitel(long double __value) noexcept(true) +# 217 + __attribute((const)); +# 220 +extern long double dreml(long double __x, long double __y) noexcept(true); extern long double __dreml(long double __x, long double __y) noexcept(true); +# 224 +extern long double significandl(long double __x) noexcept(true); extern long double __significandl(long double __x) noexcept(true); +# 231 +extern long double copysignl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 236 +extern long double nanl(const char * __tagb) noexcept(true); extern long double __nanl(const char * __tagb) noexcept(true); +# 246 "/usr/include/bits/mathcalls.h" 3 +extern int isnanl(long double __value) noexcept(true) +# 247 + __attribute((const)); +# 253 +extern long double j0l(long double) noexcept(true); extern long double __j0l(long double) noexcept(true); +# 254 +extern long double j1l(long double) noexcept(true); extern long double __j1l(long double) noexcept(true); +# 255 +extern long double jnl(int, long double) noexcept(true); extern long double __jnl(int, long double) noexcept(true); +# 256 +extern long double y0l(long double) noexcept(true); extern long double __y0l(long double) noexcept(true); +# 257 +extern long double y1l(long double) noexcept(true); extern long double __y1l(long double) noexcept(true); +# 258 +extern long double ynl(int, long double) noexcept(true); extern long double __ynl(int, long double) noexcept(true); +# 264 +extern long double erfl(long double) noexcept(true); extern long double __erfl(long double) noexcept(true); +# 265 +extern long double erfcl(long double) noexcept(true); extern long double __erfcl(long double) noexcept(true); +# 266 +extern long double lgammal(long double) noexcept(true); extern long double __lgammal(long double) noexcept(true); +# 271 +extern long double tgammal(long double) noexcept(true); extern long double __tgammal(long double) noexcept(true); +# 277 +extern long double gammal(long double) noexcept(true); extern long double __gammal(long double) noexcept(true); +# 285 +extern long double lgammal_r(long double, int * __signgamp) noexcept(true); extern long double __lgammal_r(long double, int * __signgamp) noexcept(true); +# 292 +extern long double rintl(long double __x) noexcept(true); extern long double __rintl(long double __x) noexcept(true); +# 295 +extern long double nextafterl(long double __x, long double __y) noexcept(true); extern long double __nextafterl(long double __x, long double __y) noexcept(true); +# 297 +extern long double nexttowardl(long double __x, long double __y) noexcept(true); extern long double __nexttowardl(long double __x, long double __y) noexcept(true); +# 302 +extern long double nextdownl(long double __x) noexcept(true); extern long double __nextdownl(long double __x) noexcept(true); +# 304 +extern long double nextupl(long double __x) noexcept(true); extern long double __nextupl(long double __x) noexcept(true); +# 308 +extern long double remainderl(long double __x, long double __y) noexcept(true); extern long double __remainderl(long double __x, long double __y) noexcept(true); +# 312 +extern long double scalbnl(long double __x, int __n) noexcept(true); extern long double __scalbnl(long double __x, int __n) noexcept(true); +# 316 +extern int ilogbl(long double __x) noexcept(true); extern int __ilogbl(long double __x) noexcept(true); +# 321 +extern long llogbl(long double __x) noexcept(true); extern long __llogbl(long double __x) noexcept(true); +# 326 +extern long double scalblnl(long double __x, long __n) noexcept(true); extern long double __scalblnl(long double __x, long __n) noexcept(true); +# 330 +extern long double nearbyintl(long double __x) noexcept(true); extern long double __nearbyintl(long double __x) noexcept(true); +# 334 +extern long double roundl(long double __x) noexcept(true) __attribute((const)); +# 338 +extern long double truncl(long double __x) noexcept(true) __attribute((const)); +# 343 +extern long double remquol(long double __x, long double __y, int * __quo) noexcept(true); extern long double __remquol(long double __x, long double __y, int * __quo) noexcept(true); +# 350 +extern long lrintl(long double __x) noexcept(true); extern long __lrintl(long double __x) noexcept(true); +# 352 +__extension__ extern long long llrintl(long double __x) noexcept(true); extern long long __llrintl(long double __x) noexcept(true); +# 356 +extern long lroundl(long double __x) noexcept(true); extern long __lroundl(long double __x) noexcept(true); +# 358 +__extension__ extern long long llroundl(long double __x) noexcept(true); extern long long __llroundl(long double __x) noexcept(true); +# 362 +extern long double fdiml(long double __x, long double __y) noexcept(true); extern long double __fdiml(long double __x, long double __y) noexcept(true); +# 366 +extern long double fmaxl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 369 +extern long double fminl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 373 +extern long double fmal(long double __x, long double __y, long double __z) noexcept(true); extern long double __fmal(long double __x, long double __y, long double __z) noexcept(true); +# 378 +extern long double roundevenl(long double __x) noexcept(true) __attribute((const)); +# 382 +extern __intmax_t fromfpl(long double __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpl(long double __x, int __round, unsigned __width) noexcept(true); +# 387 +extern __uintmax_t ufromfpl(long double __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpl(long double __x, int __round, unsigned __width) noexcept(true); +# 393 +extern __intmax_t fromfpxl(long double __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpxl(long double __x, int __round, unsigned __width) noexcept(true); +# 399 +extern __uintmax_t ufromfpxl(long double __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpxl(long double __x, int __round, unsigned __width) noexcept(true); +# 403 +extern int canonicalizel(long double * __cx, const long double * __x) noexcept(true); +# 410 +extern long double fmaxmagl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 413 +extern long double fminmagl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 418 +extern long double fmaximuml(long double __x, long double __y) noexcept(true) __attribute((const)); +# 421 +extern long double fminimuml(long double __x, long double __y) noexcept(true) __attribute((const)); +# 424 +extern long double fmaximum_numl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 427 +extern long double fminimum_numl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 430 +extern long double fmaximum_magl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 433 +extern long double fminimum_magl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 436 +extern long double fmaximum_mag_numl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 439 +extern long double fminimum_mag_numl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 444 +extern int totalorderl(const long double * __x, const long double * __y) noexcept(true) +# 446 + __attribute((__pure__)); +# 449 +extern int totalordermagl(const long double * __x, const long double * __y) noexcept(true) +# 451 + __attribute((__pure__)); +# 454 +extern long double getpayloadl(const long double * __x) noexcept(true); extern long double __getpayloadl(const long double * __x) noexcept(true); +# 457 +extern int setpayloadl(long double * __x, long double __payload) noexcept(true); +# 460 +extern int setpayloadsigl(long double * __x, long double __payload) noexcept(true); +# 468 +extern long double scalbl(long double __x, long double __n) noexcept(true); extern long double __scalbl(long double __x, long double __n) noexcept(true); +# 53 "/usr/include/bits/mathcalls.h" 3 +extern _Float32 acosf32(_Float32 __x) noexcept(true); extern _Float32 __acosf32(_Float32 __x) noexcept(true); +# 55 +extern _Float32 asinf32(_Float32 __x) noexcept(true); extern _Float32 __asinf32(_Float32 __x) noexcept(true); +# 57 +extern _Float32 atanf32(_Float32 __x) noexcept(true); extern _Float32 __atanf32(_Float32 __x) noexcept(true); +# 59 +extern _Float32 atan2f32(_Float32 __y, _Float32 __x) noexcept(true); extern _Float32 __atan2f32(_Float32 __y, _Float32 __x) noexcept(true); +# 62 +extern _Float32 cosf32(_Float32 __x) noexcept(true); extern _Float32 __cosf32(_Float32 __x) noexcept(true); +# 64 +extern _Float32 sinf32(_Float32 __x) noexcept(true); extern _Float32 __sinf32(_Float32 __x) noexcept(true); +# 66 +extern _Float32 tanf32(_Float32 __x) noexcept(true); extern _Float32 __tanf32(_Float32 __x) noexcept(true); +# 70 +extern _Float32 acospif32(_Float32 __x) noexcept(true); extern _Float32 __acospif32(_Float32 __x) noexcept(true); +# 72 +extern _Float32 asinpif32(_Float32 __x) noexcept(true); extern _Float32 __asinpif32(_Float32 __x) noexcept(true); +# 74 +extern _Float32 atanpif32(_Float32 __x) noexcept(true); extern _Float32 __atanpif32(_Float32 __x) noexcept(true); +# 76 +extern _Float32 atan2pif32(_Float32 __y, _Float32 __x) noexcept(true); extern _Float32 __atan2pif32(_Float32 __y, _Float32 __x) noexcept(true); +# 79 +extern _Float32 cospif32(_Float32 __x) noexcept(true); extern _Float32 __cospif32(_Float32 __x) noexcept(true); +# 81 +extern _Float32 sinpif32(_Float32 __x) noexcept(true); extern _Float32 __sinpif32(_Float32 __x) noexcept(true); +# 83 +extern _Float32 tanpif32(_Float32 __x) noexcept(true); extern _Float32 __tanpif32(_Float32 __x) noexcept(true); +# 89 +extern _Float32 coshf32(_Float32 __x) noexcept(true); extern _Float32 __coshf32(_Float32 __x) noexcept(true); +# 91 +extern _Float32 sinhf32(_Float32 __x) noexcept(true); extern _Float32 __sinhf32(_Float32 __x) noexcept(true); +# 93 +extern _Float32 tanhf32(_Float32 __x) noexcept(true); extern _Float32 __tanhf32(_Float32 __x) noexcept(true); +# 97 +extern void sincosf32(_Float32 __x, _Float32 * __sinx, _Float32 * __cosx) noexcept(true); extern void __sincosf32(_Float32 __x, _Float32 * __sinx, _Float32 * __cosx) noexcept(true); +# 103 +extern _Float32 acoshf32(_Float32 __x) noexcept(true); extern _Float32 __acoshf32(_Float32 __x) noexcept(true); +# 105 +extern _Float32 asinhf32(_Float32 __x) noexcept(true); extern _Float32 __asinhf32(_Float32 __x) noexcept(true); +# 107 +extern _Float32 atanhf32(_Float32 __x) noexcept(true); extern _Float32 __atanhf32(_Float32 __x) noexcept(true); +# 113 +extern _Float32 expf32(_Float32 __x) noexcept(true); extern _Float32 __expf32(_Float32 __x) noexcept(true); +# 116 +extern _Float32 frexpf32(_Float32 __x, int * __exponent) noexcept(true); extern _Float32 __frexpf32(_Float32 __x, int * __exponent) noexcept(true); +# 119 +extern _Float32 ldexpf32(_Float32 __x, int __exponent) noexcept(true); extern _Float32 __ldexpf32(_Float32 __x, int __exponent) noexcept(true); +# 122 +extern _Float32 logf32(_Float32 __x) noexcept(true); extern _Float32 __logf32(_Float32 __x) noexcept(true); +# 125 +extern _Float32 log10f32(_Float32 __x) noexcept(true); extern _Float32 __log10f32(_Float32 __x) noexcept(true); +# 128 +extern _Float32 modff32(_Float32 __x, _Float32 * __iptr) noexcept(true); extern _Float32 __modff32(_Float32 __x, _Float32 * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 132 +extern _Float32 exp10f32(_Float32 __x) noexcept(true); extern _Float32 __exp10f32(_Float32 __x) noexcept(true); +# 135 +extern _Float32 exp2m1f32(_Float32 __x) noexcept(true); extern _Float32 __exp2m1f32(_Float32 __x) noexcept(true); +# 138 +extern _Float32 exp10m1f32(_Float32 __x) noexcept(true); extern _Float32 __exp10m1f32(_Float32 __x) noexcept(true); +# 141 +extern _Float32 log2p1f32(_Float32 __x) noexcept(true); extern _Float32 __log2p1f32(_Float32 __x) noexcept(true); +# 144 +extern _Float32 log10p1f32(_Float32 __x) noexcept(true); extern _Float32 __log10p1f32(_Float32 __x) noexcept(true); +# 147 +extern _Float32 logp1f32(_Float32 __x) noexcept(true); extern _Float32 __logp1f32(_Float32 __x) noexcept(true); +# 152 +extern _Float32 expm1f32(_Float32 __x) noexcept(true); extern _Float32 __expm1f32(_Float32 __x) noexcept(true); +# 155 +extern _Float32 log1pf32(_Float32 __x) noexcept(true); extern _Float32 __log1pf32(_Float32 __x) noexcept(true); +# 158 +extern _Float32 logbf32(_Float32 __x) noexcept(true); extern _Float32 __logbf32(_Float32 __x) noexcept(true); +# 163 +extern _Float32 exp2f32(_Float32 __x) noexcept(true); extern _Float32 __exp2f32(_Float32 __x) noexcept(true); +# 166 +extern _Float32 log2f32(_Float32 __x) noexcept(true); extern _Float32 __log2f32(_Float32 __x) noexcept(true); +# 173 +extern _Float32 powf32(_Float32 __x, _Float32 __y) noexcept(true); extern _Float32 __powf32(_Float32 __x, _Float32 __y) noexcept(true); +# 176 +extern _Float32 sqrtf32(_Float32 __x) noexcept(true); extern _Float32 __sqrtf32(_Float32 __x) noexcept(true); +# 180 +extern _Float32 hypotf32(_Float32 __x, _Float32 __y) noexcept(true); extern _Float32 __hypotf32(_Float32 __x, _Float32 __y) noexcept(true); +# 185 +extern _Float32 cbrtf32(_Float32 __x) noexcept(true); extern _Float32 __cbrtf32(_Float32 __x) noexcept(true); +# 192 +extern _Float32 ceilf32(_Float32 __x) noexcept(true) __attribute((const)); +# 195 +extern _Float32 fabsf32(_Float32 __x) noexcept(true) __attribute((const)); +# 198 +extern _Float32 floorf32(_Float32 __x) noexcept(true) __attribute((const)); +# 201 +extern _Float32 fmodf32(_Float32 __x, _Float32 __y) noexcept(true); extern _Float32 __fmodf32(_Float32 __x, _Float32 __y) noexcept(true); +# 231 "/usr/include/bits/mathcalls.h" 3 +extern _Float32 copysignf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 236 +extern _Float32 nanf32(const char * __tagb) noexcept(true); extern _Float32 __nanf32(const char * __tagb) noexcept(true); +# 253 "/usr/include/bits/mathcalls.h" 3 +extern _Float32 j0f32(_Float32) noexcept(true); extern _Float32 __j0f32(_Float32) noexcept(true); +# 254 +extern _Float32 j1f32(_Float32) noexcept(true); extern _Float32 __j1f32(_Float32) noexcept(true); +# 255 +extern _Float32 jnf32(int, _Float32) noexcept(true); extern _Float32 __jnf32(int, _Float32) noexcept(true); +# 256 +extern _Float32 y0f32(_Float32) noexcept(true); extern _Float32 __y0f32(_Float32) noexcept(true); +# 257 +extern _Float32 y1f32(_Float32) noexcept(true); extern _Float32 __y1f32(_Float32) noexcept(true); +# 258 +extern _Float32 ynf32(int, _Float32) noexcept(true); extern _Float32 __ynf32(int, _Float32) noexcept(true); +# 264 +extern _Float32 erff32(_Float32) noexcept(true); extern _Float32 __erff32(_Float32) noexcept(true); +# 265 +extern _Float32 erfcf32(_Float32) noexcept(true); extern _Float32 __erfcf32(_Float32) noexcept(true); +# 266 +extern _Float32 lgammaf32(_Float32) noexcept(true); extern _Float32 __lgammaf32(_Float32) noexcept(true); +# 271 +extern _Float32 tgammaf32(_Float32) noexcept(true); extern _Float32 __tgammaf32(_Float32) noexcept(true); +# 285 "/usr/include/bits/mathcalls.h" 3 +extern _Float32 lgammaf32_r(_Float32, int * __signgamp) noexcept(true); extern _Float32 __lgammaf32_r(_Float32, int * __signgamp) noexcept(true); +# 292 +extern _Float32 rintf32(_Float32 __x) noexcept(true); extern _Float32 __rintf32(_Float32 __x) noexcept(true); +# 295 +extern _Float32 nextafterf32(_Float32 __x, _Float32 __y) noexcept(true); extern _Float32 __nextafterf32(_Float32 __x, _Float32 __y) noexcept(true); +# 302 +extern _Float32 nextdownf32(_Float32 __x) noexcept(true); extern _Float32 __nextdownf32(_Float32 __x) noexcept(true); +# 304 +extern _Float32 nextupf32(_Float32 __x) noexcept(true); extern _Float32 __nextupf32(_Float32 __x) noexcept(true); +# 308 +extern _Float32 remainderf32(_Float32 __x, _Float32 __y) noexcept(true); extern _Float32 __remainderf32(_Float32 __x, _Float32 __y) noexcept(true); +# 312 +extern _Float32 scalbnf32(_Float32 __x, int __n) noexcept(true); extern _Float32 __scalbnf32(_Float32 __x, int __n) noexcept(true); +# 316 +extern int ilogbf32(_Float32 __x) noexcept(true); extern int __ilogbf32(_Float32 __x) noexcept(true); +# 321 +extern long llogbf32(_Float32 __x) noexcept(true); extern long __llogbf32(_Float32 __x) noexcept(true); +# 326 +extern _Float32 scalblnf32(_Float32 __x, long __n) noexcept(true); extern _Float32 __scalblnf32(_Float32 __x, long __n) noexcept(true); +# 330 +extern _Float32 nearbyintf32(_Float32 __x) noexcept(true); extern _Float32 __nearbyintf32(_Float32 __x) noexcept(true); +# 334 +extern _Float32 roundf32(_Float32 __x) noexcept(true) __attribute((const)); +# 338 +extern _Float32 truncf32(_Float32 __x) noexcept(true) __attribute((const)); +# 343 +extern _Float32 remquof32(_Float32 __x, _Float32 __y, int * __quo) noexcept(true); extern _Float32 __remquof32(_Float32 __x, _Float32 __y, int * __quo) noexcept(true); +# 350 +extern long lrintf32(_Float32 __x) noexcept(true); extern long __lrintf32(_Float32 __x) noexcept(true); +# 352 +__extension__ extern long long llrintf32(_Float32 __x) noexcept(true); extern long long __llrintf32(_Float32 __x) noexcept(true); +# 356 +extern long lroundf32(_Float32 __x) noexcept(true); extern long __lroundf32(_Float32 __x) noexcept(true); +# 358 +__extension__ extern long long llroundf32(_Float32 __x) noexcept(true); extern long long __llroundf32(_Float32 __x) noexcept(true); +# 362 +extern _Float32 fdimf32(_Float32 __x, _Float32 __y) noexcept(true); extern _Float32 __fdimf32(_Float32 __x, _Float32 __y) noexcept(true); +# 366 +extern _Float32 fmaxf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 369 +extern _Float32 fminf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 373 +extern _Float32 fmaf32(_Float32 __x, _Float32 __y, _Float32 __z) noexcept(true); extern _Float32 __fmaf32(_Float32 __x, _Float32 __y, _Float32 __z) noexcept(true); +# 378 +extern _Float32 roundevenf32(_Float32 __x) noexcept(true) __attribute((const)); +# 382 +extern __intmax_t fromfpf32(_Float32 __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpf32(_Float32 __x, int __round, unsigned __width) noexcept(true); +# 387 +extern __uintmax_t ufromfpf32(_Float32 __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpf32(_Float32 __x, int __round, unsigned __width) noexcept(true); +# 393 +extern __intmax_t fromfpxf32(_Float32 __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpxf32(_Float32 __x, int __round, unsigned __width) noexcept(true); +# 399 +extern __uintmax_t ufromfpxf32(_Float32 __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpxf32(_Float32 __x, int __round, unsigned __width) noexcept(true); +# 403 +extern int canonicalizef32(_Float32 * __cx, const _Float32 * __x) noexcept(true); +# 410 +extern _Float32 fmaxmagf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 413 +extern _Float32 fminmagf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 418 +extern _Float32 fmaximumf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 421 +extern _Float32 fminimumf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 424 +extern _Float32 fmaximum_numf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 427 +extern _Float32 fminimum_numf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 430 +extern _Float32 fmaximum_magf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 433 +extern _Float32 fminimum_magf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 436 +extern _Float32 fmaximum_mag_numf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 439 +extern _Float32 fminimum_mag_numf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 444 +extern int totalorderf32(const _Float32 * __x, const _Float32 * __y) noexcept(true) +# 446 + __attribute((__pure__)); +# 449 +extern int totalordermagf32(const _Float32 * __x, const _Float32 * __y) noexcept(true) +# 451 + __attribute((__pure__)); +# 454 +extern _Float32 getpayloadf32(const _Float32 * __x) noexcept(true); extern _Float32 __getpayloadf32(const _Float32 * __x) noexcept(true); +# 457 +extern int setpayloadf32(_Float32 * __x, _Float32 __payload) noexcept(true); +# 460 +extern int setpayloadsigf32(_Float32 * __x, _Float32 __payload) noexcept(true); +# 53 "/usr/include/bits/mathcalls.h" 3 +extern _Float64 acosf64(_Float64 __x) noexcept(true); extern _Float64 __acosf64(_Float64 __x) noexcept(true); +# 55 +extern _Float64 asinf64(_Float64 __x) noexcept(true); extern _Float64 __asinf64(_Float64 __x) noexcept(true); +# 57 +extern _Float64 atanf64(_Float64 __x) noexcept(true); extern _Float64 __atanf64(_Float64 __x) noexcept(true); +# 59 +extern _Float64 atan2f64(_Float64 __y, _Float64 __x) noexcept(true); extern _Float64 __atan2f64(_Float64 __y, _Float64 __x) noexcept(true); +# 62 +extern _Float64 cosf64(_Float64 __x) noexcept(true); extern _Float64 __cosf64(_Float64 __x) noexcept(true); +# 64 +extern _Float64 sinf64(_Float64 __x) noexcept(true); extern _Float64 __sinf64(_Float64 __x) noexcept(true); +# 66 +extern _Float64 tanf64(_Float64 __x) noexcept(true); extern _Float64 __tanf64(_Float64 __x) noexcept(true); +# 70 +extern _Float64 acospif64(_Float64 __x) noexcept(true); extern _Float64 __acospif64(_Float64 __x) noexcept(true); +# 72 +extern _Float64 asinpif64(_Float64 __x) noexcept(true); extern _Float64 __asinpif64(_Float64 __x) noexcept(true); +# 74 +extern _Float64 atanpif64(_Float64 __x) noexcept(true); extern _Float64 __atanpif64(_Float64 __x) noexcept(true); +# 76 +extern _Float64 atan2pif64(_Float64 __y, _Float64 __x) noexcept(true); extern _Float64 __atan2pif64(_Float64 __y, _Float64 __x) noexcept(true); +# 79 +extern _Float64 cospif64(_Float64 __x) noexcept(true); extern _Float64 __cospif64(_Float64 __x) noexcept(true); +# 81 +extern _Float64 sinpif64(_Float64 __x) noexcept(true); extern _Float64 __sinpif64(_Float64 __x) noexcept(true); +# 83 +extern _Float64 tanpif64(_Float64 __x) noexcept(true); extern _Float64 __tanpif64(_Float64 __x) noexcept(true); +# 89 +extern _Float64 coshf64(_Float64 __x) noexcept(true); extern _Float64 __coshf64(_Float64 __x) noexcept(true); +# 91 +extern _Float64 sinhf64(_Float64 __x) noexcept(true); extern _Float64 __sinhf64(_Float64 __x) noexcept(true); +# 93 +extern _Float64 tanhf64(_Float64 __x) noexcept(true); extern _Float64 __tanhf64(_Float64 __x) noexcept(true); +# 97 +extern void sincosf64(_Float64 __x, _Float64 * __sinx, _Float64 * __cosx) noexcept(true); extern void __sincosf64(_Float64 __x, _Float64 * __sinx, _Float64 * __cosx) noexcept(true); +# 103 +extern _Float64 acoshf64(_Float64 __x) noexcept(true); extern _Float64 __acoshf64(_Float64 __x) noexcept(true); +# 105 +extern _Float64 asinhf64(_Float64 __x) noexcept(true); extern _Float64 __asinhf64(_Float64 __x) noexcept(true); +# 107 +extern _Float64 atanhf64(_Float64 __x) noexcept(true); extern _Float64 __atanhf64(_Float64 __x) noexcept(true); +# 113 +extern _Float64 expf64(_Float64 __x) noexcept(true); extern _Float64 __expf64(_Float64 __x) noexcept(true); +# 116 +extern _Float64 frexpf64(_Float64 __x, int * __exponent) noexcept(true); extern _Float64 __frexpf64(_Float64 __x, int * __exponent) noexcept(true); +# 119 +extern _Float64 ldexpf64(_Float64 __x, int __exponent) noexcept(true); extern _Float64 __ldexpf64(_Float64 __x, int __exponent) noexcept(true); +# 122 +extern _Float64 logf64(_Float64 __x) noexcept(true); extern _Float64 __logf64(_Float64 __x) noexcept(true); +# 125 +extern _Float64 log10f64(_Float64 __x) noexcept(true); extern _Float64 __log10f64(_Float64 __x) noexcept(true); +# 128 +extern _Float64 modff64(_Float64 __x, _Float64 * __iptr) noexcept(true); extern _Float64 __modff64(_Float64 __x, _Float64 * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 132 +extern _Float64 exp10f64(_Float64 __x) noexcept(true); extern _Float64 __exp10f64(_Float64 __x) noexcept(true); +# 135 +extern _Float64 exp2m1f64(_Float64 __x) noexcept(true); extern _Float64 __exp2m1f64(_Float64 __x) noexcept(true); +# 138 +extern _Float64 exp10m1f64(_Float64 __x) noexcept(true); extern _Float64 __exp10m1f64(_Float64 __x) noexcept(true); +# 141 +extern _Float64 log2p1f64(_Float64 __x) noexcept(true); extern _Float64 __log2p1f64(_Float64 __x) noexcept(true); +# 144 +extern _Float64 log10p1f64(_Float64 __x) noexcept(true); extern _Float64 __log10p1f64(_Float64 __x) noexcept(true); +# 147 +extern _Float64 logp1f64(_Float64 __x) noexcept(true); extern _Float64 __logp1f64(_Float64 __x) noexcept(true); +# 152 +extern _Float64 expm1f64(_Float64 __x) noexcept(true); extern _Float64 __expm1f64(_Float64 __x) noexcept(true); +# 155 +extern _Float64 log1pf64(_Float64 __x) noexcept(true); extern _Float64 __log1pf64(_Float64 __x) noexcept(true); +# 158 +extern _Float64 logbf64(_Float64 __x) noexcept(true); extern _Float64 __logbf64(_Float64 __x) noexcept(true); +# 163 +extern _Float64 exp2f64(_Float64 __x) noexcept(true); extern _Float64 __exp2f64(_Float64 __x) noexcept(true); +# 166 +extern _Float64 log2f64(_Float64 __x) noexcept(true); extern _Float64 __log2f64(_Float64 __x) noexcept(true); +# 173 +extern _Float64 powf64(_Float64 __x, _Float64 __y) noexcept(true); extern _Float64 __powf64(_Float64 __x, _Float64 __y) noexcept(true); +# 176 +extern _Float64 sqrtf64(_Float64 __x) noexcept(true); extern _Float64 __sqrtf64(_Float64 __x) noexcept(true); +# 180 +extern _Float64 hypotf64(_Float64 __x, _Float64 __y) noexcept(true); extern _Float64 __hypotf64(_Float64 __x, _Float64 __y) noexcept(true); +# 185 +extern _Float64 cbrtf64(_Float64 __x) noexcept(true); extern _Float64 __cbrtf64(_Float64 __x) noexcept(true); +# 192 +extern _Float64 ceilf64(_Float64 __x) noexcept(true) __attribute((const)); +# 195 +extern _Float64 fabsf64(_Float64 __x) noexcept(true) __attribute((const)); +# 198 +extern _Float64 floorf64(_Float64 __x) noexcept(true) __attribute((const)); +# 201 +extern _Float64 fmodf64(_Float64 __x, _Float64 __y) noexcept(true); extern _Float64 __fmodf64(_Float64 __x, _Float64 __y) noexcept(true); +# 231 "/usr/include/bits/mathcalls.h" 3 +extern _Float64 copysignf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 236 +extern _Float64 nanf64(const char * __tagb) noexcept(true); extern _Float64 __nanf64(const char * __tagb) noexcept(true); +# 253 "/usr/include/bits/mathcalls.h" 3 +extern _Float64 j0f64(_Float64) noexcept(true); extern _Float64 __j0f64(_Float64) noexcept(true); +# 254 +extern _Float64 j1f64(_Float64) noexcept(true); extern _Float64 __j1f64(_Float64) noexcept(true); +# 255 +extern _Float64 jnf64(int, _Float64) noexcept(true); extern _Float64 __jnf64(int, _Float64) noexcept(true); +# 256 +extern _Float64 y0f64(_Float64) noexcept(true); extern _Float64 __y0f64(_Float64) noexcept(true); +# 257 +extern _Float64 y1f64(_Float64) noexcept(true); extern _Float64 __y1f64(_Float64) noexcept(true); +# 258 +extern _Float64 ynf64(int, _Float64) noexcept(true); extern _Float64 __ynf64(int, _Float64) noexcept(true); +# 264 +extern _Float64 erff64(_Float64) noexcept(true); extern _Float64 __erff64(_Float64) noexcept(true); +# 265 +extern _Float64 erfcf64(_Float64) noexcept(true); extern _Float64 __erfcf64(_Float64) noexcept(true); +# 266 +extern _Float64 lgammaf64(_Float64) noexcept(true); extern _Float64 __lgammaf64(_Float64) noexcept(true); +# 271 +extern _Float64 tgammaf64(_Float64) noexcept(true); extern _Float64 __tgammaf64(_Float64) noexcept(true); +# 285 "/usr/include/bits/mathcalls.h" 3 +extern _Float64 lgammaf64_r(_Float64, int * __signgamp) noexcept(true); extern _Float64 __lgammaf64_r(_Float64, int * __signgamp) noexcept(true); +# 292 +extern _Float64 rintf64(_Float64 __x) noexcept(true); extern _Float64 __rintf64(_Float64 __x) noexcept(true); +# 295 +extern _Float64 nextafterf64(_Float64 __x, _Float64 __y) noexcept(true); extern _Float64 __nextafterf64(_Float64 __x, _Float64 __y) noexcept(true); +# 302 +extern _Float64 nextdownf64(_Float64 __x) noexcept(true); extern _Float64 __nextdownf64(_Float64 __x) noexcept(true); +# 304 +extern _Float64 nextupf64(_Float64 __x) noexcept(true); extern _Float64 __nextupf64(_Float64 __x) noexcept(true); +# 308 +extern _Float64 remainderf64(_Float64 __x, _Float64 __y) noexcept(true); extern _Float64 __remainderf64(_Float64 __x, _Float64 __y) noexcept(true); +# 312 +extern _Float64 scalbnf64(_Float64 __x, int __n) noexcept(true); extern _Float64 __scalbnf64(_Float64 __x, int __n) noexcept(true); +# 316 +extern int ilogbf64(_Float64 __x) noexcept(true); extern int __ilogbf64(_Float64 __x) noexcept(true); +# 321 +extern long llogbf64(_Float64 __x) noexcept(true); extern long __llogbf64(_Float64 __x) noexcept(true); +# 326 +extern _Float64 scalblnf64(_Float64 __x, long __n) noexcept(true); extern _Float64 __scalblnf64(_Float64 __x, long __n) noexcept(true); +# 330 +extern _Float64 nearbyintf64(_Float64 __x) noexcept(true); extern _Float64 __nearbyintf64(_Float64 __x) noexcept(true); +# 334 +extern _Float64 roundf64(_Float64 __x) noexcept(true) __attribute((const)); +# 338 +extern _Float64 truncf64(_Float64 __x) noexcept(true) __attribute((const)); +# 343 +extern _Float64 remquof64(_Float64 __x, _Float64 __y, int * __quo) noexcept(true); extern _Float64 __remquof64(_Float64 __x, _Float64 __y, int * __quo) noexcept(true); +# 350 +extern long lrintf64(_Float64 __x) noexcept(true); extern long __lrintf64(_Float64 __x) noexcept(true); +# 352 +__extension__ extern long long llrintf64(_Float64 __x) noexcept(true); extern long long __llrintf64(_Float64 __x) noexcept(true); +# 356 +extern long lroundf64(_Float64 __x) noexcept(true); extern long __lroundf64(_Float64 __x) noexcept(true); +# 358 +__extension__ extern long long llroundf64(_Float64 __x) noexcept(true); extern long long __llroundf64(_Float64 __x) noexcept(true); +# 362 +extern _Float64 fdimf64(_Float64 __x, _Float64 __y) noexcept(true); extern _Float64 __fdimf64(_Float64 __x, _Float64 __y) noexcept(true); +# 366 +extern _Float64 fmaxf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 369 +extern _Float64 fminf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 373 +extern _Float64 fmaf64(_Float64 __x, _Float64 __y, _Float64 __z) noexcept(true); extern _Float64 __fmaf64(_Float64 __x, _Float64 __y, _Float64 __z) noexcept(true); +# 378 +extern _Float64 roundevenf64(_Float64 __x) noexcept(true) __attribute((const)); +# 382 +extern __intmax_t fromfpf64(_Float64 __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpf64(_Float64 __x, int __round, unsigned __width) noexcept(true); +# 387 +extern __uintmax_t ufromfpf64(_Float64 __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpf64(_Float64 __x, int __round, unsigned __width) noexcept(true); +# 393 +extern __intmax_t fromfpxf64(_Float64 __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpxf64(_Float64 __x, int __round, unsigned __width) noexcept(true); +# 399 +extern __uintmax_t ufromfpxf64(_Float64 __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpxf64(_Float64 __x, int __round, unsigned __width) noexcept(true); +# 403 +extern int canonicalizef64(_Float64 * __cx, const _Float64 * __x) noexcept(true); +# 410 +extern _Float64 fmaxmagf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 413 +extern _Float64 fminmagf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 418 +extern _Float64 fmaximumf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 421 +extern _Float64 fminimumf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 424 +extern _Float64 fmaximum_numf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 427 +extern _Float64 fminimum_numf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 430 +extern _Float64 fmaximum_magf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 433 +extern _Float64 fminimum_magf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 436 +extern _Float64 fmaximum_mag_numf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 439 +extern _Float64 fminimum_mag_numf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 444 +extern int totalorderf64(const _Float64 * __x, const _Float64 * __y) noexcept(true) +# 446 + __attribute((__pure__)); +# 449 +extern int totalordermagf64(const _Float64 * __x, const _Float64 * __y) noexcept(true) +# 451 + __attribute((__pure__)); +# 454 +extern _Float64 getpayloadf64(const _Float64 * __x) noexcept(true); extern _Float64 __getpayloadf64(const _Float64 * __x) noexcept(true); +# 457 +extern int setpayloadf64(_Float64 * __x, _Float64 __payload) noexcept(true); +# 460 +extern int setpayloadsigf64(_Float64 * __x, _Float64 __payload) noexcept(true); +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 +extern int __fpclassifyf128(_Float128 __value) noexcept(true) +# 21 + __attribute((const)); +# 24 +extern int __signbitf128(_Float128 __value) noexcept(true) +# 25 + __attribute((const)); +# 29 +extern int __isinff128(_Float128 __value) noexcept(true) +# 30 + __attribute((const)); +# 33 +extern int __finitef128(_Float128 __value) noexcept(true) +# 34 + __attribute((const)); +# 37 +extern int __isnanf128(_Float128 __value) noexcept(true) +# 38 + __attribute((const)); +# 41 +extern int __iseqsigf128(_Float128 __x, _Float128 __y) noexcept(true); +# 44 +extern int __issignalingf128(_Float128 __value) noexcept(true) +# 45 + __attribute((const)); +# 53 "/usr/include/bits/mathcalls.h" 3 +extern _Float128 acosf128(_Float128 __x) noexcept(true); extern _Float128 __acosf128(_Float128 __x) noexcept(true); +# 55 +extern _Float128 asinf128(_Float128 __x) noexcept(true); extern _Float128 __asinf128(_Float128 __x) noexcept(true); +# 57 +extern _Float128 atanf128(_Float128 __x) noexcept(true); extern _Float128 __atanf128(_Float128 __x) noexcept(true); +# 59 +extern _Float128 atan2f128(_Float128 __y, _Float128 __x) noexcept(true); extern _Float128 __atan2f128(_Float128 __y, _Float128 __x) noexcept(true); +# 62 +extern _Float128 cosf128(_Float128 __x) noexcept(true); extern _Float128 __cosf128(_Float128 __x) noexcept(true); +# 64 +extern _Float128 sinf128(_Float128 __x) noexcept(true); extern _Float128 __sinf128(_Float128 __x) noexcept(true); +# 66 +extern _Float128 tanf128(_Float128 __x) noexcept(true); extern _Float128 __tanf128(_Float128 __x) noexcept(true); +# 70 +extern _Float128 acospif128(_Float128 __x) noexcept(true); extern _Float128 __acospif128(_Float128 __x) noexcept(true); +# 72 +extern _Float128 asinpif128(_Float128 __x) noexcept(true); extern _Float128 __asinpif128(_Float128 __x) noexcept(true); +# 74 +extern _Float128 atanpif128(_Float128 __x) noexcept(true); extern _Float128 __atanpif128(_Float128 __x) noexcept(true); +# 76 +extern _Float128 atan2pif128(_Float128 __y, _Float128 __x) noexcept(true); extern _Float128 __atan2pif128(_Float128 __y, _Float128 __x) noexcept(true); +# 79 +extern _Float128 cospif128(_Float128 __x) noexcept(true); extern _Float128 __cospif128(_Float128 __x) noexcept(true); +# 81 +extern _Float128 sinpif128(_Float128 __x) noexcept(true); extern _Float128 __sinpif128(_Float128 __x) noexcept(true); +# 83 +extern _Float128 tanpif128(_Float128 __x) noexcept(true); extern _Float128 __tanpif128(_Float128 __x) noexcept(true); +# 89 +extern _Float128 coshf128(_Float128 __x) noexcept(true); extern _Float128 __coshf128(_Float128 __x) noexcept(true); +# 91 +extern _Float128 sinhf128(_Float128 __x) noexcept(true); extern _Float128 __sinhf128(_Float128 __x) noexcept(true); +# 93 +extern _Float128 tanhf128(_Float128 __x) noexcept(true); extern _Float128 __tanhf128(_Float128 __x) noexcept(true); +# 97 +extern void sincosf128(_Float128 __x, _Float128 * __sinx, _Float128 * __cosx) noexcept(true); extern void __sincosf128(_Float128 __x, _Float128 * __sinx, _Float128 * __cosx) noexcept(true); +# 103 +extern _Float128 acoshf128(_Float128 __x) noexcept(true); extern _Float128 __acoshf128(_Float128 __x) noexcept(true); +# 105 +extern _Float128 asinhf128(_Float128 __x) noexcept(true); extern _Float128 __asinhf128(_Float128 __x) noexcept(true); +# 107 +extern _Float128 atanhf128(_Float128 __x) noexcept(true); extern _Float128 __atanhf128(_Float128 __x) noexcept(true); +# 113 +extern _Float128 expf128(_Float128 __x) noexcept(true); extern _Float128 __expf128(_Float128 __x) noexcept(true); +# 116 +extern _Float128 frexpf128(_Float128 __x, int * __exponent) noexcept(true); extern _Float128 __frexpf128(_Float128 __x, int * __exponent) noexcept(true); +# 119 +extern _Float128 ldexpf128(_Float128 __x, int __exponent) noexcept(true); extern _Float128 __ldexpf128(_Float128 __x, int __exponent) noexcept(true); +# 122 +extern _Float128 logf128(_Float128 __x) noexcept(true); extern _Float128 __logf128(_Float128 __x) noexcept(true); +# 125 +extern _Float128 log10f128(_Float128 __x) noexcept(true); extern _Float128 __log10f128(_Float128 __x) noexcept(true); +# 128 +extern _Float128 modff128(_Float128 __x, _Float128 * __iptr) noexcept(true); extern _Float128 __modff128(_Float128 __x, _Float128 * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 132 +extern _Float128 exp10f128(_Float128 __x) noexcept(true); extern _Float128 __exp10f128(_Float128 __x) noexcept(true); +# 135 +extern _Float128 exp2m1f128(_Float128 __x) noexcept(true); extern _Float128 __exp2m1f128(_Float128 __x) noexcept(true); +# 138 +extern _Float128 exp10m1f128(_Float128 __x) noexcept(true); extern _Float128 __exp10m1f128(_Float128 __x) noexcept(true); +# 141 +extern _Float128 log2p1f128(_Float128 __x) noexcept(true); extern _Float128 __log2p1f128(_Float128 __x) noexcept(true); +# 144 +extern _Float128 log10p1f128(_Float128 __x) noexcept(true); extern _Float128 __log10p1f128(_Float128 __x) noexcept(true); +# 147 +extern _Float128 logp1f128(_Float128 __x) noexcept(true); extern _Float128 __logp1f128(_Float128 __x) noexcept(true); +# 152 +extern _Float128 expm1f128(_Float128 __x) noexcept(true); extern _Float128 __expm1f128(_Float128 __x) noexcept(true); +# 155 +extern _Float128 log1pf128(_Float128 __x) noexcept(true); extern _Float128 __log1pf128(_Float128 __x) noexcept(true); +# 158 +extern _Float128 logbf128(_Float128 __x) noexcept(true); extern _Float128 __logbf128(_Float128 __x) noexcept(true); +# 163 +extern _Float128 exp2f128(_Float128 __x) noexcept(true); extern _Float128 __exp2f128(_Float128 __x) noexcept(true); +# 166 +extern _Float128 log2f128(_Float128 __x) noexcept(true); extern _Float128 __log2f128(_Float128 __x) noexcept(true); +# 173 +extern _Float128 powf128(_Float128 __x, _Float128 __y) noexcept(true); extern _Float128 __powf128(_Float128 __x, _Float128 __y) noexcept(true); +# 176 +extern _Float128 sqrtf128(_Float128 __x) noexcept(true); extern _Float128 __sqrtf128(_Float128 __x) noexcept(true); +# 180 +extern _Float128 hypotf128(_Float128 __x, _Float128 __y) noexcept(true); extern _Float128 __hypotf128(_Float128 __x, _Float128 __y) noexcept(true); +# 185 +extern _Float128 cbrtf128(_Float128 __x) noexcept(true); extern _Float128 __cbrtf128(_Float128 __x) noexcept(true); +# 192 +extern _Float128 ceilf128(_Float128 __x) noexcept(true) __attribute((const)); +# 195 +extern _Float128 fabsf128(_Float128 __x) noexcept(true) __attribute((const)); +# 198 +extern _Float128 floorf128(_Float128 __x) noexcept(true) __attribute((const)); +# 201 +extern _Float128 fmodf128(_Float128 __x, _Float128 __y) noexcept(true); extern _Float128 __fmodf128(_Float128 __x, _Float128 __y) noexcept(true); +# 231 "/usr/include/bits/mathcalls.h" 3 +extern _Float128 copysignf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 236 +extern _Float128 nanf128(const char * __tagb) noexcept(true); extern _Float128 __nanf128(const char * __tagb) noexcept(true); +# 253 "/usr/include/bits/mathcalls.h" 3 +extern _Float128 j0f128(_Float128) noexcept(true); extern _Float128 __j0f128(_Float128) noexcept(true); +# 254 +extern _Float128 j1f128(_Float128) noexcept(true); extern _Float128 __j1f128(_Float128) noexcept(true); +# 255 +extern _Float128 jnf128(int, _Float128) noexcept(true); extern _Float128 __jnf128(int, _Float128) noexcept(true); +# 256 +extern _Float128 y0f128(_Float128) noexcept(true); extern _Float128 __y0f128(_Float128) noexcept(true); +# 257 +extern _Float128 y1f128(_Float128) noexcept(true); extern _Float128 __y1f128(_Float128) noexcept(true); +# 258 +extern _Float128 ynf128(int, _Float128) noexcept(true); extern _Float128 __ynf128(int, _Float128) noexcept(true); +# 264 +extern _Float128 erff128(_Float128) noexcept(true); extern _Float128 __erff128(_Float128) noexcept(true); +# 265 +extern _Float128 erfcf128(_Float128) noexcept(true); extern _Float128 __erfcf128(_Float128) noexcept(true); +# 266 +extern _Float128 lgammaf128(_Float128) noexcept(true); extern _Float128 __lgammaf128(_Float128) noexcept(true); +# 271 +extern _Float128 tgammaf128(_Float128) noexcept(true); extern _Float128 __tgammaf128(_Float128) noexcept(true); +# 285 "/usr/include/bits/mathcalls.h" 3 +extern _Float128 lgammaf128_r(_Float128, int * __signgamp) noexcept(true); extern _Float128 __lgammaf128_r(_Float128, int * __signgamp) noexcept(true); +# 292 +extern _Float128 rintf128(_Float128 __x) noexcept(true); extern _Float128 __rintf128(_Float128 __x) noexcept(true); +# 295 +extern _Float128 nextafterf128(_Float128 __x, _Float128 __y) noexcept(true); extern _Float128 __nextafterf128(_Float128 __x, _Float128 __y) noexcept(true); +# 302 +extern _Float128 nextdownf128(_Float128 __x) noexcept(true); extern _Float128 __nextdownf128(_Float128 __x) noexcept(true); +# 304 +extern _Float128 nextupf128(_Float128 __x) noexcept(true); extern _Float128 __nextupf128(_Float128 __x) noexcept(true); +# 308 +extern _Float128 remainderf128(_Float128 __x, _Float128 __y) noexcept(true); extern _Float128 __remainderf128(_Float128 __x, _Float128 __y) noexcept(true); +# 312 +extern _Float128 scalbnf128(_Float128 __x, int __n) noexcept(true); extern _Float128 __scalbnf128(_Float128 __x, int __n) noexcept(true); +# 316 +extern int ilogbf128(_Float128 __x) noexcept(true); extern int __ilogbf128(_Float128 __x) noexcept(true); +# 321 +extern long llogbf128(_Float128 __x) noexcept(true); extern long __llogbf128(_Float128 __x) noexcept(true); +# 326 +extern _Float128 scalblnf128(_Float128 __x, long __n) noexcept(true); extern _Float128 __scalblnf128(_Float128 __x, long __n) noexcept(true); +# 330 +extern _Float128 nearbyintf128(_Float128 __x) noexcept(true); extern _Float128 __nearbyintf128(_Float128 __x) noexcept(true); +# 334 +extern _Float128 roundf128(_Float128 __x) noexcept(true) __attribute((const)); +# 338 +extern _Float128 truncf128(_Float128 __x) noexcept(true) __attribute((const)); +# 343 +extern _Float128 remquof128(_Float128 __x, _Float128 __y, int * __quo) noexcept(true); extern _Float128 __remquof128(_Float128 __x, _Float128 __y, int * __quo) noexcept(true); +# 350 +extern long lrintf128(_Float128 __x) noexcept(true); extern long __lrintf128(_Float128 __x) noexcept(true); +# 352 +__extension__ extern long long llrintf128(_Float128 __x) noexcept(true); extern long long __llrintf128(_Float128 __x) noexcept(true); +# 356 +extern long lroundf128(_Float128 __x) noexcept(true); extern long __lroundf128(_Float128 __x) noexcept(true); +# 358 +__extension__ extern long long llroundf128(_Float128 __x) noexcept(true); extern long long __llroundf128(_Float128 __x) noexcept(true); +# 362 +extern _Float128 fdimf128(_Float128 __x, _Float128 __y) noexcept(true); extern _Float128 __fdimf128(_Float128 __x, _Float128 __y) noexcept(true); +# 366 +extern _Float128 fmaxf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 369 +extern _Float128 fminf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 373 +extern _Float128 fmaf128(_Float128 __x, _Float128 __y, _Float128 __z) noexcept(true); extern _Float128 __fmaf128(_Float128 __x, _Float128 __y, _Float128 __z) noexcept(true); +# 378 +extern _Float128 roundevenf128(_Float128 __x) noexcept(true) __attribute((const)); +# 382 +extern __intmax_t fromfpf128(_Float128 __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpf128(_Float128 __x, int __round, unsigned __width) noexcept(true); +# 387 +extern __uintmax_t ufromfpf128(_Float128 __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpf128(_Float128 __x, int __round, unsigned __width) noexcept(true); +# 393 +extern __intmax_t fromfpxf128(_Float128 __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpxf128(_Float128 __x, int __round, unsigned __width) noexcept(true); +# 399 +extern __uintmax_t ufromfpxf128(_Float128 __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpxf128(_Float128 __x, int __round, unsigned __width) noexcept(true); +# 403 +extern int canonicalizef128(_Float128 * __cx, const _Float128 * __x) noexcept(true); +# 410 +extern _Float128 fmaxmagf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 413 +extern _Float128 fminmagf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 418 +extern _Float128 fmaximumf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 421 +extern _Float128 fminimumf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 424 +extern _Float128 fmaximum_numf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 427 +extern _Float128 fminimum_numf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 430 +extern _Float128 fmaximum_magf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 433 +extern _Float128 fminimum_magf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 436 +extern _Float128 fmaximum_mag_numf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 439 +extern _Float128 fminimum_mag_numf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 444 +extern int totalorderf128(const _Float128 * __x, const _Float128 * __y) noexcept(true) +# 446 + __attribute((__pure__)); +# 449 +extern int totalordermagf128(const _Float128 * __x, const _Float128 * __y) noexcept(true) +# 451 + __attribute((__pure__)); +# 454 +extern _Float128 getpayloadf128(const _Float128 * __x) noexcept(true); extern _Float128 __getpayloadf128(const _Float128 * __x) noexcept(true); +# 457 +extern int setpayloadf128(_Float128 * __x, _Float128 __payload) noexcept(true); +# 460 +extern int setpayloadsigf128(_Float128 * __x, _Float128 __payload) noexcept(true); +# 53 "/usr/include/bits/mathcalls.h" 3 +extern _Float32x acosf32x(_Float32x __x) noexcept(true); extern _Float32x __acosf32x(_Float32x __x) noexcept(true); +# 55 +extern _Float32x asinf32x(_Float32x __x) noexcept(true); extern _Float32x __asinf32x(_Float32x __x) noexcept(true); +# 57 +extern _Float32x atanf32x(_Float32x __x) noexcept(true); extern _Float32x __atanf32x(_Float32x __x) noexcept(true); +# 59 +extern _Float32x atan2f32x(_Float32x __y, _Float32x __x) noexcept(true); extern _Float32x __atan2f32x(_Float32x __y, _Float32x __x) noexcept(true); +# 62 +extern _Float32x cosf32x(_Float32x __x) noexcept(true); extern _Float32x __cosf32x(_Float32x __x) noexcept(true); +# 64 +extern _Float32x sinf32x(_Float32x __x) noexcept(true); extern _Float32x __sinf32x(_Float32x __x) noexcept(true); +# 66 +extern _Float32x tanf32x(_Float32x __x) noexcept(true); extern _Float32x __tanf32x(_Float32x __x) noexcept(true); +# 70 +extern _Float32x acospif32x(_Float32x __x) noexcept(true); extern _Float32x __acospif32x(_Float32x __x) noexcept(true); +# 72 +extern _Float32x asinpif32x(_Float32x __x) noexcept(true); extern _Float32x __asinpif32x(_Float32x __x) noexcept(true); +# 74 +extern _Float32x atanpif32x(_Float32x __x) noexcept(true); extern _Float32x __atanpif32x(_Float32x __x) noexcept(true); +# 76 +extern _Float32x atan2pif32x(_Float32x __y, _Float32x __x) noexcept(true); extern _Float32x __atan2pif32x(_Float32x __y, _Float32x __x) noexcept(true); +# 79 +extern _Float32x cospif32x(_Float32x __x) noexcept(true); extern _Float32x __cospif32x(_Float32x __x) noexcept(true); +# 81 +extern _Float32x sinpif32x(_Float32x __x) noexcept(true); extern _Float32x __sinpif32x(_Float32x __x) noexcept(true); +# 83 +extern _Float32x tanpif32x(_Float32x __x) noexcept(true); extern _Float32x __tanpif32x(_Float32x __x) noexcept(true); +# 89 +extern _Float32x coshf32x(_Float32x __x) noexcept(true); extern _Float32x __coshf32x(_Float32x __x) noexcept(true); +# 91 +extern _Float32x sinhf32x(_Float32x __x) noexcept(true); extern _Float32x __sinhf32x(_Float32x __x) noexcept(true); +# 93 +extern _Float32x tanhf32x(_Float32x __x) noexcept(true); extern _Float32x __tanhf32x(_Float32x __x) noexcept(true); +# 97 +extern void sincosf32x(_Float32x __x, _Float32x * __sinx, _Float32x * __cosx) noexcept(true); extern void __sincosf32x(_Float32x __x, _Float32x * __sinx, _Float32x * __cosx) noexcept(true); +# 103 +extern _Float32x acoshf32x(_Float32x __x) noexcept(true); extern _Float32x __acoshf32x(_Float32x __x) noexcept(true); +# 105 +extern _Float32x asinhf32x(_Float32x __x) noexcept(true); extern _Float32x __asinhf32x(_Float32x __x) noexcept(true); +# 107 +extern _Float32x atanhf32x(_Float32x __x) noexcept(true); extern _Float32x __atanhf32x(_Float32x __x) noexcept(true); +# 113 +extern _Float32x expf32x(_Float32x __x) noexcept(true); extern _Float32x __expf32x(_Float32x __x) noexcept(true); +# 116 +extern _Float32x frexpf32x(_Float32x __x, int * __exponent) noexcept(true); extern _Float32x __frexpf32x(_Float32x __x, int * __exponent) noexcept(true); +# 119 +extern _Float32x ldexpf32x(_Float32x __x, int __exponent) noexcept(true); extern _Float32x __ldexpf32x(_Float32x __x, int __exponent) noexcept(true); +# 122 +extern _Float32x logf32x(_Float32x __x) noexcept(true); extern _Float32x __logf32x(_Float32x __x) noexcept(true); +# 125 +extern _Float32x log10f32x(_Float32x __x) noexcept(true); extern _Float32x __log10f32x(_Float32x __x) noexcept(true); +# 128 +extern _Float32x modff32x(_Float32x __x, _Float32x * __iptr) noexcept(true); extern _Float32x __modff32x(_Float32x __x, _Float32x * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 132 +extern _Float32x exp10f32x(_Float32x __x) noexcept(true); extern _Float32x __exp10f32x(_Float32x __x) noexcept(true); +# 135 +extern _Float32x exp2m1f32x(_Float32x __x) noexcept(true); extern _Float32x __exp2m1f32x(_Float32x __x) noexcept(true); +# 138 +extern _Float32x exp10m1f32x(_Float32x __x) noexcept(true); extern _Float32x __exp10m1f32x(_Float32x __x) noexcept(true); +# 141 +extern _Float32x log2p1f32x(_Float32x __x) noexcept(true); extern _Float32x __log2p1f32x(_Float32x __x) noexcept(true); +# 144 +extern _Float32x log10p1f32x(_Float32x __x) noexcept(true); extern _Float32x __log10p1f32x(_Float32x __x) noexcept(true); +# 147 +extern _Float32x logp1f32x(_Float32x __x) noexcept(true); extern _Float32x __logp1f32x(_Float32x __x) noexcept(true); +# 152 +extern _Float32x expm1f32x(_Float32x __x) noexcept(true); extern _Float32x __expm1f32x(_Float32x __x) noexcept(true); +# 155 +extern _Float32x log1pf32x(_Float32x __x) noexcept(true); extern _Float32x __log1pf32x(_Float32x __x) noexcept(true); +# 158 +extern _Float32x logbf32x(_Float32x __x) noexcept(true); extern _Float32x __logbf32x(_Float32x __x) noexcept(true); +# 163 +extern _Float32x exp2f32x(_Float32x __x) noexcept(true); extern _Float32x __exp2f32x(_Float32x __x) noexcept(true); +# 166 +extern _Float32x log2f32x(_Float32x __x) noexcept(true); extern _Float32x __log2f32x(_Float32x __x) noexcept(true); +# 173 +extern _Float32x powf32x(_Float32x __x, _Float32x __y) noexcept(true); extern _Float32x __powf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 176 +extern _Float32x sqrtf32x(_Float32x __x) noexcept(true); extern _Float32x __sqrtf32x(_Float32x __x) noexcept(true); +# 180 +extern _Float32x hypotf32x(_Float32x __x, _Float32x __y) noexcept(true); extern _Float32x __hypotf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 185 +extern _Float32x cbrtf32x(_Float32x __x) noexcept(true); extern _Float32x __cbrtf32x(_Float32x __x) noexcept(true); +# 192 +extern _Float32x ceilf32x(_Float32x __x) noexcept(true) __attribute((const)); +# 195 +extern _Float32x fabsf32x(_Float32x __x) noexcept(true) __attribute((const)); +# 198 +extern _Float32x floorf32x(_Float32x __x) noexcept(true) __attribute((const)); +# 201 +extern _Float32x fmodf32x(_Float32x __x, _Float32x __y) noexcept(true); extern _Float32x __fmodf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 231 "/usr/include/bits/mathcalls.h" 3 +extern _Float32x copysignf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 236 +extern _Float32x nanf32x(const char * __tagb) noexcept(true); extern _Float32x __nanf32x(const char * __tagb) noexcept(true); +# 253 "/usr/include/bits/mathcalls.h" 3 +extern _Float32x j0f32x(_Float32x) noexcept(true); extern _Float32x __j0f32x(_Float32x) noexcept(true); +# 254 +extern _Float32x j1f32x(_Float32x) noexcept(true); extern _Float32x __j1f32x(_Float32x) noexcept(true); +# 255 +extern _Float32x jnf32x(int, _Float32x) noexcept(true); extern _Float32x __jnf32x(int, _Float32x) noexcept(true); +# 256 +extern _Float32x y0f32x(_Float32x) noexcept(true); extern _Float32x __y0f32x(_Float32x) noexcept(true); +# 257 +extern _Float32x y1f32x(_Float32x) noexcept(true); extern _Float32x __y1f32x(_Float32x) noexcept(true); +# 258 +extern _Float32x ynf32x(int, _Float32x) noexcept(true); extern _Float32x __ynf32x(int, _Float32x) noexcept(true); +# 264 +extern _Float32x erff32x(_Float32x) noexcept(true); extern _Float32x __erff32x(_Float32x) noexcept(true); +# 265 +extern _Float32x erfcf32x(_Float32x) noexcept(true); extern _Float32x __erfcf32x(_Float32x) noexcept(true); +# 266 +extern _Float32x lgammaf32x(_Float32x) noexcept(true); extern _Float32x __lgammaf32x(_Float32x) noexcept(true); +# 271 +extern _Float32x tgammaf32x(_Float32x) noexcept(true); extern _Float32x __tgammaf32x(_Float32x) noexcept(true); +# 285 "/usr/include/bits/mathcalls.h" 3 +extern _Float32x lgammaf32x_r(_Float32x, int * __signgamp) noexcept(true); extern _Float32x __lgammaf32x_r(_Float32x, int * __signgamp) noexcept(true); +# 292 +extern _Float32x rintf32x(_Float32x __x) noexcept(true); extern _Float32x __rintf32x(_Float32x __x) noexcept(true); +# 295 +extern _Float32x nextafterf32x(_Float32x __x, _Float32x __y) noexcept(true); extern _Float32x __nextafterf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 302 +extern _Float32x nextdownf32x(_Float32x __x) noexcept(true); extern _Float32x __nextdownf32x(_Float32x __x) noexcept(true); +# 304 +extern _Float32x nextupf32x(_Float32x __x) noexcept(true); extern _Float32x __nextupf32x(_Float32x __x) noexcept(true); +# 308 +extern _Float32x remainderf32x(_Float32x __x, _Float32x __y) noexcept(true); extern _Float32x __remainderf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 312 +extern _Float32x scalbnf32x(_Float32x __x, int __n) noexcept(true); extern _Float32x __scalbnf32x(_Float32x __x, int __n) noexcept(true); +# 316 +extern int ilogbf32x(_Float32x __x) noexcept(true); extern int __ilogbf32x(_Float32x __x) noexcept(true); +# 321 +extern long llogbf32x(_Float32x __x) noexcept(true); extern long __llogbf32x(_Float32x __x) noexcept(true); +# 326 +extern _Float32x scalblnf32x(_Float32x __x, long __n) noexcept(true); extern _Float32x __scalblnf32x(_Float32x __x, long __n) noexcept(true); +# 330 +extern _Float32x nearbyintf32x(_Float32x __x) noexcept(true); extern _Float32x __nearbyintf32x(_Float32x __x) noexcept(true); +# 334 +extern _Float32x roundf32x(_Float32x __x) noexcept(true) __attribute((const)); +# 338 +extern _Float32x truncf32x(_Float32x __x) noexcept(true) __attribute((const)); +# 343 +extern _Float32x remquof32x(_Float32x __x, _Float32x __y, int * __quo) noexcept(true); extern _Float32x __remquof32x(_Float32x __x, _Float32x __y, int * __quo) noexcept(true); +# 350 +extern long lrintf32x(_Float32x __x) noexcept(true); extern long __lrintf32x(_Float32x __x) noexcept(true); +# 352 +__extension__ extern long long llrintf32x(_Float32x __x) noexcept(true); extern long long __llrintf32x(_Float32x __x) noexcept(true); +# 356 +extern long lroundf32x(_Float32x __x) noexcept(true); extern long __lroundf32x(_Float32x __x) noexcept(true); +# 358 +__extension__ extern long long llroundf32x(_Float32x __x) noexcept(true); extern long long __llroundf32x(_Float32x __x) noexcept(true); +# 362 +extern _Float32x fdimf32x(_Float32x __x, _Float32x __y) noexcept(true); extern _Float32x __fdimf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 366 +extern _Float32x fmaxf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 369 +extern _Float32x fminf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 373 +extern _Float32x fmaf32x(_Float32x __x, _Float32x __y, _Float32x __z) noexcept(true); extern _Float32x __fmaf32x(_Float32x __x, _Float32x __y, _Float32x __z) noexcept(true); +# 378 +extern _Float32x roundevenf32x(_Float32x __x) noexcept(true) __attribute((const)); +# 382 +extern __intmax_t fromfpf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); +# 387 +extern __uintmax_t ufromfpf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); +# 393 +extern __intmax_t fromfpxf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpxf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); +# 399 +extern __uintmax_t ufromfpxf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpxf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); +# 403 +extern int canonicalizef32x(_Float32x * __cx, const _Float32x * __x) noexcept(true); +# 410 +extern _Float32x fmaxmagf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 413 +extern _Float32x fminmagf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 418 +extern _Float32x fmaximumf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 421 +extern _Float32x fminimumf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 424 +extern _Float32x fmaximum_numf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 427 +extern _Float32x fminimum_numf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 430 +extern _Float32x fmaximum_magf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 433 +extern _Float32x fminimum_magf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 436 +extern _Float32x fmaximum_mag_numf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 439 +extern _Float32x fminimum_mag_numf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 444 +extern int totalorderf32x(const _Float32x * __x, const _Float32x * __y) noexcept(true) +# 446 + __attribute((__pure__)); +# 449 +extern int totalordermagf32x(const _Float32x * __x, const _Float32x * __y) noexcept(true) +# 451 + __attribute((__pure__)); +# 454 +extern _Float32x getpayloadf32x(const _Float32x * __x) noexcept(true); extern _Float32x __getpayloadf32x(const _Float32x * __x) noexcept(true); +# 457 +extern int setpayloadf32x(_Float32x * __x, _Float32x __payload) noexcept(true); +# 460 +extern int setpayloadsigf32x(_Float32x * __x, _Float32x __payload) noexcept(true); +# 53 "/usr/include/bits/mathcalls.h" 3 +extern _Float64x acosf64x(_Float64x __x) noexcept(true); extern _Float64x __acosf64x(_Float64x __x) noexcept(true); +# 55 +extern _Float64x asinf64x(_Float64x __x) noexcept(true); extern _Float64x __asinf64x(_Float64x __x) noexcept(true); +# 57 +extern _Float64x atanf64x(_Float64x __x) noexcept(true); extern _Float64x __atanf64x(_Float64x __x) noexcept(true); +# 59 +extern _Float64x atan2f64x(_Float64x __y, _Float64x __x) noexcept(true); extern _Float64x __atan2f64x(_Float64x __y, _Float64x __x) noexcept(true); +# 62 +extern _Float64x cosf64x(_Float64x __x) noexcept(true); extern _Float64x __cosf64x(_Float64x __x) noexcept(true); +# 64 +extern _Float64x sinf64x(_Float64x __x) noexcept(true); extern _Float64x __sinf64x(_Float64x __x) noexcept(true); +# 66 +extern _Float64x tanf64x(_Float64x __x) noexcept(true); extern _Float64x __tanf64x(_Float64x __x) noexcept(true); +# 70 +extern _Float64x acospif64x(_Float64x __x) noexcept(true); extern _Float64x __acospif64x(_Float64x __x) noexcept(true); +# 72 +extern _Float64x asinpif64x(_Float64x __x) noexcept(true); extern _Float64x __asinpif64x(_Float64x __x) noexcept(true); +# 74 +extern _Float64x atanpif64x(_Float64x __x) noexcept(true); extern _Float64x __atanpif64x(_Float64x __x) noexcept(true); +# 76 +extern _Float64x atan2pif64x(_Float64x __y, _Float64x __x) noexcept(true); extern _Float64x __atan2pif64x(_Float64x __y, _Float64x __x) noexcept(true); +# 79 +extern _Float64x cospif64x(_Float64x __x) noexcept(true); extern _Float64x __cospif64x(_Float64x __x) noexcept(true); +# 81 +extern _Float64x sinpif64x(_Float64x __x) noexcept(true); extern _Float64x __sinpif64x(_Float64x __x) noexcept(true); +# 83 +extern _Float64x tanpif64x(_Float64x __x) noexcept(true); extern _Float64x __tanpif64x(_Float64x __x) noexcept(true); +# 89 +extern _Float64x coshf64x(_Float64x __x) noexcept(true); extern _Float64x __coshf64x(_Float64x __x) noexcept(true); +# 91 +extern _Float64x sinhf64x(_Float64x __x) noexcept(true); extern _Float64x __sinhf64x(_Float64x __x) noexcept(true); +# 93 +extern _Float64x tanhf64x(_Float64x __x) noexcept(true); extern _Float64x __tanhf64x(_Float64x __x) noexcept(true); +# 97 +extern void sincosf64x(_Float64x __x, _Float64x * __sinx, _Float64x * __cosx) noexcept(true); extern void __sincosf64x(_Float64x __x, _Float64x * __sinx, _Float64x * __cosx) noexcept(true); +# 103 +extern _Float64x acoshf64x(_Float64x __x) noexcept(true); extern _Float64x __acoshf64x(_Float64x __x) noexcept(true); +# 105 +extern _Float64x asinhf64x(_Float64x __x) noexcept(true); extern _Float64x __asinhf64x(_Float64x __x) noexcept(true); +# 107 +extern _Float64x atanhf64x(_Float64x __x) noexcept(true); extern _Float64x __atanhf64x(_Float64x __x) noexcept(true); +# 113 +extern _Float64x expf64x(_Float64x __x) noexcept(true); extern _Float64x __expf64x(_Float64x __x) noexcept(true); +# 116 +extern _Float64x frexpf64x(_Float64x __x, int * __exponent) noexcept(true); extern _Float64x __frexpf64x(_Float64x __x, int * __exponent) noexcept(true); +# 119 +extern _Float64x ldexpf64x(_Float64x __x, int __exponent) noexcept(true); extern _Float64x __ldexpf64x(_Float64x __x, int __exponent) noexcept(true); +# 122 +extern _Float64x logf64x(_Float64x __x) noexcept(true); extern _Float64x __logf64x(_Float64x __x) noexcept(true); +# 125 +extern _Float64x log10f64x(_Float64x __x) noexcept(true); extern _Float64x __log10f64x(_Float64x __x) noexcept(true); +# 128 +extern _Float64x modff64x(_Float64x __x, _Float64x * __iptr) noexcept(true); extern _Float64x __modff64x(_Float64x __x, _Float64x * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 132 +extern _Float64x exp10f64x(_Float64x __x) noexcept(true); extern _Float64x __exp10f64x(_Float64x __x) noexcept(true); +# 135 +extern _Float64x exp2m1f64x(_Float64x __x) noexcept(true); extern _Float64x __exp2m1f64x(_Float64x __x) noexcept(true); +# 138 +extern _Float64x exp10m1f64x(_Float64x __x) noexcept(true); extern _Float64x __exp10m1f64x(_Float64x __x) noexcept(true); +# 141 +extern _Float64x log2p1f64x(_Float64x __x) noexcept(true); extern _Float64x __log2p1f64x(_Float64x __x) noexcept(true); +# 144 +extern _Float64x log10p1f64x(_Float64x __x) noexcept(true); extern _Float64x __log10p1f64x(_Float64x __x) noexcept(true); +# 147 +extern _Float64x logp1f64x(_Float64x __x) noexcept(true); extern _Float64x __logp1f64x(_Float64x __x) noexcept(true); +# 152 +extern _Float64x expm1f64x(_Float64x __x) noexcept(true); extern _Float64x __expm1f64x(_Float64x __x) noexcept(true); +# 155 +extern _Float64x log1pf64x(_Float64x __x) noexcept(true); extern _Float64x __log1pf64x(_Float64x __x) noexcept(true); +# 158 +extern _Float64x logbf64x(_Float64x __x) noexcept(true); extern _Float64x __logbf64x(_Float64x __x) noexcept(true); +# 163 +extern _Float64x exp2f64x(_Float64x __x) noexcept(true); extern _Float64x __exp2f64x(_Float64x __x) noexcept(true); +# 166 +extern _Float64x log2f64x(_Float64x __x) noexcept(true); extern _Float64x __log2f64x(_Float64x __x) noexcept(true); +# 173 +extern _Float64x powf64x(_Float64x __x, _Float64x __y) noexcept(true); extern _Float64x __powf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 176 +extern _Float64x sqrtf64x(_Float64x __x) noexcept(true); extern _Float64x __sqrtf64x(_Float64x __x) noexcept(true); +# 180 +extern _Float64x hypotf64x(_Float64x __x, _Float64x __y) noexcept(true); extern _Float64x __hypotf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 185 +extern _Float64x cbrtf64x(_Float64x __x) noexcept(true); extern _Float64x __cbrtf64x(_Float64x __x) noexcept(true); +# 192 +extern _Float64x ceilf64x(_Float64x __x) noexcept(true) __attribute((const)); +# 195 +extern _Float64x fabsf64x(_Float64x __x) noexcept(true) __attribute((const)); +# 198 +extern _Float64x floorf64x(_Float64x __x) noexcept(true) __attribute((const)); +# 201 +extern _Float64x fmodf64x(_Float64x __x, _Float64x __y) noexcept(true); extern _Float64x __fmodf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 231 "/usr/include/bits/mathcalls.h" 3 +extern _Float64x copysignf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 236 +extern _Float64x nanf64x(const char * __tagb) noexcept(true); extern _Float64x __nanf64x(const char * __tagb) noexcept(true); +# 253 "/usr/include/bits/mathcalls.h" 3 +extern _Float64x j0f64x(_Float64x) noexcept(true); extern _Float64x __j0f64x(_Float64x) noexcept(true); +# 254 +extern _Float64x j1f64x(_Float64x) noexcept(true); extern _Float64x __j1f64x(_Float64x) noexcept(true); +# 255 +extern _Float64x jnf64x(int, _Float64x) noexcept(true); extern _Float64x __jnf64x(int, _Float64x) noexcept(true); +# 256 +extern _Float64x y0f64x(_Float64x) noexcept(true); extern _Float64x __y0f64x(_Float64x) noexcept(true); +# 257 +extern _Float64x y1f64x(_Float64x) noexcept(true); extern _Float64x __y1f64x(_Float64x) noexcept(true); +# 258 +extern _Float64x ynf64x(int, _Float64x) noexcept(true); extern _Float64x __ynf64x(int, _Float64x) noexcept(true); +# 264 +extern _Float64x erff64x(_Float64x) noexcept(true); extern _Float64x __erff64x(_Float64x) noexcept(true); +# 265 +extern _Float64x erfcf64x(_Float64x) noexcept(true); extern _Float64x __erfcf64x(_Float64x) noexcept(true); +# 266 +extern _Float64x lgammaf64x(_Float64x) noexcept(true); extern _Float64x __lgammaf64x(_Float64x) noexcept(true); +# 271 +extern _Float64x tgammaf64x(_Float64x) noexcept(true); extern _Float64x __tgammaf64x(_Float64x) noexcept(true); +# 285 "/usr/include/bits/mathcalls.h" 3 +extern _Float64x lgammaf64x_r(_Float64x, int * __signgamp) noexcept(true); extern _Float64x __lgammaf64x_r(_Float64x, int * __signgamp) noexcept(true); +# 292 +extern _Float64x rintf64x(_Float64x __x) noexcept(true); extern _Float64x __rintf64x(_Float64x __x) noexcept(true); +# 295 +extern _Float64x nextafterf64x(_Float64x __x, _Float64x __y) noexcept(true); extern _Float64x __nextafterf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 302 +extern _Float64x nextdownf64x(_Float64x __x) noexcept(true); extern _Float64x __nextdownf64x(_Float64x __x) noexcept(true); +# 304 +extern _Float64x nextupf64x(_Float64x __x) noexcept(true); extern _Float64x __nextupf64x(_Float64x __x) noexcept(true); +# 308 +extern _Float64x remainderf64x(_Float64x __x, _Float64x __y) noexcept(true); extern _Float64x __remainderf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 312 +extern _Float64x scalbnf64x(_Float64x __x, int __n) noexcept(true); extern _Float64x __scalbnf64x(_Float64x __x, int __n) noexcept(true); +# 316 +extern int ilogbf64x(_Float64x __x) noexcept(true); extern int __ilogbf64x(_Float64x __x) noexcept(true); +# 321 +extern long llogbf64x(_Float64x __x) noexcept(true); extern long __llogbf64x(_Float64x __x) noexcept(true); +# 326 +extern _Float64x scalblnf64x(_Float64x __x, long __n) noexcept(true); extern _Float64x __scalblnf64x(_Float64x __x, long __n) noexcept(true); +# 330 +extern _Float64x nearbyintf64x(_Float64x __x) noexcept(true); extern _Float64x __nearbyintf64x(_Float64x __x) noexcept(true); +# 334 +extern _Float64x roundf64x(_Float64x __x) noexcept(true) __attribute((const)); +# 338 +extern _Float64x truncf64x(_Float64x __x) noexcept(true) __attribute((const)); +# 343 +extern _Float64x remquof64x(_Float64x __x, _Float64x __y, int * __quo) noexcept(true); extern _Float64x __remquof64x(_Float64x __x, _Float64x __y, int * __quo) noexcept(true); +# 350 +extern long lrintf64x(_Float64x __x) noexcept(true); extern long __lrintf64x(_Float64x __x) noexcept(true); +# 352 +__extension__ extern long long llrintf64x(_Float64x __x) noexcept(true); extern long long __llrintf64x(_Float64x __x) noexcept(true); +# 356 +extern long lroundf64x(_Float64x __x) noexcept(true); extern long __lroundf64x(_Float64x __x) noexcept(true); +# 358 +__extension__ extern long long llroundf64x(_Float64x __x) noexcept(true); extern long long __llroundf64x(_Float64x __x) noexcept(true); +# 362 +extern _Float64x fdimf64x(_Float64x __x, _Float64x __y) noexcept(true); extern _Float64x __fdimf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 366 +extern _Float64x fmaxf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 369 +extern _Float64x fminf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 373 +extern _Float64x fmaf64x(_Float64x __x, _Float64x __y, _Float64x __z) noexcept(true); extern _Float64x __fmaf64x(_Float64x __x, _Float64x __y, _Float64x __z) noexcept(true); +# 378 +extern _Float64x roundevenf64x(_Float64x __x) noexcept(true) __attribute((const)); +# 382 +extern __intmax_t fromfpf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); +# 387 +extern __uintmax_t ufromfpf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); +# 393 +extern __intmax_t fromfpxf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpxf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); +# 399 +extern __uintmax_t ufromfpxf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpxf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); +# 403 +extern int canonicalizef64x(_Float64x * __cx, const _Float64x * __x) noexcept(true); +# 410 +extern _Float64x fmaxmagf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 413 +extern _Float64x fminmagf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 418 +extern _Float64x fmaximumf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 421 +extern _Float64x fminimumf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 424 +extern _Float64x fmaximum_numf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 427 +extern _Float64x fminimum_numf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 430 +extern _Float64x fmaximum_magf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 433 +extern _Float64x fminimum_magf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 436 +extern _Float64x fmaximum_mag_numf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 439 +extern _Float64x fminimum_mag_numf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 444 +extern int totalorderf64x(const _Float64x * __x, const _Float64x * __y) noexcept(true) +# 446 + __attribute((__pure__)); +# 449 +extern int totalordermagf64x(const _Float64x * __x, const _Float64x * __y) noexcept(true) +# 451 + __attribute((__pure__)); +# 454 +extern _Float64x getpayloadf64x(const _Float64x * __x) noexcept(true); extern _Float64x __getpayloadf64x(const _Float64x * __x) noexcept(true); +# 457 +extern int setpayloadf64x(_Float64x * __x, _Float64x __payload) noexcept(true); +# 460 +extern int setpayloadsigf64x(_Float64x * __x, _Float64x __payload) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern float fadd(double __x, double __y) noexcept(true); +# 27 +extern float fdiv(double __x, double __y) noexcept(true); +# 30 +extern float ffma(double __x, double __y, double __z) noexcept(true); +# 33 +extern float fmul(double __x, double __y) noexcept(true); +# 36 +extern float fsqrt(double __x) noexcept(true); +# 39 +extern float fsub(double __x, double __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern float faddl(long double __x, long double __y) noexcept(true); +# 27 +extern float fdivl(long double __x, long double __y) noexcept(true); +# 30 +extern float ffmal(long double __x, long double __y, long double __z) noexcept(true); +# 33 +extern float fmull(long double __x, long double __y) noexcept(true); +# 36 +extern float fsqrtl(long double __x) noexcept(true); +# 39 +extern float fsubl(long double __x, long double __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern double daddl(long double __x, long double __y) noexcept(true); +# 27 +extern double ddivl(long double __x, long double __y) noexcept(true); +# 30 +extern double dfmal(long double __x, long double __y, long double __z) noexcept(true); +# 33 +extern double dmull(long double __x, long double __y) noexcept(true); +# 36 +extern double dsqrtl(long double __x) noexcept(true); +# 39 +extern double dsubl(long double __x, long double __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern _Float32 f32addf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 27 +extern _Float32 f32divf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 30 +extern _Float32 f32fmaf32x(_Float32x __x, _Float32x __y, _Float32x __z) noexcept(true); +# 33 +extern _Float32 f32mulf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 36 +extern _Float32 f32sqrtf32x(_Float32x __x) noexcept(true); +# 39 +extern _Float32 f32subf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern _Float32 f32addf64(_Float64 __x, _Float64 __y) noexcept(true); +# 27 +extern _Float32 f32divf64(_Float64 __x, _Float64 __y) noexcept(true); +# 30 +extern _Float32 f32fmaf64(_Float64 __x, _Float64 __y, _Float64 __z) noexcept(true); +# 33 +extern _Float32 f32mulf64(_Float64 __x, _Float64 __y) noexcept(true); +# 36 +extern _Float32 f32sqrtf64(_Float64 __x) noexcept(true); +# 39 +extern _Float32 f32subf64(_Float64 __x, _Float64 __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern _Float32 f32addf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 27 +extern _Float32 f32divf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 30 +extern _Float32 f32fmaf64x(_Float64x __x, _Float64x __y, _Float64x __z) noexcept(true); +# 33 +extern _Float32 f32mulf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 36 +extern _Float32 f32sqrtf64x(_Float64x __x) noexcept(true); +# 39 +extern _Float32 f32subf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern _Float32 f32addf128(_Float128 __x, _Float128 __y) noexcept(true); +# 27 +extern _Float32 f32divf128(_Float128 __x, _Float128 __y) noexcept(true); +# 30 +extern _Float32 f32fmaf128(_Float128 __x, _Float128 __y, _Float128 __z) noexcept(true); +# 33 +extern _Float32 f32mulf128(_Float128 __x, _Float128 __y) noexcept(true); +# 36 +extern _Float32 f32sqrtf128(_Float128 __x) noexcept(true); +# 39 +extern _Float32 f32subf128(_Float128 __x, _Float128 __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern _Float32x f32xaddf64(_Float64 __x, _Float64 __y) noexcept(true); +# 27 +extern _Float32x f32xdivf64(_Float64 __x, _Float64 __y) noexcept(true); +# 30 +extern _Float32x f32xfmaf64(_Float64 __x, _Float64 __y, _Float64 __z) noexcept(true); +# 33 +extern _Float32x f32xmulf64(_Float64 __x, _Float64 __y) noexcept(true); +# 36 +extern _Float32x f32xsqrtf64(_Float64 __x) noexcept(true); +# 39 +extern _Float32x f32xsubf64(_Float64 __x, _Float64 __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern _Float32x f32xaddf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 27 +extern _Float32x f32xdivf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 30 +extern _Float32x f32xfmaf64x(_Float64x __x, _Float64x __y, _Float64x __z) noexcept(true); +# 33 +extern _Float32x f32xmulf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 36 +extern _Float32x f32xsqrtf64x(_Float64x __x) noexcept(true); +# 39 +extern _Float32x f32xsubf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern _Float32x f32xaddf128(_Float128 __x, _Float128 __y) noexcept(true); +# 27 +extern _Float32x f32xdivf128(_Float128 __x, _Float128 __y) noexcept(true); +# 30 +extern _Float32x f32xfmaf128(_Float128 __x, _Float128 __y, _Float128 __z) noexcept(true); +# 33 +extern _Float32x f32xmulf128(_Float128 __x, _Float128 __y) noexcept(true); +# 36 +extern _Float32x f32xsqrtf128(_Float128 __x) noexcept(true); +# 39 +extern _Float32x f32xsubf128(_Float128 __x, _Float128 __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern _Float64 f64addf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 27 +extern _Float64 f64divf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 30 +extern _Float64 f64fmaf64x(_Float64x __x, _Float64x __y, _Float64x __z) noexcept(true); +# 33 +extern _Float64 f64mulf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 36 +extern _Float64 f64sqrtf64x(_Float64x __x) noexcept(true); +# 39 +extern _Float64 f64subf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern _Float64 f64addf128(_Float128 __x, _Float128 __y) noexcept(true); +# 27 +extern _Float64 f64divf128(_Float128 __x, _Float128 __y) noexcept(true); +# 30 +extern _Float64 f64fmaf128(_Float128 __x, _Float128 __y, _Float128 __z) noexcept(true); +# 33 +extern _Float64 f64mulf128(_Float128 __x, _Float128 __y) noexcept(true); +# 36 +extern _Float64 f64sqrtf128(_Float128 __x) noexcept(true); +# 39 +extern _Float64 f64subf128(_Float128 __x, _Float128 __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern _Float64x f64xaddf128(_Float128 __x, _Float128 __y) noexcept(true); +# 27 +extern _Float64x f64xdivf128(_Float128 __x, _Float128 __y) noexcept(true); +# 30 +extern _Float64x f64xfmaf128(_Float128 __x, _Float128 __y, _Float128 __z) noexcept(true); +# 33 +extern _Float64x f64xmulf128(_Float128 __x, _Float128 __y) noexcept(true); +# 36 +extern _Float64x f64xsqrtf128(_Float128 __x) noexcept(true); +# 39 +extern _Float64x f64xsubf128(_Float128 __x, _Float128 __y) noexcept(true); +# 823 "/usr/include/math.h" 3 +extern int signgam; +# 904 "/usr/include/math.h" 3 +enum { +# 905 +FP_NAN, +# 908 +FP_INFINITE, +# 911 +FP_ZERO, +# 914 +FP_SUBNORMAL, +# 917 +FP_NORMAL +# 920 +}; +# 23 "/usr/include/bits/iscanonical.h" 3 +extern int __iscanonicall(long double __x) noexcept(true) +# 24 + __attribute((const)); +# 46 "/usr/include/bits/iscanonical.h" 3 +extern "C++" { +# 47 +inline int iscanonical(float __val) { return (((void)((__typeof__(__val))__val)), 1); } +# 48 +inline int iscanonical(double __val) { return (((void)((__typeof__(__val))__val)), 1); } +# 49 +inline int iscanonical(long double __val) { return __iscanonicall(__val); } +# 51 +inline int iscanonical(_Float128 __val) { return (((void)((__typeof__(__val))__val)), 1); } +# 53 +} +# 1036 "/usr/include/math.h" 3 +extern "C++" { +# 1037 +inline int issignaling(float __val) { return __issignalingf(__val); } +# 1038 +inline int issignaling(double __val) { return __issignaling(__val); } +# 1040 +inline int issignaling(long double __val) +# 1041 +{ +# 1045 +return __issignalingl(__val); +# 1047 +} +# 1051 +inline int issignaling(_Float128 __val) { return __issignalingf128(__val); } +# 1053 +} +# 1067 "/usr/include/math.h" 3 +extern "C++" { +# 1098 "/usr/include/math.h" 3 +template< class __T> inline bool +# 1099 +iszero(__T __val) +# 1100 +{ +# 1101 +return __val == 0; +# 1102 +} +# 1104 +} +# 1333 "/usr/include/math.h" 3 +extern "C++" { +# 1334 +template< class > struct __iseqsig_type; +# 1336 +template<> struct __iseqsig_type< float> { +# 1338 +static int __call(float __x, float __y) throw() +# 1339 +{ +# 1340 +return __iseqsigf(__x, __y); +# 1341 +} +# 1342 +}; +# 1344 +template<> struct __iseqsig_type< double> { +# 1346 +static int __call(double __x, double __y) throw() +# 1347 +{ +# 1348 +return __iseqsig(__x, __y); +# 1349 +} +# 1350 +}; +# 1352 +template<> struct __iseqsig_type< long double> { +# 1354 +static int __call(long double __x, long double __y) throw() +# 1355 +{ +# 1357 +return __iseqsigl(__x, __y); +# 1361 +} +# 1362 +}; +# 1365 +template<> struct __iseqsig_type< _Float32> { +# 1367 +static int __call(_Float32 __x, _Float32 __y) throw() +# 1368 +{ +# 1369 +return __iseqsigf(__x, __y); +# 1370 +} +# 1371 +}; +# 1375 +template<> struct __iseqsig_type< _Float64> { +# 1377 +static int __call(_Float64 __x, _Float64 __y) throw() +# 1378 +{ +# 1379 +return __iseqsig(__x, __y); +# 1380 +} +# 1381 +}; +# 1387 +template<> struct __iseqsig_type< _Float128> { +# 1389 +static int __call(_Float128 __x, _Float128 __y) throw() +# 1390 +{ +# 1392 +return __iseqsigf128(__x, __y); +# 1396 +} +# 1397 +}; +# 1401 +template<> struct __iseqsig_type< _Float32x> { +# 1403 +static int __call(_Float32x __x, _Float32x __y) throw() +# 1404 +{ +# 1405 +return __iseqsig(__x, __y); +# 1406 +} +# 1407 +}; +# 1411 +template<> struct __iseqsig_type< _Float64x> { +# 1413 +static int __call(_Float64x __x, _Float64x __y) throw() +# 1414 +{ +# 1416 +return __iseqsigl(__x, __y); +# 1420 +} +# 1421 +}; +# 1424 +template< class _T1, class _T2> inline int +# 1426 +iseqsig(_T1 __x, _T2 __y) throw() +# 1427 +{ +# 1429 +typedef __decltype(((__x + __y) + (0.0F))) _T3; +# 1433 +return __iseqsig_type< __decltype(((__x + __y) + (0.0F)))> ::__call(__x, __y); +# 1434 +} +# 1436 +} +# 1441 +} +# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +extern "C++" { +# 85 +namespace std __attribute((__visibility__("default"))) { +# 89 +using ::acos; +# 93 +constexpr float acos(float __x) +# 94 +{ return __builtin_acosf(__x); } +# 97 +constexpr long double acos(long double __x) +# 98 +{ return __builtin_acosl(__x); } +# 101 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 105 +acos(_Tp __x) +# 106 +{ return __builtin_acos(__x); } +# 108 +using ::asin; +# 112 +constexpr float asin(float __x) +# 113 +{ return __builtin_asinf(__x); } +# 116 +constexpr long double asin(long double __x) +# 117 +{ return __builtin_asinl(__x); } +# 120 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 124 +asin(_Tp __x) +# 125 +{ return __builtin_asin(__x); } +# 127 +using ::atan; +# 131 +constexpr float atan(float __x) +# 132 +{ return __builtin_atanf(__x); } +# 135 +constexpr long double atan(long double __x) +# 136 +{ return __builtin_atanl(__x); } +# 139 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 143 +atan(_Tp __x) +# 144 +{ return __builtin_atan(__x); } +# 146 +using ::atan2; +# 150 +constexpr float atan2(float __y, float __x) +# 151 +{ return __builtin_atan2f(__y, __x); } +# 154 +constexpr long double atan2(long double __y, long double __x) +# 155 +{ return __builtin_atan2l(__y, __x); } +# 158 +using ::ceil; +# 162 +constexpr float ceil(float __x) +# 163 +{ return __builtin_ceilf(__x); } +# 166 +constexpr long double ceil(long double __x) +# 167 +{ return __builtin_ceill(__x); } +# 170 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 174 +ceil(_Tp __x) +# 175 +{ return __builtin_ceil(__x); } +# 177 +using ::cos; +# 181 +constexpr float cos(float __x) +# 182 +{ return __builtin_cosf(__x); } +# 185 +constexpr long double cos(long double __x) +# 186 +{ return __builtin_cosl(__x); } +# 189 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 193 +cos(_Tp __x) +# 194 +{ return __builtin_cos(__x); } +# 196 +using ::cosh; +# 200 +constexpr float cosh(float __x) +# 201 +{ return __builtin_coshf(__x); } +# 204 +constexpr long double cosh(long double __x) +# 205 +{ return __builtin_coshl(__x); } +# 208 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 212 +cosh(_Tp __x) +# 213 +{ return __builtin_cosh(__x); } +# 215 +using ::exp; +# 219 +constexpr float exp(float __x) +# 220 +{ return __builtin_expf(__x); } +# 223 +constexpr long double exp(long double __x) +# 224 +{ return __builtin_expl(__x); } +# 227 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 231 +exp(_Tp __x) +# 232 +{ return __builtin_exp(__x); } +# 234 +using ::fabs; +# 238 +constexpr float fabs(float __x) +# 239 +{ return __builtin_fabsf(__x); } +# 242 +constexpr long double fabs(long double __x) +# 243 +{ return __builtin_fabsl(__x); } +# 246 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 250 +fabs(_Tp __x) +# 251 +{ return __builtin_fabs(__x); } +# 253 +using ::floor; +# 257 +constexpr float floor(float __x) +# 258 +{ return __builtin_floorf(__x); } +# 261 +constexpr long double floor(long double __x) +# 262 +{ return __builtin_floorl(__x); } +# 265 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 269 +floor(_Tp __x) +# 270 +{ return __builtin_floor(__x); } +# 272 +using ::fmod; +# 276 +constexpr float fmod(float __x, float __y) +# 277 +{ return __builtin_fmodf(__x, __y); } +# 280 +constexpr long double fmod(long double __x, long double __y) +# 281 +{ return __builtin_fmodl(__x, __y); } +# 284 +using ::frexp; +# 288 +inline float frexp(float __x, int *__exp) +# 289 +{ return __builtin_frexpf(__x, __exp); } +# 292 +inline long double frexp(long double __x, int *__exp) +# 293 +{ return __builtin_frexpl(__x, __exp); } +# 296 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 300 +frexp(_Tp __x, int *__exp) +# 301 +{ return __builtin_frexp(__x, __exp); } +# 303 +using ::ldexp; +# 307 +constexpr float ldexp(float __x, int __exp) +# 308 +{ return __builtin_ldexpf(__x, __exp); } +# 311 +constexpr long double ldexp(long double __x, int __exp) +# 312 +{ return __builtin_ldexpl(__x, __exp); } +# 315 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 319 +ldexp(_Tp __x, int __exp) +# 320 +{ return __builtin_ldexp(__x, __exp); } +# 322 +using ::log; +# 326 +constexpr float log(float __x) +# 327 +{ return __builtin_logf(__x); } +# 330 +constexpr long double log(long double __x) +# 331 +{ return __builtin_logl(__x); } +# 334 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 338 +log(_Tp __x) +# 339 +{ return __builtin_log(__x); } +# 341 +using ::log10; +# 345 +constexpr float log10(float __x) +# 346 +{ return __builtin_log10f(__x); } +# 349 +constexpr long double log10(long double __x) +# 350 +{ return __builtin_log10l(__x); } +# 353 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 357 +log10(_Tp __x) +# 358 +{ return __builtin_log10(__x); } +# 360 +using ::modf; +# 364 +inline float modf(float __x, float *__iptr) +# 365 +{ return __builtin_modff(__x, __iptr); } +# 368 +inline long double modf(long double __x, long double *__iptr) +# 369 +{ return __builtin_modfl(__x, __iptr); } +# 372 +using ::pow; +# 376 +constexpr float pow(float __x, float __y) +# 377 +{ return __builtin_powf(__x, __y); } +# 380 +constexpr long double pow(long double __x, long double __y) +# 381 +{ return __builtin_powl(__x, __y); } +# 400 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +using ::sin; +# 404 +constexpr float sin(float __x) +# 405 +{ return __builtin_sinf(__x); } +# 408 +constexpr long double sin(long double __x) +# 409 +{ return __builtin_sinl(__x); } +# 412 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 416 +sin(_Tp __x) +# 417 +{ return __builtin_sin(__x); } +# 419 +using ::sinh; +# 423 +constexpr float sinh(float __x) +# 424 +{ return __builtin_sinhf(__x); } +# 427 +constexpr long double sinh(long double __x) +# 428 +{ return __builtin_sinhl(__x); } +# 431 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 435 +sinh(_Tp __x) +# 436 +{ return __builtin_sinh(__x); } +# 438 +using ::sqrt; +# 442 +constexpr float sqrt(float __x) +# 443 +{ return __builtin_sqrtf(__x); } +# 446 +constexpr long double sqrt(long double __x) +# 447 +{ return __builtin_sqrtl(__x); } +# 450 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 454 +sqrt(_Tp __x) +# 455 +{ return __builtin_sqrt(__x); } +# 457 +using ::tan; +# 461 +constexpr float tan(float __x) +# 462 +{ return __builtin_tanf(__x); } +# 465 +constexpr long double tan(long double __x) +# 466 +{ return __builtin_tanl(__x); } +# 469 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 473 +tan(_Tp __x) +# 474 +{ return __builtin_tan(__x); } +# 476 +using ::tanh; +# 480 +constexpr float tanh(float __x) +# 481 +{ return __builtin_tanhf(__x); } +# 484 +constexpr long double tanh(long double __x) +# 485 +{ return __builtin_tanhl(__x); } +# 488 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 492 +tanh(_Tp __x) +# 493 +{ return __builtin_tanh(__x); } +# 1053 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 1056 +atan2(_Tp __y, _Up __x) +# 1057 +{ +# 1058 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1059 +return atan2((__type)__y, (__type)__x); +# 1060 +} +# 1062 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 1065 +fmod(_Tp __x, _Up __y) +# 1066 +{ +# 1067 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1068 +return fmod((__type)__x, (__type)__y); +# 1069 +} +# 1071 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 1074 +pow(_Tp __x, _Up __y) +# 1075 +{ +# 1076 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1077 +return pow((__type)__x, (__type)__y); +# 1078 +} +# 1101 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +constexpr int fpclassify(float __x) +# 1102 +{ return __builtin_fpclassify(0, 1, 4, 3, 2, __x); +# 1103 +} +# 1106 +constexpr int fpclassify(double __x) +# 1107 +{ return __builtin_fpclassify(0, 1, 4, 3, 2, __x); +# 1108 +} +# 1111 +constexpr int fpclassify(long double __x) +# 1112 +{ return __builtin_fpclassify(0, 1, 4, 3, 2, __x); +# 1113 +} +# 1117 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, int> ::__type +# 1120 +fpclassify(_Tp __x) +# 1121 +{ return (__x != 0) ? 4 : 2; } +# 1126 +constexpr bool isfinite(float __x) +# 1127 +{ return __builtin_isfinite(__x); } +# 1130 +constexpr bool isfinite(double __x) +# 1131 +{ return __builtin_isfinite(__x); } +# 1134 +constexpr bool isfinite(long double __x) +# 1135 +{ return __builtin_isfinite(__x); } +# 1139 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, bool> ::__type +# 1142 +isfinite(_Tp) +# 1143 +{ return true; } +# 1148 +constexpr bool isinf(float __x) +# 1149 +{ return __builtin_isinf(__x); } +# 1156 +constexpr bool isinf(double __x) +# 1157 +{ return __builtin_isinf(__x); } +# 1161 +constexpr bool isinf(long double __x) +# 1162 +{ return __builtin_isinf(__x); } +# 1166 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, bool> ::__type +# 1169 +isinf(_Tp) +# 1170 +{ return false; } +# 1175 +constexpr bool isnan(float __x) +# 1176 +{ return __builtin_isnan(__x); } +# 1183 +constexpr bool isnan(double __x) +# 1184 +{ return __builtin_isnan(__x); } +# 1188 +constexpr bool isnan(long double __x) +# 1189 +{ return __builtin_isnan(__x); } +# 1193 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, bool> ::__type +# 1196 +isnan(_Tp) +# 1197 +{ return false; } +# 1202 +constexpr bool isnormal(float __x) +# 1203 +{ return __builtin_isnormal(__x); } +# 1206 +constexpr bool isnormal(double __x) +# 1207 +{ return __builtin_isnormal(__x); } +# 1210 +constexpr bool isnormal(long double __x) +# 1211 +{ return __builtin_isnormal(__x); } +# 1215 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, bool> ::__type +# 1218 +isnormal(_Tp __x) +# 1219 +{ return (__x != 0) ? true : false; } +# 1225 +constexpr bool signbit(float __x) +# 1226 +{ return __builtin_signbit(__x); } +# 1229 +constexpr bool signbit(double __x) +# 1230 +{ return __builtin_signbit(__x); } +# 1233 +constexpr bool signbit(long double __x) +# 1234 +{ return __builtin_signbit(__x); } +# 1238 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, bool> ::__type +# 1241 +signbit(_Tp __x) +# 1242 +{ return (__x < 0) ? true : false; } +# 1247 +constexpr bool isgreater(float __x, float __y) +# 1248 +{ return __builtin_isgreater(__x, __y); } +# 1251 +constexpr bool isgreater(double __x, double __y) +# 1252 +{ return __builtin_isgreater(__x, __y); } +# 1255 +constexpr bool isgreater(long double __x, long double __y) +# 1256 +{ return __builtin_isgreater(__x, __y); } +# 1260 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__enable_if< __is_arithmetic< _Tp> ::__value && __is_arithmetic< _Up> ::__value, bool> ::__type +# 1264 +isgreater(_Tp __x, _Up __y) +# 1265 +{ +# 1266 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1267 +return __builtin_isgreater((__type)__x, (__type)__y); +# 1268 +} +# 1273 +constexpr bool isgreaterequal(float __x, float __y) +# 1274 +{ return __builtin_isgreaterequal(__x, __y); } +# 1277 +constexpr bool isgreaterequal(double __x, double __y) +# 1278 +{ return __builtin_isgreaterequal(__x, __y); } +# 1281 +constexpr bool isgreaterequal(long double __x, long double __y) +# 1282 +{ return __builtin_isgreaterequal(__x, __y); } +# 1286 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__enable_if< __is_arithmetic< _Tp> ::__value && __is_arithmetic< _Up> ::__value, bool> ::__type +# 1290 +isgreaterequal(_Tp __x, _Up __y) +# 1291 +{ +# 1292 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1293 +return __builtin_isgreaterequal((__type)__x, (__type)__y); +# 1294 +} +# 1299 +constexpr bool isless(float __x, float __y) +# 1300 +{ return __builtin_isless(__x, __y); } +# 1303 +constexpr bool isless(double __x, double __y) +# 1304 +{ return __builtin_isless(__x, __y); } +# 1307 +constexpr bool isless(long double __x, long double __y) +# 1308 +{ return __builtin_isless(__x, __y); } +# 1312 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__enable_if< __is_arithmetic< _Tp> ::__value && __is_arithmetic< _Up> ::__value, bool> ::__type +# 1316 +isless(_Tp __x, _Up __y) +# 1317 +{ +# 1318 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1319 +return __builtin_isless((__type)__x, (__type)__y); +# 1320 +} +# 1325 +constexpr bool islessequal(float __x, float __y) +# 1326 +{ return __builtin_islessequal(__x, __y); } +# 1329 +constexpr bool islessequal(double __x, double __y) +# 1330 +{ return __builtin_islessequal(__x, __y); } +# 1333 +constexpr bool islessequal(long double __x, long double __y) +# 1334 +{ return __builtin_islessequal(__x, __y); } +# 1338 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__enable_if< __is_arithmetic< _Tp> ::__value && __is_arithmetic< _Up> ::__value, bool> ::__type +# 1342 +islessequal(_Tp __x, _Up __y) +# 1343 +{ +# 1344 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1345 +return __builtin_islessequal((__type)__x, (__type)__y); +# 1346 +} +# 1351 +constexpr bool islessgreater(float __x, float __y) +# 1352 +{ return __builtin_islessgreater(__x, __y); } +# 1355 +constexpr bool islessgreater(double __x, double __y) +# 1356 +{ return __builtin_islessgreater(__x, __y); } +# 1359 +constexpr bool islessgreater(long double __x, long double __y) +# 1360 +{ return __builtin_islessgreater(__x, __y); } +# 1364 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__enable_if< __is_arithmetic< _Tp> ::__value && __is_arithmetic< _Up> ::__value, bool> ::__type +# 1368 +islessgreater(_Tp __x, _Up __y) +# 1369 +{ +# 1370 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1371 +return __builtin_islessgreater((__type)__x, (__type)__y); +# 1372 +} +# 1377 +constexpr bool isunordered(float __x, float __y) +# 1378 +{ return __builtin_isunordered(__x, __y); } +# 1381 +constexpr bool isunordered(double __x, double __y) +# 1382 +{ return __builtin_isunordered(__x, __y); } +# 1385 +constexpr bool isunordered(long double __x, long double __y) +# 1386 +{ return __builtin_isunordered(__x, __y); } +# 1390 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__enable_if< __is_arithmetic< _Tp> ::__value && __is_arithmetic< _Up> ::__value, bool> ::__type +# 1394 +isunordered(_Tp __x, _Up __y) +# 1395 +{ +# 1396 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1397 +return __builtin_isunordered((__type)__x, (__type)__y); +# 1398 +} +# 1820 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +using ::acosf; +# 1823 +using ::acosl; +# 1827 +using ::asinf; +# 1830 +using ::asinl; +# 1834 +using ::atanf; +# 1837 +using ::atanl; +# 1841 +using ::atan2f; +# 1844 +using ::atan2l; +# 1848 +using ::ceilf; +# 1851 +using ::ceill; +# 1855 +using ::cosf; +# 1858 +using ::cosl; +# 1862 +using ::coshf; +# 1865 +using ::coshl; +# 1869 +using ::expf; +# 1872 +using ::expl; +# 1876 +using ::fabsf; +# 1879 +using ::fabsl; +# 1883 +using ::floorf; +# 1886 +using ::floorl; +# 1890 +using ::fmodf; +# 1893 +using ::fmodl; +# 1897 +using ::frexpf; +# 1900 +using ::frexpl; +# 1904 +using ::ldexpf; +# 1907 +using ::ldexpl; +# 1911 +using ::logf; +# 1914 +using ::logl; +# 1918 +using ::log10f; +# 1921 +using ::log10l; +# 1925 +using ::modff; +# 1928 +using ::modfl; +# 1932 +using ::powf; +# 1935 +using ::powl; +# 1939 +using ::sinf; +# 1942 +using ::sinl; +# 1946 +using ::sinhf; +# 1949 +using ::sinhl; +# 1953 +using ::sqrtf; +# 1956 +using ::sqrtl; +# 1960 +using ::tanf; +# 1963 +using ::tanl; +# 1967 +using ::tanhf; +# 1970 +using ::tanhl; +# 2085 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +using ::double_t; +# 2086 +using ::float_t; +# 2090 +using ::acosh; +# 2091 +using ::acoshf; +# 2092 +using ::acoshl; +# 2094 +using ::asinh; +# 2095 +using ::asinhf; +# 2096 +using ::asinhl; +# 2098 +using ::atanh; +# 2099 +using ::atanhf; +# 2100 +using ::atanhl; +# 2102 +using ::cbrt; +# 2103 +using ::cbrtf; +# 2104 +using ::cbrtl; +# 2106 +using ::copysign; +# 2107 +using ::copysignf; +# 2108 +using ::copysignl; +# 2110 +using ::erf; +# 2111 +using ::erff; +# 2112 +using ::erfl; +# 2114 +using ::erfc; +# 2115 +using ::erfcf; +# 2116 +using ::erfcl; +# 2118 +using ::exp2; +# 2119 +using ::exp2f; +# 2120 +using ::exp2l; +# 2122 +using ::expm1; +# 2123 +using ::expm1f; +# 2124 +using ::expm1l; +# 2126 +using ::fdim; +# 2127 +using ::fdimf; +# 2128 +using ::fdiml; +# 2130 +using ::fma; +# 2131 +using ::fmaf; +# 2132 +using ::fmal; +# 2134 +using ::fmax; +# 2135 +using ::fmaxf; +# 2136 +using ::fmaxl; +# 2138 +using ::fmin; +# 2139 +using ::fminf; +# 2140 +using ::fminl; +# 2142 +using ::hypot; +# 2143 +using ::hypotf; +# 2144 +using ::hypotl; +# 2146 +using ::ilogb; +# 2147 +using ::ilogbf; +# 2148 +using ::ilogbl; +# 2150 +using ::lgamma; +# 2151 +using ::lgammaf; +# 2152 +using ::lgammal; +# 2155 +using ::llrint; +# 2156 +using ::llrintf; +# 2157 +using ::llrintl; +# 2159 +using ::llround; +# 2160 +using ::llroundf; +# 2161 +using ::llroundl; +# 2164 +using ::log1p; +# 2165 +using ::log1pf; +# 2166 +using ::log1pl; +# 2168 +using ::log2; +# 2169 +using ::log2f; +# 2170 +using ::log2l; +# 2172 +using ::logb; +# 2173 +using ::logbf; +# 2174 +using ::logbl; +# 2176 +using ::lrint; +# 2177 +using ::lrintf; +# 2178 +using ::lrintl; +# 2180 +using ::lround; +# 2181 +using ::lroundf; +# 2182 +using ::lroundl; +# 2184 +using ::nan; +# 2185 +using ::nanf; +# 2186 +using ::nanl; +# 2188 +using ::nearbyint; +# 2189 +using ::nearbyintf; +# 2190 +using ::nearbyintl; +# 2192 +using ::nextafter; +# 2193 +using ::nextafterf; +# 2194 +using ::nextafterl; +# 2196 +using ::nexttoward; +# 2197 +using ::nexttowardf; +# 2198 +using ::nexttowardl; +# 2200 +using ::remainder; +# 2201 +using ::remainderf; +# 2202 +using ::remainderl; +# 2204 +using ::remquo; +# 2205 +using ::remquof; +# 2206 +using ::remquol; +# 2208 +using ::rint; +# 2209 +using ::rintf; +# 2210 +using ::rintl; +# 2212 +using ::round; +# 2213 +using ::roundf; +# 2214 +using ::roundl; +# 2216 +using ::scalbln; +# 2217 +using ::scalblnf; +# 2218 +using ::scalblnl; +# 2220 +using ::scalbn; +# 2221 +using ::scalbnf; +# 2222 +using ::scalbnl; +# 2224 +using ::tgamma; +# 2225 +using ::tgammaf; +# 2226 +using ::tgammal; +# 2228 +using ::trunc; +# 2229 +using ::truncf; +# 2230 +using ::truncl; +# 2235 +constexpr float acosh(float __x) +# 2236 +{ return __builtin_acoshf(__x); } +# 2239 +constexpr long double acosh(long double __x) +# 2240 +{ return __builtin_acoshl(__x); } +# 2244 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2247 +acosh(_Tp __x) +# 2248 +{ return __builtin_acosh(__x); } +# 2253 +constexpr float asinh(float __x) +# 2254 +{ return __builtin_asinhf(__x); } +# 2257 +constexpr long double asinh(long double __x) +# 2258 +{ return __builtin_asinhl(__x); } +# 2262 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2265 +asinh(_Tp __x) +# 2266 +{ return __builtin_asinh(__x); } +# 2271 +constexpr float atanh(float __x) +# 2272 +{ return __builtin_atanhf(__x); } +# 2275 +constexpr long double atanh(long double __x) +# 2276 +{ return __builtin_atanhl(__x); } +# 2280 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2283 +atanh(_Tp __x) +# 2284 +{ return __builtin_atanh(__x); } +# 2289 +constexpr float cbrt(float __x) +# 2290 +{ return __builtin_cbrtf(__x); } +# 2293 +constexpr long double cbrt(long double __x) +# 2294 +{ return __builtin_cbrtl(__x); } +# 2298 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2301 +cbrt(_Tp __x) +# 2302 +{ return __builtin_cbrt(__x); } +# 2307 +constexpr float copysign(float __x, float __y) +# 2308 +{ return __builtin_copysignf(__x, __y); } +# 2311 +constexpr long double copysign(long double __x, long double __y) +# 2312 +{ return __builtin_copysignl(__x, __y); } +# 2317 +constexpr float erf(float __x) +# 2318 +{ return __builtin_erff(__x); } +# 2321 +constexpr long double erf(long double __x) +# 2322 +{ return __builtin_erfl(__x); } +# 2326 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2329 +erf(_Tp __x) +# 2330 +{ return __builtin_erf(__x); } +# 2335 +constexpr float erfc(float __x) +# 2336 +{ return __builtin_erfcf(__x); } +# 2339 +constexpr long double erfc(long double __x) +# 2340 +{ return __builtin_erfcl(__x); } +# 2344 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2347 +erfc(_Tp __x) +# 2348 +{ return __builtin_erfc(__x); } +# 2353 +constexpr float exp2(float __x) +# 2354 +{ return __builtin_exp2f(__x); } +# 2357 +constexpr long double exp2(long double __x) +# 2358 +{ return __builtin_exp2l(__x); } +# 2362 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2365 +exp2(_Tp __x) +# 2366 +{ return __builtin_exp2(__x); } +# 2371 +constexpr float expm1(float __x) +# 2372 +{ return __builtin_expm1f(__x); } +# 2375 +constexpr long double expm1(long double __x) +# 2376 +{ return __builtin_expm1l(__x); } +# 2380 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2383 +expm1(_Tp __x) +# 2384 +{ return __builtin_expm1(__x); } +# 2389 +constexpr float fdim(float __x, float __y) +# 2390 +{ return __builtin_fdimf(__x, __y); } +# 2393 +constexpr long double fdim(long double __x, long double __y) +# 2394 +{ return __builtin_fdiml(__x, __y); } +# 2399 +constexpr float fma(float __x, float __y, float __z) +# 2400 +{ return __builtin_fmaf(__x, __y, __z); } +# 2403 +constexpr long double fma(long double __x, long double __y, long double __z) +# 2404 +{ return __builtin_fmal(__x, __y, __z); } +# 2409 +constexpr float fmax(float __x, float __y) +# 2410 +{ return __builtin_fmaxf(__x, __y); } +# 2413 +constexpr long double fmax(long double __x, long double __y) +# 2414 +{ return __builtin_fmaxl(__x, __y); } +# 2419 +constexpr float fmin(float __x, float __y) +# 2420 +{ return __builtin_fminf(__x, __y); } +# 2423 +constexpr long double fmin(long double __x, long double __y) +# 2424 +{ return __builtin_fminl(__x, __y); } +# 2429 +constexpr float hypot(float __x, float __y) +# 2430 +{ return __builtin_hypotf(__x, __y); } +# 2433 +constexpr long double hypot(long double __x, long double __y) +# 2434 +{ return __builtin_hypotl(__x, __y); } +# 2439 +constexpr int ilogb(float __x) +# 2440 +{ return __builtin_ilogbf(__x); } +# 2443 +constexpr int ilogb(long double __x) +# 2444 +{ return __builtin_ilogbl(__x); } +# 2448 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, int> ::__type +# 2452 +ilogb(_Tp __x) +# 2453 +{ return __builtin_ilogb(__x); } +# 2458 +constexpr float lgamma(float __x) +# 2459 +{ return __builtin_lgammaf(__x); } +# 2462 +constexpr long double lgamma(long double __x) +# 2463 +{ return __builtin_lgammal(__x); } +# 2467 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2470 +lgamma(_Tp __x) +# 2471 +{ return __builtin_lgamma(__x); } +# 2476 +constexpr long long llrint(float __x) +# 2477 +{ return __builtin_llrintf(__x); } +# 2480 +constexpr long long llrint(long double __x) +# 2481 +{ return __builtin_llrintl(__x); } +# 2485 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, long long> ::__type +# 2488 +llrint(_Tp __x) +# 2489 +{ return __builtin_llrint(__x); } +# 2494 +constexpr long long llround(float __x) +# 2495 +{ return __builtin_llroundf(__x); } +# 2498 +constexpr long long llround(long double __x) +# 2499 +{ return __builtin_llroundl(__x); } +# 2503 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, long long> ::__type +# 2506 +llround(_Tp __x) +# 2507 +{ return __builtin_llround(__x); } +# 2512 +constexpr float log1p(float __x) +# 2513 +{ return __builtin_log1pf(__x); } +# 2516 +constexpr long double log1p(long double __x) +# 2517 +{ return __builtin_log1pl(__x); } +# 2521 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2524 +log1p(_Tp __x) +# 2525 +{ return __builtin_log1p(__x); } +# 2531 +constexpr float log2(float __x) +# 2532 +{ return __builtin_log2f(__x); } +# 2535 +constexpr long double log2(long double __x) +# 2536 +{ return __builtin_log2l(__x); } +# 2540 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2543 +log2(_Tp __x) +# 2544 +{ return __builtin_log2(__x); } +# 2549 +constexpr float logb(float __x) +# 2550 +{ return __builtin_logbf(__x); } +# 2553 +constexpr long double logb(long double __x) +# 2554 +{ return __builtin_logbl(__x); } +# 2558 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2561 +logb(_Tp __x) +# 2562 +{ return __builtin_logb(__x); } +# 2567 +constexpr long lrint(float __x) +# 2568 +{ return __builtin_lrintf(__x); } +# 2571 +constexpr long lrint(long double __x) +# 2572 +{ return __builtin_lrintl(__x); } +# 2576 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, long> ::__type +# 2579 +lrint(_Tp __x) +# 2580 +{ return __builtin_lrint(__x); } +# 2585 +constexpr long lround(float __x) +# 2586 +{ return __builtin_lroundf(__x); } +# 2589 +constexpr long lround(long double __x) +# 2590 +{ return __builtin_lroundl(__x); } +# 2594 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, long> ::__type +# 2597 +lround(_Tp __x) +# 2598 +{ return __builtin_lround(__x); } +# 2603 +constexpr float nearbyint(float __x) +# 2604 +{ return __builtin_nearbyintf(__x); } +# 2607 +constexpr long double nearbyint(long double __x) +# 2608 +{ return __builtin_nearbyintl(__x); } +# 2612 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2615 +nearbyint(_Tp __x) +# 2616 +{ return __builtin_nearbyint(__x); } +# 2621 +constexpr float nextafter(float __x, float __y) +# 2622 +{ return __builtin_nextafterf(__x, __y); } +# 2625 +constexpr long double nextafter(long double __x, long double __y) +# 2626 +{ return __builtin_nextafterl(__x, __y); } +# 2631 +constexpr float nexttoward(float __x, long double __y) +# 2632 +{ return __builtin_nexttowardf(__x, __y); } +# 2635 +constexpr long double nexttoward(long double __x, long double __y) +# 2636 +{ return __builtin_nexttowardl(__x, __y); } +# 2640 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2643 +nexttoward(_Tp __x, long double __y) +# 2644 +{ return __builtin_nexttoward(__x, __y); } +# 2649 +constexpr float remainder(float __x, float __y) +# 2650 +{ return __builtin_remainderf(__x, __y); } +# 2653 +constexpr long double remainder(long double __x, long double __y) +# 2654 +{ return __builtin_remainderl(__x, __y); } +# 2659 +inline float remquo(float __x, float __y, int *__pquo) +# 2660 +{ return __builtin_remquof(__x, __y, __pquo); } +# 2663 +inline long double remquo(long double __x, long double __y, int *__pquo) +# 2664 +{ return __builtin_remquol(__x, __y, __pquo); } +# 2669 +constexpr float rint(float __x) +# 2670 +{ return __builtin_rintf(__x); } +# 2673 +constexpr long double rint(long double __x) +# 2674 +{ return __builtin_rintl(__x); } +# 2678 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2681 +rint(_Tp __x) +# 2682 +{ return __builtin_rint(__x); } +# 2687 +constexpr float round(float __x) +# 2688 +{ return __builtin_roundf(__x); } +# 2691 +constexpr long double round(long double __x) +# 2692 +{ return __builtin_roundl(__x); } +# 2696 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2699 +round(_Tp __x) +# 2700 +{ return __builtin_round(__x); } +# 2705 +constexpr float scalbln(float __x, long __ex) +# 2706 +{ return __builtin_scalblnf(__x, __ex); } +# 2709 +constexpr long double scalbln(long double __x, long __ex) +# 2710 +{ return __builtin_scalblnl(__x, __ex); } +# 2714 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2717 +scalbln(_Tp __x, long __ex) +# 2718 +{ return __builtin_scalbln(__x, __ex); } +# 2723 +constexpr float scalbn(float __x, int __ex) +# 2724 +{ return __builtin_scalbnf(__x, __ex); } +# 2727 +constexpr long double scalbn(long double __x, int __ex) +# 2728 +{ return __builtin_scalbnl(__x, __ex); } +# 2732 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2735 +scalbn(_Tp __x, int __ex) +# 2736 +{ return __builtin_scalbn(__x, __ex); } +# 2741 +constexpr float tgamma(float __x) +# 2742 +{ return __builtin_tgammaf(__x); } +# 2745 +constexpr long double tgamma(long double __x) +# 2746 +{ return __builtin_tgammal(__x); } +# 2750 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2753 +tgamma(_Tp __x) +# 2754 +{ return __builtin_tgamma(__x); } +# 2759 +constexpr float trunc(float __x) +# 2760 +{ return __builtin_truncf(__x); } +# 2763 +constexpr long double trunc(long double __x) +# 2764 +{ return __builtin_truncl(__x); } +# 2768 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2771 +trunc(_Tp __x) +# 2772 +{ return __builtin_trunc(__x); } +# 3682 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 3684 +copysign(_Tp __x, _Up __y) +# 3685 +{ +# 3686 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 3687 +return copysign((__type)__x, (__type)__y); +# 3688 +} +# 3690 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 3692 +fdim(_Tp __x, _Up __y) +# 3693 +{ +# 3694 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 3695 +return fdim((__type)__x, (__type)__y); +# 3696 +} +# 3698 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 3700 +fmax(_Tp __x, _Up __y) +# 3701 +{ +# 3702 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 3703 +return fmax((__type)__x, (__type)__y); +# 3704 +} +# 3706 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 3708 +fmin(_Tp __x, _Up __y) +# 3709 +{ +# 3710 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 3711 +return fmin((__type)__x, (__type)__y); +# 3712 +} +# 3714 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 3716 +hypot(_Tp __x, _Up __y) +# 3717 +{ +# 3718 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 3719 +return hypot((__type)__x, (__type)__y); +# 3720 +} +# 3722 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 3724 +nextafter(_Tp __x, _Up __y) +# 3725 +{ +# 3726 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 3727 +return nextafter((__type)__x, (__type)__y); +# 3728 +} +# 3730 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 3732 +remainder(_Tp __x, _Up __y) +# 3733 +{ +# 3734 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 3735 +return remainder((__type)__x, (__type)__y); +# 3736 +} +# 3738 +template< class _Tp, class _Up> inline typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 3740 +remquo(_Tp __x, _Up __y, int *__pquo) +# 3741 +{ +# 3742 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 3743 +return remquo((__type)__x, (__type)__y, __pquo); +# 3744 +} +# 3746 +template< class _Tp, class _Up, class _Vp> constexpr typename __gnu_cxx::__promote_3< _Tp, _Up, _Vp> ::__type +# 3748 +fma(_Tp __x, _Up __y, _Vp __z) +# 3749 +{ +# 3750 +typedef typename __gnu_cxx::__promote_3< _Tp, _Up, _Vp> ::__type __type; +# 3751 +return fma((__type)__x, (__type)__y, (__type)__z); +# 3752 +} +# 3760 +template< class _Tp> inline _Tp +# 3762 +__hypot3(_Tp __x, _Tp __y, _Tp __z) +# 3763 +{ +# 3764 +__x = std::abs(__x); +# 3765 +__y = std::abs(__y); +# 3766 +__z = std::abs(__z); +# 3767 +if (_Tp __a = (__x < __y) ? (__y < __z) ? __z : __y : ((__x < __z) ? __z : __x)) { +# 3768 +return __a * std::sqrt((((__x / __a) * (__x / __a)) + ((__y / __a) * (__y / __a))) + ((__z / __a) * (__z / __a))); } else { +# 3772 +return {}; } +# 3773 +} +# 3776 +inline float hypot(float __x, float __y, float __z) +# 3777 +{ return std::__hypot3< float> (__x, __y, __z); } +# 3780 +inline double hypot(double __x, double __y, double __z) +# 3781 +{ return std::__hypot3< double> (__x, __y, __z); } +# 3784 +inline long double hypot(long double __x, long double __y, long double __z) +# 3785 +{ return std::__hypot3< long double> (__x, __y, __z); } +# 3787 +template< class _Tp, class _Up, class _Vp> __gnu_cxx::__promoted_t< _Tp, _Up, _Vp> +# 3789 +hypot(_Tp __x, _Up __y, _Vp __z) +# 3790 +{ +# 3791 +using __type = __gnu_cxx::__promoted_t< _Tp, _Up, _Vp> ; +# 3792 +return std::__hypot3< __gnu_cxx::__promoted_t< _Tp, _Up, _Vp> > (__x, __y, __z); +# 3793 +} +# 3903 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +} +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 49 +void __throw_bad_exception() __attribute((__noreturn__)); +# 53 +void __throw_bad_alloc() __attribute((__noreturn__)); +# 56 +void __throw_bad_array_new_length() __attribute((__noreturn__)); +# 60 +void __throw_bad_cast() __attribute((__noreturn__, __cold__)); +# 63 +void __throw_bad_typeid() __attribute((__noreturn__, __cold__)); +# 67 +void __throw_logic_error(const char *) __attribute((__noreturn__, __cold__)); +# 70 +void __throw_domain_error(const char *) __attribute((__noreturn__, __cold__)); +# 73 +void __throw_invalid_argument(const char *) __attribute((__noreturn__, __cold__)); +# 76 +void __throw_length_error(const char *) __attribute((__noreturn__, __cold__)); +# 79 +void __throw_out_of_range(const char *) __attribute((__noreturn__, __cold__)); +# 82 +void __throw_out_of_range_fmt(const char *, ...) __attribute((__noreturn__, __cold__)) +# 83 + __attribute((__format__(__gnu_printf__, 1, 2))); +# 86 +void __throw_runtime_error(const char *) __attribute((__noreturn__, __cold__)); +# 89 +void __throw_range_error(const char *) __attribute((__noreturn__, __cold__)); +# 92 +void __throw_overflow_error(const char *) __attribute((__noreturn__, __cold__)); +# 95 +void __throw_underflow_error(const char *) __attribute((__noreturn__, __cold__)); +# 99 +void __throw_ios_failure(const char *) __attribute((__noreturn__, __cold__)); +# 102 +void __throw_ios_failure(const char *, int) __attribute((__noreturn__, __cold__)); +# 106 +void __throw_system_error(int) __attribute((__noreturn__, __cold__)); +# 110 +void __throw_future_error(int) __attribute((__noreturn__, __cold__)); +# 114 +void __throw_bad_function_call() __attribute((__noreturn__, __cold__)); +# 141 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h" 3 +} +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 +namespace __gnu_cxx __attribute((__visibility__("default"))) { +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 +template< class _Tp> +# 51 +struct __is_integer_nonstrict : public std::__is_integer< _Tp> { +# 54 +using std::__is_integer< _Tp> ::__value; +# 57 +enum { __width = (__value) ? sizeof(_Tp) * (8) : (0)}; +# 58 +}; +# 60 +template< class _Value> +# 61 +struct __numeric_traits_integer { +# 64 +static_assert((__is_integer_nonstrict< _Value> ::__value), "invalid specialization"); +# 70 +static const bool __is_signed = (((_Value)(-1)) < 0); +# 71 +static const int __digits = (__is_integer_nonstrict< _Value> ::__width - __is_signed); +# 75 +static const _Value __max = (__is_signed ? (((((_Value)1) << (__digits - 1)) - 1) << 1) + 1 : (~((_Value)0))); +# 78 +static const _Value __min = (__is_signed ? (-__max) - 1 : ((_Value)0)); +# 79 +}; +# 81 +template< class _Value> const _Value __numeric_traits_integer< _Value> ::__min; +# 84 +template< class _Value> const _Value __numeric_traits_integer< _Value> ::__max; +# 87 +template< class _Value> const bool __numeric_traits_integer< _Value> ::__is_signed; +# 90 +template< class _Value> const int __numeric_traits_integer< _Value> ::__digits; +# 137 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 +template< class _Tp> using __int_traits = __numeric_traits_integer< _Tp> ; +# 157 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 +template< class _Value> +# 158 +struct __numeric_traits_floating { +# 161 +static const int __max_digits10 = ((2) + ((((std::template __are_same< _Value, float> ::__value) ? 24 : ((std::template __are_same< _Value, double> ::__value) ? 53 : 64)) * 643L) / (2136))); +# 164 +static const bool __is_signed = true; +# 165 +static const int __digits10 = ((std::template __are_same< _Value, float> ::__value) ? 6 : ((std::template __are_same< _Value, double> ::__value) ? 15 : 18)); +# 166 +static const int __max_exponent10 = ((std::template __are_same< _Value, float> ::__value) ? 38 : ((std::template __are_same< _Value, double> ::__value) ? 308 : 4932)); +# 167 +}; +# 169 +template< class _Value> const int __numeric_traits_floating< _Value> ::__max_digits10; +# 172 +template< class _Value> const bool __numeric_traits_floating< _Value> ::__is_signed; +# 175 +template< class _Value> const int __numeric_traits_floating< _Value> ::__digits10; +# 178 +template< class _Value> const int __numeric_traits_floating< _Value> ::__max_exponent10; +# 186 +template< class _Value> +# 187 +struct __numeric_traits : public __numeric_traits_integer< _Value> { +# 189 +}; +# 192 +template<> struct __numeric_traits< float> : public __numeric_traits_floating< float> { +# 194 +}; +# 197 +template<> struct __numeric_traits< double> : public __numeric_traits_floating< double> { +# 199 +}; +# 202 +template<> struct __numeric_traits< long double> : public __numeric_traits_floating< long double> { +# 204 +}; +# 239 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 +} +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +namespace std __attribute((__visibility__("default"))) { +# 69 +template< class _Tp> class reference_wrapper; +# 86 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp, _Tp __v> +# 87 +struct integral_constant { +# 89 +static constexpr inline _Tp value = (__v); +# 90 +using value_type = _Tp; +# 91 +using type = integral_constant; +# 92 +constexpr operator value_type() const noexcept { return value; } +# 95 +constexpr value_type operator()() const noexcept { return value; } +# 97 +}; +# 106 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< bool __v> using __bool_constant = integral_constant< bool, __v> ; +# 111 +using true_type = __bool_constant< true> ; +# 114 +using false_type = __bool_constant< false> ; +# 119 +template< bool __v> using bool_constant = __bool_constant< __v> ; +# 127 +template< bool , class _Tp = void> +# 128 +struct enable_if { +# 129 +}; +# 132 +template< class _Tp> +# 133 +struct enable_if< true, _Tp> { +# 134 +using type = _Tp; }; +# 137 +template< bool _Cond, class _Tp = void> using __enable_if_t = typename enable_if< _Cond, _Tp> ::type; +# 140 +template< bool > +# 141 +struct __conditional { +# 143 +template< class _Tp, class > using type = _Tp; +# 145 +}; +# 148 +template<> struct __conditional< false> { +# 150 +template< class , class _Up> using type = _Up; +# 152 +}; +# 155 +template< bool _Cond, class _If, class _Else> using __conditional_t = typename __conditional< _Cond> ::template type< _If, _Else> ; +# 160 +template< class _Type> +# 161 +struct __type_identity { +# 162 +using type = _Type; }; +# 164 +template< class _Tp> using __type_identity_t = typename __type_identity< _Tp> ::type; +# 167 +namespace __detail { +# 170 +template< class _Tp, class ...> using __first_t = _Tp; +# 174 +template< class ..._Bn> auto __or_fn(int)->__first_t< integral_constant< bool, false> , __enable_if_t< !((bool)_Bn::value)> ...> ; +# 178 +template< class ..._Bn> auto __or_fn(...)->true_type; +# 181 +template< class ..._Bn> auto __and_fn(int)->__first_t< integral_constant< bool, true> , __enable_if_t< (bool)_Bn::value> ...> ; +# 185 +template< class ..._Bn> auto __and_fn(...)->false_type; +# 187 +} +# 192 +template< class ..._Bn> +# 193 +struct __or_ : public __decltype((__detail::__or_fn< _Bn...> (0))) { +# 195 +}; +# 197 +template< class ..._Bn> +# 198 +struct __and_ : public __decltype((__detail::__and_fn< _Bn...> (0))) { +# 200 +}; +# 202 +template< class _Pp> +# 203 +struct __not_ : public __bool_constant< !((bool)_Pp::value)> { +# 205 +}; +# 211 +template< class ..._Bn> constexpr inline bool +# 212 +__or_v = (__or_< _Bn...> ::value); +# 213 +template< class ..._Bn> constexpr inline bool +# 214 +__and_v = (__and_< _Bn...> ::value); +# 216 +namespace __detail { +# 218 +template< class , class _B1, class ..._Bn> +# 219 +struct __disjunction_impl { +# 220 +using type = _B1; }; +# 222 +template< class _B1, class _B2, class ..._Bn> +# 223 +struct __disjunction_impl< __enable_if_t< !((bool)_B1::value)> , _B1, _B2, _Bn...> { +# 224 +using type = typename __detail::__disjunction_impl< void, _B2, _Bn...> ::type; }; +# 226 +template< class , class _B1, class ..._Bn> +# 227 +struct __conjunction_impl { +# 228 +using type = _B1; }; +# 230 +template< class _B1, class _B2, class ..._Bn> +# 231 +struct __conjunction_impl< __enable_if_t< (bool)_B1::value> , _B1, _B2, _Bn...> { +# 232 +using type = typename __detail::__conjunction_impl< void, _B2, _Bn...> ::type; }; +# 233 +} +# 236 +template< class ..._Bn> +# 237 +struct conjunction : public __detail::__conjunction_impl< void, _Bn...> ::type { +# 239 +}; +# 242 +template<> struct conjunction< > : public true_type { +# 244 +}; +# 246 +template< class ..._Bn> +# 247 +struct disjunction : public __detail::__disjunction_impl< void, _Bn...> ::type { +# 249 +}; +# 252 +template<> struct disjunction< > : public false_type { +# 254 +}; +# 256 +template< class _Pp> +# 257 +struct negation : public __not_< _Pp> ::type { +# 259 +}; +# 264 +template< class ..._Bn> constexpr inline bool +# 265 +conjunction_v = (conjunction< _Bn...> ::value); +# 267 +template< class ..._Bn> constexpr inline bool +# 268 +disjunction_v = (disjunction< _Bn...> ::value); +# 270 +template< class _Pp> constexpr inline bool +# 271 +negation_v = (negation< _Pp> ::value); +# 277 +template< class > struct is_reference; +# 279 +template< class > struct is_function; +# 281 +template< class > struct is_void; +# 283 +template< class > struct remove_cv; +# 285 +template< class > struct is_const; +# 289 +template< class > struct __is_array_unknown_bounds; +# 295 +template< class _Tp, size_t = sizeof(_Tp)> constexpr true_type +# 296 +__is_complete_or_unbounded(__type_identity< _Tp> ) +# 297 +{ return {}; } +# 299 +template< class _TypeIdentity, class +# 300 +_NestedType = typename _TypeIdentity::type> constexpr typename __or_< is_reference< _NestedType> , is_function< _NestedType> , is_void< _NestedType> , __is_array_unknown_bounds< _NestedType> > ::type +# 306 +__is_complete_or_unbounded(_TypeIdentity) +# 307 +{ return {}; } +# 310 +template< class _Tp> using __remove_cv_t = typename remove_cv< _Tp> ::type; +# 317 +template< class _Tp> +# 318 +struct is_void : public false_type { +# 319 +}; +# 322 +template<> struct is_void< void> : public true_type { +# 323 +}; +# 326 +template<> struct is_void< const void> : public true_type { +# 327 +}; +# 330 +template<> struct is_void< volatile void> : public true_type { +# 331 +}; +# 334 +template<> struct is_void< const volatile void> : public true_type { +# 335 +}; +# 338 +template< class > +# 339 +struct __is_integral_helper : public false_type { +# 340 +}; +# 343 +template<> struct __is_integral_helper< bool> : public true_type { +# 344 +}; +# 347 +template<> struct __is_integral_helper< char> : public true_type { +# 348 +}; +# 351 +template<> struct __is_integral_helper< signed char> : public true_type { +# 352 +}; +# 355 +template<> struct __is_integral_helper< unsigned char> : public true_type { +# 356 +}; +# 362 +template<> struct __is_integral_helper< wchar_t> : public true_type { +# 363 +}; +# 372 +template<> struct __is_integral_helper< char16_t> : public true_type { +# 373 +}; +# 376 +template<> struct __is_integral_helper< char32_t> : public true_type { +# 377 +}; +# 380 +template<> struct __is_integral_helper< short> : public true_type { +# 381 +}; +# 384 +template<> struct __is_integral_helper< unsigned short> : public true_type { +# 385 +}; +# 388 +template<> struct __is_integral_helper< int> : public true_type { +# 389 +}; +# 392 +template<> struct __is_integral_helper< unsigned> : public true_type { +# 393 +}; +# 396 +template<> struct __is_integral_helper< long> : public true_type { +# 397 +}; +# 400 +template<> struct __is_integral_helper< unsigned long> : public true_type { +# 401 +}; +# 404 +template<> struct __is_integral_helper< long long> : public true_type { +# 405 +}; +# 408 +template<> struct __is_integral_helper< unsigned long long> : public true_type { +# 409 +}; +# 416 +template<> struct __is_integral_helper< __int128> : public true_type { +# 417 +}; +# 421 +template<> struct __is_integral_helper< unsigned __int128> : public true_type { +# 422 +}; +# 460 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> +# 461 +struct is_integral : public __is_integral_helper< __remove_cv_t< _Tp> > ::type { +# 463 +}; +# 466 +template< class > +# 467 +struct __is_floating_point_helper : public false_type { +# 468 +}; +# 471 +template<> struct __is_floating_point_helper< float> : public true_type { +# 472 +}; +# 475 +template<> struct __is_floating_point_helper< double> : public true_type { +# 476 +}; +# 479 +template<> struct __is_floating_point_helper< long double> : public true_type { +# 480 +}; +# 514 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template<> struct __is_floating_point_helper< __float128> : public true_type { +# 515 +}; +# 520 +template< class _Tp> +# 521 +struct is_floating_point : public __is_floating_point_helper< __remove_cv_t< _Tp> > ::type { +# 523 +}; +# 527 +template< class _Tp> +# 528 +struct is_array : public __bool_constant< __is_array(_Tp)> { +# 530 +}; +# 545 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class > +# 546 +struct __is_pointer_helper : public false_type { +# 547 +}; +# 549 +template< class _Tp> +# 550 +struct __is_pointer_helper< _Tp *> : public true_type { +# 551 +}; +# 554 +template< class _Tp> +# 555 +struct is_pointer : public __is_pointer_helper< __remove_cv_t< _Tp> > ::type { +# 557 +}; +# 560 +template< class > +# 561 +struct is_lvalue_reference : public false_type { +# 562 +}; +# 564 +template< class _Tp> +# 565 +struct is_lvalue_reference< _Tp &> : public true_type { +# 566 +}; +# 569 +template< class > +# 570 +struct is_rvalue_reference : public false_type { +# 571 +}; +# 573 +template< class _Tp> +# 574 +struct is_rvalue_reference< _Tp &&> : public true_type { +# 575 +}; +# 579 +template< class _Tp> +# 580 +struct is_member_object_pointer : public __bool_constant< __is_member_object_pointer(_Tp)> { +# 582 +}; +# 601 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> +# 602 +struct is_member_function_pointer : public __bool_constant< __is_member_function_pointer(_Tp)> { +# 604 +}; +# 622 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> +# 623 +struct is_enum : public __bool_constant< __is_enum(_Tp)> { +# 625 +}; +# 628 +template< class _Tp> +# 629 +struct is_union : public __bool_constant< __is_union(_Tp)> { +# 631 +}; +# 634 +template< class _Tp> +# 635 +struct is_class : public __bool_constant< __is_class(_Tp)> { +# 637 +}; +# 641 +template< class _Tp> +# 642 +struct is_function : public __bool_constant< __is_function(_Tp)> { +# 644 +}; +# 661 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> +# 662 +struct is_null_pointer : public false_type { +# 663 +}; +# 666 +template<> struct is_null_pointer< __decltype((nullptr))> : public true_type { +# 667 +}; +# 670 +template<> struct is_null_pointer< const __decltype((nullptr))> : public true_type { +# 671 +}; +# 674 +template<> struct is_null_pointer< volatile __decltype((nullptr))> : public true_type { +# 675 +}; +# 678 +template<> struct is_null_pointer< const volatile __decltype((nullptr))> : public true_type { +# 679 +}; +# 683 +template< class _Tp> +# 684 +struct __is_nullptr_t : public is_null_pointer< _Tp> { +# 686 +} __attribute((__deprecated__("use \'std::is_null_pointer\' instead"))); +# 693 +template< class _Tp> +# 694 +struct is_reference : public __bool_constant< __is_reference(_Tp)> { +# 696 +}; +# 715 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> +# 716 +struct is_arithmetic : public __or_< is_integral< _Tp> , is_floating_point< _Tp> > ::type { +# 718 +}; +# 721 +template< class _Tp> +# 722 +struct is_fundamental : public __or_< is_arithmetic< _Tp> , is_void< _Tp> , is_null_pointer< _Tp> > ::type { +# 725 +}; +# 729 +template< class _Tp> +# 730 +struct is_object : public __bool_constant< __is_object(_Tp)> { +# 732 +}; +# 741 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class > struct is_member_pointer; +# 745 +template< class _Tp> +# 746 +struct is_scalar : public __or_< is_arithmetic< _Tp> , is_enum< _Tp> , is_pointer< _Tp> , is_member_pointer< _Tp> , is_null_pointer< _Tp> > ::type { +# 749 +}; +# 752 +template< class _Tp> +# 753 +struct is_compound : public __bool_constant< !is_fundamental< _Tp> ::value> { +# 754 +}; +# 758 +template< class _Tp> +# 759 +struct is_member_pointer : public __bool_constant< __is_member_pointer(_Tp)> { +# 761 +}; +# 779 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class , class > struct is_same; +# 783 +template< class _Tp, class ..._Types> using __is_one_of = __or_< is_same< _Tp, _Types> ...> ; +# 788 +template< class _Tp> using __is_signed_integer = __is_one_of< __remove_cv_t< _Tp> , signed char, signed short, signed int, signed long, signed long long, signed __int128> ; +# 808 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> using __is_unsigned_integer = __is_one_of< __remove_cv_t< _Tp> , unsigned char, unsigned short, unsigned, unsigned long, unsigned long long, unsigned __int128> ; +# 827 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> using __is_standard_integer = __or_< __is_signed_integer< _Tp> , __is_unsigned_integer< _Tp> > ; +# 832 +template< class ...> using __void_t = void; +# 838 +template< class > +# 839 +struct is_const : public false_type { +# 840 +}; +# 842 +template< class _Tp> +# 843 +struct is_const< const _Tp> : public true_type { +# 844 +}; +# 847 +template< class > +# 848 +struct is_volatile : public false_type { +# 849 +}; +# 851 +template< class _Tp> +# 852 +struct is_volatile< volatile _Tp> : public true_type { +# 853 +}; +# 856 +template< class _Tp> +# 857 +struct is_trivial : public __bool_constant< __is_trivial(_Tp)> { +# 860 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 862 +}; +# 865 +template< class _Tp> +# 866 +struct is_trivially_copyable : public __bool_constant< __is_trivially_copyable(_Tp)> { +# 869 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 871 +}; +# 874 +template< class _Tp> +# 875 +struct is_standard_layout : public __bool_constant< __is_standard_layout(_Tp)> { +# 878 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 880 +}; +# 887 +template< class _Tp> +# 890 +struct is_pod : public __bool_constant< __is_pod(_Tp)> { +# 893 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 895 +}; +# 901 +template< class _Tp> +# 904 +struct +# 903 + [[__deprecated__]] is_literal_type : public __bool_constant< __is_literal_type(_Tp)> { +# 907 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 909 +}; +# 912 +template< class _Tp> +# 913 +struct is_empty : public __bool_constant< __is_empty(_Tp)> { +# 915 +}; +# 918 +template< class _Tp> +# 919 +struct is_polymorphic : public __bool_constant< __is_polymorphic(_Tp)> { +# 921 +}; +# 926 +template< class _Tp> +# 927 +struct is_final : public __bool_constant< __is_final(_Tp)> { +# 929 +}; +# 933 +template< class _Tp> +# 934 +struct is_abstract : public __bool_constant< __is_abstract(_Tp)> { +# 936 +}; +# 939 +template< class _Tp, bool +# 940 + = is_arithmetic< _Tp> ::value> +# 941 +struct __is_signed_helper : public false_type { +# 942 +}; +# 944 +template< class _Tp> +# 945 +struct __is_signed_helper< _Tp, true> : public __bool_constant< ((_Tp)(-1)) < ((_Tp)0)> { +# 947 +}; +# 951 +template< class _Tp> +# 952 +struct is_signed : public __is_signed_helper< _Tp> ::type { +# 954 +}; +# 957 +template< class _Tp> +# 958 +struct is_unsigned : public __and_< is_arithmetic< _Tp> , __not_< is_signed< _Tp> > > ::type { +# 960 +}; +# 963 +template< class _Tp, class _Up = _Tp &&> _Up __declval(int); +# 967 +template< class _Tp> _Tp __declval(long); +# 972 +template< class _Tp> auto declval() noexcept->__decltype((__declval< _Tp> (0))); +# 975 +template< class > struct remove_all_extents; +# 979 +template< class _Tp> +# 980 +struct __is_array_known_bounds : public false_type { +# 982 +}; +# 984 +template< class _Tp, size_t _Size> +# 985 +struct __is_array_known_bounds< _Tp [_Size]> : public true_type { +# 987 +}; +# 989 +template< class _Tp> +# 990 +struct __is_array_unknown_bounds : public false_type { +# 992 +}; +# 994 +template< class _Tp> +# 995 +struct __is_array_unknown_bounds< _Tp []> : public true_type { +# 997 +}; +# 1006 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +struct __do_is_destructible_impl { +# 1008 +template< class _Tp, class = __decltype((declval< _Tp &> ().~_Tp()))> static true_type __test(int); +# 1011 +template< class > static false_type __test(...); +# 1013 +}; +# 1015 +template< class _Tp> +# 1016 +struct __is_destructible_impl : public __do_is_destructible_impl { +# 1019 +using type = __decltype((__test< _Tp> (0))); +# 1020 +}; +# 1022 +template< class _Tp, bool +# 1023 + = __or_< is_void< _Tp> , __is_array_unknown_bounds< _Tp> , is_function< _Tp> > ::value, bool +# 1026 + = __or_< is_reference< _Tp> , is_scalar< _Tp> > ::value> struct __is_destructible_safe; +# 1029 +template< class _Tp> +# 1030 +struct __is_destructible_safe< _Tp, false, false> : public __is_destructible_impl< typename remove_all_extents< _Tp> ::type> ::type { +# 1033 +}; +# 1035 +template< class _Tp> +# 1036 +struct __is_destructible_safe< _Tp, true, false> : public false_type { +# 1037 +}; +# 1039 +template< class _Tp> +# 1040 +struct __is_destructible_safe< _Tp, false, true> : public true_type { +# 1041 +}; +# 1045 +template< class _Tp> +# 1046 +struct is_destructible : public __is_destructible_safe< _Tp> ::type { +# 1049 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1051 +}; +# 1059 +struct __do_is_nt_destructible_impl { +# 1061 +template< class _Tp> static __bool_constant< noexcept(declval< _Tp &> ().~_Tp())> __test(int); +# 1065 +template< class > static false_type __test(...); +# 1067 +}; +# 1069 +template< class _Tp> +# 1070 +struct __is_nt_destructible_impl : public __do_is_nt_destructible_impl { +# 1073 +using type = __decltype((__test< _Tp> (0))); +# 1074 +}; +# 1076 +template< class _Tp, bool +# 1077 + = __or_< is_void< _Tp> , __is_array_unknown_bounds< _Tp> , is_function< _Tp> > ::value, bool +# 1080 + = __or_< is_reference< _Tp> , is_scalar< _Tp> > ::value> struct __is_nt_destructible_safe; +# 1083 +template< class _Tp> +# 1084 +struct __is_nt_destructible_safe< _Tp, false, false> : public __is_nt_destructible_impl< typename remove_all_extents< _Tp> ::type> ::type { +# 1087 +}; +# 1089 +template< class _Tp> +# 1090 +struct __is_nt_destructible_safe< _Tp, true, false> : public false_type { +# 1091 +}; +# 1093 +template< class _Tp> +# 1094 +struct __is_nt_destructible_safe< _Tp, false, true> : public true_type { +# 1095 +}; +# 1099 +template< class _Tp> +# 1100 +struct is_nothrow_destructible : public __is_nt_destructible_safe< _Tp> ::type { +# 1103 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1105 +}; +# 1108 +template< class _Tp, class ..._Args> using __is_constructible_impl = __bool_constant< __is_constructible(_Tp, _Args...)> ; +# 1114 +template< class _Tp, class ..._Args> +# 1115 +struct is_constructible : public __is_constructible_impl< _Tp, _Args...> { +# 1118 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1120 +}; +# 1123 +template< class _Tp> +# 1124 +struct is_default_constructible : public __is_constructible_impl< _Tp> { +# 1127 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1129 +}; +# 1132 +template< class _Tp, class = void> +# 1133 +struct __add_lvalue_reference_helper { +# 1134 +using type = _Tp; }; +# 1136 +template< class _Tp> +# 1137 +struct __add_lvalue_reference_helper< _Tp, __void_t< _Tp &> > { +# 1138 +using type = _Tp &; }; +# 1140 +template< class _Tp> using __add_lval_ref_t = typename __add_lvalue_reference_helper< _Tp> ::type; +# 1145 +template< class _Tp> +# 1146 +struct is_copy_constructible : public __is_constructible_impl< _Tp, __add_lval_ref_t< const _Tp> > { +# 1149 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1151 +}; +# 1154 +template< class _Tp, class = void> +# 1155 +struct __add_rvalue_reference_helper { +# 1156 +using type = _Tp; }; +# 1158 +template< class _Tp> +# 1159 +struct __add_rvalue_reference_helper< _Tp, __void_t< _Tp &&> > { +# 1160 +using type = _Tp &&; }; +# 1162 +template< class _Tp> using __add_rval_ref_t = typename __add_rvalue_reference_helper< _Tp> ::type; +# 1167 +template< class _Tp> +# 1168 +struct is_move_constructible : public __is_constructible_impl< _Tp, __add_rval_ref_t< _Tp> > { +# 1171 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1173 +}; +# 1176 +template< class _Tp, class ..._Args> using __is_nothrow_constructible_impl = __bool_constant< __is_nothrow_constructible(_Tp, _Args...)> ; +# 1182 +template< class _Tp, class ..._Args> +# 1183 +struct is_nothrow_constructible : public __is_nothrow_constructible_impl< _Tp, _Args...> { +# 1186 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1188 +}; +# 1191 +template< class _Tp> +# 1192 +struct is_nothrow_default_constructible : public __is_nothrow_constructible_impl< _Tp> { +# 1195 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1197 +}; +# 1200 +template< class _Tp> +# 1201 +struct is_nothrow_copy_constructible : public __is_nothrow_constructible_impl< _Tp, __add_lval_ref_t< const _Tp> > { +# 1204 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1206 +}; +# 1209 +template< class _Tp> +# 1210 +struct is_nothrow_move_constructible : public __is_nothrow_constructible_impl< _Tp, __add_rval_ref_t< _Tp> > { +# 1213 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1215 +}; +# 1218 +template< class _Tp, class _Up> using __is_assignable_impl = __bool_constant< __is_assignable(_Tp, _Up)> ; +# 1223 +template< class _Tp, class _Up> +# 1224 +struct is_assignable : public __is_assignable_impl< _Tp, _Up> { +# 1227 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1229 +}; +# 1232 +template< class _Tp> +# 1233 +struct is_copy_assignable : public __is_assignable_impl< __add_lval_ref_t< _Tp> , __add_lval_ref_t< const _Tp> > { +# 1237 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1239 +}; +# 1242 +template< class _Tp> +# 1243 +struct is_move_assignable : public __is_assignable_impl< __add_lval_ref_t< _Tp> , __add_rval_ref_t< _Tp> > { +# 1246 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1248 +}; +# 1251 +template< class _Tp, class _Up> using __is_nothrow_assignable_impl = __bool_constant< __is_nothrow_assignable(_Tp, _Up)> ; +# 1257 +template< class _Tp, class _Up> +# 1258 +struct is_nothrow_assignable : public __is_nothrow_assignable_impl< _Tp, _Up> { +# 1261 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1263 +}; +# 1266 +template< class _Tp> +# 1267 +struct is_nothrow_copy_assignable : public __is_nothrow_assignable_impl< __add_lval_ref_t< _Tp> , __add_lval_ref_t< const _Tp> > { +# 1271 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1273 +}; +# 1276 +template< class _Tp> +# 1277 +struct is_nothrow_move_assignable : public __is_nothrow_assignable_impl< __add_lval_ref_t< _Tp> , __add_rval_ref_t< _Tp> > { +# 1281 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1283 +}; +# 1286 +template< class _Tp, class ..._Args> using __is_trivially_constructible_impl = __bool_constant< __is_trivially_constructible(_Tp, _Args...)> ; +# 1292 +template< class _Tp, class ..._Args> +# 1293 +struct is_trivially_constructible : public __is_trivially_constructible_impl< _Tp, _Args...> { +# 1296 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1298 +}; +# 1301 +template< class _Tp> +# 1302 +struct is_trivially_default_constructible : public __is_trivially_constructible_impl< _Tp> { +# 1305 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1307 +}; +# 1319 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +struct __do_is_implicitly_default_constructible_impl { +# 1321 +template< class _Tp> static void __helper(const _Tp &); +# 1324 +template< class _Tp> static true_type __test(const _Tp &, __decltype((__helper< const _Tp &> ({}))) * = 0); +# 1328 +static false_type __test(...); +# 1329 +}; +# 1331 +template< class _Tp> +# 1332 +struct __is_implicitly_default_constructible_impl : public __do_is_implicitly_default_constructible_impl { +# 1335 +using type = __decltype((__test(declval< _Tp> ()))); +# 1336 +}; +# 1338 +template< class _Tp> +# 1339 +struct __is_implicitly_default_constructible_safe : public __is_implicitly_default_constructible_impl< _Tp> ::type { +# 1341 +}; +# 1343 +template< class _Tp> +# 1344 +struct __is_implicitly_default_constructible : public __and_< __is_constructible_impl< _Tp> , __is_implicitly_default_constructible_safe< _Tp> > ::type { +# 1347 +}; +# 1351 +template< class _Tp> +# 1352 +struct is_trivially_copy_constructible : public __is_trivially_constructible_impl< _Tp, __add_lval_ref_t< const _Tp> > { +# 1355 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1357 +}; +# 1360 +template< class _Tp> +# 1361 +struct is_trivially_move_constructible : public __is_trivially_constructible_impl< _Tp, __add_rval_ref_t< _Tp> > { +# 1364 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1366 +}; +# 1369 +template< class _Tp, class _Up> using __is_trivially_assignable_impl = __bool_constant< __is_trivially_assignable(_Tp, _Up)> ; +# 1375 +template< class _Tp, class _Up> +# 1376 +struct is_trivially_assignable : public __is_trivially_assignable_impl< _Tp, _Up> { +# 1379 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1381 +}; +# 1384 +template< class _Tp> +# 1385 +struct is_trivially_copy_assignable : public __is_trivially_assignable_impl< __add_lval_ref_t< _Tp> , __add_lval_ref_t< const _Tp> > { +# 1389 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1391 +}; +# 1394 +template< class _Tp> +# 1395 +struct is_trivially_move_assignable : public __is_trivially_assignable_impl< __add_lval_ref_t< _Tp> , __add_rval_ref_t< _Tp> > { +# 1399 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1401 +}; +# 1404 +template< class _Tp> +# 1405 +struct is_trivially_destructible : public __and_< __is_destructible_safe< _Tp> , __bool_constant< __has_trivial_destructor(_Tp)> > ::type { +# 1409 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1411 +}; +# 1415 +template< class _Tp> +# 1416 +struct has_virtual_destructor : public __bool_constant< __has_virtual_destructor(_Tp)> { +# 1419 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1421 +}; +# 1427 +template< class _Tp> +# 1428 +struct alignment_of : public integral_constant< unsigned long, __alignof__(_Tp)> { +# 1431 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1433 +}; +# 1436 +template< class > +# 1437 +struct rank : public integral_constant< unsigned long, 0UL> { +# 1438 +}; +# 1440 +template< class _Tp, size_t _Size> +# 1441 +struct rank< _Tp [_Size]> : public integral_constant< unsigned long, 1 + std::rank< _Tp> ::value> { +# 1442 +}; +# 1444 +template< class _Tp> +# 1445 +struct rank< _Tp []> : public integral_constant< unsigned long, 1 + std::rank< _Tp> ::value> { +# 1446 +}; +# 1449 +template< class , unsigned _Uint = 0U> +# 1450 +struct extent : public integral_constant< unsigned long, 0UL> { +# 1451 +}; +# 1453 +template< class _Tp, size_t _Size> +# 1454 +struct extent< _Tp [_Size], 0> : public integral_constant< unsigned long, _Size> { +# 1455 +}; +# 1457 +template< class _Tp, unsigned _Uint, size_t _Size> +# 1458 +struct extent< _Tp [_Size], _Uint> : public std::extent< _Tp, _Uint - (1)> ::type { +# 1459 +}; +# 1461 +template< class _Tp> +# 1462 +struct extent< _Tp [], 0> : public integral_constant< unsigned long, 0UL> { +# 1463 +}; +# 1465 +template< class _Tp, unsigned _Uint> +# 1466 +struct extent< _Tp [], _Uint> : public std::extent< _Tp, _Uint - (1)> ::type { +# 1467 +}; +# 1474 +template< class _Tp, class _Up> +# 1475 +struct is_same : public __bool_constant< __is_same(_Tp, _Up)> { +# 1477 +}; +# 1491 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Base, class _Derived> +# 1492 +struct is_base_of : public __bool_constant< __is_base_of(_Base, _Derived)> { +# 1494 +}; +# 1497 +template< class _From, class _To> +# 1498 +struct is_convertible : public __bool_constant< __is_convertible(_From, _To)> { +# 1500 +}; +# 1540 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _ToElementType, class _FromElementType> using __is_array_convertible = is_convertible< _FromElementType (*)[], _ToElementType (*)[]> ; +# 1600 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++14-extensions" +template< class _Tp, class ..._Args> +# 1603 +struct __is_nothrow_new_constructible_impl : public __bool_constant< noexcept((::new (std::declval< void *> ()) _Tp(std::declval< _Args> ()...)))> { +# 1607 +}; +# 1609 +template< class _Tp, class ..._Args> constexpr inline bool +# 1610 +__is_nothrow_new_constructible = (__and_< is_constructible< _Tp, _Args...> , __is_nothrow_new_constructible_impl< _Tp, _Args...> > ::value); +# 1613 +#pragma GCC diagnostic pop +# 1618 +template< class _Tp> +# 1619 +struct remove_const { +# 1620 +using type = _Tp; }; +# 1622 +template< class _Tp> +# 1623 +struct remove_const< const _Tp> { +# 1624 +using type = _Tp; }; +# 1627 +template< class _Tp> +# 1628 +struct remove_volatile { +# 1629 +using type = _Tp; }; +# 1631 +template< class _Tp> +# 1632 +struct remove_volatile< volatile _Tp> { +# 1633 +using type = _Tp; }; +# 1637 +template< class _Tp> +# 1638 +struct remove_cv { +# 1639 +using type = __remove_cv(_Tp); }; +# 1659 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> +# 1660 +struct add_const { +# 1661 +using type = const _Tp; }; +# 1664 +template< class _Tp> +# 1665 +struct add_volatile { +# 1666 +using type = volatile _Tp; }; +# 1669 +template< class _Tp> +# 1670 +struct add_cv { +# 1671 +using type = const volatile _Tp; }; +# 1675 +template< class _Tp> using remove_const_t = typename remove_const< _Tp> ::type; +# 1679 +template< class _Tp> using remove_volatile_t = typename remove_volatile< _Tp> ::type; +# 1683 +template< class _Tp> using remove_cv_t = typename remove_cv< _Tp> ::type; +# 1687 +template< class _Tp> using add_const_t = typename add_const< _Tp> ::type; +# 1691 +template< class _Tp> using add_volatile_t = typename add_volatile< _Tp> ::type; +# 1695 +template< class _Tp> using add_cv_t = typename add_cv< _Tp> ::type; +# 1703 +template< class _Tp> +# 1704 +struct remove_reference { +# 1705 +using type = __remove_reference(_Tp); }; +# 1721 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> +# 1722 +struct add_lvalue_reference { +# 1723 +using type = __add_lval_ref_t< _Tp> ; }; +# 1726 +template< class _Tp> +# 1727 +struct add_rvalue_reference { +# 1728 +using type = __add_rval_ref_t< _Tp> ; }; +# 1732 +template< class _Tp> using remove_reference_t = typename remove_reference< _Tp> ::type; +# 1736 +template< class _Tp> using add_lvalue_reference_t = typename add_lvalue_reference< _Tp> ::type; +# 1740 +template< class _Tp> using add_rvalue_reference_t = typename add_rvalue_reference< _Tp> ::type; +# 1749 +template< class _Unqualified, bool _IsConst, bool _IsVol> struct __cv_selector; +# 1752 +template< class _Unqualified> +# 1753 +struct __cv_selector< _Unqualified, false, false> { +# 1754 +using __type = _Unqualified; }; +# 1756 +template< class _Unqualified> +# 1757 +struct __cv_selector< _Unqualified, false, true> { +# 1758 +using __type = volatile _Unqualified; }; +# 1760 +template< class _Unqualified> +# 1761 +struct __cv_selector< _Unqualified, true, false> { +# 1762 +using __type = const _Unqualified; }; +# 1764 +template< class _Unqualified> +# 1765 +struct __cv_selector< _Unqualified, true, true> { +# 1766 +using __type = const volatile _Unqualified; }; +# 1768 +template< class _Qualified, class _Unqualified, bool +# 1769 +_IsConst = is_const< _Qualified> ::value, bool +# 1770 +_IsVol = is_volatile< _Qualified> ::value> +# 1771 +class __match_cv_qualifiers { +# 1773 +using __match = __cv_selector< _Unqualified, _IsConst, _IsVol> ; +# 1776 +public: using __type = typename __cv_selector< _Unqualified, _IsConst, _IsVol> ::__type; +# 1777 +}; +# 1780 +template< class _Tp> +# 1781 +struct __make_unsigned { +# 1782 +using __type = _Tp; }; +# 1785 +template<> struct __make_unsigned< char> { +# 1786 +using __type = unsigned char; }; +# 1789 +template<> struct __make_unsigned< signed char> { +# 1790 +using __type = unsigned char; }; +# 1793 +template<> struct __make_unsigned< short> { +# 1794 +using __type = unsigned short; }; +# 1797 +template<> struct __make_unsigned< int> { +# 1798 +using __type = unsigned; }; +# 1801 +template<> struct __make_unsigned< long> { +# 1802 +using __type = unsigned long; }; +# 1805 +template<> struct __make_unsigned< long long> { +# 1806 +using __type = unsigned long long; }; +# 1811 +template<> struct __make_unsigned< __int128> { +# 1812 +using __type = unsigned __int128; }; +# 1834 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp, bool +# 1835 +_IsInt = is_integral< _Tp> ::value, bool +# 1836 +_IsEnum = __is_enum(_Tp)> class __make_unsigned_selector; +# 1839 +template< class _Tp> +# 1840 +class __make_unsigned_selector< _Tp, true, false> { +# 1842 +using __unsigned_type = typename __make_unsigned< __remove_cv_t< _Tp> > ::__type; +# 1846 +public: using __type = typename __match_cv_qualifiers< _Tp, __unsigned_type> ::__type; +# 1848 +}; +# 1850 +class __make_unsigned_selector_base { +# 1853 +protected: template< class ...> struct _List { }; +# 1855 +template< class _Tp, class ..._Up> +# 1856 +struct _List< _Tp, _Up...> : public __make_unsigned_selector_base::template _List< _Up...> { +# 1857 +static constexpr inline std::size_t __size = sizeof(_Tp); }; +# 1859 +template< size_t _Sz, class _Tp, bool = _Sz <= _Tp::__size> struct __select; +# 1862 +template< size_t _Sz, class _Uint, class ..._UInts> +# 1863 +struct __select< _Sz, _List< _Uint, _UInts...> , true> { +# 1864 +using __type = _Uint; }; +# 1866 +template< size_t _Sz, class _Uint, class ..._UInts> +# 1867 +struct __select< _Sz, _List< _Uint, _UInts...> , false> : public __make_unsigned_selector_base::template __select< _Sz, _List< _UInts...> > { +# 1869 +}; +# 1870 +}; +# 1873 +template< class _Tp> +# 1874 +class __make_unsigned_selector< _Tp, false, true> : private __make_unsigned_selector_base { +# 1878 +using _UInts = _List< unsigned char, unsigned short, unsigned, unsigned long, unsigned long long> ; +# 1881 +using __unsigned_type = typename __select< sizeof(_Tp), _List< unsigned char, unsigned short, unsigned, unsigned long, unsigned long long> > ::__type; +# 1884 +public: using __type = typename __match_cv_qualifiers< _Tp, __unsigned_type> ::__type; +# 1886 +}; +# 1893 +template<> struct __make_unsigned< wchar_t> { +# 1895 +using __type = __make_unsigned_selector< wchar_t, false, true> ::__type; +# 1897 +}; +# 1909 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template<> struct __make_unsigned< char16_t> { +# 1911 +using __type = __make_unsigned_selector< char16_t, false, true> ::__type; +# 1913 +}; +# 1916 +template<> struct __make_unsigned< char32_t> { +# 1918 +using __type = __make_unsigned_selector< char32_t, false, true> ::__type; +# 1920 +}; +# 1927 +template< class _Tp> +# 1928 +struct make_unsigned { +# 1929 +using type = typename __make_unsigned_selector< _Tp> ::__type; }; +# 1932 +template<> struct make_unsigned< bool> ; +# 1933 +template<> struct make_unsigned< const bool> ; +# 1934 +template<> struct make_unsigned< volatile bool> ; +# 1935 +template<> struct make_unsigned< const volatile bool> ; +# 1940 +template< class _Tp> +# 1941 +struct __make_signed { +# 1942 +using __type = _Tp; }; +# 1945 +template<> struct __make_signed< char> { +# 1946 +using __type = signed char; }; +# 1949 +template<> struct __make_signed< unsigned char> { +# 1950 +using __type = signed char; }; +# 1953 +template<> struct __make_signed< unsigned short> { +# 1954 +using __type = signed short; }; +# 1957 +template<> struct __make_signed< unsigned> { +# 1958 +using __type = signed int; }; +# 1961 +template<> struct __make_signed< unsigned long> { +# 1962 +using __type = signed long; }; +# 1965 +template<> struct __make_signed< unsigned long long> { +# 1966 +using __type = signed long long; }; +# 1971 +template<> struct __make_signed< unsigned __int128> { +# 1972 +using __type = __int128; }; +# 1994 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp, bool +# 1995 +_IsInt = is_integral< _Tp> ::value, bool +# 1996 +_IsEnum = __is_enum(_Tp)> class __make_signed_selector; +# 1999 +template< class _Tp> +# 2000 +class __make_signed_selector< _Tp, true, false> { +# 2002 +using __signed_type = typename __make_signed< __remove_cv_t< _Tp> > ::__type; +# 2006 +public: using __type = typename __match_cv_qualifiers< _Tp, __signed_type> ::__type; +# 2008 +}; +# 2011 +template< class _Tp> +# 2012 +class __make_signed_selector< _Tp, false, true> { +# 2014 +using __unsigned_type = typename __make_unsigned_selector< _Tp> ::__type; +# 2017 +public: using __type = typename std::__make_signed_selector< __unsigned_type> ::__type; +# 2018 +}; +# 2025 +template<> struct __make_signed< wchar_t> { +# 2027 +using __type = __make_signed_selector< wchar_t, false, true> ::__type; +# 2029 +}; +# 2041 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template<> struct __make_signed< char16_t> { +# 2043 +using __type = __make_signed_selector< char16_t, false, true> ::__type; +# 2045 +}; +# 2048 +template<> struct __make_signed< char32_t> { +# 2050 +using __type = __make_signed_selector< char32_t, false, true> ::__type; +# 2052 +}; +# 2059 +template< class _Tp> +# 2060 +struct make_signed { +# 2061 +using type = typename __make_signed_selector< _Tp> ::__type; }; +# 2064 +template<> struct make_signed< bool> ; +# 2065 +template<> struct make_signed< const bool> ; +# 2066 +template<> struct make_signed< volatile bool> ; +# 2067 +template<> struct make_signed< const volatile bool> ; +# 2071 +template< class _Tp> using make_signed_t = typename make_signed< _Tp> ::type; +# 2075 +template< class _Tp> using make_unsigned_t = typename make_unsigned< _Tp> ::type; +# 2082 +template< class _Tp> +# 2083 +struct remove_extent { +# 2084 +using type = _Tp; }; +# 2086 +template< class _Tp, size_t _Size> +# 2087 +struct remove_extent< _Tp [_Size]> { +# 2088 +using type = _Tp; }; +# 2090 +template< class _Tp> +# 2091 +struct remove_extent< _Tp []> { +# 2092 +using type = _Tp; }; +# 2095 +template< class _Tp> +# 2096 +struct remove_all_extents { +# 2097 +using type = _Tp; }; +# 2099 +template< class _Tp, size_t _Size> +# 2100 +struct remove_all_extents< _Tp [_Size]> { +# 2101 +using type = typename std::remove_all_extents< _Tp> ::type; }; +# 2103 +template< class _Tp> +# 2104 +struct remove_all_extents< _Tp []> { +# 2105 +using type = typename std::remove_all_extents< _Tp> ::type; }; +# 2109 +template< class _Tp> using remove_extent_t = typename remove_extent< _Tp> ::type; +# 2113 +template< class _Tp> using remove_all_extents_t = typename remove_all_extents< _Tp> ::type; +# 2121 +template< class _Tp> +# 2122 +struct remove_pointer { +# 2123 +using type = __remove_pointer(_Tp); }; +# 2139 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp, class = void> +# 2140 +struct __add_pointer_helper { +# 2141 +using type = _Tp; }; +# 2143 +template< class _Tp> +# 2144 +struct __add_pointer_helper< _Tp, __void_t< _Tp *> > { +# 2145 +using type = _Tp *; }; +# 2148 +template< class _Tp> +# 2149 +struct add_pointer : public __add_pointer_helper< _Tp> { +# 2151 +}; +# 2153 +template< class _Tp> +# 2154 +struct add_pointer< _Tp &> { +# 2155 +using type = _Tp *; }; +# 2157 +template< class _Tp> +# 2158 +struct add_pointer< _Tp &&> { +# 2159 +using type = _Tp *; }; +# 2163 +template< class _Tp> using remove_pointer_t = typename remove_pointer< _Tp> ::type; +# 2167 +template< class _Tp> using add_pointer_t = typename add_pointer< _Tp> ::type; +# 2171 +template< size_t _Len> +# 2172 +struct __aligned_storage_msa { +# 2174 +union __type { +# 2176 +unsigned char __data[_Len]; +# 2177 +struct __attribute((__aligned__)) { } __align; +# 2178 +}; +# 2179 +}; +# 2194 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< size_t _Len, size_t _Align = __alignof__(typename __aligned_storage_msa< _Len> ::__type)> +# 2198 +struct aligned_storage { +# 2200 +union type { +# 2202 +unsigned char __data[_Len]; +# 2203 +struct __attribute((__aligned__(_Align))) { } __align; +# 2204 +}; +# 2205 +}; +# 2207 +template< class ..._Types> +# 2208 +struct __strictest_alignment { +# 2210 +static const size_t _S_alignment = (0); +# 2211 +static const size_t _S_size = (0); +# 2212 +}; +# 2214 +template< class _Tp, class ..._Types> +# 2215 +struct __strictest_alignment< _Tp, _Types...> { +# 2217 +static const size_t _S_alignment = ((__alignof__(_Tp) > __strictest_alignment< _Types...> ::_S_alignment) ? __alignof__(_Tp) : __strictest_alignment< _Types...> ::_S_alignment); +# 2220 +static const size_t _S_size = ((sizeof(_Tp) > __strictest_alignment< _Types...> ::_S_size) ? sizeof(_Tp) : __strictest_alignment< _Types...> ::_S_size); +# 2223 +}; +# 2225 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 2240 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< size_t _Len, class ..._Types> +# 2243 +struct aligned_union { +# 2246 +static_assert((sizeof...(_Types) != (0)), "At least one type is required"); +# 2248 +private: using __strictest = __strictest_alignment< _Types...> ; +# 2249 +static const size_t _S_len = ((_Len > __strictest::_S_size) ? _Len : __strictest::_S_size); +# 2253 +public: static const size_t alignment_value = (__strictest::_S_alignment); +# 2255 +using type = typename aligned_storage< _S_len, alignment_value> ::type; +# 2256 +}; +# 2258 +template< size_t _Len, class ..._Types> const size_t aligned_union< _Len, _Types...> ::alignment_value; +# 2260 +#pragma GCC diagnostic pop +# 2266 +template< class _Up> +# 2267 +struct __decay_selector : public __conditional_t< is_const< const _Up> ::value, remove_cv< _Up> , add_pointer< _Up> > { +# 2271 +}; +# 2273 +template< class _Up, size_t _Nm> +# 2274 +struct __decay_selector< _Up [_Nm]> { +# 2275 +using type = _Up *; }; +# 2277 +template< class _Up> +# 2278 +struct __decay_selector< _Up []> { +# 2279 +using type = _Up *; }; +# 2284 +template< class _Tp> +# 2285 +struct decay { +# 2286 +using type = typename __decay_selector< _Tp> ::type; }; +# 2288 +template< class _Tp> +# 2289 +struct decay< _Tp &> { +# 2290 +using type = typename __decay_selector< _Tp> ::type; }; +# 2292 +template< class _Tp> +# 2293 +struct decay< _Tp &&> { +# 2294 +using type = typename __decay_selector< _Tp> ::type; }; +# 2299 +template< class _Tp> +# 2300 +struct __strip_reference_wrapper { +# 2302 +using __type = _Tp; +# 2303 +}; +# 2305 +template< class _Tp> +# 2306 +struct __strip_reference_wrapper< reference_wrapper< _Tp> > { +# 2308 +using __type = _Tp &; +# 2309 +}; +# 2312 +template< class _Tp> using __decay_t = typename decay< _Tp> ::type; +# 2315 +template< class _Tp> using __decay_and_strip = __strip_reference_wrapper< __decay_t< _Tp> > ; +# 2322 +template< class ..._Cond> using _Require = __enable_if_t< __and_< _Cond...> ::value> ; +# 2326 +template< class _Tp> using __remove_cvref_t = typename remove_cv< typename remove_reference< _Tp> ::type> ::type; +# 2333 +template< bool _Cond, class _Iftrue, class _Iffalse> +# 2334 +struct conditional { +# 2335 +using type = _Iftrue; }; +# 2338 +template< class _Iftrue, class _Iffalse> +# 2339 +struct conditional< false, _Iftrue, _Iffalse> { +# 2340 +using type = _Iffalse; }; +# 2343 +template< class ..._Tp> struct common_type; +# 2355 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> +# 2356 +struct __success_type { +# 2357 +using type = _Tp; }; +# 2359 +struct __failure_type { +# 2360 +}; +# 2362 +struct __do_common_type_impl { +# 2364 +template< class _Tp, class _Up> using __cond_t = __decltype((true ? std::declval< _Tp> () : std::declval< _Up> ())); +# 2370 +template< class _Tp, class _Up> static __success_type< __decay_t< __cond_t< _Tp, _Up> > > _S_test(int); +# 2382 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class , class > static __failure_type _S_test_2(...); +# 2386 +template< class _Tp, class _Up> static __decltype((_S_test_2< _Tp, _Up> (0))) _S_test(...); +# 2389 +}; +# 2393 +template<> struct common_type< > { +# 2394 +}; +# 2397 +template< class _Tp0> +# 2398 +struct common_type< _Tp0> : public std::common_type< _Tp0, _Tp0> { +# 2400 +}; +# 2403 +template< class _Tp1, class _Tp2, class +# 2404 +_Dp1 = __decay_t< _Tp1> , class _Dp2 = __decay_t< _Tp2> > +# 2405 +struct __common_type_impl { +# 2409 +using type = common_type< _Dp1, _Dp2> ; +# 2410 +}; +# 2412 +template< class _Tp1, class _Tp2> +# 2413 +struct __common_type_impl< _Tp1, _Tp2, _Tp1, _Tp2> : private __do_common_type_impl { +# 2418 +using type = __decltype((_S_test< _Tp1, _Tp2> (0))); +# 2419 +}; +# 2422 +template< class _Tp1, class _Tp2> +# 2423 +struct common_type< _Tp1, _Tp2> : public __common_type_impl< _Tp1, _Tp2> ::type { +# 2425 +}; +# 2427 +template< class ...> +# 2428 +struct __common_type_pack { +# 2429 +}; +# 2431 +template< class , class , class = void> struct __common_type_fold; +# 2435 +template< class _Tp1, class _Tp2, class ..._Rp> +# 2436 +struct common_type< _Tp1, _Tp2, _Rp...> : public __common_type_fold< std::common_type< _Tp1, _Tp2> , __common_type_pack< _Rp...> > { +# 2439 +}; +# 2444 +template< class _CTp, class ..._Rp> +# 2445 +struct __common_type_fold< _CTp, __common_type_pack< _Rp...> , __void_t< typename _CTp::type> > : public common_type< typename _CTp::type, _Rp...> { +# 2448 +}; +# 2451 +template< class _CTp, class _Rp> +# 2452 +struct __common_type_fold< _CTp, _Rp, void> { +# 2453 +}; +# 2455 +template< class _Tp, bool = __is_enum(_Tp)> +# 2456 +struct __underlying_type_impl { +# 2458 +using type = __underlying_type(_Tp); +# 2459 +}; +# 2461 +template< class _Tp> +# 2462 +struct __underlying_type_impl< _Tp, false> { +# 2463 +}; +# 2467 +template< class _Tp> +# 2468 +struct underlying_type : public __underlying_type_impl< _Tp> { +# 2470 +}; +# 2473 +template< class _Tp> +# 2474 +struct __declval_protector { +# 2476 +static const bool __stop = false; +# 2477 +}; +# 2484 +template< class _Tp> auto +# 2485 +declval() noexcept->__decltype((__declval< _Tp> (0))) +# 2486 +{ +# 2487 +static_assert((__declval_protector< _Tp> ::__stop), "declval() must not be used!"); +# 2489 +return __declval< _Tp> (0); +# 2490 +} +# 2493 +template< class _Signature> struct result_of; +# 2499 +struct __invoke_memfun_ref { }; +# 2500 +struct __invoke_memfun_deref { }; +# 2501 +struct __invoke_memobj_ref { }; +# 2502 +struct __invoke_memobj_deref { }; +# 2503 +struct __invoke_other { }; +# 2506 +template< class _Tp, class _Tag> +# 2507 +struct __result_of_success : public __success_type< _Tp> { +# 2508 +using __invoke_type = _Tag; }; +# 2511 +struct __result_of_memfun_ref_impl { +# 2513 +template< class _Fp, class _Tp1, class ..._Args> static __result_of_success< __decltype(((std::declval< _Tp1> ().*std::declval< _Fp> ())(std::declval< _Args> ()...))), __invoke_memfun_ref> _S_test(int); +# 2518 +template< class ...> static __failure_type _S_test(...); +# 2520 +}; +# 2522 +template< class _MemPtr, class _Arg, class ..._Args> +# 2523 +struct __result_of_memfun_ref : private __result_of_memfun_ref_impl { +# 2526 +using type = __decltype((_S_test< _MemPtr, _Arg, _Args...> (0))); +# 2527 +}; +# 2530 +struct __result_of_memfun_deref_impl { +# 2532 +template< class _Fp, class _Tp1, class ..._Args> static __result_of_success< __decltype((((*std::declval< _Tp1> ()).*std::declval< _Fp> ())(std::declval< _Args> ()...))), __invoke_memfun_deref> _S_test(int); +# 2537 +template< class ...> static __failure_type _S_test(...); +# 2539 +}; +# 2541 +template< class _MemPtr, class _Arg, class ..._Args> +# 2542 +struct __result_of_memfun_deref : private __result_of_memfun_deref_impl { +# 2545 +using type = __decltype((_S_test< _MemPtr, _Arg, _Args...> (0))); +# 2546 +}; +# 2549 +struct __result_of_memobj_ref_impl { +# 2551 +template< class _Fp, class _Tp1> static __result_of_success< __decltype((std::declval< _Tp1> ().*std::declval< _Fp> ())), __invoke_memobj_ref> _S_test(int); +# 2556 +template< class , class > static __failure_type _S_test(...); +# 2558 +}; +# 2560 +template< class _MemPtr, class _Arg> +# 2561 +struct __result_of_memobj_ref : private __result_of_memobj_ref_impl { +# 2564 +using type = __decltype((_S_test< _MemPtr, _Arg> (0))); +# 2565 +}; +# 2568 +struct __result_of_memobj_deref_impl { +# 2570 +template< class _Fp, class _Tp1> static __result_of_success< __decltype(((*std::declval< _Tp1> ()).*std::declval< _Fp> ())), __invoke_memobj_deref> _S_test(int); +# 2575 +template< class , class > static __failure_type _S_test(...); +# 2577 +}; +# 2579 +template< class _MemPtr, class _Arg> +# 2580 +struct __result_of_memobj_deref : private __result_of_memobj_deref_impl { +# 2583 +using type = __decltype((_S_test< _MemPtr, _Arg> (0))); +# 2584 +}; +# 2586 +template< class _MemPtr, class _Arg> struct __result_of_memobj; +# 2589 +template< class _Res, class _Class, class _Arg> +# 2590 +struct __result_of_memobj< _Res (_Class::*), _Arg> { +# 2592 +using _Argval = __remove_cvref_t< _Arg> ; +# 2593 +using _MemPtr = _Res (_Class::*); +# 2594 +using type = typename __conditional_t< __or_< is_same< _Argval, _Class> , is_base_of< _Class, _Argval> > ::value, __result_of_memobj_ref< _MemPtr, _Arg> , __result_of_memobj_deref< _MemPtr, _Arg> > ::type; +# 2599 +}; +# 2601 +template< class _MemPtr, class _Arg, class ..._Args> struct __result_of_memfun; +# 2604 +template< class _Res, class _Class, class _Arg, class ..._Args> +# 2605 +struct __result_of_memfun< _Res (_Class::*), _Arg, _Args...> { +# 2607 +using _Argval = typename remove_reference< _Arg> ::type; +# 2608 +using _MemPtr = _Res (_Class::*); +# 2609 +using type = typename __conditional_t< is_base_of< _Class, _Argval> ::value, __result_of_memfun_ref< _MemPtr, _Arg, _Args...> , __result_of_memfun_deref< _MemPtr, _Arg, _Args...> > ::type; +# 2613 +}; +# 2620 +template< class _Tp, class _Up = __remove_cvref_t< _Tp> > +# 2621 +struct __inv_unwrap { +# 2623 +using type = _Tp; +# 2624 +}; +# 2626 +template< class _Tp, class _Up> +# 2627 +struct __inv_unwrap< _Tp, reference_wrapper< _Up> > { +# 2629 +using type = _Up &; +# 2630 +}; +# 2632 +template< bool , bool , class _Functor, class ..._ArgTypes> +# 2633 +struct __result_of_impl { +# 2635 +using type = __failure_type; +# 2636 +}; +# 2638 +template< class _MemPtr, class _Arg> +# 2639 +struct __result_of_impl< true, false, _MemPtr, _Arg> : public __result_of_memobj< __decay_t< _MemPtr> , typename __inv_unwrap< _Arg> ::type> { +# 2642 +}; +# 2644 +template< class _MemPtr, class _Arg, class ..._Args> +# 2645 +struct __result_of_impl< false, true, _MemPtr, _Arg, _Args...> : public __result_of_memfun< __decay_t< _MemPtr> , typename __inv_unwrap< _Arg> ::type, _Args...> { +# 2648 +}; +# 2651 +struct __result_of_other_impl { +# 2653 +template< class _Fn, class ..._Args> static __result_of_success< __decltype((std::declval< _Fn> ()(std::declval< _Args> ()...))), __invoke_other> _S_test(int); +# 2658 +template< class ...> static __failure_type _S_test(...); +# 2660 +}; +# 2662 +template< class _Functor, class ..._ArgTypes> +# 2663 +struct __result_of_impl< false, false, _Functor, _ArgTypes...> : private __result_of_other_impl { +# 2666 +using type = __decltype((_S_test< _Functor, _ArgTypes...> (0))); +# 2667 +}; +# 2670 +template< class _Functor, class ..._ArgTypes> +# 2671 +struct __invoke_result : public __result_of_impl< is_member_object_pointer< typename remove_reference< _Functor> ::type> ::value, is_member_function_pointer< typename remove_reference< _Functor> ::type> ::value, _Functor, _ArgTypes...> ::type { +# 2681 +}; +# 2684 +template< class _Fn, class ..._Args> using __invoke_result_t = typename __invoke_result< _Fn, _Args...> ::type; +# 2688 +template< class _Functor, class ..._ArgTypes> +# 2689 +struct result_of< _Functor (_ArgTypes ...)> : public __invoke_result< _Functor, _ArgTypes...> { +# 2691 +} __attribute((__deprecated__("use \'std::invoke_result\' instead"))); +# 2694 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 2697 +template< size_t _Len, size_t _Align = __alignof__(typename __aligned_storage_msa< _Len> ::__type)> using aligned_storage_t = typename aligned_storage< _Len, _Align> ::type; +# 2701 +template< size_t _Len, class ..._Types> using aligned_union_t = typename aligned_union< _Len, _Types...> ::type; +# 2703 +#pragma GCC diagnostic pop +# 2706 +template< class _Tp> using decay_t = typename decay< _Tp> ::type; +# 2710 +template< bool _Cond, class _Tp = void> using enable_if_t = typename enable_if< _Cond, _Tp> ::type; +# 2714 +template< bool _Cond, class _Iftrue, class _Iffalse> using conditional_t = typename conditional< _Cond, _Iftrue, _Iffalse> ::type; +# 2718 +template< class ..._Tp> using common_type_t = typename common_type< _Tp...> ::type; +# 2722 +template< class _Tp> using underlying_type_t = typename underlying_type< _Tp> ::type; +# 2726 +template< class _Tp> using result_of_t = typename result_of< _Tp> ::type; +# 2732 +template< class ...> using void_t = void; +# 2759 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Default, class _AlwaysVoid, +# 2760 +template< class ...> class _Op, class ..._Args> +# 2761 +struct __detector { +# 2763 +using type = _Default; +# 2764 +using __is_detected = false_type; +# 2765 +}; +# 2768 +template< class _Default, template< class ...> class _Op, class ... +# 2769 +_Args> +# 2770 +struct __detector< _Default, __void_t< _Op< _Args...> > , _Op, _Args...> { +# 2772 +using type = _Op< _Args...> ; +# 2773 +using __is_detected = true_type; +# 2774 +}; +# 2776 +template< class _Default, template< class ...> class _Op, class ... +# 2777 +_Args> using __detected_or = __detector< _Default, void, _Op, _Args...> ; +# 2782 +template< class _Default, template< class ...> class _Op, class ... +# 2783 +_Args> using __detected_or_t = typename __detected_or< _Default, _Op, _Args...> ::type; +# 2801 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> struct __is_swappable; +# 2804 +template< class _Tp> struct __is_nothrow_swappable; +# 2807 +template< class > +# 2808 +struct __is_tuple_like_impl : public false_type { +# 2809 +}; +# 2812 +template< class _Tp> +# 2813 +struct __is_tuple_like : public __is_tuple_like_impl< __remove_cvref_t< _Tp> > ::type { +# 2815 +}; +# 2818 +template< class _Tp> inline _Require< __not_< __is_tuple_like< _Tp> > , is_move_constructible< _Tp> , is_move_assignable< _Tp> > swap(_Tp &, _Tp &) noexcept(__and_< is_nothrow_move_constructible< _Tp> , is_nothrow_move_assignable< _Tp> > ::value); +# 2828 +template< class _Tp, size_t _Nm> inline __enable_if_t< __is_swappable< _Tp> ::value> swap(_Tp (& __a)[_Nm], _Tp (& __b)[_Nm]) noexcept(__is_nothrow_swappable< _Tp> ::value); +# 2836 +namespace __swappable_details { +# 2837 +using std::swap; +# 2839 +struct __do_is_swappable_impl { +# 2841 +template< class _Tp, class +# 2842 + = __decltype((swap(std::declval< _Tp &> (), std::declval< _Tp &> ())))> static true_type +# 2841 +__test(int); +# 2845 +template< class > static false_type __test(...); +# 2847 +}; +# 2849 +struct __do_is_nothrow_swappable_impl { +# 2851 +template< class _Tp> static __bool_constant< noexcept(swap(std::declval< _Tp &> (), std::declval< _Tp &> ()))> __test(int); +# 2856 +template< class > static false_type __test(...); +# 2858 +}; +# 2860 +} +# 2862 +template< class _Tp> +# 2863 +struct __is_swappable_impl : public __swappable_details::__do_is_swappable_impl { +# 2866 +using type = __decltype((__test< _Tp> (0))); +# 2867 +}; +# 2869 +template< class _Tp> +# 2870 +struct __is_nothrow_swappable_impl : public __swappable_details::__do_is_nothrow_swappable_impl { +# 2873 +using type = __decltype((__test< _Tp> (0))); +# 2874 +}; +# 2876 +template< class _Tp> +# 2877 +struct __is_swappable : public __is_swappable_impl< _Tp> ::type { +# 2879 +}; +# 2881 +template< class _Tp> +# 2882 +struct __is_nothrow_swappable : public __is_nothrow_swappable_impl< _Tp> ::type { +# 2884 +}; +# 2891 +template< class _Tp> +# 2892 +struct is_swappable : public __is_swappable_impl< _Tp> ::type { +# 2895 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 2897 +}; +# 2900 +template< class _Tp> +# 2901 +struct is_nothrow_swappable : public __is_nothrow_swappable_impl< _Tp> ::type { +# 2904 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 2906 +}; +# 2910 +template< class _Tp> constexpr inline bool +# 2911 +is_swappable_v = (is_swappable< _Tp> ::value); +# 2915 +template< class _Tp> constexpr inline bool +# 2916 +is_nothrow_swappable_v = (is_nothrow_swappable< _Tp> ::value); +# 2921 +namespace __swappable_with_details { +# 2922 +using std::swap; +# 2924 +struct __do_is_swappable_with_impl { +# 2926 +template< class _Tp, class _Up, class +# 2927 + = __decltype((swap(std::declval< _Tp> (), std::declval< _Up> ()))), class +# 2929 + = __decltype((swap(std::declval< _Up> (), std::declval< _Tp> ())))> static true_type +# 2926 +__test(int); +# 2932 +template< class , class > static false_type __test(...); +# 2934 +}; +# 2936 +struct __do_is_nothrow_swappable_with_impl { +# 2938 +template< class _Tp, class _Up> static __bool_constant< noexcept(swap(std::declval< _Tp> (), std::declval< _Up> ())) && noexcept(swap(std::declval< _Up> (), std::declval< _Tp> ()))> __test(int); +# 2945 +template< class , class > static false_type __test(...); +# 2947 +}; +# 2949 +} +# 2951 +template< class _Tp, class _Up> +# 2952 +struct __is_swappable_with_impl : public __swappable_with_details::__do_is_swappable_with_impl { +# 2955 +using type = __decltype((__test< _Tp, _Up> (0))); +# 2956 +}; +# 2959 +template< class _Tp> +# 2960 +struct __is_swappable_with_impl< _Tp &, _Tp &> : public __swappable_details::__do_is_swappable_impl { +# 2963 +using type = __decltype((__test< _Tp &> (0))); +# 2964 +}; +# 2966 +template< class _Tp, class _Up> +# 2967 +struct __is_nothrow_swappable_with_impl : public __swappable_with_details::__do_is_nothrow_swappable_with_impl { +# 2970 +using type = __decltype((__test< _Tp, _Up> (0))); +# 2971 +}; +# 2974 +template< class _Tp> +# 2975 +struct __is_nothrow_swappable_with_impl< _Tp &, _Tp &> : public __swappable_details::__do_is_nothrow_swappable_impl { +# 2978 +using type = __decltype((__test< _Tp &> (0))); +# 2979 +}; +# 2983 +template< class _Tp, class _Up> +# 2984 +struct is_swappable_with : public __is_swappable_with_impl< _Tp, _Up> ::type { +# 2987 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "first template argument must be a complete class or an unbounded array"); +# 2989 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Up> {})), "second template argument must be a complete class or an unbounded array"); +# 2991 +}; +# 2994 +template< class _Tp, class _Up> +# 2995 +struct is_nothrow_swappable_with : public __is_nothrow_swappable_with_impl< _Tp, _Up> ::type { +# 2998 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "first template argument must be a complete class or an unbounded array"); +# 3000 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Up> {})), "second template argument must be a complete class or an unbounded array"); +# 3002 +}; +# 3006 +template< class _Tp, class _Up> constexpr inline bool +# 3007 +is_swappable_with_v = (is_swappable_with< _Tp, _Up> ::value); +# 3011 +template< class _Tp, class _Up> constexpr inline bool +# 3012 +is_nothrow_swappable_with_v = (is_nothrow_swappable_with< _Tp, _Up> ::value); +# 3023 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Result, class _Ret, bool +# 3024 + = is_void< _Ret> ::value, class = void> +# 3025 +struct __is_invocable_impl : public false_type { +# 3028 +using __nothrow_conv = false_type; +# 3029 +}; +# 3032 +template< class _Result, class _Ret> +# 3033 +struct __is_invocable_impl< _Result, _Ret, true, __void_t< typename _Result::type> > : public true_type { +# 3038 +using __nothrow_conv = true_type; +# 3039 +}; +# 3041 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" +# 3044 +template< class _Result, class _Ret> +# 3045 +struct __is_invocable_impl< _Result, _Ret, false, __void_t< typename _Result::type> > { +# 3051 +private: using _Res_t = typename _Result::type; +# 3055 +static _Res_t _S_get() noexcept; +# 3058 +template< class _Tp> static void _S_conv(__type_identity_t< _Tp> ) noexcept; +# 3062 +template< class _Tp, bool +# 3063 +_Nothrow = noexcept(_S_conv< _Tp> ((_S_get)())), class +# 3064 + = __decltype((_S_conv< _Tp> ((_S_get)()))), bool +# 3066 +_Dangle = __reference_converts_from_temporary(_Tp, _Res_t)> static __bool_constant< _Nothrow && (!_Dangle)> +# 3062 +_S_test(int); +# 3074 +template< class _Tp, bool = false> static false_type _S_test(...); +# 3080 +public: using type = __decltype((_S_test< _Ret, true> (1))); +# 3083 +using __nothrow_conv = __decltype((_S_test< _Ret> (1))); +# 3084 +}; +#pragma GCC diagnostic pop +# 3087 +template< class _Fn, class ..._ArgTypes> +# 3088 +struct __is_invocable : public __is_invocable_impl< __invoke_result< _Fn, _ArgTypes...> , void> ::type { +# 3090 +}; +# 3092 +template< class _Fn, class _Tp, class ..._Args> constexpr bool +# 3093 +__call_is_nt(__invoke_memfun_ref) +# 3094 +{ +# 3095 +using _Up = typename __inv_unwrap< _Tp> ::type; +# 3096 +return noexcept((std::declval< typename __inv_unwrap< _Tp> ::type> ().*std::declval< _Fn> ())(std::declval< _Args> ()...)); +# 3098 +} +# 3100 +template< class _Fn, class _Tp, class ..._Args> constexpr bool +# 3101 +__call_is_nt(__invoke_memfun_deref) +# 3102 +{ +# 3103 +return noexcept(((*std::declval< _Tp> ()).*std::declval< _Fn> ())(std::declval< _Args> ()...)); +# 3105 +} +# 3107 +template< class _Fn, class _Tp> constexpr bool +# 3108 +__call_is_nt(__invoke_memobj_ref) +# 3109 +{ +# 3110 +using _Up = typename __inv_unwrap< _Tp> ::type; +# 3111 +return noexcept((std::declval< typename __inv_unwrap< _Tp> ::type> ().*std::declval< _Fn> ())); +# 3112 +} +# 3114 +template< class _Fn, class _Tp> constexpr bool +# 3115 +__call_is_nt(__invoke_memobj_deref) +# 3116 +{ +# 3117 +return noexcept(((*std::declval< _Tp> ()).*std::declval< _Fn> ())); +# 3118 +} +# 3120 +template< class _Fn, class ..._Args> constexpr bool +# 3121 +__call_is_nt(__invoke_other) +# 3122 +{ +# 3123 +return noexcept(std::declval< _Fn> ()(std::declval< _Args> ()...)); +# 3124 +} +# 3126 +template< class _Result, class _Fn, class ..._Args> +# 3127 +struct __call_is_nothrow : public __bool_constant< std::__call_is_nt< _Fn, _Args...> (typename _Result::__invoke_type{})> { +# 3131 +}; +# 3133 +template< class _Fn, class ..._Args> using __call_is_nothrow_ = __call_is_nothrow< __invoke_result< _Fn, _Args...> , _Fn, _Args...> ; +# 3138 +template< class _Fn, class ..._Args> +# 3139 +struct __is_nothrow_invocable : public __and_< __is_invocable< _Fn, _Args...> , __call_is_nothrow_< _Fn, _Args...> > ::type { +# 3142 +}; +# 3144 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" +struct __nonesuchbase { }; +# 3147 +struct __nonesuch : private __nonesuchbase { +# 3148 +~__nonesuch() = delete; +# 3149 +__nonesuch(const __nonesuch &) = delete; +# 3150 +void operator=(const __nonesuch &) = delete; +# 3151 +}; +#pragma GCC diagnostic pop +# 3157 +template< class _Functor, class ..._ArgTypes> +# 3158 +struct invoke_result : public __invoke_result< _Functor, _ArgTypes...> { +# 3161 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Functor> {})), "_Functor must be a complete class or an unbounded array"); +# 3163 +static_assert(((std::__is_complete_or_unbounded(__type_identity< _ArgTypes> {}) && ... )), "each argument type must be a complete class or an unbounded array"); +# 3166 +}; +# 3169 +template< class _Fn, class ..._Args> using invoke_result_t = typename invoke_result< _Fn, _Args...> ::type; +# 3173 +template< class _Fn, class ..._ArgTypes> +# 3174 +struct is_invocable : public __is_invocable_impl< __invoke_result< _Fn, _ArgTypes...> , void> ::type { +# 3177 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Fn> {})), "_Fn must be a complete class or an unbounded array"); +# 3179 +static_assert(((std::__is_complete_or_unbounded(__type_identity< _ArgTypes> {}) && ... )), "each argument type must be a complete class or an unbounded array"); +# 3182 +}; +# 3185 +template< class _Ret, class _Fn, class ..._ArgTypes> +# 3186 +struct is_invocable_r : public __is_invocable_impl< __invoke_result< _Fn, _ArgTypes...> , _Ret> ::type { +# 3189 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Fn> {})), "_Fn must be a complete class or an unbounded array"); +# 3191 +static_assert(((std::__is_complete_or_unbounded(__type_identity< _ArgTypes> {}) && ... )), "each argument type must be a complete class or an unbounded array"); +# 3194 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Ret> {})), "_Ret must be a complete class or an unbounded array"); +# 3196 +}; +# 3199 +template< class _Fn, class ..._ArgTypes> +# 3200 +struct is_nothrow_invocable : public __and_< __is_invocable_impl< __invoke_result< _Fn, _ArgTypes...> , void> , __call_is_nothrow_< _Fn, _ArgTypes...> > ::type { +# 3204 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Fn> {})), "_Fn must be a complete class or an unbounded array"); +# 3206 +static_assert(((std::__is_complete_or_unbounded(__type_identity< _ArgTypes> {}) && ... )), "each argument type must be a complete class or an unbounded array"); +# 3209 +}; +# 3215 +template< class _Result, class _Ret> using __is_nt_invocable_impl = typename __is_invocable_impl< _Result, _Ret> ::__nothrow_conv; +# 3221 +template< class _Ret, class _Fn, class ..._ArgTypes> +# 3222 +struct is_nothrow_invocable_r : public __and_< __is_nt_invocable_impl< __invoke_result< _Fn, _ArgTypes...> , _Ret> , __call_is_nothrow_< _Fn, _ArgTypes...> > ::type { +# 3226 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Fn> {})), "_Fn must be a complete class or an unbounded array"); +# 3228 +static_assert(((std::__is_complete_or_unbounded(__type_identity< _ArgTypes> {}) && ... )), "each argument type must be a complete class or an unbounded array"); +# 3231 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Ret> {})), "_Ret must be a complete class or an unbounded array"); +# 3233 +}; +# 3251 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> constexpr inline bool +# 3252 +is_void_v = (is_void< _Tp> ::value); +# 3253 +template< class _Tp> constexpr inline bool +# 3254 +is_null_pointer_v = (is_null_pointer< _Tp> ::value); +# 3255 +template< class _Tp> constexpr inline bool +# 3256 +is_integral_v = (is_integral< _Tp> ::value); +# 3257 +template< class _Tp> constexpr inline bool +# 3258 +is_floating_point_v = (is_floating_point< _Tp> ::value); +# 3261 +template< class _Tp> constexpr inline bool +# 3262 +is_array_v = __is_array(_Tp); +# 3272 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> constexpr inline bool +# 3273 +is_pointer_v = (is_pointer< _Tp> ::value); +# 3274 +template< class _Tp> constexpr inline bool +# 3275 +is_lvalue_reference_v = false; +# 3276 +template< class _Tp> constexpr inline bool +# 3277 +is_lvalue_reference_v< _Tp &> = true; +# 3278 +template< class _Tp> constexpr inline bool +# 3279 +is_rvalue_reference_v = false; +# 3280 +template< class _Tp> constexpr inline bool +# 3281 +is_rvalue_reference_v< _Tp &&> = true; +# 3284 +template< class _Tp> constexpr inline bool +# 3285 +is_member_object_pointer_v = __is_member_object_pointer(_Tp); +# 3294 +template< class _Tp> constexpr inline bool +# 3295 +is_member_function_pointer_v = __is_member_function_pointer(_Tp); +# 3303 +template< class _Tp> constexpr inline bool +# 3304 +is_enum_v = __is_enum(_Tp); +# 3305 +template< class _Tp> constexpr inline bool +# 3306 +is_union_v = __is_union(_Tp); +# 3307 +template< class _Tp> constexpr inline bool +# 3308 +is_class_v = __is_class(_Tp); +# 3312 +template< class _Tp> constexpr inline bool +# 3313 +is_reference_v = __is_reference(_Tp); +# 3323 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> constexpr inline bool +# 3324 +is_arithmetic_v = (is_arithmetic< _Tp> ::value); +# 3325 +template< class _Tp> constexpr inline bool +# 3326 +is_fundamental_v = (is_fundamental< _Tp> ::value); +# 3329 +template< class _Tp> constexpr inline bool +# 3330 +is_object_v = __is_object(_Tp); +# 3336 +template< class _Tp> constexpr inline bool +# 3337 +is_scalar_v = (is_scalar< _Tp> ::value); +# 3338 +template< class _Tp> constexpr inline bool +# 3339 +is_compound_v = (!is_fundamental_v< _Tp> ); +# 3342 +template< class _Tp> constexpr inline bool +# 3343 +is_member_pointer_v = __is_member_pointer(_Tp); +# 3349 +template< class _Tp> constexpr inline bool +# 3350 +is_const_v = false; +# 3351 +template< class _Tp> constexpr inline bool +# 3352 +is_const_v< const _Tp> = true; +# 3355 +template< class _Tp> constexpr inline bool +# 3356 +is_function_v = __is_function(_Tp); +# 3366 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> constexpr inline bool +# 3367 +is_volatile_v = false; +# 3368 +template< class _Tp> constexpr inline bool +# 3369 +is_volatile_v< volatile _Tp> = true; +# 3371 +template< class _Tp> constexpr inline bool +# 3372 +is_trivial_v = __is_trivial(_Tp); +# 3373 +template< class _Tp> constexpr inline bool +# 3374 +is_trivially_copyable_v = __is_trivially_copyable(_Tp); +# 3375 +template< class _Tp> constexpr inline bool +# 3376 +is_standard_layout_v = __is_standard_layout(_Tp); +# 3377 +template< class _Tp> constexpr inline bool +# 3379 +is_pod_v = __is_pod(_Tp); +# 3380 +template< class _Tp> +# 3381 +[[__deprecated__]] constexpr inline bool +# 3382 +is_literal_type_v = __is_literal_type(_Tp); +# 3383 +template< class _Tp> constexpr inline bool +# 3384 +is_empty_v = __is_empty(_Tp); +# 3385 +template< class _Tp> constexpr inline bool +# 3386 +is_polymorphic_v = __is_polymorphic(_Tp); +# 3387 +template< class _Tp> constexpr inline bool +# 3388 +is_abstract_v = __is_abstract(_Tp); +# 3389 +template< class _Tp> constexpr inline bool +# 3390 +is_final_v = __is_final(_Tp); +# 3392 +template< class _Tp> constexpr inline bool +# 3393 +is_signed_v = (is_signed< _Tp> ::value); +# 3394 +template< class _Tp> constexpr inline bool +# 3395 +is_unsigned_v = (is_unsigned< _Tp> ::value); +# 3397 +template< class _Tp, class ..._Args> constexpr inline bool +# 3398 +is_constructible_v = __is_constructible(_Tp, _Args...); +# 3399 +template< class _Tp> constexpr inline bool +# 3400 +is_default_constructible_v = __is_constructible(_Tp); +# 3401 +template< class _Tp> constexpr inline bool +# 3402 +is_copy_constructible_v = __is_constructible(_Tp, __add_lval_ref_t< const _Tp> ); +# 3404 +template< class _Tp> constexpr inline bool +# 3405 +is_move_constructible_v = __is_constructible(_Tp, __add_rval_ref_t< _Tp> ); +# 3408 +template< class _Tp, class _Up> constexpr inline bool +# 3409 +is_assignable_v = __is_assignable(_Tp, _Up); +# 3410 +template< class _Tp> constexpr inline bool +# 3411 +is_copy_assignable_v = __is_assignable(__add_lval_ref_t< _Tp> , __add_lval_ref_t< const _Tp> ); +# 3413 +template< class _Tp> constexpr inline bool +# 3414 +is_move_assignable_v = __is_assignable(__add_lval_ref_t< _Tp> , __add_rval_ref_t< _Tp> ); +# 3417 +template< class _Tp> constexpr inline bool +# 3418 +is_destructible_v = (is_destructible< _Tp> ::value); +# 3420 +template< class _Tp, class ..._Args> constexpr inline bool +# 3421 +is_trivially_constructible_v = __is_trivially_constructible(_Tp, _Args...); +# 3423 +template< class _Tp> constexpr inline bool +# 3424 +is_trivially_default_constructible_v = __is_trivially_constructible(_Tp); +# 3426 +template< class _Tp> constexpr inline bool +# 3427 +is_trivially_copy_constructible_v = __is_trivially_constructible(_Tp, __add_lval_ref_t< const _Tp> ); +# 3429 +template< class _Tp> constexpr inline bool +# 3430 +is_trivially_move_constructible_v = __is_trivially_constructible(_Tp, __add_rval_ref_t< _Tp> ); +# 3433 +template< class _Tp, class _Up> constexpr inline bool +# 3434 +is_trivially_assignable_v = __is_trivially_assignable(_Tp, _Up); +# 3436 +template< class _Tp> constexpr inline bool +# 3437 +is_trivially_copy_assignable_v = __is_trivially_assignable(__add_lval_ref_t< _Tp> , __add_lval_ref_t< const _Tp> ); +# 3440 +template< class _Tp> constexpr inline bool +# 3441 +is_trivially_move_assignable_v = __is_trivially_assignable(__add_lval_ref_t< _Tp> , __add_rval_ref_t< _Tp> ); +# 3461 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> constexpr inline bool +# 3462 +is_trivially_destructible_v = (is_trivially_destructible< _Tp> ::value); +# 3466 +template< class _Tp, class ..._Args> constexpr inline bool +# 3467 +is_nothrow_constructible_v = __is_nothrow_constructible(_Tp, _Args...); +# 3469 +template< class _Tp> constexpr inline bool +# 3470 +is_nothrow_default_constructible_v = __is_nothrow_constructible(_Tp); +# 3472 +template< class _Tp> constexpr inline bool +# 3473 +is_nothrow_copy_constructible_v = __is_nothrow_constructible(_Tp, __add_lval_ref_t< const _Tp> ); +# 3475 +template< class _Tp> constexpr inline bool +# 3476 +is_nothrow_move_constructible_v = __is_nothrow_constructible(_Tp, __add_rval_ref_t< _Tp> ); +# 3479 +template< class _Tp, class _Up> constexpr inline bool +# 3480 +is_nothrow_assignable_v = __is_nothrow_assignable(_Tp, _Up); +# 3482 +template< class _Tp> constexpr inline bool +# 3483 +is_nothrow_copy_assignable_v = __is_nothrow_assignable(__add_lval_ref_t< _Tp> , __add_lval_ref_t< const _Tp> ); +# 3486 +template< class _Tp> constexpr inline bool +# 3487 +is_nothrow_move_assignable_v = __is_nothrow_assignable(__add_lval_ref_t< _Tp> , __add_rval_ref_t< _Tp> ); +# 3490 +template< class _Tp> constexpr inline bool +# 3491 +is_nothrow_destructible_v = (is_nothrow_destructible< _Tp> ::value); +# 3494 +template< class _Tp> constexpr inline bool +# 3495 +has_virtual_destructor_v = __has_virtual_destructor(_Tp); +# 3498 +template< class _Tp> constexpr inline size_t +# 3499 +alignment_of_v = (alignment_of< _Tp> ::value); +# 3501 +template< class _Tp> constexpr inline size_t +# 3502 +rank_v = (0); +# 3503 +template< class _Tp, size_t _Size> constexpr inline size_t +# 3504 +rank_v< _Tp [_Size]> = 1 + rank_v< _Tp> ; +# 3505 +template< class _Tp> constexpr inline size_t +# 3506 +rank_v< _Tp []> = 1 + rank_v< _Tp> ; +# 3508 +template< class _Tp, unsigned _Idx = 0U> constexpr inline size_t +# 3509 +extent_v = (0); +# 3510 +template< class _Tp, size_t _Size> constexpr inline size_t +# 3511 +extent_v< _Tp [_Size], 0> = _Size; +# 3512 +template< class _Tp, unsigned _Idx, size_t _Size> constexpr inline size_t +# 3513 +extent_v< _Tp [_Size], _Idx> = extent_v< _Tp, _Idx - (1)> ; +# 3514 +template< class _Tp> constexpr inline size_t +# 3515 +extent_v< _Tp [], 0> = (0); +# 3516 +template< class _Tp, unsigned _Idx> constexpr inline size_t +# 3517 +extent_v< _Tp [], _Idx> = extent_v< _Tp, _Idx - (1)> ; +# 3520 +template< class _Tp, class _Up> constexpr inline bool +# 3521 +is_same_v = __is_same(_Tp, _Up); +# 3528 +template< class _Base, class _Derived> constexpr inline bool +# 3529 +is_base_of_v = __is_base_of(_Base, _Derived); +# 3531 +template< class _From, class _To> constexpr inline bool +# 3532 +is_convertible_v = __is_convertible(_From, _To); +# 3537 +template< class _Fn, class ..._Args> constexpr inline bool +# 3538 +is_invocable_v = (is_invocable< _Fn, _Args...> ::value); +# 3539 +template< class _Fn, class ..._Args> constexpr inline bool +# 3540 +is_nothrow_invocable_v = (is_nothrow_invocable< _Fn, _Args...> ::value); +# 3542 +template< class _Ret, class _Fn, class ..._Args> constexpr inline bool +# 3543 +is_invocable_r_v = (is_invocable_r< _Ret, _Fn, _Args...> ::value); +# 3545 +template< class _Ret, class _Fn, class ..._Args> constexpr inline bool +# 3546 +is_nothrow_invocable_r_v = (is_nothrow_invocable_r< _Ret, _Fn, _Args...> ::value); +# 3554 +template< class _Tp> +# 3555 +struct has_unique_object_representations : public bool_constant< __has_unique_object_representations(remove_cv_t< remove_all_extents_t< _Tp> > )> { +# 3560 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 3562 +}; +# 3566 +template< class _Tp> constexpr inline bool +# 3567 +has_unique_object_representations_v = (has_unique_object_representations< _Tp> ::value); +# 3575 +template< class _Tp> +# 3576 +struct is_aggregate : public bool_constant< __is_aggregate(remove_cv_t< _Tp> )> { +# 3578 +}; +# 3585 +template< class _Tp> constexpr inline bool +# 3586 +is_aggregate_v = __is_aggregate(remove_cv_t< _Tp> ); +# 4018 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +} +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 49 +template< class _Tp> constexpr _Tp * +# 51 +__addressof(_Tp &__r) noexcept +# 52 +{ return __builtin_addressof(__r); } +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 +template< class _Tp> +# 69 +[[__nodiscard__]] constexpr _Tp && +# 71 +forward(typename remove_reference< _Tp> ::type &__t) noexcept +# 72 +{ return static_cast< _Tp &&>(__t); } +# 81 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 +template< class _Tp> +# 82 +[[__nodiscard__]] constexpr _Tp && +# 84 +forward(typename remove_reference< _Tp> ::type &&__t) noexcept +# 85 +{ +# 86 +static_assert((!std::template is_lvalue_reference< _Tp> ::value), "std::forward must not be used to convert an rvalue to an lvalue"); +# 88 +return static_cast< _Tp &&>(__t); +# 89 +} +# 134 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 +template< class _Tp> +# 135 +[[__nodiscard__]] constexpr typename remove_reference< _Tp> ::type && +# 137 +move(_Tp &&__t) noexcept +# 138 +{ return static_cast< typename remove_reference< _Tp> ::type &&>(__t); } +# 141 +template< class _Tp> +# 142 +struct __move_if_noexcept_cond : public __and_< __not_< is_nothrow_move_constructible< _Tp> > , is_copy_constructible< _Tp> > ::type { +# 144 +}; +# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 +template< class _Tp> +# 156 +[[__nodiscard__]] constexpr __conditional_t< __move_if_noexcept_cond< _Tp> ::value, const _Tp &, _Tp &&> +# 159 +move_if_noexcept(_Tp &__x) noexcept +# 160 +{ return std::move(__x); } +# 172 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 +template< class _Tp> +# 173 +[[__nodiscard__]] constexpr _Tp * +# 175 +addressof(_Tp &__r) noexcept +# 176 +{ return std::__addressof(__r); } +# 180 +template < typename _Tp > + const _Tp * addressof ( const _Tp && ) = delete; +# 184 +template< class _Tp, class _Up = _Tp> inline _Tp +# 187 +__exchange(_Tp &__obj, _Up &&__new_val) +# 188 +{ +# 189 +_Tp __old_val = std::move(__obj); +# 190 +__obj = std::forward< _Up> (__new_val); +# 191 +return __old_val; +# 192 +} +# 216 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 +template< class _Tp> inline typename enable_if< __and_< __not_< __is_tuple_like< _Tp> > , is_move_constructible< _Tp> , is_move_assignable< _Tp> > ::value> ::type +# 226 +swap(_Tp &__a, _Tp &__b) noexcept(__and_< is_nothrow_move_constructible< _Tp> , is_nothrow_move_assignable< _Tp> > ::value) +# 229 +{ +# 234 +_Tp __tmp = std::move(__a); +# 235 +__a = std::move(__b); +# 236 +__b = std::move(__tmp); +# 237 +} +# 242 +template< class _Tp, size_t _Nm> inline typename enable_if< __is_swappable< _Tp> ::value> ::type +# 250 +swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) noexcept(__is_nothrow_swappable< _Tp> ::value) +# 252 +{ +# 253 +for (size_t __n = (0); __n < _Nm; ++__n) { +# 254 +swap(__a[__n], __b[__n]); } +# 255 +} +# 259 +} +# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 48 +template< class _Tp> struct tuple_size; +# 55 +template< class _Tp, class +# 56 +_Up = typename remove_cv< _Tp> ::type, class +# 57 + = typename enable_if< is_same< _Tp, _Up> ::value> ::type, size_t +# 58 + = tuple_size< _Tp> ::value> using __enable_if_has_tuple_size = _Tp; +# 61 +template< class _Tp> +# 62 +struct tuple_size< const __enable_if_has_tuple_size< _Tp> > : public std::tuple_size< _Tp> { +# 63 +}; +# 65 +template< class _Tp> +# 66 +struct tuple_size< volatile __enable_if_has_tuple_size< _Tp> > : public std::tuple_size< _Tp> { +# 67 +}; +# 69 +template< class _Tp> +# 70 +struct tuple_size< const volatile __enable_if_has_tuple_size< _Tp> > : public std::tuple_size< _Tp> { +# 71 +}; +# 74 +template< class _Tp> constexpr inline size_t +# 75 +tuple_size_v = (tuple_size< _Tp> ::value); +# 79 +template< size_t __i, class _Tp> struct tuple_element; +# 83 +template< size_t __i, class _Tp> using __tuple_element_t = typename tuple_element< __i, _Tp> ::type; +# 86 +template< size_t __i, class _Tp> +# 87 +struct tuple_element< __i, const _Tp> { +# 89 +using type = const __tuple_element_t< __i, _Tp> ; +# 90 +}; +# 92 +template< size_t __i, class _Tp> +# 93 +struct tuple_element< __i, volatile _Tp> { +# 95 +using type = volatile __tuple_element_t< __i, _Tp> ; +# 96 +}; +# 98 +template< size_t __i, class _Tp> +# 99 +struct tuple_element< __i, const volatile _Tp> { +# 101 +using type = const volatile __tuple_element_t< __i, _Tp> ; +# 102 +}; +# 108 +template< class _Tp, class ..._Types> constexpr size_t +# 110 +__find_uniq_type_in_pack() +# 111 +{ +# 112 +constexpr size_t __sz = sizeof...(_Types); +# 113 +constexpr bool __found[__sz] = {__is_same(_Tp, _Types)...}; +# 114 +size_t __n = __sz; +# 115 +for (size_t __i = (0); __i < __sz; ++__i) +# 116 +{ +# 117 +if (__found[__i]) +# 118 +{ +# 119 +if (__n < __sz) { +# 120 +return __sz; } +# 121 +__n = __i; +# 122 +} +# 123 +} +# 124 +return __n; +# 125 +} +# 134 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 +template< size_t __i, class _Tp> using tuple_element_t = typename tuple_element< __i, _Tp> ::type; +# 140 +template< size_t ..._Indexes> struct _Index_tuple { }; +# 143 +template< size_t _Num> +# 144 +struct _Build_index_tuple { +# 154 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 +using __type = _Index_tuple< __integer_pack(_Num)...> ; +# 156 +}; +# 161 +template< class _Tp, _Tp ..._Idx> +# 162 +struct integer_sequence { +# 167 +typedef _Tp value_type; +# 168 +static constexpr size_t size() noexcept { return sizeof...(_Idx); } +# 169 +}; +# 172 +template< class _Tp, _Tp _Num> using make_integer_sequence = integer_sequence< _Tp, __integer_pack(_Num)...> ; +# 181 +template< size_t ..._Idx> using index_sequence = integer_sequence< unsigned long, _Idx...> ; +# 185 +template< size_t _Num> using make_index_sequence = make_integer_sequence< unsigned long, _Num> ; +# 189 +template< class ..._Types> using index_sequence_for = make_index_sequence< sizeof...(_Types)> ; +# 195 +struct in_place_t { +# 196 +explicit in_place_t() = default; +# 197 +}; +# 199 +constexpr inline in_place_t in_place{}; +# 201 +template< class _Tp> struct in_place_type_t { +# 203 +explicit in_place_type_t() = default; +# 204 +}; +# 206 +template< class _Tp> constexpr inline in_place_type_t< _Tp> +# 207 +in_place_type{}; +# 209 +template< size_t _Idx> struct in_place_index_t { +# 211 +explicit in_place_index_t() = default; +# 212 +}; +# 214 +template< size_t _Idx> constexpr inline in_place_index_t< _Idx> +# 215 +in_place_index{}; +# 217 +template< class > constexpr inline bool +# 218 +__is_in_place_type_v = false; +# 220 +template< class _Tp> constexpr inline bool +# 221 +__is_in_place_type_v< in_place_type_t< _Tp> > = true; +# 223 +template< class _Tp> using __is_in_place_type = bool_constant< __is_in_place_type_v< _Tp> > ; +# 226 +template< class > constexpr inline bool +# 227 +__is_in_place_index_v = false; +# 229 +template< size_t _Nm> constexpr inline bool +# 230 +__is_in_place_index_v< in_place_index_t< _Nm> > = true; +# 235 +template< size_t _Np, class ..._Types> +# 236 +struct _Nth_type { +# 237 +using type = __type_pack_element< _Np, _Types...> ; }; +# 284 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 +} +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +struct piecewise_construct_t { explicit piecewise_construct_t() = default;}; +# 82 +constexpr inline piecewise_construct_t piecewise_construct = piecewise_construct_t(); +# 88 +template< class _T1, class _T2> struct pair; +# 91 +template< class ...> class tuple; +# 98 +template< class _Tp, size_t _Nm> struct array; +# 101 +template< size_t ...> struct _Index_tuple; +# 104 +template< size_t _Int, class _Tp1, class _Tp2> constexpr typename tuple_element< _Int, pair< _Tp1, _Tp2> > ::type &get(pair< _Tp1, _Tp2> & __in) noexcept; +# 108 +template< size_t _Int, class _Tp1, class _Tp2> constexpr typename tuple_element< _Int, pair< _Tp1, _Tp2> > ::type &&get(pair< _Tp1, _Tp2> && __in) noexcept; +# 112 +template< size_t _Int, class _Tp1, class _Tp2> constexpr const typename tuple_element< _Int, pair< _Tp1, _Tp2> > ::type &get(const pair< _Tp1, _Tp2> & __in) noexcept; +# 116 +template< size_t _Int, class _Tp1, class _Tp2> constexpr const typename tuple_element< _Int, pair< _Tp1, _Tp2> > ::type &&get(const pair< _Tp1, _Tp2> && __in) noexcept; +# 120 +template< size_t __i, class ..._Elements> constexpr __tuple_element_t< __i, tuple< _Elements...> > &get(tuple< _Elements...> & __t) noexcept; +# 124 +template< size_t __i, class ..._Elements> constexpr const __tuple_element_t< __i, tuple< _Elements...> > &get(const tuple< _Elements...> & __t) noexcept; +# 128 +template< size_t __i, class ..._Elements> constexpr __tuple_element_t< __i, tuple< _Elements...> > &&get(tuple< _Elements...> && __t) noexcept; +# 132 +template< size_t __i, class ..._Elements> constexpr const __tuple_element_t< __i, tuple< _Elements...> > &&get(const tuple< _Elements...> && __t) noexcept; +# 136 +template< size_t _Int, class _Tp, size_t _Nm> constexpr _Tp &get(array< _Tp, _Nm> &) noexcept; +# 140 +template< size_t _Int, class _Tp, size_t _Nm> constexpr _Tp &&get(array< _Tp, _Nm> &&) noexcept; +# 144 +template< size_t _Int, class _Tp, size_t _Nm> constexpr const _Tp &get(const array< _Tp, _Nm> &) noexcept; +# 148 +template< size_t _Int, class _Tp, size_t _Nm> constexpr const _Tp &&get(const array< _Tp, _Nm> &&) noexcept; +# 158 +template< bool , class _T1, class _T2> +# 159 +struct _PCC { +# 161 +template< class _U1, class _U2> static constexpr bool +# 162 +_ConstructiblePair() +# 163 +{ +# 164 +return __and_< is_constructible< _T1, const _U1 &> , is_constructible< _T2, const _U2 &> > ::value; +# 166 +} +# 168 +template< class _U1, class _U2> static constexpr bool +# 169 +_ImplicitlyConvertiblePair() +# 170 +{ +# 171 +return __and_< is_convertible< const _U1 &, _T1> , is_convertible< const _U2 &, _T2> > ::value; +# 173 +} +# 175 +template< class _U1, class _U2> static constexpr bool +# 176 +_MoveConstructiblePair() +# 177 +{ +# 178 +return __and_< is_constructible< _T1, _U1 &&> , is_constructible< _T2, _U2 &&> > ::value; +# 180 +} +# 182 +template< class _U1, class _U2> static constexpr bool +# 183 +_ImplicitlyMoveConvertiblePair() +# 184 +{ +# 185 +return __and_< is_convertible< _U1 &&, _T1> , is_convertible< _U2 &&, _T2> > ::value; +# 187 +} +# 188 +}; +# 190 +template< class _T1, class _T2> +# 191 +struct _PCC< false, _T1, _T2> { +# 193 +template< class _U1, class _U2> static constexpr bool +# 194 +_ConstructiblePair() +# 195 +{ +# 196 +return false; +# 197 +} +# 199 +template< class _U1, class _U2> static constexpr bool +# 200 +_ImplicitlyConvertiblePair() +# 201 +{ +# 202 +return false; +# 203 +} +# 205 +template< class _U1, class _U2> static constexpr bool +# 206 +_MoveConstructiblePair() +# 207 +{ +# 208 +return false; +# 209 +} +# 211 +template< class _U1, class _U2> static constexpr bool +# 212 +_ImplicitlyMoveConvertiblePair() +# 213 +{ +# 214 +return false; +# 215 +} +# 216 +}; +# 260 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +template< class _U1, class _U2> class __pair_base { +# 263 +template< class _T1, class _T2> friend struct pair; +# 264 +__pair_base() = default; +# 265 +~__pair_base() = default; +# 266 +__pair_base(const __pair_base &) = default; +# 267 +__pair_base &operator=(const __pair_base &) = delete; +# 269 +}; +# 283 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +template< class _T1, class _T2> +# 284 +struct pair : public __pair_base< _T1, _T2> { +# 287 +typedef _T1 first_type; +# 288 +typedef _T2 second_type; +# 290 +_T1 first; +# 291 +_T2 second; +# 294 +constexpr pair(const pair &) = default; +# 295 +constexpr pair(pair &&) = default; +# 297 +template< class ..._Args1, class ..._Args2> pair(std::piecewise_construct_t, tuple< _Args1...> , tuple< _Args2...> ); +# 303 +void swap(pair &__p) noexcept(__and_< __is_nothrow_swappable< _T1> , __is_nothrow_swappable< _T2> > ::value) +# 306 +{ +# 307 +using std::swap; +# 308 +swap(first, __p.first); +# 309 +swap(second, __p.second); +# 310 +} +# 332 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +private: template< class ..._Args1, std::size_t ..._Indexes1, class ... +# 333 +_Args2, std::size_t ..._Indexes2> +# 332 +pair(tuple< _Args1...> &, tuple< _Args2...> &, _Index_tuple< _Indexes1...> , _Index_tuple< _Indexes2...> ); +# 725 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +public: +# 719 +template< class _U1 = _T1, class +# 720 +_U2 = _T2, typename enable_if< __and_< __is_implicitly_default_constructible< _U1> , __is_implicitly_default_constructible< _U2> > ::value, bool> ::type +# 724 + = true> constexpr +# 725 +pair() : first(), second() +# 726 +{ } +# 728 +template< class _U1 = _T1, class +# 729 +_U2 = _T2, typename enable_if< __and_< is_default_constructible< _U1> , is_default_constructible< _U2> , __not_< __and_< __is_implicitly_default_constructible< _U1> , __is_implicitly_default_constructible< _U2> > > > ::value, bool> ::type +# 736 + = false> constexpr explicit +# 737 +pair() : first(), second() +# 738 +{ } +# 742 +using _PCCP = _PCC< true, _T1, _T2> ; +# 746 +template< class _U1 = _T1, class _U2 = _T2, typename enable_if< _PCC< true, _T1, _T2> ::template _ConstructiblePair< _U1, _U2> () && _PCC< true, _T1, _T2> ::template _ImplicitlyConvertiblePair< _U1, _U2> (), bool> ::type +# 751 + = true> constexpr +# 752 +pair(const _T1 &__a, const _T2 &__b) : first(__a), second(__b) +# 753 +{ } +# 756 +template< class _U1 = _T1, class _U2 = _T2, typename enable_if< _PCC< true, _T1, _T2> ::template _ConstructiblePair< _U1, _U2> () && (!_PCC< true, _T1, _T2> ::template _ImplicitlyConvertiblePair< _U1, _U2> ()), bool> ::type +# 761 + = false> constexpr explicit +# 762 +pair(const _T1 &__a, const _T2 &__b) : first(__a), second(__b) +# 763 +{ } +# 767 +template< class _U1, class _U2> using _PCCFP = _PCC< (!is_same< _T1, _U1> ::value) || (!is_same< _T2, _U2> ::value), _T1, _T2> ; +# 773 +template< class _U1, class _U2, typename enable_if< _PCC< (!is_same< _T1, _U1> ::value) || (!is_same< _T2, _U2> ::value), _T1, _T2> ::template _ConstructiblePair< _U1, _U2> () && _PCC< (!is_same< _T1, _U1> ::value) || (!is_same< _T2, _U2> ::value), _T1, _T2> ::template _ImplicitlyConvertiblePair< _U1, _U2> (), bool> ::type +# 778 + = true> constexpr +# 779 +pair(const pair< _U1, _U2> &__p) : first((__p.first)), second((__p.second)) +# 781 +{ ; } +# 783 +template< class _U1, class _U2, typename enable_if< _PCC< (!is_same< _T1, _U1> ::value) || (!is_same< _T2, _U2> ::value), _T1, _T2> ::template _ConstructiblePair< _U1, _U2> () && (!_PCC< (!is_same< _T1, _U1> ::value) || (!is_same< _T2, _U2> ::value), _T1, _T2> ::template _ImplicitlyConvertiblePair< _U1, _U2> ()), bool> ::type +# 788 + = false> constexpr explicit +# 789 +pair(const pair< _U1, _U2> &__p) : first((__p.first)), second((__p.second)) +# 791 +{ ; } +# 807 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +private: struct __zero_as_null_pointer_constant { +# 809 +__zero_as_null_pointer_constant(int (__zero_as_null_pointer_constant::*)) +# 810 +{ } +# 811 +template < typename _Tp, + typename = __enable_if_t < is_null_pointer < _Tp > :: value > > + __zero_as_null_pointer_constant ( _Tp ) = delete; +# 814 +}; +# 830 +public: +# 821 +template< class _U1, std::__enable_if_t< __and_< __not_< is_reference< _U1> > , is_pointer< _T2> , is_constructible< _T1, _U1> , __not_< is_constructible< _T1, const _U1 &> > , is_convertible< _U1, _T1> > ::value, bool> +# 827 + = true> +# 828 +__attribute((__deprecated__("use \'nullptr\' instead of \'0\' to initialize std::pair of move-only type and pointer"))) constexpr +# 830 +pair(_U1 &&__x, __zero_as_null_pointer_constant, ...) : first(std::forward< _U1> (__x)), second(nullptr) +# 832 +{ ; } +# 834 +template< class _U1, std::__enable_if_t< __and_< __not_< is_reference< _U1> > , is_pointer< _T2> , is_constructible< _T1, _U1> , __not_< is_constructible< _T1, const _U1 &> > , __not_< is_convertible< _U1, _T1> > > ::value, bool> +# 840 + = false> +# 841 +__attribute((__deprecated__("use \'nullptr\' instead of \'0\' to initialize std::pair of move-only type and pointer"))) constexpr explicit +# 843 +pair(_U1 &&__x, __zero_as_null_pointer_constant, ...) : first(std::forward< _U1> (__x)), second(nullptr) +# 845 +{ ; } +# 847 +template< class _U2, std::__enable_if_t< __and_< is_pointer< _T1> , __not_< is_reference< _U2> > , is_constructible< _T2, _U2> , __not_< is_constructible< _T2, const _U2 &> > , is_convertible< _U2, _T2> > ::value, bool> +# 853 + = true> +# 854 +__attribute((__deprecated__("use \'nullptr\' instead of \'0\' to initialize std::pair of move-only type and pointer"))) constexpr +# 856 +pair(__zero_as_null_pointer_constant, _U2 &&__y, ...) : first(nullptr), second(std::forward< _U2> (__y)) +# 858 +{ ; } +# 860 +template< class _U2, std::__enable_if_t< __and_< is_pointer< _T1> , __not_< is_reference< _U2> > , is_constructible< _T2, _U2> , __not_< is_constructible< _T2, const _U2 &> > , __not_< is_convertible< _U2, _T2> > > ::value, bool> +# 866 + = false> +# 867 +__attribute((__deprecated__("use \'nullptr\' instead of \'0\' to initialize std::pair of move-only type and pointer"))) constexpr explicit +# 869 +pair(__zero_as_null_pointer_constant, _U2 &&__y, ...) : first(nullptr), second(std::forward< _U2> (__y)) +# 871 +{ ; } +# 875 +template< class _U1, class _U2, typename enable_if< _PCC< true, _T1, _T2> ::template _MoveConstructiblePair< _U1, _U2> () && _PCC< true, _T1, _T2> ::template _ImplicitlyMoveConvertiblePair< _U1, _U2> (), bool> ::type +# 880 + = true> constexpr +# 881 +pair(_U1 &&__x, _U2 &&__y) : first(std::forward< _U1> (__x)), second(std::forward< _U2> (__y)) +# 883 +{ ; } +# 885 +template< class _U1, class _U2, typename enable_if< _PCC< true, _T1, _T2> ::template _MoveConstructiblePair< _U1, _U2> () && (!_PCC< true, _T1, _T2> ::template _ImplicitlyMoveConvertiblePair< _U1, _U2> ()), bool> ::type +# 890 + = false> constexpr explicit +# 891 +pair(_U1 &&__x, _U2 &&__y) : first(std::forward< _U1> (__x)), second(std::forward< _U2> (__y)) +# 893 +{ ; } +# 896 +template< class _U1, class _U2, typename enable_if< _PCC< (!is_same< _T1, _U1> ::value) || (!is_same< _T2, _U2> ::value), _T1, _T2> ::template _MoveConstructiblePair< _U1, _U2> () && _PCC< (!is_same< _T1, _U1> ::value) || (!is_same< _T2, _U2> ::value), _T1, _T2> ::template _ImplicitlyMoveConvertiblePair< _U1, _U2> (), bool> ::type +# 901 + = true> constexpr +# 902 +pair(pair< _U1, _U2> &&__p) : first(std::forward< _U1> ((__p.first))), second(std::forward< _U2> ((__p.second))) +# 905 +{ ; } +# 907 +template< class _U1, class _U2, typename enable_if< _PCC< (!is_same< _T1, _U1> ::value) || (!is_same< _T2, _U2> ::value), _T1, _T2> ::template _MoveConstructiblePair< _U1, _U2> () && (!_PCC< (!is_same< _T1, _U1> ::value) || (!is_same< _T2, _U2> ::value), _T1, _T2> ::template _ImplicitlyMoveConvertiblePair< _U1, _U2> ()), bool> ::type +# 912 + = false> constexpr explicit +# 913 +pair(pair< _U1, _U2> &&__p) : first(std::forward< _U1> ((__p.first))), second(std::forward< _U2> ((__p.second))) +# 916 +{ ; } +# 921 +pair &operator=(std::__conditional_t< __and_< is_copy_assignable< _T1> , is_copy_assignable< _T2> > ::value, const pair &, const std::__nonesuch &> +# 923 +__p) +# 924 +{ +# 925 +(first) = (__p.first); +# 926 +(second) = (__p.second); +# 927 +return *this; +# 928 +} +# 931 +pair &operator=(std::__conditional_t< __and_< is_move_assignable< _T1> , is_move_assignable< _T2> > ::value, pair &&, std::__nonesuch &&> +# 933 +__p) noexcept(__and_< is_nothrow_move_assignable< _T1> , is_nothrow_move_assignable< _T2> > ::value) +# 936 +{ +# 937 +(first) = std::forward< first_type> ((__p.first)); +# 938 +(second) = std::forward< second_type> ((__p.second)); +# 939 +return *this; +# 940 +} +# 942 +template< class _U1, class _U2> typename enable_if< __and_< is_assignable< _T1 &, const _U1 &> , is_assignable< _T2 &, const _U2 &> > ::value, pair &> ::type +# 946 +operator=(const pair< _U1, _U2> &__p) +# 947 +{ +# 948 +(first) = (__p.first); +# 949 +(second) = (__p.second); +# 950 +return *this; +# 951 +} +# 953 +template< class _U1, class _U2> typename enable_if< __and_< is_assignable< _T1 &, _U1 &&> , is_assignable< _T2 &, _U2 &&> > ::value, pair &> ::type +# 957 +operator=(pair< _U1, _U2> &&__p) +# 958 +{ +# 959 +(first) = std::forward< _U1> ((__p.first)); +# 960 +(second) = std::forward< _U2> ((__p.second)); +# 961 +return *this; +# 962 +} +# 995 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +}; +# 1000 +template< class _T1, class _T2> pair(_T1, _T2)->pair< _T1, _T2> ; +# 1031 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +template< class _T1, class _T2> constexpr bool +# 1033 +operator==(const pair< _T1, _T2> &__x, const pair< _T1, _T2> &__y) +# 1034 +{ return ((__x.first) == (__y.first)) && ((__x.second) == (__y.second)); } +# 1043 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +template< class _T1, class _T2> constexpr bool +# 1045 +operator<(const pair< _T1, _T2> &__x, const pair< _T1, _T2> &__y) +# 1046 +{ return ((__x.first) < (__y.first)) || ((!((__y.first) < (__x.first))) && ((__x.second) < (__y.second))); +# 1047 +} +# 1050 +template< class _T1, class _T2> constexpr bool +# 1052 +operator!=(const pair< _T1, _T2> &__x, const pair< _T1, _T2> &__y) +# 1053 +{ return !(__x == __y); } +# 1056 +template< class _T1, class _T2> constexpr bool +# 1058 +operator>(const pair< _T1, _T2> &__x, const pair< _T1, _T2> &__y) +# 1059 +{ return __y < __x; } +# 1062 +template< class _T1, class _T2> constexpr bool +# 1064 +operator<=(const pair< _T1, _T2> &__x, const pair< _T1, _T2> &__y) +# 1065 +{ return !(__y < __x); } +# 1068 +template< class _T1, class _T2> constexpr bool +# 1070 +operator>=(const pair< _T1, _T2> &__x, const pair< _T1, _T2> &__y) +# 1071 +{ return !(__x < __y); } +# 1080 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +template< class _T1, class _T2> inline typename enable_if< __and_< __is_swappable< _T1> , __is_swappable< _T2> > ::value> ::type +# 1089 +swap(pair< _T1, _T2> &__x, pair< _T1, _T2> &__y) noexcept(noexcept(__x.swap(__y))) +# 1091 +{ __x.swap(__y); } +# 1103 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +template < typename _T1, typename _T2 > + typename enable_if < ! __and_ < __is_swappable < _T1 >, + __is_swappable < _T2 > > :: value > :: type + swap ( pair < _T1, _T2 > &, pair < _T1, _T2 > & ) = delete; +# 1129 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +template< class _T1, class _T2> constexpr pair< typename __decay_and_strip< _T1> ::__type, typename __decay_and_strip< _T2> ::__type> +# 1132 +make_pair(_T1 &&__x, _T2 &&__y) +# 1133 +{ +# 1134 +typedef typename __decay_and_strip< _T1> ::__type __ds_type1; +# 1135 +typedef typename __decay_and_strip< _T2> ::__type __ds_type2; +# 1136 +typedef pair< typename __decay_and_strip< _T1> ::__type, typename __decay_and_strip< _T2> ::__type> __pair_type; +# 1137 +return __pair_type(std::forward< _T1> (__x), std::forward< _T2> (__y)); +# 1138 +} +# 1152 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +template< class _T1, class _T2> +# 1153 +struct __is_tuple_like_impl< pair< _T1, _T2> > : public true_type { +# 1154 +}; +# 1158 +template< class _Tp1, class _Tp2> +# 1159 +struct tuple_size< pair< _Tp1, _Tp2> > : public integral_constant< unsigned long, 2UL> { +# 1160 +}; +# 1163 +template< class _Tp1, class _Tp2> +# 1164 +struct tuple_element< 0, pair< _Tp1, _Tp2> > { +# 1165 +typedef _Tp1 type; }; +# 1168 +template< class _Tp1, class _Tp2> +# 1169 +struct tuple_element< 1, pair< _Tp1, _Tp2> > { +# 1170 +typedef _Tp2 type; }; +# 1174 +template< size_t __i, class ..._Types> struct tuple_element< __i, tuple< _Types...> > ; +# 1178 +template< class _Tp1, class _Tp2> constexpr inline size_t +# 1179 +tuple_size_v< pair< _Tp1, _Tp2> > = (2); +# 1181 +template< class _Tp1, class _Tp2> constexpr inline size_t +# 1182 +tuple_size_v< const pair< _Tp1, _Tp2> > = (2); +# 1184 +template< class _Tp> constexpr inline bool +# 1185 +__is_pair = false; +# 1187 +template< class _Tp, class _Up> constexpr inline bool +# 1188 +__is_pair< pair< _Tp, _Up> > = true; +# 1192 +template< size_t _Int> struct __pair_get; +# 1196 +template<> struct __pair_get< 0UL> { +# 1198 +template< class _Tp1, class _Tp2> static constexpr _Tp1 & +# 1200 +__get(pair< _Tp1, _Tp2> &__pair) noexcept +# 1201 +{ return __pair.first; } +# 1203 +template< class _Tp1, class _Tp2> static constexpr _Tp1 && +# 1205 +__move_get(pair< _Tp1, _Tp2> &&__pair) noexcept +# 1206 +{ return std::forward< _Tp1> ((__pair.first)); } +# 1208 +template< class _Tp1, class _Tp2> static constexpr const _Tp1 & +# 1210 +__const_get(const pair< _Tp1, _Tp2> &__pair) noexcept +# 1211 +{ return __pair.first; } +# 1213 +template< class _Tp1, class _Tp2> static constexpr const _Tp1 && +# 1215 +__const_move_get(const pair< _Tp1, _Tp2> &&__pair) noexcept +# 1216 +{ return std::forward< const _Tp1> ((__pair.first)); } +# 1217 +}; +# 1220 +template<> struct __pair_get< 1UL> { +# 1222 +template< class _Tp1, class _Tp2> static constexpr _Tp2 & +# 1224 +__get(pair< _Tp1, _Tp2> &__pair) noexcept +# 1225 +{ return __pair.second; } +# 1227 +template< class _Tp1, class _Tp2> static constexpr _Tp2 && +# 1229 +__move_get(pair< _Tp1, _Tp2> &&__pair) noexcept +# 1230 +{ return std::forward< _Tp2> ((__pair.second)); } +# 1232 +template< class _Tp1, class _Tp2> static constexpr const _Tp2 & +# 1234 +__const_get(const pair< _Tp1, _Tp2> &__pair) noexcept +# 1235 +{ return __pair.second; } +# 1237 +template< class _Tp1, class _Tp2> static constexpr const _Tp2 && +# 1239 +__const_move_get(const pair< _Tp1, _Tp2> &&__pair) noexcept +# 1240 +{ return std::forward< const _Tp2> ((__pair.second)); } +# 1241 +}; +# 1248 +template< size_t _Int, class _Tp1, class _Tp2> constexpr typename tuple_element< _Int, pair< _Tp1, _Tp2> > ::type & +# 1250 +get(pair< _Tp1, _Tp2> &__in) noexcept +# 1251 +{ return __pair_get< _Int> ::__get(__in); } +# 1253 +template< size_t _Int, class _Tp1, class _Tp2> constexpr typename tuple_element< _Int, pair< _Tp1, _Tp2> > ::type && +# 1255 +get(pair< _Tp1, _Tp2> &&__in) noexcept +# 1256 +{ return __pair_get< _Int> ::__move_get(std::move(__in)); } +# 1258 +template< size_t _Int, class _Tp1, class _Tp2> constexpr const typename tuple_element< _Int, pair< _Tp1, _Tp2> > ::type & +# 1260 +get(const pair< _Tp1, _Tp2> &__in) noexcept +# 1261 +{ return __pair_get< _Int> ::__const_get(__in); } +# 1263 +template< size_t _Int, class _Tp1, class _Tp2> constexpr const typename tuple_element< _Int, pair< _Tp1, _Tp2> > ::type && +# 1265 +get(const pair< _Tp1, _Tp2> &&__in) noexcept +# 1266 +{ return __pair_get< _Int> ::__const_move_get(std::move(__in)); } +# 1270 +template< class _Tp, class _Up> constexpr _Tp & +# 1272 +get(pair< _Tp, _Up> &__p) noexcept +# 1273 +{ return __p.first; } +# 1275 +template< class _Tp, class _Up> constexpr const _Tp & +# 1277 +get(const pair< _Tp, _Up> &__p) noexcept +# 1278 +{ return __p.first; } +# 1280 +template< class _Tp, class _Up> constexpr _Tp && +# 1282 +get(pair< _Tp, _Up> &&__p) noexcept +# 1283 +{ return std::move((__p.first)); } +# 1285 +template< class _Tp, class _Up> constexpr const _Tp && +# 1287 +get(const pair< _Tp, _Up> &&__p) noexcept +# 1288 +{ return std::move((__p.first)); } +# 1290 +template< class _Tp, class _Up> constexpr _Tp & +# 1292 +get(pair< _Up, _Tp> &__p) noexcept +# 1293 +{ return __p.second; } +# 1295 +template< class _Tp, class _Up> constexpr const _Tp & +# 1297 +get(const pair< _Up, _Tp> &__p) noexcept +# 1298 +{ return __p.second; } +# 1300 +template< class _Tp, class _Up> constexpr _Tp && +# 1302 +get(pair< _Up, _Tp> &&__p) noexcept +# 1303 +{ return std::move((__p.second)); } +# 1305 +template< class _Tp, class _Up> constexpr const _Tp && +# 1307 +get(const pair< _Up, _Tp> &&__p) noexcept +# 1308 +{ return std::move((__p.second)); } +# 1333 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +} +# 74 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 93 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 +struct input_iterator_tag { }; +# 96 +struct output_iterator_tag { }; +# 99 +struct forward_iterator_tag : public input_iterator_tag { }; +# 103 +struct bidirectional_iterator_tag : public forward_iterator_tag { }; +# 107 +struct random_access_iterator_tag : public bidirectional_iterator_tag { }; +# 125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 +template< class _Category, class _Tp, class _Distance = ptrdiff_t, class +# 126 +_Pointer = _Tp *, class _Reference = _Tp &> +# 127 +struct [[__deprecated__]] iterator { +# 130 +typedef _Category iterator_category; +# 132 +typedef _Tp value_type; +# 134 +typedef _Distance difference_type; +# 136 +typedef _Pointer pointer; +# 138 +typedef _Reference reference; +# 139 +}; +# 149 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 +template< class _Iterator> struct iterator_traits; +# 155 +template< class _Iterator, class = __void_t< > > +# 156 +struct __iterator_traits { }; +# 160 +template< class _Iterator> +# 161 +struct __iterator_traits< _Iterator, __void_t< typename _Iterator::iterator_category, typename _Iterator::value_type, typename _Iterator::difference_type, typename _Iterator::pointer, typename _Iterator::reference> > { +# 168 +typedef typename _Iterator::iterator_category iterator_category; +# 169 +typedef typename _Iterator::value_type value_type; +# 170 +typedef typename _Iterator::difference_type difference_type; +# 171 +typedef typename _Iterator::pointer pointer; +# 172 +typedef typename _Iterator::reference reference; +# 173 +}; +# 176 +template< class _Iterator> +# 177 +struct iterator_traits : public __iterator_traits< _Iterator> { +# 178 +}; +# 209 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 +template< class _Tp> +# 210 +struct iterator_traits< _Tp *> { +# 212 +typedef random_access_iterator_tag iterator_category; +# 213 +typedef _Tp value_type; +# 214 +typedef ptrdiff_t difference_type; +# 215 +typedef _Tp *pointer; +# 216 +typedef _Tp &reference; +# 217 +}; +# 220 +template< class _Tp> +# 221 +struct iterator_traits< const _Tp *> { +# 223 +typedef random_access_iterator_tag iterator_category; +# 224 +typedef _Tp value_type; +# 225 +typedef ptrdiff_t difference_type; +# 226 +typedef const _Tp *pointer; +# 227 +typedef const _Tp &reference; +# 228 +}; +# 235 +template< class _Iter> +# 236 +__attribute((__always_inline__)) constexpr typename iterator_traits< _Iter> ::iterator_category +# 239 +__iterator_category(const _Iter &) +# 240 +{ return typename iterator_traits< _Iter> ::iterator_category(); } +# 245 +template< class _Iter> using __iter_category_t = typename iterator_traits< _Iter> ::iterator_category; +# 249 +template< class _InIter> using _RequireInputIter = __enable_if_t< is_convertible< __iter_category_t< _InIter> , input_iterator_tag> ::value> ; +# 254 +template< class _It, class +# 255 +_Cat = __iter_category_t< _It> > +# 256 +struct __is_random_access_iter : public is_base_of< random_access_iterator_tag, _Cat> { +# 259 +typedef is_base_of< std::random_access_iterator_tag, _Cat> _Base; +# 260 +enum { __value = is_base_of< std::random_access_iterator_tag, _Cat> ::value}; +# 261 +}; +# 270 +} +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 74 +template< class > struct _List_iterator; +# 75 +template< class > struct _List_const_iterator; +# 78 +template< class _InputIterator> constexpr typename iterator_traits< _InputIterator> ::difference_type +# 81 +__distance(_InputIterator __first, _InputIterator __last, input_iterator_tag) +# 83 +{ +# 87 +typename iterator_traits< _InputIterator> ::difference_type __n = (0); +# 88 +while (__first != __last) +# 89 +{ +# 90 +++__first; +# 91 +++__n; +# 92 +} +# 93 +return __n; +# 94 +} +# 96 +template< class _RandomAccessIterator> +# 97 +__attribute((__always_inline__)) constexpr typename iterator_traits< _RandomAccessIterator> ::difference_type +# 100 +__distance(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag) +# 102 +{ +# 106 +return __last - __first; +# 107 +} +# 111 +template< class _Tp> ptrdiff_t __distance(_List_iterator< _Tp> , _List_iterator< _Tp> , input_iterator_tag); +# 117 +template< class _Tp> ptrdiff_t __distance(_List_const_iterator< _Tp> , _List_const_iterator< _Tp> , input_iterator_tag); +# 126 +template < typename _OutputIterator > + void + __distance ( _OutputIterator, _OutputIterator, output_iterator_tag ) = delete; +# 144 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 +template< class _InputIterator> +# 145 +[[__nodiscard__]] __attribute((__always_inline__)) constexpr typename iterator_traits< _InputIterator> ::difference_type +# 148 +distance(_InputIterator __first, _InputIterator __last) +# 149 +{ +# 151 +return std::__distance(__first, __last, std::__iterator_category(__first)); +# 153 +} +# 155 +template< class _InputIterator, class _Distance> constexpr void +# 157 +__advance(_InputIterator &__i, _Distance __n, input_iterator_tag) +# 158 +{ +# 161 +do { if (std::__is_constant_evaluated() && (!((bool)(__n >= 0)))) { std::__glibcxx_assert_fail(); } } while (false); +# 162 +while (__n--) { +# 163 +++__i; } +# 164 +} +# 166 +template< class _BidirectionalIterator, class _Distance> constexpr void +# 168 +__advance(_BidirectionalIterator &__i, _Distance __n, bidirectional_iterator_tag) +# 170 +{ +# 174 +if (__n > 0) { +# 175 +while (__n--) { +# 176 +++__i; } } else { +# 178 +while (__n++) { +# 179 +--__i; } } +# 180 +} +# 182 +template< class _RandomAccessIterator, class _Distance> constexpr void +# 184 +__advance(_RandomAccessIterator &__i, _Distance __n, random_access_iterator_tag) +# 186 +{ +# 190 +if (__builtin_constant_p(__n) && (__n == 1)) { +# 191 +++__i; } else { +# 192 +if (__builtin_constant_p(__n) && (__n == (-1))) { +# 193 +--__i; } else { +# 195 +__i += __n; } } +# 196 +} +# 200 +template < typename _OutputIterator, typename _Distance > + void + __advance ( _OutputIterator &, _Distance, output_iterator_tag ) = delete; +# 217 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 +template< class _InputIterator, class _Distance> +# 218 +__attribute((__always_inline__)) constexpr void +# 220 +advance(_InputIterator &__i, _Distance __n) +# 221 +{ +# 223 +typename iterator_traits< _InputIterator> ::difference_type __d = __n; +# 224 +std::__advance(__i, __d, std::__iterator_category(__i)); +# 225 +} +# 229 +template< class _InputIterator> +# 230 +[[__nodiscard__]] [[__gnu__::__always_inline__]] constexpr _InputIterator +# 232 +next(_InputIterator __x, typename iterator_traits< _InputIterator> ::difference_type +# 233 +__n = 1) +# 234 +{ +# 237 +std::advance(__x, __n); +# 238 +return __x; +# 239 +} +# 241 +template< class _BidirectionalIterator> +# 242 +[[__nodiscard__]] [[__gnu__::__always_inline__]] constexpr _BidirectionalIterator +# 244 +prev(_BidirectionalIterator __x, typename iterator_traits< _BidirectionalIterator> ::difference_type +# 245 +__n = 1) +# 246 +{ +# 250 +std::advance(__x, -__n); +# 251 +return __x; +# 252 +} +# 257 +} +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/ptr_traits.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 48 +class __undefined; +# 52 +template< class _Tp> +# 53 +struct __get_first_arg { +# 54 +using type = __undefined; }; +# 56 +template< template< class , class ...> class _SomeTemplate, class _Tp, class ... +# 57 +_Types> +# 58 +struct __get_first_arg< _SomeTemplate< _Tp, _Types...> > { +# 59 +using type = _Tp; }; +# 63 +template< class _Tp, class _Up> +# 64 +struct __replace_first_arg { +# 65 +}; +# 67 +template< template< class , class ...> class _SomeTemplate, class _Up, class +# 68 +_Tp, class ..._Types> +# 69 +struct __replace_first_arg< _SomeTemplate< _Tp, _Types...> , _Up> { +# 70 +using type = _SomeTemplate< _Up, _Types...> ; }; +# 73 +template< class _Ptr, class = void> +# 74 +struct __ptr_traits_elem : public __get_first_arg< _Ptr> { +# 75 +}; +# 83 +template< class _Ptr> +# 84 +struct __ptr_traits_elem< _Ptr, __void_t< typename _Ptr::element_type> > { +# 85 +using type = typename _Ptr::element_type; }; +# 88 +template< class _Ptr> using __ptr_traits_elem_t = typename __ptr_traits_elem< _Ptr> ::type; +# 94 +template< class _Ptr, class _Elt, bool = is_void< _Elt> ::value> +# 95 +struct __ptr_traits_ptr_to { +# 97 +using pointer = _Ptr; +# 98 +using element_type = _Elt; +# 107 +static pointer pointer_to(element_type &__r) +# 113 +{ return pointer::pointer_to(__r); } +# 114 +}; +# 117 +template< class _Ptr, class _Elt> +# 118 +struct __ptr_traits_ptr_to< _Ptr, _Elt, true> { +# 119 +}; +# 122 +template< class _Tp> +# 123 +struct __ptr_traits_ptr_to< _Tp *, _Tp, false> { +# 125 +using pointer = _Tp *; +# 126 +using element_type = _Tp; +# 134 +static pointer pointer_to(element_type &__r) noexcept +# 135 +{ return std::addressof(__r); } +# 136 +}; +# 138 +template< class _Ptr, class _Elt> +# 139 +struct __ptr_traits_impl : public __ptr_traits_ptr_to< _Ptr, _Elt> { +# 143 +private: +# 142 +template< class _Tp> using __diff_t = typename _Tp::difference_type; +# 145 +template< class _Tp, class _Up> using __rebind = __type_identity< typename _Tp::template rebind< _Up> > ; +# 150 +public: using pointer = _Ptr; +# 153 +using element_type = _Elt; +# 156 +using difference_type = std::__detected_or_t< std::ptrdiff_t, __diff_t, _Ptr> ; +# 159 +template< class _Up> using rebind = typename std::__detected_or_t< __replace_first_arg< _Ptr, _Up> , __rebind, _Ptr, _Up> ::type; +# 162 +}; +# 166 +template< class _Ptr> +# 167 +struct __ptr_traits_impl< _Ptr, __undefined> { +# 168 +}; +# 176 +template< class _Ptr> +# 177 +struct pointer_traits : public __ptr_traits_impl< _Ptr, __ptr_traits_elem_t< _Ptr> > { +# 178 +}; +# 186 +template< class _Tp> +# 187 +struct pointer_traits< _Tp *> : public __ptr_traits_ptr_to< _Tp *, _Tp> { +# 190 +typedef _Tp *pointer; +# 192 +typedef _Tp element_type; +# 194 +typedef std::ptrdiff_t difference_type; +# 196 +template< class _Up> using rebind = _Up *; +# 197 +}; +# 200 +template< class _Ptr, class _Tp> using __ptr_rebind = typename pointer_traits< _Ptr> ::template rebind< _Tp> ; +# 203 +template< class _Tp> constexpr _Tp * +# 205 +__to_address(_Tp *__ptr) noexcept +# 206 +{ +# 207 +static_assert((!std::template is_function< _Tp> ::value), "not a function pointer"); +# 208 +return __ptr; +# 209 +} +# 212 +template< class _Ptr> constexpr typename pointer_traits< _Ptr> ::element_type * +# 214 +__to_address(const _Ptr &__ptr) +# 215 +{ return std::__to_address(__ptr.operator->()); } +# 258 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/ptr_traits.h" 3 +} +# 85 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 106 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 128 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Iterator> +# 129 +class reverse_iterator : public iterator< typename iterator_traits< _Iterator> ::iterator_category, typename iterator_traits< _Iterator> ::value_type, typename iterator_traits< _Iterator> ::difference_type, typename iterator_traits< _Iterator> ::pointer, typename iterator_traits< _Iterator> ::reference> { +# 136 +template< class _Iter> friend class reverse_iterator; +# 148 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +protected: _Iterator current; +# 150 +typedef iterator_traits< _Iterator> __traits_type; +# 153 +public: typedef _Iterator iterator_type; +# 154 +typedef typename iterator_traits< _Iterator> ::pointer pointer; +# 156 +typedef typename iterator_traits< _Iterator> ::difference_type difference_type; +# 157 +typedef typename iterator_traits< _Iterator> ::reference reference; +# 179 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +constexpr reverse_iterator() noexcept(noexcept((_Iterator()))) : current() +# 182 +{ } +# 188 +constexpr explicit reverse_iterator(iterator_type __x) noexcept(noexcept(((_Iterator)__x))) : current(__x) +# 191 +{ } +# 197 +constexpr reverse_iterator(const reverse_iterator &__x) noexcept(noexcept(((_Iterator)(__x.current)))) : current(__x.current) +# 200 +{ } +# 203 +reverse_iterator &operator=(const reverse_iterator &) = default; +# 210 +template< class _Iter> constexpr +# 215 +reverse_iterator(const reverse_iterator< _Iter> &__x) noexcept(noexcept(((_Iterator)(__x.current)))) : current((__x.current)) +# 218 +{ } +# 221 +template< class _Iter> constexpr reverse_iterator & +# 228 +operator=(const reverse_iterator< _Iter> &__x) noexcept(noexcept(((current) = (__x.current)))) +# 230 +{ +# 231 +(current) = (__x.current); +# 232 +return *this; +# 233 +} +# 239 +[[__nodiscard__]] constexpr iterator_type +# 241 +base() const noexcept(noexcept(((_Iterator)(current)))) +# 243 +{ return current; } +# 255 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +[[__nodiscard__]] constexpr reference +# 257 +operator*() const +# 258 +{ +# 259 +_Iterator __tmp = current; +# 260 +return *(--__tmp); +# 261 +} +# 268 +[[__nodiscard__]] constexpr pointer +# 270 +operator->() const +# 275 +{ +# 278 +_Iterator __tmp = current; +# 279 +--__tmp; +# 280 +return _S_to_pointer(__tmp); +# 281 +} +# 289 +constexpr reverse_iterator &operator++() +# 290 +{ +# 291 +--(current); +# 292 +return *this; +# 293 +} +# 301 +constexpr reverse_iterator operator++(int) +# 302 +{ +# 303 +reverse_iterator __tmp = *this; +# 304 +--(current); +# 305 +return __tmp; +# 306 +} +# 314 +constexpr reverse_iterator &operator--() +# 315 +{ +# 316 +++(current); +# 317 +return *this; +# 318 +} +# 326 +constexpr reverse_iterator operator--(int) +# 327 +{ +# 328 +reverse_iterator __tmp = *this; +# 329 +++(current); +# 330 +return __tmp; +# 331 +} +# 338 +[[__nodiscard__]] constexpr reverse_iterator +# 340 +operator+(difference_type __n) const +# 341 +{ return ((reverse_iterator)((current) - __n)); } +# 350 +constexpr reverse_iterator &operator+=(difference_type __n) +# 351 +{ +# 352 +(current) -= __n; +# 353 +return *this; +# 354 +} +# 361 +[[__nodiscard__]] constexpr reverse_iterator +# 363 +operator-(difference_type __n) const +# 364 +{ return ((reverse_iterator)((current) + __n)); } +# 373 +constexpr reverse_iterator &operator-=(difference_type __n) +# 374 +{ +# 375 +(current) += __n; +# 376 +return *this; +# 377 +} +# 384 +[[__nodiscard__]] constexpr reference +# 386 +operator[](difference_type __n) const +# 387 +{ return *((*this) + __n); } +# 418 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +private: +# 416 +template< class _Tp> static constexpr _Tp * +# 418 +_S_to_pointer(_Tp *__p) +# 419 +{ return __p; } +# 421 +template< class _Tp> static constexpr pointer +# 423 +_S_to_pointer(_Tp __t) +# 424 +{ return __t.operator->(); } +# 425 +}; +# 438 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Iterator> +# 439 +[[__nodiscard__]] constexpr bool +# 441 +operator==(const reverse_iterator< _Iterator> &__x, const reverse_iterator< _Iterator> & +# 442 +__y) +# 443 +{ return __x.base() == __y.base(); } +# 445 +template< class _Iterator> +# 446 +[[__nodiscard__]] constexpr bool +# 448 +operator<(const reverse_iterator< _Iterator> &__x, const reverse_iterator< _Iterator> & +# 449 +__y) +# 450 +{ return __y.base() < __x.base(); } +# 452 +template< class _Iterator> +# 453 +[[__nodiscard__]] constexpr bool +# 455 +operator!=(const reverse_iterator< _Iterator> &__x, const reverse_iterator< _Iterator> & +# 456 +__y) +# 457 +{ return !(__x == __y); } +# 459 +template< class _Iterator> +# 460 +[[__nodiscard__]] constexpr bool +# 462 +operator>(const reverse_iterator< _Iterator> &__x, const reverse_iterator< _Iterator> & +# 463 +__y) +# 464 +{ return __y < __x; } +# 466 +template< class _Iterator> +# 467 +[[__nodiscard__]] constexpr bool +# 469 +operator<=(const reverse_iterator< _Iterator> &__x, const reverse_iterator< _Iterator> & +# 470 +__y) +# 471 +{ return !(__y < __x); } +# 473 +template< class _Iterator> +# 474 +[[__nodiscard__]] constexpr bool +# 476 +operator>=(const reverse_iterator< _Iterator> &__x, const reverse_iterator< _Iterator> & +# 477 +__y) +# 478 +{ return !(__x < __y); } +# 483 +template< class _IteratorL, class _IteratorR> +# 484 +[[__nodiscard__]] constexpr bool +# 486 +operator==(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 487 +__y) +# 488 +{ return __x.base() == __y.base(); } +# 490 +template< class _IteratorL, class _IteratorR> +# 491 +[[__nodiscard__]] constexpr bool +# 493 +operator<(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 494 +__y) +# 495 +{ return __x.base() > __y.base(); } +# 497 +template< class _IteratorL, class _IteratorR> +# 498 +[[__nodiscard__]] constexpr bool +# 500 +operator!=(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 501 +__y) +# 502 +{ return __x.base() != __y.base(); } +# 504 +template< class _IteratorL, class _IteratorR> +# 505 +[[__nodiscard__]] constexpr bool +# 507 +operator>(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 508 +__y) +# 509 +{ return __x.base() < __y.base(); } +# 511 +template< class _IteratorL, class _IteratorR> constexpr bool +# 513 +operator<=(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 514 +__y) +# 515 +{ return __x.base() >= __y.base(); } +# 517 +template< class _IteratorL, class _IteratorR> +# 518 +[[__nodiscard__]] constexpr bool +# 520 +operator>=(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 521 +__y) +# 522 +{ return __x.base() <= __y.base(); } +# 615 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _IteratorL, class _IteratorR> +# 616 +[[__nodiscard__]] constexpr auto +# 618 +operator-(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 619 +__y)->__decltype((__y.base() - __x.base())) +# 621 +{ return __y.base() - __x.base(); } +# 624 +template< class _Iterator> +# 625 +[[__nodiscard__]] constexpr reverse_iterator< _Iterator> +# 627 +operator+(typename reverse_iterator< _Iterator> ::difference_type __n, const reverse_iterator< _Iterator> & +# 628 +__x) +# 629 +{ return ((reverse_iterator< _Iterator> )(__x.base() - __n)); } +# 633 +template< class _Iterator> constexpr reverse_iterator< _Iterator> +# 635 +__make_reverse_iterator(_Iterator __i) +# 636 +{ return ((reverse_iterator< _Iterator> )(__i)); } +# 642 +template< class _Iterator> +# 643 +[[__nodiscard__]] constexpr reverse_iterator< _Iterator> +# 645 +make_reverse_iterator(_Iterator __i) +# 646 +{ return ((reverse_iterator< _Iterator> )(__i)); } +# 657 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Iterator> auto +# 660 +__niter_base(reverse_iterator< _Iterator> __it)->__decltype((__make_reverse_iterator(__niter_base(__it.base())))) +# 662 +{ return __make_reverse_iterator(__niter_base(__it.base())); } +# 664 +template< class _Iterator> +# 665 +struct __is_move_iterator< reverse_iterator< _Iterator> > : public std::__is_move_iterator< _Iterator> { +# 667 +}; +# 669 +template< class _Iterator> auto +# 672 +__miter_base(reverse_iterator< _Iterator> __it)->__decltype((__make_reverse_iterator(__miter_base(__it.base())))) +# 674 +{ return __make_reverse_iterator(__miter_base(__it.base())); } +# 688 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Container> +# 689 +class back_insert_iterator : public iterator< output_iterator_tag, void, void, void, void> { +# 693 +protected: _Container *container; +# 697 +public: typedef _Container container_type; +# 704 +explicit back_insert_iterator(_Container &__x) : container(std::__addressof(__x)) +# 705 +{ } +# 728 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +back_insert_iterator &operator=(const typename _Container::value_type &__value) +# 729 +{ +# 730 +(container)->push_back(__value); +# 731 +return *this; +# 732 +} +# 736 +back_insert_iterator &operator=(typename _Container::value_type &&__value) +# 737 +{ +# 738 +(container)->push_back(std::move(__value)); +# 739 +return *this; +# 740 +} +# 744 +[[__nodiscard__]] back_insert_iterator & +# 746 +operator*() +# 747 +{ return *this; } +# 752 +back_insert_iterator &operator++() +# 753 +{ return *this; } +# 758 +back_insert_iterator operator++(int) +# 759 +{ return *this; } +# 760 +}; +# 773 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Container> +# 774 +[[__nodiscard__]] inline back_insert_iterator< _Container> +# 776 +back_inserter(_Container &__x) +# 777 +{ return ((back_insert_iterator< _Container> )(__x)); } +# 789 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Container> +# 790 +class front_insert_iterator : public iterator< output_iterator_tag, void, void, void, void> { +# 794 +protected: _Container *container; +# 798 +public: typedef _Container container_type; +# 805 +explicit front_insert_iterator(_Container &__x) : container(std::__addressof(__x)) +# 806 +{ } +# 829 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +front_insert_iterator &operator=(const typename _Container::value_type &__value) +# 830 +{ +# 831 +(container)->push_front(__value); +# 832 +return *this; +# 833 +} +# 837 +front_insert_iterator &operator=(typename _Container::value_type &&__value) +# 838 +{ +# 839 +(container)->push_front(std::move(__value)); +# 840 +return *this; +# 841 +} +# 845 +[[__nodiscard__]] front_insert_iterator & +# 847 +operator*() +# 848 +{ return *this; } +# 853 +front_insert_iterator &operator++() +# 854 +{ return *this; } +# 859 +front_insert_iterator operator++(int) +# 860 +{ return *this; } +# 861 +}; +# 874 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Container> +# 875 +[[__nodiscard__]] inline front_insert_iterator< _Container> +# 877 +front_inserter(_Container &__x) +# 878 +{ return ((front_insert_iterator< _Container> )(__x)); } +# 894 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Container> +# 895 +class insert_iterator : public iterator< output_iterator_tag, void, void, void, void> { +# 901 +typedef typename _Container::iterator _Iter; +# 904 +protected: _Container *container; +# 905 +_Iter iter; +# 909 +public: typedef _Container container_type; +# 920 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +insert_iterator(_Container &__x, _Iter __i) : container(std::__addressof(__x)), iter(__i) +# 921 +{ } +# 957 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +insert_iterator &operator=(const typename _Container::value_type &__value) +# 958 +{ +# 959 +(iter) = (container)->insert(iter, __value); +# 960 +++(iter); +# 961 +return *this; +# 962 +} +# 966 +insert_iterator &operator=(typename _Container::value_type &&__value) +# 967 +{ +# 968 +(iter) = (container)->insert(iter, std::move(__value)); +# 969 +++(iter); +# 970 +return *this; +# 971 +} +# 975 +[[__nodiscard__]] insert_iterator & +# 977 +operator*() +# 978 +{ return *this; } +# 983 +insert_iterator &operator++() +# 984 +{ return *this; } +# 989 +insert_iterator &operator++(int) +# 990 +{ return *this; } +# 991 +}; +# 993 +#pragma GCC diagnostic pop +# 1014 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Container> +# 1015 +[[__nodiscard__]] inline insert_iterator< _Container> +# 1017 +inserter(_Container &__x, typename _Container::iterator __i) +# 1018 +{ return insert_iterator< _Container> (__x, __i); } +# 1024 +} +# 1026 +namespace __gnu_cxx __attribute((__visibility__("default"))) { +# 1037 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Iterator, class _Container> +# 1038 +class __normal_iterator { +# 1041 +protected: _Iterator _M_current; +# 1043 +typedef std::iterator_traits< _Iterator> __traits_type; +# 1046 +template< class _Iter> using __convertible_from = std::__enable_if_t< std::is_convertible< _Iter, _Iterator> ::value> ; +# 1052 +public: typedef _Iterator iterator_type; +# 1053 +typedef typename std::iterator_traits< _Iterator> ::iterator_category iterator_category; +# 1054 +typedef typename std::iterator_traits< _Iterator> ::value_type value_type; +# 1055 +typedef typename std::iterator_traits< _Iterator> ::difference_type difference_type; +# 1056 +typedef typename std::iterator_traits< _Iterator> ::reference reference; +# 1057 +typedef typename std::iterator_traits< _Iterator> ::pointer pointer; +# 1063 +constexpr __normal_iterator() noexcept : _M_current(_Iterator()) +# 1064 +{ } +# 1067 +explicit __normal_iterator(const _Iterator &__i) noexcept : _M_current(__i) +# 1068 +{ } +# 1072 +template< class _Iter, class = __convertible_from< _Iter> > +# 1074 +__normal_iterator(const __normal_iterator< _Iter, _Container> &__i) noexcept : _M_current(__i.base()) +# 1085 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +{ } +# 1090 +reference operator*() const noexcept +# 1091 +{ return *(_M_current); } +# 1095 +pointer operator->() const noexcept +# 1096 +{ return _M_current; } +# 1100 +__normal_iterator &operator++() noexcept +# 1101 +{ +# 1102 +++(_M_current); +# 1103 +return *this; +# 1104 +} +# 1108 +__normal_iterator operator++(int) noexcept +# 1109 +{ return ((__normal_iterator)((_M_current)++)); } +# 1114 +__normal_iterator &operator--() noexcept +# 1115 +{ +# 1116 +--(_M_current); +# 1117 +return *this; +# 1118 +} +# 1122 +__normal_iterator operator--(int) noexcept +# 1123 +{ return ((__normal_iterator)((_M_current)--)); } +# 1128 +reference operator[](difference_type __n) const noexcept +# 1129 +{ return (_M_current)[__n]; } +# 1133 +__normal_iterator &operator+=(difference_type __n) noexcept +# 1134 +{ (_M_current) += __n; return *this; } +# 1138 +__normal_iterator operator+(difference_type __n) const noexcept +# 1139 +{ return ((__normal_iterator)((_M_current) + __n)); } +# 1143 +__normal_iterator &operator-=(difference_type __n) noexcept +# 1144 +{ (_M_current) -= __n; return *this; } +# 1148 +__normal_iterator operator-(difference_type __n) const noexcept +# 1149 +{ return ((__normal_iterator)((_M_current) - __n)); } +# 1153 +const _Iterator &base() const noexcept +# 1154 +{ return _M_current; } +# 1155 +}; +# 1205 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _IteratorL, class _IteratorR, class _Container> +# 1206 +[[__nodiscard__]] inline bool +# 1208 +operator==(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1209 +__rhs) noexcept +# 1211 +{ return __lhs.base() == __rhs.base(); } +# 1213 +template< class _Iterator, class _Container> +# 1214 +[[__nodiscard__]] inline bool +# 1216 +operator==(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1217 +__rhs) noexcept +# 1219 +{ return __lhs.base() == __rhs.base(); } +# 1221 +template< class _IteratorL, class _IteratorR, class _Container> +# 1222 +[[__nodiscard__]] inline bool +# 1224 +operator!=(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1225 +__rhs) noexcept +# 1227 +{ return __lhs.base() != __rhs.base(); } +# 1229 +template< class _Iterator, class _Container> +# 1230 +[[__nodiscard__]] inline bool +# 1232 +operator!=(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1233 +__rhs) noexcept +# 1235 +{ return __lhs.base() != __rhs.base(); } +# 1238 +template< class _IteratorL, class _IteratorR, class _Container> +# 1239 +[[__nodiscard__]] inline bool +# 1241 +operator<(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1242 +__rhs) noexcept +# 1244 +{ return __lhs.base() < __rhs.base(); } +# 1246 +template< class _Iterator, class _Container> +# 1247 +[[__nodiscard__]] inline bool +# 1249 +operator<(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1250 +__rhs) noexcept +# 1252 +{ return __lhs.base() < __rhs.base(); } +# 1254 +template< class _IteratorL, class _IteratorR, class _Container> +# 1255 +[[__nodiscard__]] inline bool +# 1257 +operator>(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1258 +__rhs) noexcept +# 1260 +{ return __lhs.base() > __rhs.base(); } +# 1262 +template< class _Iterator, class _Container> +# 1263 +[[__nodiscard__]] inline bool +# 1265 +operator>(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1266 +__rhs) noexcept +# 1268 +{ return __lhs.base() > __rhs.base(); } +# 1270 +template< class _IteratorL, class _IteratorR, class _Container> +# 1271 +[[__nodiscard__]] inline bool +# 1273 +operator<=(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1274 +__rhs) noexcept +# 1276 +{ return __lhs.base() <= __rhs.base(); } +# 1278 +template< class _Iterator, class _Container> +# 1279 +[[__nodiscard__]] inline bool +# 1281 +operator<=(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1282 +__rhs) noexcept +# 1284 +{ return __lhs.base() <= __rhs.base(); } +# 1286 +template< class _IteratorL, class _IteratorR, class _Container> +# 1287 +[[__nodiscard__]] inline bool +# 1289 +operator>=(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1290 +__rhs) noexcept +# 1292 +{ return __lhs.base() >= __rhs.base(); } +# 1294 +template< class _Iterator, class _Container> +# 1295 +[[__nodiscard__]] inline bool +# 1297 +operator>=(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1298 +__rhs) noexcept +# 1300 +{ return __lhs.base() >= __rhs.base(); } +# 1307 +template< class _IteratorL, class _IteratorR, class _Container> +# 1310 +[[__nodiscard__]] inline auto +# 1312 +operator-(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1313 +__rhs) noexcept->__decltype((__lhs.base() - __rhs.base())) +# 1320 +{ return __lhs.base() - __rhs.base(); } +# 1322 +template< class _Iterator, class _Container> +# 1323 +[[__nodiscard__]] inline typename __normal_iterator< _Iterator, _Container> ::difference_type +# 1325 +operator-(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1326 +__rhs) noexcept +# 1328 +{ return __lhs.base() - __rhs.base(); } +# 1330 +template< class _Iterator, class _Container> +# 1331 +[[__nodiscard__]] inline __normal_iterator< _Iterator, _Container> +# 1333 +operator+(typename __normal_iterator< _Iterator, _Container> ::difference_type +# 1334 +__n, const __normal_iterator< _Iterator, _Container> &__i) noexcept +# 1336 +{ return ((__normal_iterator< _Iterator, _Container> )(__i.base() + __n)); } +# 1339 +} +# 1341 +namespace std __attribute((__visibility__("default"))) { +# 1345 +template< class _Iterator, class _Container> _Iterator +# 1348 +__niter_base(__gnu_cxx::__normal_iterator< _Iterator, _Container> __it) noexcept(std::template is_nothrow_copy_constructible< _Iterator> ::value) +# 1350 +{ return __it.base(); } +# 1357 +template< class _Iterator, class _Container> constexpr auto +# 1359 +__to_address(const __gnu_cxx::__normal_iterator< _Iterator, _Container> & +# 1360 +__it) noexcept->__decltype((std::__to_address(__it.base()))) +# 1362 +{ return std::__to_address(__it.base()); } +# 1412 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +namespace __detail { +# 1428 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +} +# 1439 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Iterator> +# 1440 +class move_iterator { +# 1445 +_Iterator _M_current; +# 1447 +using __traits_type = iterator_traits< _Iterator> ; +# 1449 +using __base_ref = typename iterator_traits< _Iterator> ::reference; +# 1452 +template< class _Iter2> friend class move_iterator; +# 1479 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +public: using iterator_type = _Iterator; +# 1490 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +typedef typename iterator_traits< _Iterator> ::iterator_category iterator_category; +# 1491 +typedef typename iterator_traits< _Iterator> ::value_type value_type; +# 1492 +typedef typename iterator_traits< _Iterator> ::difference_type difference_type; +# 1494 +typedef _Iterator pointer; +# 1497 +using reference = __conditional_t< is_reference< __base_ref> ::value, typename remove_reference< __base_ref> ::type &&, __base_ref> ; +# 1504 +constexpr move_iterator() : _M_current() +# 1505 +{ } +# 1508 +constexpr explicit move_iterator(iterator_type __i) : _M_current(std::move(__i)) +# 1509 +{ } +# 1511 +template< class _Iter> constexpr +# 1516 +move_iterator(const move_iterator< _Iter> &__i) : _M_current((__i._M_current)) +# 1517 +{ } +# 1519 +template< class _Iter> constexpr move_iterator & +# 1525 +operator=(const move_iterator< _Iter> &__i) +# 1526 +{ +# 1527 +(_M_current) = (__i._M_current); +# 1528 +return *this; +# 1529 +} +# 1532 +[[__nodiscard__]] constexpr iterator_type +# 1534 +base() const +# 1535 +{ return _M_current; } +# 1548 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +[[__nodiscard__]] constexpr reference +# 1550 +operator*() const +# 1554 +{ return static_cast< reference>(*(_M_current)); } +# 1557 +[[__nodiscard__]] constexpr pointer +# 1559 +operator->() const +# 1560 +{ return _M_current; } +# 1563 +constexpr move_iterator &operator++() +# 1564 +{ +# 1565 +++(_M_current); +# 1566 +return *this; +# 1567 +} +# 1570 +constexpr move_iterator operator++(int) +# 1571 +{ +# 1572 +move_iterator __tmp = *this; +# 1573 +++(_M_current); +# 1574 +return __tmp; +# 1575 +} +# 1584 +constexpr move_iterator &operator--() +# 1585 +{ +# 1586 +--(_M_current); +# 1587 +return *this; +# 1588 +} +# 1591 +constexpr move_iterator operator--(int) +# 1592 +{ +# 1593 +move_iterator __tmp = *this; +# 1594 +--(_M_current); +# 1595 +return __tmp; +# 1596 +} +# 1598 +[[__nodiscard__]] constexpr move_iterator +# 1600 +operator+(difference_type __n) const +# 1601 +{ return ((move_iterator)((_M_current) + __n)); } +# 1604 +constexpr move_iterator &operator+=(difference_type __n) +# 1605 +{ +# 1606 +(_M_current) += __n; +# 1607 +return *this; +# 1608 +} +# 1610 +[[__nodiscard__]] constexpr move_iterator +# 1612 +operator-(difference_type __n) const +# 1613 +{ return ((move_iterator)((_M_current) - __n)); } +# 1616 +constexpr move_iterator &operator-=(difference_type __n) +# 1617 +{ +# 1618 +(_M_current) -= __n; +# 1619 +return *this; +# 1620 +} +# 1622 +[[__nodiscard__]] constexpr reference +# 1624 +operator[](difference_type __n) const +# 1628 +{ return std::move((_M_current)[__n]); } +# 1662 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +}; +# 1664 +template< class _IteratorL, class _IteratorR> +# 1665 +[[__nodiscard__]] constexpr bool +# 1667 +operator==(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1668 +__y) +# 1672 +{ return __x.base() == __y.base(); } +# 1683 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _IteratorL, class _IteratorR> +# 1684 +[[__nodiscard__]] constexpr bool +# 1686 +operator!=(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1687 +__y) +# 1688 +{ return !(__x == __y); } +# 1691 +template< class _IteratorL, class _IteratorR> +# 1692 +[[__nodiscard__]] constexpr bool +# 1694 +operator<(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1695 +__y) +# 1699 +{ return __x.base() < __y.base(); } +# 1701 +template< class _IteratorL, class _IteratorR> +# 1702 +[[__nodiscard__]] constexpr bool +# 1704 +operator<=(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1705 +__y) +# 1709 +{ return !(__y < __x); } +# 1711 +template< class _IteratorL, class _IteratorR> +# 1712 +[[__nodiscard__]] constexpr bool +# 1714 +operator>(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1715 +__y) +# 1719 +{ return __y < __x; } +# 1721 +template< class _IteratorL, class _IteratorR> +# 1722 +[[__nodiscard__]] constexpr bool +# 1724 +operator>=(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1725 +__y) +# 1729 +{ return !(__x < __y); } +# 1734 +template< class _Iterator> +# 1735 +[[__nodiscard__]] constexpr bool +# 1737 +operator==(const move_iterator< _Iterator> &__x, const move_iterator< _Iterator> & +# 1738 +__y) +# 1740 +{ return __x.base() == __y.base(); } +# 1750 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Iterator> +# 1751 +[[__nodiscard__]] constexpr bool +# 1753 +operator!=(const move_iterator< _Iterator> &__x, const move_iterator< _Iterator> & +# 1754 +__y) +# 1755 +{ return !(__x == __y); } +# 1757 +template< class _Iterator> +# 1758 +[[__nodiscard__]] constexpr bool +# 1760 +operator<(const move_iterator< _Iterator> &__x, const move_iterator< _Iterator> & +# 1761 +__y) +# 1762 +{ return __x.base() < __y.base(); } +# 1764 +template< class _Iterator> +# 1765 +[[__nodiscard__]] constexpr bool +# 1767 +operator<=(const move_iterator< _Iterator> &__x, const move_iterator< _Iterator> & +# 1768 +__y) +# 1769 +{ return !(__y < __x); } +# 1771 +template< class _Iterator> +# 1772 +[[__nodiscard__]] constexpr bool +# 1774 +operator>(const move_iterator< _Iterator> &__x, const move_iterator< _Iterator> & +# 1775 +__y) +# 1776 +{ return __y < __x; } +# 1778 +template< class _Iterator> +# 1779 +[[__nodiscard__]] constexpr bool +# 1781 +operator>=(const move_iterator< _Iterator> &__x, const move_iterator< _Iterator> & +# 1782 +__y) +# 1783 +{ return !(__x < __y); } +# 1787 +template< class _IteratorL, class _IteratorR> +# 1788 +[[__nodiscard__]] constexpr auto +# 1790 +operator-(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1791 +__y)->__decltype((__x.base() - __y.base())) +# 1793 +{ return __x.base() - __y.base(); } +# 1795 +template< class _Iterator> +# 1796 +[[__nodiscard__]] constexpr move_iterator< _Iterator> +# 1798 +operator+(typename move_iterator< _Iterator> ::difference_type __n, const move_iterator< _Iterator> & +# 1799 +__x) +# 1803 +{ return __x + __n; } +# 1805 +template< class _Iterator> +# 1806 +[[__nodiscard__]] constexpr move_iterator< _Iterator> +# 1808 +make_move_iterator(_Iterator __i) +# 1809 +{ return ((move_iterator< _Iterator> )(std::move(__i))); } +# 1811 +template< class _Iterator, class _ReturnType = __conditional_t< __move_if_noexcept_cond< typename iterator_traits< _Iterator> ::value_type> ::value, _Iterator, move_iterator< _Iterator> > > constexpr _ReturnType +# 1816 +__make_move_if_noexcept_iterator(_Iterator __i) +# 1817 +{ return (_ReturnType)__i; } +# 1821 +template< class _Tp, class _ReturnType = __conditional_t< __move_if_noexcept_cond< _Tp> ::value, const _Tp *, move_iterator< _Tp *> > > constexpr _ReturnType +# 1825 +__make_move_if_noexcept_iterator(_Tp *__i) +# 1826 +{ return (_ReturnType)__i; } +# 2964 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Iterator> auto +# 2967 +__niter_base(move_iterator< _Iterator> __it)->__decltype((make_move_iterator(__niter_base(__it.base())))) +# 2969 +{ return make_move_iterator(__niter_base(__it.base())); } +# 2971 +template< class _Iterator> +# 2972 +struct __is_move_iterator< move_iterator< _Iterator> > { +# 2974 +enum { __value = 1}; +# 2975 +typedef __true_type __type; +# 2976 +}; +# 2978 +template< class _Iterator> auto +# 2981 +__miter_base(move_iterator< _Iterator> __it)->__decltype((__miter_base(__it.base()))) +# 2983 +{ return __miter_base(__it.base()); } +# 2996 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _InputIterator> using __iter_key_t = remove_const_t< typename iterator_traits< _InputIterator> ::value_type::first_type> ; +# 3004 +template< class _InputIterator> using __iter_val_t = typename iterator_traits< _InputIterator> ::value_type::second_type; +# 3012 +template< class _T1, class _T2> struct pair; +# 3015 +template< class _InputIterator> using __iter_to_alloc_t = pair< const __iter_key_t< _InputIterator> , __iter_val_t< _InputIterator> > ; +# 3021 +} +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/debug/debug.h" 3 +namespace std { +# 50 +namespace __debug { } +# 51 +} +# 56 +namespace __gnu_debug { +# 58 +using namespace std::__debug; +# 60 +template< class _Ite, class _Seq, class _Cat> struct _Safe_iterator; +# 62 +} +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/predefined_ops.h" 3 +namespace __gnu_cxx { +# 37 +namespace __ops { +# 39 +struct _Iter_less_iter { +# 41 +template< class _Iterator1, class _Iterator2> constexpr bool +# 44 +operator()(_Iterator1 __it1, _Iterator2 __it2) const +# 45 +{ return (*__it1) < (*__it2); } +# 46 +}; +# 50 +constexpr _Iter_less_iter __iter_less_iter() +# 51 +{ return _Iter_less_iter(); } +# 53 +struct _Iter_less_val { +# 56 +constexpr _Iter_less_val() = default; +# 63 +explicit _Iter_less_val(_Iter_less_iter) { } +# 65 +template< class _Iterator, class _Value> bool +# 68 +operator()(_Iterator __it, _Value &__val) const +# 69 +{ return (*__it) < __val; } +# 70 +}; +# 74 +inline _Iter_less_val __iter_less_val() +# 75 +{ return _Iter_less_val(); } +# 79 +inline _Iter_less_val __iter_comp_val(_Iter_less_iter) +# 80 +{ return _Iter_less_val(); } +# 82 +struct _Val_less_iter { +# 85 +constexpr _Val_less_iter() = default; +# 92 +explicit _Val_less_iter(_Iter_less_iter) { } +# 94 +template< class _Value, class _Iterator> bool +# 97 +operator()(_Value &__val, _Iterator __it) const +# 98 +{ return __val < (*__it); } +# 99 +}; +# 103 +inline _Val_less_iter __val_less_iter() +# 104 +{ return _Val_less_iter(); } +# 108 +inline _Val_less_iter __val_comp_iter(_Iter_less_iter) +# 109 +{ return _Val_less_iter(); } +# 111 +struct _Iter_equal_to_iter { +# 113 +template< class _Iterator1, class _Iterator2> bool +# 116 +operator()(_Iterator1 __it1, _Iterator2 __it2) const +# 117 +{ return (*__it1) == (*__it2); } +# 118 +}; +# 122 +inline _Iter_equal_to_iter __iter_equal_to_iter() +# 123 +{ return _Iter_equal_to_iter(); } +# 125 +struct _Iter_equal_to_val { +# 127 +template< class _Iterator, class _Value> bool +# 130 +operator()(_Iterator __it, _Value &__val) const +# 131 +{ return (*__it) == __val; } +# 132 +}; +# 136 +inline _Iter_equal_to_val __iter_equal_to_val() +# 137 +{ return _Iter_equal_to_val(); } +# 141 +inline _Iter_equal_to_val __iter_comp_val(_Iter_equal_to_iter) +# 142 +{ return _Iter_equal_to_val(); } +# 144 +template< class _Compare> +# 145 +struct _Iter_comp_iter { +# 147 +_Compare _M_comp; +# 150 +constexpr explicit _Iter_comp_iter(_Compare __comp) : _M_comp(std::move(__comp)) +# 152 +{ } +# 154 +template< class _Iterator1, class _Iterator2> constexpr bool +# 157 +operator()(_Iterator1 __it1, _Iterator2 __it2) +# 158 +{ return (bool)(_M_comp)(*__it1, *__it2); } +# 159 +}; +# 161 +template< class _Compare> constexpr _Iter_comp_iter< _Compare> +# 164 +__iter_comp_iter(_Compare __comp) +# 165 +{ return ((_Iter_comp_iter< _Compare> )(std::move(__comp))); } +# 167 +template< class _Compare> +# 168 +struct _Iter_comp_val { +# 170 +_Compare _M_comp; +# 174 +explicit _Iter_comp_val(_Compare __comp) : _M_comp(std::move(__comp)) +# 176 +{ } +# 180 +explicit _Iter_comp_val(const _Iter_comp_iter< _Compare> &__comp) : _M_comp((__comp._M_comp)) +# 182 +{ } +# 187 +explicit _Iter_comp_val(_Iter_comp_iter< _Compare> &&__comp) : _M_comp(std::move((__comp._M_comp))) +# 189 +{ } +# 192 +template< class _Iterator, class _Value> bool +# 195 +operator()(_Iterator __it, _Value &__val) +# 196 +{ return (bool)(_M_comp)(*__it, __val); } +# 197 +}; +# 199 +template< class _Compare> inline _Iter_comp_val< _Compare> +# 202 +__iter_comp_val(_Compare __comp) +# 203 +{ return ((_Iter_comp_val< _Compare> )(std::move(__comp))); } +# 205 +template< class _Compare> inline _Iter_comp_val< _Compare> +# 208 +__iter_comp_val(_Iter_comp_iter< _Compare> __comp) +# 209 +{ return ((_Iter_comp_val< _Compare> )(std::move(__comp))); } +# 211 +template< class _Compare> +# 212 +struct _Val_comp_iter { +# 214 +_Compare _M_comp; +# 218 +explicit _Val_comp_iter(_Compare __comp) : _M_comp(std::move(__comp)) +# 220 +{ } +# 224 +explicit _Val_comp_iter(const _Iter_comp_iter< _Compare> &__comp) : _M_comp((__comp._M_comp)) +# 226 +{ } +# 231 +explicit _Val_comp_iter(_Iter_comp_iter< _Compare> &&__comp) : _M_comp(std::move((__comp._M_comp))) +# 233 +{ } +# 236 +template< class _Value, class _Iterator> bool +# 239 +operator()(_Value &__val, _Iterator __it) +# 240 +{ return (bool)(_M_comp)(__val, *__it); } +# 241 +}; +# 243 +template< class _Compare> inline _Val_comp_iter< _Compare> +# 246 +__val_comp_iter(_Compare __comp) +# 247 +{ return ((_Val_comp_iter< _Compare> )(std::move(__comp))); } +# 249 +template< class _Compare> inline _Val_comp_iter< _Compare> +# 252 +__val_comp_iter(_Iter_comp_iter< _Compare> __comp) +# 253 +{ return ((_Val_comp_iter< _Compare> )(std::move(__comp))); } +# 255 +template< class _Value> +# 256 +struct _Iter_equals_val { +# 258 +_Value &_M_value; +# 262 +explicit _Iter_equals_val(_Value &__value) : _M_value(__value) +# 264 +{ } +# 266 +template< class _Iterator> bool +# 269 +operator()(_Iterator __it) +# 270 +{ return (*__it) == (_M_value); } +# 271 +}; +# 273 +template< class _Value> inline _Iter_equals_val< _Value> +# 276 +__iter_equals_val(_Value &__val) +# 277 +{ return ((_Iter_equals_val< _Value> )(__val)); } +# 279 +template< class _Iterator1> +# 280 +struct _Iter_equals_iter { +# 282 +_Iterator1 _M_it1; +# 286 +explicit _Iter_equals_iter(_Iterator1 __it1) : _M_it1(__it1) +# 288 +{ } +# 290 +template< class _Iterator2> bool +# 293 +operator()(_Iterator2 __it2) +# 294 +{ return (*__it2) == (*(_M_it1)); } +# 295 +}; +# 297 +template< class _Iterator> inline _Iter_equals_iter< _Iterator> +# 300 +__iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) +# 301 +{ return ((_Iter_equals_iter< _Iterator> )(__it)); } +# 303 +template< class _Predicate> +# 304 +struct _Iter_pred { +# 306 +_Predicate _M_pred; +# 310 +explicit _Iter_pred(_Predicate __pred) : _M_pred(std::move(__pred)) +# 312 +{ } +# 314 +template< class _Iterator> bool +# 317 +operator()(_Iterator __it) +# 318 +{ return (bool)(_M_pred)(*__it); } +# 319 +}; +# 321 +template< class _Predicate> inline _Iter_pred< _Predicate> +# 324 +__pred_iter(_Predicate __pred) +# 325 +{ return ((_Iter_pred< _Predicate> )(std::move(__pred))); } +# 327 +template< class _Compare, class _Value> +# 328 +struct _Iter_comp_to_val { +# 330 +_Compare _M_comp; +# 331 +_Value &_M_value; +# 334 +_Iter_comp_to_val(_Compare __comp, _Value &__value) : _M_comp(std::move(__comp)), _M_value(__value) +# 336 +{ } +# 338 +template< class _Iterator> bool +# 341 +operator()(_Iterator __it) +# 342 +{ return (bool)(_M_comp)(*__it, _M_value); } +# 343 +}; +# 345 +template< class _Compare, class _Value> _Iter_comp_to_val< _Compare, _Value> +# 348 +__iter_comp_val(_Compare __comp, _Value &__val) +# 349 +{ +# 350 +return _Iter_comp_to_val< _Compare, _Value> (std::move(__comp), __val); +# 351 +} +# 353 +template< class _Compare, class _Iterator1> +# 354 +struct _Iter_comp_to_iter { +# 356 +_Compare _M_comp; +# 357 +_Iterator1 _M_it1; +# 360 +_Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) : _M_comp(std::move(__comp)), _M_it1(__it1) +# 362 +{ } +# 364 +template< class _Iterator2> bool +# 367 +operator()(_Iterator2 __it2) +# 368 +{ return (bool)(_M_comp)(*__it2, *(_M_it1)); } +# 369 +}; +# 371 +template< class _Compare, class _Iterator> inline _Iter_comp_to_iter< _Compare, _Iterator> +# 374 +__iter_comp_iter(_Iter_comp_iter< _Compare> __comp, _Iterator __it) +# 375 +{ +# 376 +return _Iter_comp_to_iter< _Compare, _Iterator> (std::move((__comp._M_comp)), __it); +# 378 +} +# 380 +template< class _Predicate> +# 381 +struct _Iter_negate { +# 383 +_Predicate _M_pred; +# 387 +explicit _Iter_negate(_Predicate __pred) : _M_pred(std::move(__pred)) +# 389 +{ } +# 391 +template< class _Iterator> bool +# 394 +operator()(_Iterator __it) +# 395 +{ return !((bool)(_M_pred)(*__it)); } +# 396 +}; +# 398 +template< class _Predicate> inline _Iter_negate< _Predicate> +# 401 +__negate(_Iter_pred< _Predicate> __pred) +# 402 +{ return ((_Iter_negate< _Predicate> )(std::move((__pred._M_pred)))); } +# 404 +} +# 405 +} +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 +namespace std __attribute((__visibility__("default"))) { +# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 +template< class _Tp> constexpr _Tp +# 157 +__rotl(_Tp __x, int __s) noexcept +# 158 +{ +# 159 +constexpr auto _Nd = (__gnu_cxx::__int_traits< _Tp> ::__digits); +# 160 +if constexpr ((_Nd & (_Nd - 1)) == 0) +# 161 +{ +# 164 +constexpr unsigned __uNd = (_Nd); +# 165 +const unsigned __r = __s; +# 166 +return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd)); +# 167 +} +# 168 +const int __r = __s % _Nd; +# 169 +if (__r == 0) { +# 170 +return __x; } else { +# 171 +if (__r > 0) { +# 172 +return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); } else { +# 174 +return (__x >> (-__r)) | (__x << ((_Nd + __r) % _Nd)); } } +# 175 +} +# 177 +template< class _Tp> constexpr _Tp +# 179 +__rotr(_Tp __x, int __s) noexcept +# 180 +{ +# 181 +constexpr auto _Nd = (__gnu_cxx::__int_traits< _Tp> ::__digits); +# 182 +if constexpr ((_Nd & (_Nd - 1)) == 0) +# 183 +{ +# 186 +constexpr unsigned __uNd = (_Nd); +# 187 +const unsigned __r = __s; +# 188 +return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd)); +# 189 +} +# 190 +const int __r = __s % _Nd; +# 191 +if (__r == 0) { +# 192 +return __x; } else { +# 193 +if (__r > 0) { +# 194 +return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); } else { +# 196 +return (__x << (-__r)) | (__x >> ((_Nd + __r) % _Nd)); } } +# 197 +} +# 199 +template< class _Tp> constexpr int +# 201 +__countl_zero(_Tp __x) noexcept +# 202 +{ +# 203 +using __gnu_cxx::__int_traits; +# 204 +constexpr auto _Nd = (__int_traits< _Tp> ::__digits); +# 206 +if (__x == 0) { +# 207 +return _Nd; } +# 209 +constexpr auto _Nd_ull = __int_traits< unsigned long long> ::__digits; +# 210 +constexpr auto _Nd_ul = __int_traits< unsigned long> ::__digits; +# 211 +constexpr auto _Nd_u = __int_traits< unsigned> ::__digits; +# 213 +if constexpr (_Nd <= _Nd_u) +# 214 +{ +# 215 +constexpr int __diff = (_Nd_u - _Nd); +# 216 +return __builtin_clz(__x) - __diff; +# 217 +} else { +# 218 +if constexpr (_Nd <= _Nd_ul) +# 219 +{ +# 220 +constexpr int __diff = (_Nd_ul - _Nd); +# 221 +return __builtin_clzl(__x) - __diff; +# 222 +} else { +# 223 +if constexpr (_Nd <= _Nd_ull) +# 224 +{ +# 225 +constexpr int __diff = (_Nd_ull - _Nd); +# 226 +return __builtin_clzll(__x) - __diff; +# 227 +} else +# 229 +{ +# 230 +static_assert((_Nd <= (2 * _Nd_ull)), "Maximum supported integer size is 128-bit"); +# 233 +unsigned long long __high = __x >> _Nd_ull; +# 234 +if (__high != (0)) +# 235 +{ +# 236 +constexpr int __diff = ((2 * _Nd_ull) - _Nd); +# 237 +return __builtin_clzll(__high) - __diff; +# 238 +} +# 239 +constexpr auto __max_ull = __int_traits< unsigned long long> ::__max; +# 240 +unsigned long long __low = __x & __max_ull; +# 241 +return (_Nd - _Nd_ull) + __builtin_clzll(__low); +# 242 +} } } +# 243 +} +# 245 +template< class _Tp> constexpr int +# 247 +__countl_one(_Tp __x) noexcept +# 248 +{ +# 249 +return std::__countl_zero< _Tp> ((_Tp)(~__x)); +# 250 +} +# 252 +template< class _Tp> constexpr int +# 254 +__countr_zero(_Tp __x) noexcept +# 255 +{ +# 256 +using __gnu_cxx::__int_traits; +# 257 +constexpr auto _Nd = (__int_traits< _Tp> ::__digits); +# 259 +if (__x == 0) { +# 260 +return _Nd; } +# 262 +constexpr auto _Nd_ull = __int_traits< unsigned long long> ::__digits; +# 263 +constexpr auto _Nd_ul = __int_traits< unsigned long> ::__digits; +# 264 +constexpr auto _Nd_u = __int_traits< unsigned> ::__digits; +# 266 +if constexpr (_Nd <= _Nd_u) { +# 267 +return __builtin_ctz(__x); } else { +# 268 +if constexpr (_Nd <= _Nd_ul) { +# 269 +return __builtin_ctzl(__x); } else { +# 270 +if constexpr (_Nd <= _Nd_ull) { +# 271 +return __builtin_ctzll(__x); } else +# 273 +{ +# 274 +static_assert((_Nd <= (2 * _Nd_ull)), "Maximum supported integer size is 128-bit"); +# 277 +constexpr auto __max_ull = __int_traits< unsigned long long> ::__max; +# 278 +unsigned long long __low = __x & __max_ull; +# 279 +if (__low != (0)) { +# 280 +return __builtin_ctzll(__low); } +# 281 +unsigned long long __high = __x >> _Nd_ull; +# 282 +return __builtin_ctzll(__high) + _Nd_ull; +# 283 +} } } +# 284 +} +# 286 +template< class _Tp> constexpr int +# 288 +__countr_one(_Tp __x) noexcept +# 289 +{ +# 290 +return std::__countr_zero((_Tp)(~__x)); +# 291 +} +# 293 +template< class _Tp> constexpr int +# 295 +__popcount(_Tp __x) noexcept +# 296 +{ +# 297 +using __gnu_cxx::__int_traits; +# 298 +constexpr auto _Nd = (__int_traits< _Tp> ::__digits); +# 300 +constexpr auto _Nd_ull = __int_traits< unsigned long long> ::__digits; +# 301 +constexpr auto _Nd_ul = __int_traits< unsigned long> ::__digits; +# 302 +constexpr auto _Nd_u = __int_traits< unsigned> ::__digits; +# 304 +if constexpr (_Nd <= _Nd_u) { +# 305 +return __builtin_popcount(__x); } else { +# 306 +if constexpr (_Nd <= _Nd_ul) { +# 307 +return __builtin_popcountl(__x); } else { +# 308 +if constexpr (_Nd <= _Nd_ull) { +# 309 +return __builtin_popcountll(__x); } else +# 311 +{ +# 312 +static_assert((_Nd <= (2 * _Nd_ull)), "Maximum supported integer size is 128-bit"); +# 315 +constexpr auto __max_ull = __int_traits< unsigned long long> ::__max; +# 316 +unsigned long long __low = __x & __max_ull; +# 317 +unsigned long long __high = __x >> _Nd_ull; +# 318 +return __builtin_popcountll(__low) + __builtin_popcountll(__high); +# 319 +} } } +# 320 +} +# 322 +template< class _Tp> constexpr bool +# 324 +__has_single_bit(_Tp __x) noexcept +# 325 +{ return std::__popcount(__x) == 1; } +# 327 +template< class _Tp> constexpr _Tp +# 329 +__bit_ceil(_Tp __x) noexcept +# 330 +{ +# 331 +using __gnu_cxx::__int_traits; +# 332 +constexpr auto _Nd = (__int_traits< _Tp> ::__digits); +# 333 +if ((__x == 0) || (__x == 1)) { +# 334 +return 1; } +# 335 +auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1U)); +# 340 +if (!std::__is_constant_evaluated()) +# 341 +{ +# 342 +do { if (std::__is_constant_evaluated() && (!((bool)(__shift_exponent != __int_traits< _Tp> ::__digits)))) { std::__glibcxx_assert_fail(); } } while (false); +# 343 +} +# 345 +using __promoted_type = __decltype((__x << 1)); +# 346 +if constexpr (!is_same< __decltype((__x << 1)), _Tp> ::value) +# 347 +{ +# 353 +const int __extra_exp = ((sizeof(__promoted_type) / sizeof(_Tp)) / (2)); +# 354 +__shift_exponent |= ((__shift_exponent & _Nd) << __extra_exp); +# 355 +} +# 356 +return ((_Tp)1U) << __shift_exponent; +# 357 +} +# 359 +template< class _Tp> constexpr _Tp +# 361 +__bit_floor(_Tp __x) noexcept +# 362 +{ +# 363 +constexpr auto _Nd = (__gnu_cxx::__int_traits< _Tp> ::__digits); +# 364 +if (__x == 0) { +# 365 +return 0; } +# 366 +return ((_Tp)1U) << (_Nd - std::__countl_zero((_Tp)(__x >> 1))); +# 367 +} +# 369 +template< class _Tp> constexpr int +# 371 +__bit_width(_Tp __x) noexcept +# 372 +{ +# 373 +constexpr auto _Nd = (__gnu_cxx::__int_traits< _Tp> ::__digits); +# 374 +return _Nd - std::__countl_zero(__x); +# 375 +} +# 483 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 +} +# 82 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 90 +template< class _Tp, class _Up> constexpr int +# 93 +__memcmp(const _Tp *__first1, const _Up *__first2, size_t __num) +# 94 +{ +# 96 +static_assert((sizeof(_Tp) == sizeof(_Up)), "can be compared with memcmp"); +# 108 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); +# 109 +} +# 152 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _ForwardIterator1, class _ForwardIterator2> inline void +# 155 +iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) +# 156 +{ +# 185 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +swap(*__a, *__b); +# 187 +} +# 201 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _ForwardIterator1, class _ForwardIterator2> _ForwardIterator2 +# 204 +swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 +# 205 +__first2) +# 206 +{ +# 212 +; +# 214 +for (; __first1 != __last1; (++__first1), ((void)(++__first2))) { +# 215 +std::iter_swap(__first1, __first2); } +# 216 +return __first2; +# 217 +} +# 230 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _Tp> +# 231 +[[__nodiscard__]] constexpr const _Tp & +# 233 +min(const _Tp &__a, const _Tp &__b) +# 234 +{ +# 238 +if (__b < __a) { +# 239 +return __b; } +# 240 +return __a; +# 241 +} +# 254 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _Tp> +# 255 +[[__nodiscard__]] constexpr const _Tp & +# 257 +max(const _Tp &__a, const _Tp &__b) +# 258 +{ +# 262 +if (__a < __b) { +# 263 +return __b; } +# 264 +return __a; +# 265 +} +# 278 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _Tp, class _Compare> +# 279 +[[__nodiscard__]] constexpr const _Tp & +# 281 +min(const _Tp &__a, const _Tp &__b, _Compare __comp) +# 282 +{ +# 284 +if (__comp(__b, __a)) { +# 285 +return __b; } +# 286 +return __a; +# 287 +} +# 300 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _Tp, class _Compare> +# 301 +[[__nodiscard__]] constexpr const _Tp & +# 303 +max(const _Tp &__a, const _Tp &__b, _Compare __comp) +# 304 +{ +# 306 +if (__comp(__a, __b)) { +# 307 +return __b; } +# 308 +return __a; +# 309 +} +# 313 +template< class _Iterator> inline _Iterator +# 316 +__niter_base(_Iterator __it) noexcept(std::template is_nothrow_copy_constructible< _Iterator> ::value) +# 318 +{ return __it; } +# 332 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _Ite, class _Seq> __decltype((std::__niter_base(std::declval< _Ite> ()))) __niter_base(const __gnu_debug::_Safe_iterator< _Ite, _Seq, random_access_iterator_tag> &) noexcept(std::template is_nothrow_copy_constructible< _Ite> ::value); +# 343 +template< class _From, class _To> inline _From +# 346 +__niter_wrap(_From __from, _To __res) +# 347 +{ return __from + (std::__niter_base(__res) - std::__niter_base(__from)); } +# 350 +template< class _Iterator> inline _Iterator +# 353 +__niter_wrap(const _Iterator &, _Iterator __res) +# 354 +{ return __res; } +# 362 +template< bool _IsMove, bool _IsSimple, class _Category> +# 363 +struct __copy_move { +# 365 +template< class _II, class _OI> static _OI +# 368 +__copy_m(_II __first, _II __last, _OI __result) +# 369 +{ +# 370 +for (; __first != __last; (++__result), ((void)(++__first))) { +# 371 +(*__result) = (*__first); } +# 372 +return __result; +# 373 +} +# 374 +}; +# 377 +template< class _Category> +# 378 +struct __copy_move< true, false, _Category> { +# 380 +template< class _II, class _OI> static _OI +# 383 +__copy_m(_II __first, _II __last, _OI __result) +# 384 +{ +# 385 +for (; __first != __last; (++__result), ((void)(++__first))) { +# 386 +(*__result) = std::move(*__first); } +# 387 +return __result; +# 388 +} +# 389 +}; +# 393 +template<> struct __copy_move< false, false, random_access_iterator_tag> { +# 395 +template< class _II, class _OI> static _OI +# 398 +__copy_m(_II __first, _II __last, _OI __result) +# 399 +{ +# 400 +typedef typename iterator_traits< _II> ::difference_type _Distance; +# 401 +for (_Distance __n = __last - __first; __n > 0; --__n) +# 402 +{ +# 403 +(*__result) = (*__first); +# 404 +++__first; +# 405 +++__result; +# 406 +} +# 407 +return __result; +# 408 +} +# 410 +template< class _Tp, class _Up> static void +# 412 +__assign_one(_Tp *__to, _Up *__from) +# 413 +{ (*__to) = (*__from); } +# 414 +}; +# 418 +template<> struct __copy_move< true, false, random_access_iterator_tag> { +# 420 +template< class _II, class _OI> static _OI +# 423 +__copy_m(_II __first, _II __last, _OI __result) +# 424 +{ +# 425 +typedef typename iterator_traits< _II> ::difference_type _Distance; +# 426 +for (_Distance __n = __last - __first; __n > 0; --__n) +# 427 +{ +# 428 +(*__result) = std::move(*__first); +# 429 +++__first; +# 430 +++__result; +# 431 +} +# 432 +return __result; +# 433 +} +# 435 +template< class _Tp, class _Up> static void +# 437 +__assign_one(_Tp *__to, _Up *__from) +# 438 +{ (*__to) = std::move(*__from); } +# 439 +}; +# 442 +template< bool _IsMove> +# 443 +struct __copy_move< _IsMove, true, random_access_iterator_tag> { +# 445 +template< class _Tp, class _Up> static _Up * +# 448 +__copy_m(_Tp *__first, _Tp *__last, _Up *__result) +# 449 +{ +# 450 +const ptrdiff_t _Num = __last - __first; +# 451 +if (__builtin_expect(_Num > (1), true)) { +# 452 +__builtin_memmove(__result, __first, sizeof(_Tp) * _Num); } else { +# 453 +if (_Num == (1)) { +# 454 +std::template __copy_move< _IsMove, false, random_access_iterator_tag> ::__assign_one(__result, __first); } } +# 456 +return __result + _Num; +# 457 +} +# 458 +}; +# 462 +template< class _Tp, class _Ref, class _Ptr> struct _Deque_iterator; +# 465 +struct _Bit_iterator; +# 472 +template< class _CharT> struct char_traits; +# 475 +template< class _CharT, class _Traits> class istreambuf_iterator; +# 478 +template< class _CharT, class _Traits> class ostreambuf_iterator; +# 481 +template< bool _IsMove, class _CharT> typename __gnu_cxx::__enable_if< __is_char< _CharT> ::__value, ostreambuf_iterator< _CharT, char_traits< _CharT> > > ::__type __copy_move_a2(_CharT *, _CharT *, ostreambuf_iterator< _CharT, char_traits< _CharT> > ); +# 487 +template< bool _IsMove, class _CharT> typename __gnu_cxx::__enable_if< __is_char< _CharT> ::__value, ostreambuf_iterator< _CharT, char_traits< _CharT> > > ::__type __copy_move_a2(const _CharT *, const _CharT *, ostreambuf_iterator< _CharT, char_traits< _CharT> > ); +# 493 +template< bool _IsMove, class _CharT> typename __gnu_cxx::__enable_if< __is_char< _CharT> ::__value, _CharT *> ::__type __copy_move_a2(istreambuf_iterator< _CharT, char_traits< _CharT> > , istreambuf_iterator< _CharT, char_traits< _CharT> > , _CharT *); +# 499 +template< bool _IsMove, class _CharT> typename __gnu_cxx::__enable_if< __is_char< _CharT> ::__value, _Deque_iterator< _CharT, _CharT &, _CharT *> > ::__type __copy_move_a2(istreambuf_iterator< _CharT, char_traits< _CharT> > , istreambuf_iterator< _CharT, char_traits< _CharT> > , _Deque_iterator< _CharT, _CharT &, _CharT *> ); +# 509 +template< bool _IsMove, class _II, class _OI> inline _OI +# 512 +__copy_move_a2(_II __first, _II __last, _OI __result) +# 513 +{ +# 514 +typedef typename iterator_traits< _II> ::iterator_category _Category; +# 520 +return std::template __copy_move< _IsMove, __memcpyable< _OI, _II> ::__value, typename iterator_traits< _II> ::iterator_category> ::__copy_m(__first, __last, __result); +# 522 +} +# 524 +template< bool _IsMove, class +# 525 +_Tp, class _Ref, class _Ptr, class _OI> _OI +# 524 +__copy_move_a1(_Deque_iterator< _Tp, _Ref, _Ptr> , _Deque_iterator< _Tp, _Ref, _Ptr> , _OI); +# 531 +template< bool _IsMove, class +# 532 +_ITp, class _IRef, class _IPtr, class _OTp> _Deque_iterator< _OTp, _OTp &, _OTp *> +# 531 +__copy_move_a1(_Deque_iterator< _ITp, _IRef, _IPtr> , _Deque_iterator< _ITp, _IRef, _IPtr> , _Deque_iterator< _OTp, _OTp &, _OTp *> ); +# 538 +template< bool _IsMove, class _II, class _Tp> typename __gnu_cxx::__enable_if< __is_random_access_iter< _II> ::__value, _Deque_iterator< _Tp, _Tp &, _Tp *> > ::__type __copy_move_a1(_II, _II, _Deque_iterator< _Tp, _Tp &, _Tp *> ); +# 544 +template< bool _IsMove, class _II, class _OI> inline _OI +# 547 +__copy_move_a1(_II __first, _II __last, _OI __result) +# 548 +{ return std::__copy_move_a2< _IsMove> (__first, __last, __result); } +# 550 +template< bool _IsMove, class _II, class _OI> inline _OI +# 553 +__copy_move_a(_II __first, _II __last, _OI __result) +# 554 +{ +# 555 +return std::__niter_wrap(__result, std::__copy_move_a1< _IsMove> (std::__niter_base(__first), std::__niter_base(__last), std::__niter_base(__result))); +# 559 +} +# 561 +template< bool _IsMove, class +# 562 +_Ite, class _Seq, class _Cat, class _OI> _OI +# 561 +__copy_move_a(const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &, const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &, _OI); +# 569 +template< bool _IsMove, class +# 570 +_II, class _Ite, class _Seq, class _Cat> __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> +# 569 +__copy_move_a(_II, _II, const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &); +# 576 +template< bool _IsMove, class +# 577 +_IIte, class _ISeq, class _ICat, class +# 578 +_OIte, class _OSeq, class _OCat> __gnu_debug::_Safe_iterator< _OIte, _OSeq, _OCat> +# 576 +__copy_move_a(const __gnu_debug::_Safe_iterator< _IIte, _ISeq, _ICat> &, const __gnu_debug::_Safe_iterator< _IIte, _ISeq, _ICat> &, const __gnu_debug::_Safe_iterator< _OIte, _OSeq, _OCat> &); +# 585 +template< class _InputIterator, class _Size, class _OutputIterator> _OutputIterator +# 588 +__copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, bool) +# 590 +{ +# 591 +if (__n > 0) +# 592 +{ +# 593 +while (true) +# 594 +{ +# 595 +(*__result) = (*__first); +# 596 +++__result; +# 597 +if ((--__n) > 0) { +# 598 +++__first; } else { +# 600 +break; } +# 601 +} +# 602 +} +# 603 +return __result; +# 604 +} +# 607 +template< class _CharT, class _Size> typename __gnu_cxx::__enable_if< __is_char< _CharT> ::__value, _CharT *> ::__type __copy_n_a(istreambuf_iterator< _CharT, char_traits< _CharT> > , _Size, _CharT *, bool); +# 613 +template< class _CharT, class _Size> typename __gnu_cxx::__enable_if< __is_char< _CharT> ::__value, _Deque_iterator< _CharT, _CharT &, _CharT *> > ::__type __copy_n_a(istreambuf_iterator< _CharT, char_traits< _CharT> > , _Size, _Deque_iterator< _CharT, _CharT &, _CharT *> , bool); +# 639 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _II, class _OI> inline _OI +# 642 +copy(_II __first, _II __last, _OI __result) +# 643 +{ +# 648 +; +# 650 +return std::__copy_move_a< __is_move_iterator< _II> ::__value> (std::__miter_base(__first), std::__miter_base(__last), __result); +# 652 +} +# 672 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _II, class _OI> inline _OI +# 675 +move(_II __first, _II __last, _OI __result) +# 676 +{ +# 681 +; +# 683 +return std::__copy_move_a< true> (std::__miter_base(__first), std::__miter_base(__last), __result); +# 685 +} +# 692 +template< bool _IsMove, bool _IsSimple, class _Category> +# 693 +struct __copy_move_backward { +# 695 +template< class _BI1, class _BI2> static _BI2 +# 698 +__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) +# 699 +{ +# 700 +while (__first != __last) { +# 701 +(*(--__result)) = (*(--__last)); } +# 702 +return __result; +# 703 +} +# 704 +}; +# 707 +template< class _Category> +# 708 +struct __copy_move_backward< true, false, _Category> { +# 710 +template< class _BI1, class _BI2> static _BI2 +# 713 +__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) +# 714 +{ +# 715 +while (__first != __last) { +# 716 +(*(--__result)) = std::move(*(--__last)); } +# 717 +return __result; +# 718 +} +# 719 +}; +# 723 +template<> struct __copy_move_backward< false, false, random_access_iterator_tag> { +# 725 +template< class _BI1, class _BI2> static _BI2 +# 728 +__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) +# 729 +{ +# 731 +typename iterator_traits< _BI1> ::difference_type __n = __last - __first; +# 732 +for (; __n > 0; --__n) { +# 733 +(*(--__result)) = (*(--__last)); } +# 734 +return __result; +# 735 +} +# 736 +}; +# 740 +template<> struct __copy_move_backward< true, false, random_access_iterator_tag> { +# 742 +template< class _BI1, class _BI2> static _BI2 +# 745 +__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) +# 746 +{ +# 748 +typename iterator_traits< _BI1> ::difference_type __n = __last - __first; +# 749 +for (; __n > 0; --__n) { +# 750 +(*(--__result)) = std::move(*(--__last)); } +# 751 +return __result; +# 752 +} +# 753 +}; +# 756 +template< bool _IsMove> +# 757 +struct __copy_move_backward< _IsMove, true, random_access_iterator_tag> { +# 759 +template< class _Tp, class _Up> static _Up * +# 762 +__copy_move_b(_Tp *__first, _Tp *__last, _Up *__result) +# 763 +{ +# 764 +const ptrdiff_t _Num = __last - __first; +# 765 +if (__builtin_expect(_Num > (1), true)) { +# 766 +__builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); } else { +# 767 +if (_Num == (1)) { +# 768 +std::template __copy_move< _IsMove, false, random_access_iterator_tag> ::__assign_one(__result - 1, __first); } } +# 770 +return __result - _Num; +# 771 +} +# 772 +}; +# 774 +template< bool _IsMove, class _BI1, class _BI2> inline _BI2 +# 777 +__copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) +# 778 +{ +# 779 +typedef typename iterator_traits< _BI1> ::iterator_category _Category; +# 785 +return std::template __copy_move_backward< _IsMove, __memcpyable< _BI2, _BI1> ::__value, typename iterator_traits< _BI1> ::iterator_category> ::__copy_move_b(__first, __last, __result); +# 790 +} +# 792 +template< bool _IsMove, class _BI1, class _BI2> inline _BI2 +# 795 +__copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) +# 796 +{ return std::__copy_move_backward_a2< _IsMove> (__first, __last, __result); } +# 798 +template< bool _IsMove, class +# 799 +_Tp, class _Ref, class _Ptr, class _OI> _OI +# 798 +__copy_move_backward_a1(_Deque_iterator< _Tp, _Ref, _Ptr> , _Deque_iterator< _Tp, _Ref, _Ptr> , _OI); +# 805 +template< bool _IsMove, class +# 806 +_ITp, class _IRef, class _IPtr, class _OTp> _Deque_iterator< _OTp, _OTp &, _OTp *> +# 805 +__copy_move_backward_a1(_Deque_iterator< _ITp, _IRef, _IPtr> , _Deque_iterator< _ITp, _IRef, _IPtr> , _Deque_iterator< _OTp, _OTp &, _OTp *> ); +# 813 +template< bool _IsMove, class _II, class _Tp> typename __gnu_cxx::__enable_if< __is_random_access_iter< _II> ::__value, _Deque_iterator< _Tp, _Tp &, _Tp *> > ::__type __copy_move_backward_a1(_II, _II, _Deque_iterator< _Tp, _Tp &, _Tp *> ); +# 820 +template< bool _IsMove, class _II, class _OI> inline _OI +# 823 +__copy_move_backward_a(_II __first, _II __last, _OI __result) +# 824 +{ +# 825 +return std::__niter_wrap(__result, std::__copy_move_backward_a1< _IsMove> (std::__niter_base(__first), std::__niter_base(__last), std::__niter_base(__result))); +# 829 +} +# 831 +template< bool _IsMove, class +# 832 +_Ite, class _Seq, class _Cat, class _OI> _OI +# 831 +__copy_move_backward_a(const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &, const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &, _OI); +# 840 +template< bool _IsMove, class +# 841 +_II, class _Ite, class _Seq, class _Cat> __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> +# 840 +__copy_move_backward_a(_II, _II, const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &); +# 847 +template< bool _IsMove, class +# 848 +_IIte, class _ISeq, class _ICat, class +# 849 +_OIte, class _OSeq, class _OCat> __gnu_debug::_Safe_iterator< _OIte, _OSeq, _OCat> +# 847 +__copy_move_backward_a(const __gnu_debug::_Safe_iterator< _IIte, _ISeq, _ICat> &, const __gnu_debug::_Safe_iterator< _IIte, _ISeq, _ICat> &, const __gnu_debug::_Safe_iterator< _OIte, _OSeq, _OCat> &); +# 875 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _BI1, class _BI2> inline _BI2 +# 878 +copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) +# 879 +{ +# 885 +; +# 887 +return std::__copy_move_backward_a< __is_move_iterator< _BI1> ::__value> (std::__miter_base(__first), std::__miter_base(__last), __result); +# 889 +} +# 910 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _BI1, class _BI2> inline _BI2 +# 913 +move_backward(_BI1 __first, _BI1 __last, _BI2 __result) +# 914 +{ +# 920 +; +# 922 +return std::__copy_move_backward_a< true> (std::__miter_base(__first), std::__miter_base(__last), __result); +# 925 +} +# 932 +template< class _ForwardIterator, class _Tp> inline typename __gnu_cxx::__enable_if< !__is_scalar< _Tp> ::__value, void> ::__type +# 936 +__fill_a1(_ForwardIterator __first, _ForwardIterator __last, const _Tp & +# 937 +__value) +# 938 +{ +# 939 +for (; __first != __last; ++__first) { +# 940 +(*__first) = __value; } +# 941 +} +# 943 +template< class _ForwardIterator, class _Tp> inline typename __gnu_cxx::__enable_if< __is_scalar< _Tp> ::__value, void> ::__type +# 947 +__fill_a1(_ForwardIterator __first, _ForwardIterator __last, const _Tp & +# 948 +__value) +# 949 +{ +# 950 +const _Tp __tmp = __value; +# 951 +for (; __first != __last; ++__first) { +# 952 +(*__first) = __tmp; } +# 953 +} +# 956 +template< class _Tp> inline typename __gnu_cxx::__enable_if< __is_byte< _Tp> ::__value, void> ::__type +# 960 +__fill_a1(_Tp *__first, _Tp *__last, const _Tp &__c) +# 961 +{ +# 962 +const _Tp __tmp = __c; +# 971 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +if (const size_t __len = __last - __first) { +# 972 +__builtin_memset(__first, static_cast< unsigned char>(__tmp), __len); } +# 973 +} +# 975 +template< class _Ite, class _Cont, class _Tp> inline void +# 978 +__fill_a1(__gnu_cxx::__normal_iterator< _Ite, _Cont> __first, __gnu_cxx::__normal_iterator< _Ite, _Cont> +# 979 +__last, const _Tp & +# 980 +__value) +# 981 +{ std::__fill_a1(__first.base(), __last.base(), __value); } +# 983 +template< class _Tp, class _VTp> void __fill_a1(const _Deque_iterator< _Tp, _Tp &, _Tp *> &, const _Deque_iterator< _Tp, _Tp &, _Tp *> &, const _VTp &); +# 991 +void __fill_a1(_Bit_iterator, _Bit_iterator, const bool &); +# 994 +template< class _FIte, class _Tp> inline void +# 997 +__fill_a(_FIte __first, _FIte __last, const _Tp &__value) +# 998 +{ std::__fill_a1(__first, __last, __value); } +# 1000 +template< class _Ite, class _Seq, class _Cat, class _Tp> void __fill_a(const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &, const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &, const _Tp &); +# 1019 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _ForwardIterator, class _Tp> inline void +# 1022 +fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp &__value) +# 1023 +{ +# 1027 +; +# 1029 +std::__fill_a(__first, __last, __value); +# 1030 +} +# 1032 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wlong-long" +# 1036 +constexpr int __size_to_integer(int __n) { return __n; } +# 1038 +constexpr unsigned __size_to_integer(unsigned __n) { return __n; } +# 1040 +constexpr long __size_to_integer(long __n) { return __n; } +# 1042 +constexpr unsigned long __size_to_integer(unsigned long __n) { return __n; } +# 1044 +constexpr long long __size_to_integer(long long __n) { return __n; } +# 1046 +constexpr unsigned long long __size_to_integer(unsigned long long __n) { return __n; } +# 1050 +__extension__ constexpr __int128 __size_to_integer(__int128 __n) { return __n; } +# 1052 +__extension__ constexpr unsigned __int128 __size_to_integer(unsigned __int128 __n) { return __n; } +# 1074 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +constexpr long long __size_to_integer(float __n) { return (long long)__n; } +# 1076 +constexpr long long __size_to_integer(double __n) { return (long long)__n; } +# 1078 +constexpr long long __size_to_integer(long double __n) { return (long long)__n; } +# 1081 +__extension__ constexpr long long __size_to_integer(__float128 __n) { return (long long)__n; } +# 1083 +#pragma GCC diagnostic pop +# 1085 +template< class _OutputIterator, class _Size, class _Tp> inline typename __gnu_cxx::__enable_if< !__is_scalar< _Tp> ::__value, _OutputIterator> ::__type +# 1089 +__fill_n_a1(_OutputIterator __first, _Size __n, const _Tp &__value) +# 1090 +{ +# 1091 +for (; __n > 0; (--__n), ((void)(++__first))) { +# 1092 +(*__first) = __value; } +# 1093 +return __first; +# 1094 +} +# 1096 +template< class _OutputIterator, class _Size, class _Tp> inline typename __gnu_cxx::__enable_if< __is_scalar< _Tp> ::__value, _OutputIterator> ::__type +# 1100 +__fill_n_a1(_OutputIterator __first, _Size __n, const _Tp &__value) +# 1101 +{ +# 1102 +const _Tp __tmp = __value; +# 1103 +for (; __n > 0; (--__n), ((void)(++__first))) { +# 1104 +(*__first) = __tmp; } +# 1105 +return __first; +# 1106 +} +# 1108 +template< class _Ite, class _Seq, class _Cat, class _Size, class +# 1109 +_Tp> __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> +# 1108 +__fill_n_a(const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> & __first, _Size __n, const _Tp & __value, input_iterator_tag); +# 1116 +template< class _OutputIterator, class _Size, class _Tp> inline _OutputIterator +# 1119 +__fill_n_a(_OutputIterator __first, _Size __n, const _Tp &__value, output_iterator_tag) +# 1121 +{ +# 1123 +static_assert((is_integral< _Size> {}), "fill_n must pass integral size"); +# 1125 +return __fill_n_a1(__first, __n, __value); +# 1126 +} +# 1128 +template< class _OutputIterator, class _Size, class _Tp> inline _OutputIterator +# 1131 +__fill_n_a(_OutputIterator __first, _Size __n, const _Tp &__value, input_iterator_tag) +# 1133 +{ +# 1135 +static_assert((is_integral< _Size> {}), "fill_n must pass integral size"); +# 1137 +return __fill_n_a1(__first, __n, __value); +# 1138 +} +# 1140 +template< class _OutputIterator, class _Size, class _Tp> inline _OutputIterator +# 1143 +__fill_n_a(_OutputIterator __first, _Size __n, const _Tp &__value, random_access_iterator_tag) +# 1145 +{ +# 1147 +static_assert((is_integral< _Size> {}), "fill_n must pass integral size"); +# 1149 +if (__n <= 0) { +# 1150 +return __first; } +# 1152 +; +# 1154 +std::__fill_a(__first, __first + __n, __value); +# 1155 +return __first + __n; +# 1156 +} +# 1175 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _OI, class _Size, class _Tp> inline _OI +# 1178 +fill_n(_OI __first, _Size __n, const _Tp &__value) +# 1179 +{ +# 1183 +return std::__fill_n_a(__first, std::__size_to_integer(__n), __value, std::__iterator_category(__first)); +# 1185 +} +# 1187 +template< bool _BoolType> +# 1188 +struct __equal { +# 1190 +template< class _II1, class _II2> static bool +# 1193 +equal(_II1 __first1, _II1 __last1, _II2 __first2) +# 1194 +{ +# 1195 +for (; __first1 != __last1; (++__first1), ((void)(++__first2))) { +# 1196 +if (!((*__first1) == (*__first2))) { +# 1197 +return false; } } +# 1198 +return true; +# 1199 +} +# 1200 +}; +# 1203 +template<> struct __equal< true> { +# 1205 +template< class _Tp> static bool +# 1208 +equal(const _Tp *__first1, const _Tp *__last1, const _Tp *__first2) +# 1209 +{ +# 1210 +if (const size_t __len = __last1 - __first1) { +# 1211 +return !std::__memcmp(__first1, __first2, __len); } +# 1212 +return true; +# 1213 +} +# 1214 +}; +# 1216 +template< class _Tp, class _Ref, class _Ptr, class _II> typename __gnu_cxx::__enable_if< __is_random_access_iter< _II> ::__value, bool> ::__type __equal_aux1(_Deque_iterator< _Tp, _Ref, _Ptr> , _Deque_iterator< _Tp, _Ref, _Ptr> , _II); +# 1223 +template< class _Tp1, class _Ref1, class _Ptr1, class +# 1224 +_Tp2, class _Ref2, class _Ptr2> bool +# 1223 +__equal_aux1(_Deque_iterator< _Tp1, _Ref1, _Ptr1> , _Deque_iterator< _Tp1, _Ref1, _Ptr1> , _Deque_iterator< _Tp2, _Ref2, _Ptr2> ); +# 1230 +template< class _II, class _Tp, class _Ref, class _Ptr> typename __gnu_cxx::__enable_if< __is_random_access_iter< _II> ::__value, bool> ::__type __equal_aux1(_II, _II, _Deque_iterator< _Tp, _Ref, _Ptr> ); +# 1236 +template< class _II1, class _II2> inline bool +# 1239 +__equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2) +# 1240 +{ +# 1241 +typedef typename iterator_traits< _II1> ::value_type _ValueType1; +# 1242 +const bool __simple = ((__is_integer< typename iterator_traits< _II1> ::value_type> ::__value || __is_pointer< typename iterator_traits< _II1> ::value_type> ::__value) && __memcmpable< _II1, _II2> ::__value); +# 1245 +return std::template __equal< __simple> ::equal(__first1, __last1, __first2); +# 1246 +} +# 1248 +template< class _II1, class _II2> inline bool +# 1251 +__equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) +# 1252 +{ +# 1253 +return std::__equal_aux1(std::__niter_base(__first1), std::__niter_base(__last1), std::__niter_base(__first2)); +# 1256 +} +# 1258 +template< class _II1, class _Seq1, class _Cat1, class _II2> bool __equal_aux(const __gnu_debug::_Safe_iterator< _II1, _Seq1, _Cat1> &, const __gnu_debug::_Safe_iterator< _II1, _Seq1, _Cat1> &, _II2); +# 1265 +template< class _II1, class _II2, class _Seq2, class _Cat2> bool __equal_aux(_II1, _II1, const __gnu_debug::_Safe_iterator< _II2, _Seq2, _Cat2> &); +# 1271 +template< class _II1, class _Seq1, class _Cat1, class +# 1272 +_II2, class _Seq2, class _Cat2> bool +# 1271 +__equal_aux(const __gnu_debug::_Safe_iterator< _II1, _Seq1, _Cat1> &, const __gnu_debug::_Safe_iterator< _II1, _Seq1, _Cat1> &, const __gnu_debug::_Safe_iterator< _II2, _Seq2, _Cat2> &); +# 1279 +template< class , class > +# 1280 +struct __lc_rai { +# 1282 +template< class _II1, class _II2> static _II1 +# 1285 +__newlast1(_II1, _II1 __last1, _II2, _II2) +# 1286 +{ return __last1; } +# 1288 +template< class _II> static bool +# 1291 +__cnd2(_II __first, _II __last) +# 1292 +{ return __first != __last; } +# 1293 +}; +# 1296 +template<> struct __lc_rai< random_access_iterator_tag, random_access_iterator_tag> { +# 1298 +template< class _RAI1, class _RAI2> static _RAI1 +# 1301 +__newlast1(_RAI1 __first1, _RAI1 __last1, _RAI2 +# 1302 +__first2, _RAI2 __last2) +# 1303 +{ +# 1305 +const typename iterator_traits< _RAI1> ::difference_type __diff1 = __last1 - __first1; +# 1307 +const typename iterator_traits< _RAI2> ::difference_type __diff2 = __last2 - __first2; +# 1308 +return (__diff2 < __diff1) ? __first1 + __diff2 : __last1; +# 1309 +} +# 1311 +template< class _RAI> static bool +# 1313 +__cnd2(_RAI, _RAI) +# 1314 +{ return true; } +# 1315 +}; +# 1317 +template< class _II1, class _II2, class _Compare> bool +# 1320 +__lexicographical_compare_impl(_II1 __first1, _II1 __last1, _II2 +# 1321 +__first2, _II2 __last2, _Compare +# 1322 +__comp) +# 1323 +{ +# 1324 +typedef typename iterator_traits< _II1> ::iterator_category _Category1; +# 1325 +typedef typename iterator_traits< _II2> ::iterator_category _Category2; +# 1326 +typedef __lc_rai< typename iterator_traits< _II1> ::iterator_category, typename iterator_traits< _II2> ::iterator_category> __rai_type; +# 1328 +__last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); +# 1329 +for (; (__first1 != __last1) && __rai_type::__cnd2(__first2, __last2); (++__first1), ((void)(++__first2))) +# 1331 +{ +# 1332 +if (__comp(__first1, __first2)) { +# 1333 +return true; } +# 1334 +if (__comp(__first2, __first1)) { +# 1335 +return false; } +# 1336 +} +# 1337 +return (__first1 == __last1) && (__first2 != __last2); +# 1338 +} +# 1340 +template< bool _BoolType> +# 1341 +struct __lexicographical_compare { +# 1343 +template< class _II1, class _II2> static bool +# 1346 +__lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) +# 1347 +{ +# 1348 +using __gnu_cxx::__ops::__iter_less_iter; +# 1349 +return std::__lexicographical_compare_impl(__first1, __last1, __first2, __last2, __iter_less_iter()); +# 1352 +} +# 1354 +template< class _II1, class _II2> static int +# 1357 +__3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) +# 1358 +{ +# 1359 +while (__first1 != __last1) +# 1360 +{ +# 1361 +if (__first2 == __last2) { +# 1362 +return +1; } +# 1363 +if ((*__first1) < (*__first2)) { +# 1364 +return -1; } +# 1365 +if ((*__first2) < (*__first1)) { +# 1366 +return +1; } +# 1367 +++__first1; +# 1368 +++__first2; +# 1369 +} +# 1370 +return ((int)(__first2 == __last2)) - 1; +# 1371 +} +# 1372 +}; +# 1375 +template<> struct __lexicographical_compare< true> { +# 1377 +template< class _Tp, class _Up> static bool +# 1380 +__lc(const _Tp *__first1, const _Tp *__last1, const _Up * +# 1381 +__first2, const _Up *__last2) +# 1382 +{ return __3way(__first1, __last1, __first2, __last2) < 0; } +# 1384 +template< class _Tp, class _Up> static ptrdiff_t +# 1387 +__3way(const _Tp *__first1, const _Tp *__last1, const _Up * +# 1388 +__first2, const _Up *__last2) +# 1389 +{ +# 1390 +const size_t __len1 = __last1 - __first1; +# 1391 +const size_t __len2 = __last2 - __first2; +# 1392 +if (const size_t __len = std::min(__len1, __len2)) { +# 1393 +if (int __result = std::__memcmp(__first1, __first2, __len)) { +# 1394 +return __result; } } +# 1395 +return (ptrdiff_t)(__len1 - __len2); +# 1396 +} +# 1397 +}; +# 1399 +template< class _II1, class _II2> inline bool +# 1402 +__lexicographical_compare_aux1(_II1 __first1, _II1 __last1, _II2 +# 1403 +__first2, _II2 __last2) +# 1404 +{ +# 1405 +typedef typename iterator_traits< _II1> ::value_type _ValueType1; +# 1406 +typedef typename iterator_traits< _II2> ::value_type _ValueType2; +# 1407 +const bool __simple = (__is_memcmp_ordered_with< typename iterator_traits< _II1> ::value_type, typename iterator_traits< _II2> ::value_type> ::__value && __is_pointer< _II1> ::__value && __is_pointer< _II2> ::__value); +# 1420 +return std::template __lexicographical_compare< __simple> ::__lc(__first1, __last1, __first2, __last2); +# 1422 +} +# 1424 +template< class _Tp1, class _Ref1, class _Ptr1, class +# 1425 +_Tp2> bool +# 1424 +__lexicographical_compare_aux1(_Deque_iterator< _Tp1, _Ref1, _Ptr1> , _Deque_iterator< _Tp1, _Ref1, _Ptr1> , _Tp2 *, _Tp2 *); +# 1432 +template< class _Tp1, class +# 1433 +_Tp2, class _Ref2, class _Ptr2> bool +# 1432 +__lexicographical_compare_aux1(_Tp1 *, _Tp1 *, _Deque_iterator< _Tp2, _Ref2, _Ptr2> , _Deque_iterator< _Tp2, _Ref2, _Ptr2> ); +# 1439 +template< class _Tp1, class _Ref1, class _Ptr1, class +# 1440 +_Tp2, class _Ref2, class _Ptr2> bool +# 1439 +__lexicographical_compare_aux1(_Deque_iterator< _Tp1, _Ref1, _Ptr1> , _Deque_iterator< _Tp1, _Ref1, _Ptr1> , _Deque_iterator< _Tp2, _Ref2, _Ptr2> , _Deque_iterator< _Tp2, _Ref2, _Ptr2> ); +# 1448 +template< class _II1, class _II2> inline bool +# 1451 +__lexicographical_compare_aux(_II1 __first1, _II1 __last1, _II2 +# 1452 +__first2, _II2 __last2) +# 1453 +{ +# 1454 +return std::__lexicographical_compare_aux1(std::__niter_base(__first1), std::__niter_base(__last1), std::__niter_base(__first2), std::__niter_base(__last2)); +# 1458 +} +# 1460 +template< class _Iter1, class _Seq1, class _Cat1, class +# 1461 +_II2> bool +# 1460 +__lexicographical_compare_aux(const __gnu_debug::_Safe_iterator< _Iter1, _Seq1, _Cat1> &, const __gnu_debug::_Safe_iterator< _Iter1, _Seq1, _Cat1> &, _II2, _II2); +# 1469 +template< class _II1, class +# 1470 +_Iter2, class _Seq2, class _Cat2> bool +# 1469 +__lexicographical_compare_aux(_II1, _II1, const __gnu_debug::_Safe_iterator< _Iter2, _Seq2, _Cat2> &, const __gnu_debug::_Safe_iterator< _Iter2, _Seq2, _Cat2> &); +# 1478 +template< class _Iter1, class _Seq1, class _Cat1, class +# 1479 +_Iter2, class _Seq2, class _Cat2> bool +# 1478 +__lexicographical_compare_aux(const __gnu_debug::_Safe_iterator< _Iter1, _Seq1, _Cat1> &, const __gnu_debug::_Safe_iterator< _Iter1, _Seq1, _Cat1> &, const __gnu_debug::_Safe_iterator< _Iter2, _Seq2, _Cat2> &, const __gnu_debug::_Safe_iterator< _Iter2, _Seq2, _Cat2> &); +# 1488 +template< class _ForwardIterator, class _Tp, class _Compare> _ForwardIterator +# 1491 +__lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp & +# 1492 +__val, _Compare __comp) +# 1493 +{ +# 1495 +typedef typename iterator_traits< _ForwardIterator> ::difference_type _DistanceType; +# 1497 +_DistanceType __len = std::distance(__first, __last); +# 1499 +while (__len > 0) +# 1500 +{ +# 1501 +_DistanceType __half = __len >> 1; +# 1502 +_ForwardIterator __middle = __first; +# 1503 +std::advance(__middle, __half); +# 1504 +if (__comp(__middle, __val)) +# 1505 +{ +# 1506 +__first = __middle; +# 1507 +++__first; +# 1508 +__len = ((__len - __half) - 1); +# 1509 +} else { +# 1511 +__len = __half; } +# 1512 +} +# 1513 +return __first; +# 1514 +} +# 1527 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _ForwardIterator, class _Tp> +# 1528 +[[__nodiscard__]] inline _ForwardIterator +# 1530 +lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp & +# 1531 +__val) +# 1532 +{ +# 1537 +; +# 1539 +return std::__lower_bound(__first, __last, __val, __gnu_cxx::__ops::__iter_less_val()); +# 1541 +} +# 1545 +template< class _Tp> constexpr _Tp +# 1547 +__lg(_Tp __n) +# 1548 +{ +# 1550 +return std::__bit_width((make_unsigned_t< _Tp> )__n) - 1; +# 1563 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +} +# 1579 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _II1, class _II2> +# 1580 +[[__nodiscard__]] inline bool +# 1582 +equal(_II1 __first1, _II1 __last1, _II2 __first2) +# 1583 +{ +# 1590 +; +# 1592 +return std::__equal_aux(__first1, __last1, __first2); +# 1593 +} +# 1610 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _IIter1, class _IIter2, class _BinaryPredicate> +# 1611 +[[__nodiscard__]] inline bool +# 1613 +equal(_IIter1 __first1, _IIter1 __last1, _IIter2 +# 1614 +__first2, _BinaryPredicate __binary_pred) +# 1615 +{ +# 1619 +; +# 1621 +for (; __first1 != __last1; (++__first1), ((void)(++__first2))) { +# 1622 +if (!((bool)__binary_pred(*__first1, *__first2))) { +# 1623 +return false; } } +# 1624 +return true; +# 1625 +} +# 1628 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++17-extensions" +# 1632 +template< class _II1, class _II2> inline bool +# 1635 +__equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) +# 1636 +{ +# 1637 +using _RATag = random_access_iterator_tag; +# 1638 +using _Cat1 = typename iterator_traits< _II1> ::iterator_category; +# 1639 +using _Cat2 = typename iterator_traits< _II2> ::iterator_category; +# 1640 +using _RAIters = __and_< is_same< typename iterator_traits< _II1> ::iterator_category, random_access_iterator_tag> , is_same< typename iterator_traits< _II2> ::iterator_category, random_access_iterator_tag> > ; +# 1641 +if constexpr (_RAIters::value) +# 1642 +{ +# 1643 +if ((__last1 - __first1) != (__last2 - __first2)) { +# 1644 +return false; } +# 1645 +return std::equal(__first1, __last1, __first2); +# 1646 +} else +# 1648 +{ +# 1649 +for (; (__first1 != __last1) && (__first2 != __last2); (++__first1), ((void)(++__first2))) { +# 1651 +if (!((*__first1) == (*__first2))) { +# 1652 +return false; } } +# 1653 +return (__first1 == __last1) && (__first2 == __last2); +# 1654 +} +# 1655 +} +# 1658 +template< class _II1, class _II2, class _BinaryPredicate> inline bool +# 1661 +__equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, _BinaryPredicate +# 1662 +__binary_pred) +# 1663 +{ +# 1664 +using _RATag = random_access_iterator_tag; +# 1665 +using _Cat1 = typename iterator_traits< _II1> ::iterator_category; +# 1666 +using _Cat2 = typename iterator_traits< _II2> ::iterator_category; +# 1667 +using _RAIters = __and_< is_same< typename iterator_traits< _II1> ::iterator_category, random_access_iterator_tag> , is_same< typename iterator_traits< _II2> ::iterator_category, random_access_iterator_tag> > ; +# 1668 +if constexpr (_RAIters::value) +# 1669 +{ +# 1670 +if ((__last1 - __first1) != (__last2 - __first2)) { +# 1671 +return false; } +# 1672 +return std::equal(__first1, __last1, __first2, __binary_pred); +# 1674 +} else +# 1676 +{ +# 1677 +for (; (__first1 != __last1) && (__first2 != __last2); (++__first1), ((void)(++__first2))) { +# 1679 +if (!((bool)__binary_pred(*__first1, *__first2))) { +# 1680 +return false; } } +# 1681 +return (__first1 == __last1) && (__first2 == __last2); +# 1682 +} +# 1683 +} +#pragma GCC diagnostic pop +# 1701 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _II1, class _II2> +# 1702 +[[__nodiscard__]] inline bool +# 1704 +equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) +# 1705 +{ +# 1712 +; +# 1713 +; +# 1715 +return std::__equal4(__first1, __last1, __first2, __last2); +# 1716 +} +# 1734 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _IIter1, class _IIter2, class _BinaryPredicate> +# 1735 +[[__nodiscard__]] inline bool +# 1737 +equal(_IIter1 __first1, _IIter1 __last1, _IIter2 +# 1738 +__first2, _IIter2 __last2, _BinaryPredicate __binary_pred) +# 1739 +{ +# 1743 +; +# 1744 +; +# 1746 +return std::__equal4(__first1, __last1, __first2, __last2, __binary_pred); +# 1748 +} +# 1766 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _II1, class _II2> +# 1767 +[[__nodiscard__]] inline bool +# 1769 +lexicographical_compare(_II1 __first1, _II1 __last1, _II2 +# 1770 +__first2, _II2 __last2) +# 1771 +{ +# 1781 +; +# 1782 +; +# 1784 +return std::__lexicographical_compare_aux(__first1, __last1, __first2, __last2); +# 1786 +} +# 1801 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _II1, class _II2, class _Compare> +# 1802 +[[__nodiscard__]] inline bool +# 1804 +lexicographical_compare(_II1 __first1, _II1 __last1, _II2 +# 1805 +__first2, _II2 __last2, _Compare __comp) +# 1806 +{ +# 1810 +; +# 1811 +; +# 1813 +return std::__lexicographical_compare_impl(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__comp)); +# 1816 +} +# 1916 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _InputIterator1, class _InputIterator2, class +# 1917 +_BinaryPredicate> pair< _InputIterator1, _InputIterator2> +# 1920 +__mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 +# 1921 +__first2, _BinaryPredicate __binary_pred) +# 1922 +{ +# 1923 +while ((__first1 != __last1) && __binary_pred(__first1, __first2)) +# 1924 +{ +# 1925 +++__first1; +# 1926 +++__first2; +# 1927 +} +# 1928 +return pair< _InputIterator1, _InputIterator2> (__first1, __first2); +# 1929 +} +# 1944 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _InputIterator1, class _InputIterator2> +# 1945 +[[__nodiscard__]] inline pair< _InputIterator1, _InputIterator2> +# 1947 +mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 +# 1948 +__first2) +# 1949 +{ +# 1956 +; +# 1958 +return std::__mismatch(__first1, __last1, __first2, __gnu_cxx::__ops::__iter_equal_to_iter()); +# 1960 +} +# 1978 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _InputIterator1, class _InputIterator2, class +# 1979 +_BinaryPredicate> +# 1980 +[[__nodiscard__]] inline pair< _InputIterator1, _InputIterator2> +# 1982 +mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 +# 1983 +__first2, _BinaryPredicate __binary_pred) +# 1984 +{ +# 1988 +; +# 1990 +return std::__mismatch(__first1, __last1, __first2, __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); +# 1992 +} +# 1995 +template< class _InputIterator1, class _InputIterator2, class +# 1996 +_BinaryPredicate> pair< _InputIterator1, _InputIterator2> +# 1999 +__mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 +# 2000 +__first2, _InputIterator2 __last2, _BinaryPredicate +# 2001 +__binary_pred) +# 2002 +{ +# 2003 +while ((__first1 != __last1) && (__first2 != __last2) && __binary_pred(__first1, __first2)) +# 2005 +{ +# 2006 +++__first1; +# 2007 +++__first2; +# 2008 +} +# 2009 +return pair< _InputIterator1, _InputIterator2> (__first1, __first2); +# 2010 +} +# 2026 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _InputIterator1, class _InputIterator2> +# 2027 +[[__nodiscard__]] inline pair< _InputIterator1, _InputIterator2> +# 2029 +mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 +# 2030 +__first2, _InputIterator2 __last2) +# 2031 +{ +# 2038 +; +# 2039 +; +# 2041 +return std::__mismatch(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_equal_to_iter()); +# 2043 +} +# 2062 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _InputIterator1, class _InputIterator2, class +# 2063 +_BinaryPredicate> +# 2064 +[[__nodiscard__]] inline pair< _InputIterator1, _InputIterator2> +# 2066 +mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 +# 2067 +__first2, _InputIterator2 __last2, _BinaryPredicate +# 2068 +__binary_pred) +# 2069 +{ +# 2073 +; +# 2074 +; +# 2076 +return std::__mismatch(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); +# 2078 +} +# 2084 +template< class _InputIterator, class _Predicate> inline _InputIterator +# 2087 +__find_if(_InputIterator __first, _InputIterator __last, _Predicate +# 2088 +__pred, input_iterator_tag) +# 2089 +{ +# 2090 +while ((__first != __last) && (!__pred(__first))) { +# 2091 +++__first; } +# 2092 +return __first; +# 2093 +} +# 2096 +template< class _RandomAccessIterator, class _Predicate> _RandomAccessIterator +# 2099 +__find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, _Predicate +# 2100 +__pred, random_access_iterator_tag) +# 2101 +{ +# 2103 +typename iterator_traits< _RandomAccessIterator> ::difference_type __trip_count = (__last - __first) >> 2; +# 2105 +for (; __trip_count > 0; --__trip_count) +# 2106 +{ +# 2107 +if (__pred(__first)) { +# 2108 +return __first; } +# 2109 +++__first; +# 2111 +if (__pred(__first)) { +# 2112 +return __first; } +# 2113 +++__first; +# 2115 +if (__pred(__first)) { +# 2116 +return __first; } +# 2117 +++__first; +# 2119 +if (__pred(__first)) { +# 2120 +return __first; } +# 2121 +++__first; +# 2122 +} +# 2124 +switch (__last - __first) +# 2125 +{ +# 2126 +case 3: +# 2127 +if (__pred(__first)) { +# 2128 +return __first; } +# 2129 +++__first; +# 2131 +case 2: +# 2132 +if (__pred(__first)) { +# 2133 +return __first; } +# 2134 +++__first; +# 2136 +case 1: +# 2137 +if (__pred(__first)) { +# 2138 +return __first; } +# 2139 +++__first; +# 2141 +case 0: +# 2142 +default: +# 2143 +return __last; +# 2144 +} +# 2145 +} +# 2147 +template< class _Iterator, class _Predicate> inline _Iterator +# 2150 +__find_if(_Iterator __first, _Iterator __last, _Predicate __pred) +# 2151 +{ +# 2152 +return __find_if(__first, __last, __pred, std::__iterator_category(__first)); +# 2154 +} +# 2156 +template< class _InputIterator, class _Predicate> typename iterator_traits< _InputIterator> ::difference_type +# 2159 +__count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) +# 2160 +{ +# 2161 +typename iterator_traits< _InputIterator> ::difference_type __n = (0); +# 2162 +for (; __first != __last; ++__first) { +# 2163 +if (__pred(__first)) { +# 2164 +++__n; } } +# 2165 +return __n; +# 2166 +} +# 2168 +template< class _ForwardIterator, class _Predicate> _ForwardIterator +# 2171 +__remove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate +# 2172 +__pred) +# 2173 +{ +# 2174 +__first = std::__find_if(__first, __last, __pred); +# 2175 +if (__first == __last) { +# 2176 +return __first; } +# 2177 +_ForwardIterator __result = __first; +# 2178 +++__first; +# 2179 +for (; __first != __last; ++__first) { +# 2180 +if (!__pred(__first)) +# 2181 +{ +# 2182 +(*__result) = std::move(*__first); +# 2183 +++__result; +# 2184 +} } +# 2185 +return __result; +# 2186 +} +# 2188 +template< class _ForwardIterator1, class _ForwardIterator2, class +# 2189 +_BinaryPredicate> _ForwardIterator1 +# 2192 +__search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 +# 2193 +__first2, _ForwardIterator2 __last2, _BinaryPredicate +# 2194 +__predicate) +# 2195 +{ +# 2197 +if ((__first1 == __last1) || (__first2 == __last2)) { +# 2198 +return __first1; } +# 2201 +_ForwardIterator2 __p1(__first2); +# 2202 +if ((++__p1) == __last2) { +# 2203 +return std::__find_if(__first1, __last1, __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); } +# 2207 +_ForwardIterator1 __current = __first1; +# 2209 +for (; ;) +# 2210 +{ +# 2211 +__first1 = std::__find_if(__first1, __last1, __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); +# 2215 +if (__first1 == __last1) { +# 2216 +return __last1; } +# 2218 +_ForwardIterator2 __p = __p1; +# 2219 +__current = __first1; +# 2220 +if ((++__current) == __last1) { +# 2221 +return __last1; } +# 2223 +while (__predicate(__current, __p)) +# 2224 +{ +# 2225 +if ((++__p) == __last2) { +# 2226 +return __first1; } +# 2227 +if ((++__current) == __last1) { +# 2228 +return __last1; } +# 2229 +} +# 2230 +++__first1; +# 2231 +} +# 2232 +return __first1; +# 2233 +} +# 2236 +template< class _ForwardIterator1, class _ForwardIterator2, class +# 2237 +_BinaryPredicate> bool +# 2240 +__is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 +# 2241 +__first2, _BinaryPredicate __pred) +# 2242 +{ +# 2245 +for (; __first1 != __last1; (++__first1), ((void)(++__first2))) { +# 2246 +if (!__pred(__first1, __first2)) { +# 2247 +break; } } +# 2249 +if (__first1 == __last1) { +# 2250 +return true; } +# 2254 +_ForwardIterator2 __last2 = __first2; +# 2255 +std::advance(__last2, std::distance(__first1, __last1)); +# 2256 +for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) +# 2257 +{ +# 2258 +if (__scan != std::__find_if(__first1, __scan, __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) { +# 2260 +continue; } +# 2262 +auto __matches = std::__count_if(__first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); +# 2265 +if ((0 == __matches) || (std::__count_if(__scan, __last1, __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) != __matches)) { +# 2269 +return false; } +# 2270 +} +# 2271 +return true; +# 2272 +} +# 2286 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _ForwardIterator1, class _ForwardIterator2> inline bool +# 2289 +is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 +# 2290 +__first2) +# 2291 +{ +# 2298 +; +# 2300 +return std::__is_permutation(__first1, __last1, __first2, __gnu_cxx::__ops::__iter_equal_to_iter()); +# 2302 +} +# 2328 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _ForwardIterator1, class _ForwardIterator2, class +# 2329 +_BinaryPredicate> inline _ForwardIterator1 +# 2332 +search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 +# 2333 +__first2, _ForwardIterator2 __last2, _BinaryPredicate +# 2334 +__predicate) +# 2335 +{ +# 2342 +; +# 2343 +; +# 2345 +return std::__search(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__predicate)); +# 2347 +} +# 2351 +} +# 158 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +namespace std __attribute((__visibility__("default"))) { +# 167 +enum float_round_style { +# 169 +round_indeterminate = (-1), +# 170 +round_toward_zero = 0, +# 171 +round_to_nearest, +# 172 +round_toward_infinity, +# 173 +round_toward_neg_infinity +# 174 +}; +# 182 +enum float_denorm_style { +# 185 +denorm_indeterminate = (-1), +# 187 +denorm_absent = 0, +# 189 +denorm_present +# 190 +}; +# 202 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +struct __numeric_limits_base { +# 206 +static constexpr inline bool is_specialized = false; +# 211 +static constexpr inline int digits = 0; +# 214 +static constexpr inline int digits10 = 0; +# 219 +static constexpr inline int max_digits10 = 0; +# 223 +static constexpr inline bool is_signed = false; +# 226 +static constexpr inline bool is_integer = false; +# 231 +static constexpr inline bool is_exact = false; +# 235 +static constexpr inline int radix = 0; +# 239 +static constexpr inline int min_exponent = 0; +# 243 +static constexpr inline int min_exponent10 = 0; +# 248 +static constexpr inline int max_exponent = 0; +# 252 +static constexpr inline int max_exponent10 = 0; +# 255 +static constexpr inline bool has_infinity = false; +# 259 +static constexpr inline bool has_quiet_NaN = false; +# 263 +static constexpr inline bool has_signaling_NaN = false; +# 266 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 270 +static constexpr inline bool has_denorm_loss = false; +# 274 +static constexpr inline bool is_iec559 = false; +# 279 +static constexpr inline bool is_bounded = false; +# 288 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +static constexpr inline bool is_modulo = false; +# 291 +static constexpr inline bool traps = false; +# 294 +static constexpr inline bool tinyness_before = false; +# 299 +static constexpr inline float_round_style round_style = round_toward_zero; +# 301 +}; +# 311 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +template< class _Tp> +# 312 +struct numeric_limits : public __numeric_limits_base { +# 317 +static constexpr _Tp min() noexcept { return _Tp(); } +# 321 +static constexpr _Tp max() noexcept { return _Tp(); } +# 327 +static constexpr _Tp lowest() noexcept { return _Tp(); } +# 333 +static constexpr _Tp epsilon() noexcept { return _Tp(); } +# 337 +static constexpr _Tp round_error() noexcept { return _Tp(); } +# 341 +static constexpr _Tp infinity() noexcept { return _Tp(); } +# 346 +static constexpr _Tp quiet_NaN() noexcept { return _Tp(); } +# 351 +static constexpr _Tp signaling_NaN() noexcept { return _Tp(); } +# 357 +static constexpr _Tp denorm_min() noexcept { return _Tp(); } +# 358 +}; +# 363 +template< class _Tp> +# 364 +struct numeric_limits< const _Tp> : public std::numeric_limits< _Tp> { +# 365 +}; +# 367 +template< class _Tp> +# 368 +struct numeric_limits< volatile _Tp> : public std::numeric_limits< _Tp> { +# 369 +}; +# 371 +template< class _Tp> +# 372 +struct numeric_limits< const volatile _Tp> : public std::numeric_limits< _Tp> { +# 373 +}; +# 384 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +template<> struct numeric_limits< bool> { +# 386 +static constexpr inline bool is_specialized = true; +# 389 +static constexpr bool min() noexcept { return false; } +# 392 +static constexpr bool max() noexcept { return true; } +# 396 +static constexpr bool lowest() noexcept { return min(); } +# 398 +static constexpr inline int digits = 1; +# 399 +static constexpr inline int digits10 = 0; +# 401 +static constexpr inline int max_digits10 = 0; +# 403 +static constexpr inline bool is_signed = false; +# 404 +static constexpr inline bool is_integer = true; +# 405 +static constexpr inline bool is_exact = true; +# 406 +static constexpr inline int radix = 2; +# 409 +static constexpr bool epsilon() noexcept { return false; } +# 412 +static constexpr bool round_error() noexcept { return false; } +# 414 +static constexpr inline int min_exponent = 0; +# 415 +static constexpr inline int min_exponent10 = 0; +# 416 +static constexpr inline int max_exponent = 0; +# 417 +static constexpr inline int max_exponent10 = 0; +# 419 +static constexpr inline bool has_infinity = false; +# 420 +static constexpr inline bool has_quiet_NaN = false; +# 421 +static constexpr inline bool has_signaling_NaN = false; +# 422 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 424 +static constexpr inline bool has_denorm_loss = false; +# 427 +static constexpr bool infinity() noexcept { return false; } +# 430 +static constexpr bool quiet_NaN() noexcept { return false; } +# 433 +static constexpr bool signaling_NaN() noexcept { return false; } +# 436 +static constexpr bool denorm_min() noexcept { return false; } +# 438 +static constexpr inline bool is_iec559 = false; +# 439 +static constexpr inline bool is_bounded = true; +# 440 +static constexpr inline bool is_modulo = false; +# 445 +static constexpr inline bool traps = true; +# 446 +static constexpr inline bool tinyness_before = false; +# 447 +static constexpr inline float_round_style round_style = round_toward_zero; +# 449 +}; +# 453 +template<> struct numeric_limits< char> { +# 455 +static constexpr inline bool is_specialized = true; +# 458 +static constexpr char min() noexcept { return ((((char)(-1)) < 0) ? (-((((char)(-1)) < 0) ? (((((char)1) << (((sizeof(char) * (8)) - (((char)(-1)) < 0)) - (1))) - 1) << 1) + 1 : (~((char)0)))) - 1 : ((char)0)); } +# 461 +static constexpr char max() noexcept { return ((((char)(-1)) < 0) ? (((((char)1) << (((sizeof(char) * (8)) - (((char)(-1)) < 0)) - (1))) - 1) << 1) + 1 : (~((char)0))); } +# 465 +static constexpr char lowest() noexcept { return min(); } +# 468 +static constexpr inline int digits = ((sizeof(char) * (8)) - (((char)(-1)) < 0)); +# 469 +static constexpr inline int digits10 = ((((sizeof(char) * (8)) - (((char)(-1)) < 0)) * (643L)) / (2136)); +# 471 +static constexpr inline int max_digits10 = 0; +# 473 +static constexpr inline bool is_signed = (((char)(-1)) < 0); +# 474 +static constexpr inline bool is_integer = true; +# 475 +static constexpr inline bool is_exact = true; +# 476 +static constexpr inline int radix = 2; +# 479 +static constexpr char epsilon() noexcept { return 0; } +# 482 +static constexpr char round_error() noexcept { return 0; } +# 484 +static constexpr inline int min_exponent = 0; +# 485 +static constexpr inline int min_exponent10 = 0; +# 486 +static constexpr inline int max_exponent = 0; +# 487 +static constexpr inline int max_exponent10 = 0; +# 489 +static constexpr inline bool has_infinity = false; +# 490 +static constexpr inline bool has_quiet_NaN = false; +# 491 +static constexpr inline bool has_signaling_NaN = false; +# 492 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 494 +static constexpr inline bool has_denorm_loss = false; +# 497 +static constexpr char infinity() noexcept { return ((char)0); } +# 500 +static constexpr char quiet_NaN() noexcept { return ((char)0); } +# 503 +static constexpr char signaling_NaN() noexcept { return ((char)0); } +# 506 +static constexpr char denorm_min() noexcept { return static_cast< char>(0); } +# 508 +static constexpr inline bool is_iec559 = false; +# 509 +static constexpr inline bool is_bounded = true; +# 510 +static constexpr inline bool is_modulo = (!is_signed); +# 512 +static constexpr inline bool traps = true; +# 513 +static constexpr inline bool tinyness_before = false; +# 514 +static constexpr inline float_round_style round_style = round_toward_zero; +# 516 +}; +# 520 +template<> struct numeric_limits< signed char> { +# 522 +static constexpr inline bool is_specialized = true; +# 525 +static constexpr signed char min() noexcept { return (-127) - 1; } +# 528 +static constexpr signed char max() noexcept { return 127; } +# 532 +static constexpr signed char lowest() noexcept { return min(); } +# 535 +static constexpr inline int digits = ((sizeof(signed char) * (8)) - (((signed char)(-1)) < 0)); +# 536 +static constexpr inline int digits10 = ((((sizeof(signed char) * (8)) - (((signed char)(-1)) < 0)) * (643L)) / (2136)); +# 539 +static constexpr inline int max_digits10 = 0; +# 541 +static constexpr inline bool is_signed = true; +# 542 +static constexpr inline bool is_integer = true; +# 543 +static constexpr inline bool is_exact = true; +# 544 +static constexpr inline int radix = 2; +# 547 +static constexpr signed char epsilon() noexcept { return 0; } +# 550 +static constexpr signed char round_error() noexcept { return 0; } +# 552 +static constexpr inline int min_exponent = 0; +# 553 +static constexpr inline int min_exponent10 = 0; +# 554 +static constexpr inline int max_exponent = 0; +# 555 +static constexpr inline int max_exponent10 = 0; +# 557 +static constexpr inline bool has_infinity = false; +# 558 +static constexpr inline bool has_quiet_NaN = false; +# 559 +static constexpr inline bool has_signaling_NaN = false; +# 560 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 562 +static constexpr inline bool has_denorm_loss = false; +# 565 +static constexpr signed char infinity() noexcept { return static_cast< signed char>(0); } +# 568 +static constexpr signed char quiet_NaN() noexcept { return static_cast< signed char>(0); } +# 571 +static constexpr signed char signaling_NaN() noexcept +# 572 +{ return static_cast< signed char>(0); } +# 575 +static constexpr signed char denorm_min() noexcept +# 576 +{ return static_cast< signed char>(0); } +# 578 +static constexpr inline bool is_iec559 = false; +# 579 +static constexpr inline bool is_bounded = true; +# 580 +static constexpr inline bool is_modulo = false; +# 582 +static constexpr inline bool traps = true; +# 583 +static constexpr inline bool tinyness_before = false; +# 584 +static constexpr inline float_round_style round_style = round_toward_zero; +# 586 +}; +# 590 +template<> struct numeric_limits< unsigned char> { +# 592 +static constexpr inline bool is_specialized = true; +# 595 +static constexpr unsigned char min() noexcept { return 0; } +# 598 +static constexpr unsigned char max() noexcept { return ((127) * 2U) + (1); } +# 602 +static constexpr unsigned char lowest() noexcept { return min(); } +# 605 +static constexpr inline int digits = ((sizeof(unsigned char) * (8)) - (((unsigned char)(-1)) < 0)); +# 607 +static constexpr inline int digits10 = ((((sizeof(unsigned char) * (8)) - (((unsigned char)(-1)) < 0)) * (643L)) / (2136)); +# 610 +static constexpr inline int max_digits10 = 0; +# 612 +static constexpr inline bool is_signed = false; +# 613 +static constexpr inline bool is_integer = true; +# 614 +static constexpr inline bool is_exact = true; +# 615 +static constexpr inline int radix = 2; +# 618 +static constexpr unsigned char epsilon() noexcept { return 0; } +# 621 +static constexpr unsigned char round_error() noexcept { return 0; } +# 623 +static constexpr inline int min_exponent = 0; +# 624 +static constexpr inline int min_exponent10 = 0; +# 625 +static constexpr inline int max_exponent = 0; +# 626 +static constexpr inline int max_exponent10 = 0; +# 628 +static constexpr inline bool has_infinity = false; +# 629 +static constexpr inline bool has_quiet_NaN = false; +# 630 +static constexpr inline bool has_signaling_NaN = false; +# 631 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 633 +static constexpr inline bool has_denorm_loss = false; +# 636 +static constexpr unsigned char infinity() noexcept +# 637 +{ return static_cast< unsigned char>(0); } +# 640 +static constexpr unsigned char quiet_NaN() noexcept +# 641 +{ return static_cast< unsigned char>(0); } +# 644 +static constexpr unsigned char signaling_NaN() noexcept +# 645 +{ return static_cast< unsigned char>(0); } +# 648 +static constexpr unsigned char denorm_min() noexcept +# 649 +{ return static_cast< unsigned char>(0); } +# 651 +static constexpr inline bool is_iec559 = false; +# 652 +static constexpr inline bool is_bounded = true; +# 653 +static constexpr inline bool is_modulo = true; +# 655 +static constexpr inline bool traps = true; +# 656 +static constexpr inline bool tinyness_before = false; +# 657 +static constexpr inline float_round_style round_style = round_toward_zero; +# 659 +}; +# 663 +template<> struct numeric_limits< wchar_t> { +# 665 +static constexpr inline bool is_specialized = true; +# 668 +static constexpr wchar_t min() noexcept { return ((((wchar_t)(-1)) < 0) ? (-((((wchar_t)(-1)) < 0) ? (((((wchar_t)1) << (((sizeof(wchar_t) * (8)) - (((wchar_t)(-1)) < 0)) - (1))) - 1) << 1) + 1 : (~((wchar_t)0)))) - 1 : ((wchar_t)0)); } +# 671 +static constexpr wchar_t max() noexcept { return ((((wchar_t)(-1)) < 0) ? (((((wchar_t)1) << (((sizeof(wchar_t) * (8)) - (((wchar_t)(-1)) < 0)) - (1))) - 1) << 1) + 1 : (~((wchar_t)0))); } +# 675 +static constexpr wchar_t lowest() noexcept { return min(); } +# 678 +static constexpr inline int digits = ((sizeof(wchar_t) * (8)) - (((wchar_t)(-1)) < 0)); +# 679 +static constexpr inline int digits10 = ((((sizeof(wchar_t) * (8)) - (((wchar_t)(-1)) < 0)) * (643L)) / (2136)); +# 682 +static constexpr inline int max_digits10 = 0; +# 684 +static constexpr inline bool is_signed = (((wchar_t)(-1)) < 0); +# 685 +static constexpr inline bool is_integer = true; +# 686 +static constexpr inline bool is_exact = true; +# 687 +static constexpr inline int radix = 2; +# 690 +static constexpr wchar_t epsilon() noexcept { return 0; } +# 693 +static constexpr wchar_t round_error() noexcept { return 0; } +# 695 +static constexpr inline int min_exponent = 0; +# 696 +static constexpr inline int min_exponent10 = 0; +# 697 +static constexpr inline int max_exponent = 0; +# 698 +static constexpr inline int max_exponent10 = 0; +# 700 +static constexpr inline bool has_infinity = false; +# 701 +static constexpr inline bool has_quiet_NaN = false; +# 702 +static constexpr inline bool has_signaling_NaN = false; +# 703 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 705 +static constexpr inline bool has_denorm_loss = false; +# 708 +static constexpr wchar_t infinity() noexcept { return ((wchar_t)0); } +# 711 +static constexpr wchar_t quiet_NaN() noexcept { return ((wchar_t)0); } +# 714 +static constexpr wchar_t signaling_NaN() noexcept { return ((wchar_t)0); } +# 717 +static constexpr wchar_t denorm_min() noexcept { return ((wchar_t)0); } +# 719 +static constexpr inline bool is_iec559 = false; +# 720 +static constexpr inline bool is_bounded = true; +# 721 +static constexpr inline bool is_modulo = (!is_signed); +# 723 +static constexpr inline bool traps = true; +# 724 +static constexpr inline bool tinyness_before = false; +# 725 +static constexpr inline float_round_style round_style = round_toward_zero; +# 727 +}; +# 797 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +template<> struct numeric_limits< char16_t> { +# 799 +static constexpr inline bool is_specialized = true; +# 802 +static constexpr char16_t min() noexcept { return ((((char16_t)(-1)) < 0) ? (-((((char16_t)(-1)) < 0) ? (((((char16_t)1) << (((sizeof(char16_t) * (8)) - (((char16_t)(-1)) < 0)) - (1))) - 1) << 1) + 1 : (~((char16_t)0)))) - 1 : ((char16_t)0)); } +# 805 +static constexpr char16_t max() noexcept { return ((((char16_t)(-1)) < 0) ? (((((char16_t)1) << (((sizeof(char16_t) * (8)) - (((char16_t)(-1)) < 0)) - (1))) - 1) << 1) + 1 : (~((char16_t)0))); } +# 808 +static constexpr char16_t lowest() noexcept { return min(); } +# 810 +static constexpr inline int digits = ((sizeof(char16_t) * (8)) - (((char16_t)(-1)) < 0)); +# 811 +static constexpr inline int digits10 = ((((sizeof(char16_t) * (8)) - (((char16_t)(-1)) < 0)) * (643L)) / (2136)); +# 812 +static constexpr inline int max_digits10 = 0; +# 813 +static constexpr inline bool is_signed = (((char16_t)(-1)) < 0); +# 814 +static constexpr inline bool is_integer = true; +# 815 +static constexpr inline bool is_exact = true; +# 816 +static constexpr inline int radix = 2; +# 819 +static constexpr char16_t epsilon() noexcept { return 0; } +# 822 +static constexpr char16_t round_error() noexcept { return 0; } +# 824 +static constexpr inline int min_exponent = 0; +# 825 +static constexpr inline int min_exponent10 = 0; +# 826 +static constexpr inline int max_exponent = 0; +# 827 +static constexpr inline int max_exponent10 = 0; +# 829 +static constexpr inline bool has_infinity = false; +# 830 +static constexpr inline bool has_quiet_NaN = false; +# 831 +static constexpr inline bool has_signaling_NaN = false; +# 832 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 833 +static constexpr inline bool has_denorm_loss = false; +# 836 +static constexpr char16_t infinity() noexcept { return ((char16_t)0); } +# 839 +static constexpr char16_t quiet_NaN() noexcept { return ((char16_t)0); } +# 842 +static constexpr char16_t signaling_NaN() noexcept { return ((char16_t)0); } +# 845 +static constexpr char16_t denorm_min() noexcept { return ((char16_t)0); } +# 847 +static constexpr inline bool is_iec559 = false; +# 848 +static constexpr inline bool is_bounded = true; +# 849 +static constexpr inline bool is_modulo = (!is_signed); +# 851 +static constexpr inline bool traps = true; +# 852 +static constexpr inline bool tinyness_before = false; +# 853 +static constexpr inline float_round_style round_style = round_toward_zero; +# 854 +}; +# 858 +template<> struct numeric_limits< char32_t> { +# 860 +static constexpr inline bool is_specialized = true; +# 863 +static constexpr char32_t min() noexcept { return ((((char32_t)(-1)) < (0)) ? (-((((char32_t)(-1)) < (0)) ? (((((char32_t)1) << (((sizeof(char32_t) * (8)) - (((char32_t)(-1)) < (0))) - (1))) - (1)) << 1) + (1) : (~((char32_t)0)))) - (1) : ((char32_t)0)); } +# 866 +static constexpr char32_t max() noexcept { return ((((char32_t)(-1)) < (0)) ? (((((char32_t)1) << (((sizeof(char32_t) * (8)) - (((char32_t)(-1)) < (0))) - (1))) - (1)) << 1) + (1) : (~((char32_t)0))); } +# 869 +static constexpr char32_t lowest() noexcept { return min(); } +# 871 +static constexpr inline int digits = ((sizeof(char32_t) * (8)) - (((char32_t)(-1)) < (0))); +# 872 +static constexpr inline int digits10 = ((((sizeof(char32_t) * (8)) - (((char32_t)(-1)) < (0))) * (643L)) / (2136)); +# 873 +static constexpr inline int max_digits10 = 0; +# 874 +static constexpr inline bool is_signed = (((char32_t)(-1)) < (0)); +# 875 +static constexpr inline bool is_integer = true; +# 876 +static constexpr inline bool is_exact = true; +# 877 +static constexpr inline int radix = 2; +# 880 +static constexpr char32_t epsilon() noexcept { return 0; } +# 883 +static constexpr char32_t round_error() noexcept { return 0; } +# 885 +static constexpr inline int min_exponent = 0; +# 886 +static constexpr inline int min_exponent10 = 0; +# 887 +static constexpr inline int max_exponent = 0; +# 888 +static constexpr inline int max_exponent10 = 0; +# 890 +static constexpr inline bool has_infinity = false; +# 891 +static constexpr inline bool has_quiet_NaN = false; +# 892 +static constexpr inline bool has_signaling_NaN = false; +# 893 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 894 +static constexpr inline bool has_denorm_loss = false; +# 897 +static constexpr char32_t infinity() noexcept { return ((char32_t)0); } +# 900 +static constexpr char32_t quiet_NaN() noexcept { return ((char32_t)0); } +# 903 +static constexpr char32_t signaling_NaN() noexcept { return ((char32_t)0); } +# 906 +static constexpr char32_t denorm_min() noexcept { return ((char32_t)0); } +# 908 +static constexpr inline bool is_iec559 = false; +# 909 +static constexpr inline bool is_bounded = true; +# 910 +static constexpr inline bool is_modulo = (!is_signed); +# 912 +static constexpr inline bool traps = true; +# 913 +static constexpr inline bool tinyness_before = false; +# 914 +static constexpr inline float_round_style round_style = round_toward_zero; +# 915 +}; +# 920 +template<> struct numeric_limits< short> { +# 922 +static constexpr inline bool is_specialized = true; +# 925 +static constexpr short min() noexcept { return (-32767) - 1; } +# 928 +static constexpr short max() noexcept { return 32767; } +# 932 +static constexpr short lowest() noexcept { return min(); } +# 935 +static constexpr inline int digits = ((sizeof(short) * (8)) - (((short)(-1)) < 0)); +# 936 +static constexpr inline int digits10 = ((((sizeof(short) * (8)) - (((short)(-1)) < 0)) * (643L)) / (2136)); +# 938 +static constexpr inline int max_digits10 = 0; +# 940 +static constexpr inline bool is_signed = true; +# 941 +static constexpr inline bool is_integer = true; +# 942 +static constexpr inline bool is_exact = true; +# 943 +static constexpr inline int radix = 2; +# 946 +static constexpr short epsilon() noexcept { return 0; } +# 949 +static constexpr short round_error() noexcept { return 0; } +# 951 +static constexpr inline int min_exponent = 0; +# 952 +static constexpr inline int min_exponent10 = 0; +# 953 +static constexpr inline int max_exponent = 0; +# 954 +static constexpr inline int max_exponent10 = 0; +# 956 +static constexpr inline bool has_infinity = false; +# 957 +static constexpr inline bool has_quiet_NaN = false; +# 958 +static constexpr inline bool has_signaling_NaN = false; +# 959 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 961 +static constexpr inline bool has_denorm_loss = false; +# 964 +static constexpr short infinity() noexcept { return ((short)0); } +# 967 +static constexpr short quiet_NaN() noexcept { return ((short)0); } +# 970 +static constexpr short signaling_NaN() noexcept { return ((short)0); } +# 973 +static constexpr short denorm_min() noexcept { return ((short)0); } +# 975 +static constexpr inline bool is_iec559 = false; +# 976 +static constexpr inline bool is_bounded = true; +# 977 +static constexpr inline bool is_modulo = false; +# 979 +static constexpr inline bool traps = true; +# 980 +static constexpr inline bool tinyness_before = false; +# 981 +static constexpr inline float_round_style round_style = round_toward_zero; +# 983 +}; +# 987 +template<> struct numeric_limits< unsigned short> { +# 989 +static constexpr inline bool is_specialized = true; +# 992 +static constexpr unsigned short min() noexcept { return 0; } +# 995 +static constexpr unsigned short max() noexcept { return ((32767) * 2U) + (1); } +# 999 +static constexpr unsigned short lowest() noexcept { return min(); } +# 1002 +static constexpr inline int digits = ((sizeof(unsigned short) * (8)) - (((unsigned short)(-1)) < 0)); +# 1004 +static constexpr inline int digits10 = ((((sizeof(unsigned short) * (8)) - (((unsigned short)(-1)) < 0)) * (643L)) / (2136)); +# 1007 +static constexpr inline int max_digits10 = 0; +# 1009 +static constexpr inline bool is_signed = false; +# 1010 +static constexpr inline bool is_integer = true; +# 1011 +static constexpr inline bool is_exact = true; +# 1012 +static constexpr inline int radix = 2; +# 1015 +static constexpr unsigned short epsilon() noexcept { return 0; } +# 1018 +static constexpr unsigned short round_error() noexcept { return 0; } +# 1020 +static constexpr inline int min_exponent = 0; +# 1021 +static constexpr inline int min_exponent10 = 0; +# 1022 +static constexpr inline int max_exponent = 0; +# 1023 +static constexpr inline int max_exponent10 = 0; +# 1025 +static constexpr inline bool has_infinity = false; +# 1026 +static constexpr inline bool has_quiet_NaN = false; +# 1027 +static constexpr inline bool has_signaling_NaN = false; +# 1028 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 1030 +static constexpr inline bool has_denorm_loss = false; +# 1033 +static constexpr unsigned short infinity() noexcept +# 1034 +{ return static_cast< unsigned short>(0); } +# 1037 +static constexpr unsigned short quiet_NaN() noexcept +# 1038 +{ return static_cast< unsigned short>(0); } +# 1041 +static constexpr unsigned short signaling_NaN() noexcept +# 1042 +{ return static_cast< unsigned short>(0); } +# 1045 +static constexpr unsigned short denorm_min() noexcept +# 1046 +{ return static_cast< unsigned short>(0); } +# 1048 +static constexpr inline bool is_iec559 = false; +# 1049 +static constexpr inline bool is_bounded = true; +# 1050 +static constexpr inline bool is_modulo = true; +# 1052 +static constexpr inline bool traps = true; +# 1053 +static constexpr inline bool tinyness_before = false; +# 1054 +static constexpr inline float_round_style round_style = round_toward_zero; +# 1056 +}; +# 1060 +template<> struct numeric_limits< int> { +# 1062 +static constexpr inline bool is_specialized = true; +# 1065 +static constexpr int min() noexcept { return (-2147483647) - 1; } +# 1068 +static constexpr int max() noexcept { return 2147483647; } +# 1072 +static constexpr int lowest() noexcept { return min(); } +# 1075 +static constexpr inline int digits = ((sizeof(int) * (8)) - (((int)(-1)) < 0)); +# 1076 +static constexpr inline int digits10 = ((((sizeof(int) * (8)) - (((int)(-1)) < 0)) * (643L)) / (2136)); +# 1078 +static constexpr inline int max_digits10 = 0; +# 1080 +static constexpr inline bool is_signed = true; +# 1081 +static constexpr inline bool is_integer = true; +# 1082 +static constexpr inline bool is_exact = true; +# 1083 +static constexpr inline int radix = 2; +# 1086 +static constexpr int epsilon() noexcept { return 0; } +# 1089 +static constexpr int round_error() noexcept { return 0; } +# 1091 +static constexpr inline int min_exponent = 0; +# 1092 +static constexpr inline int min_exponent10 = 0; +# 1093 +static constexpr inline int max_exponent = 0; +# 1094 +static constexpr inline int max_exponent10 = 0; +# 1096 +static constexpr inline bool has_infinity = false; +# 1097 +static constexpr inline bool has_quiet_NaN = false; +# 1098 +static constexpr inline bool has_signaling_NaN = false; +# 1099 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 1101 +static constexpr inline bool has_denorm_loss = false; +# 1104 +static constexpr int infinity() noexcept { return static_cast< int>(0); } +# 1107 +static constexpr int quiet_NaN() noexcept { return static_cast< int>(0); } +# 1110 +static constexpr int signaling_NaN() noexcept { return static_cast< int>(0); } +# 1113 +static constexpr int denorm_min() noexcept { return static_cast< int>(0); } +# 1115 +static constexpr inline bool is_iec559 = false; +# 1116 +static constexpr inline bool is_bounded = true; +# 1117 +static constexpr inline bool is_modulo = false; +# 1119 +static constexpr inline bool traps = true; +# 1120 +static constexpr inline bool tinyness_before = false; +# 1121 +static constexpr inline float_round_style round_style = round_toward_zero; +# 1123 +}; +# 1127 +template<> struct numeric_limits< unsigned> { +# 1129 +static constexpr inline bool is_specialized = true; +# 1132 +static constexpr unsigned min() noexcept { return 0; } +# 1135 +static constexpr unsigned max() noexcept { return ((2147483647) * 2U) + (1); } +# 1139 +static constexpr unsigned lowest() noexcept { return min(); } +# 1142 +static constexpr inline int digits = ((sizeof(unsigned) * (8)) - (((unsigned)(-1)) < (0))); +# 1144 +static constexpr inline int digits10 = ((((sizeof(unsigned) * (8)) - (((unsigned)(-1)) < (0))) * (643L)) / (2136)); +# 1147 +static constexpr inline int max_digits10 = 0; +# 1149 +static constexpr inline bool is_signed = false; +# 1150 +static constexpr inline bool is_integer = true; +# 1151 +static constexpr inline bool is_exact = true; +# 1152 +static constexpr inline int radix = 2; +# 1155 +static constexpr unsigned epsilon() noexcept { return 0; } +# 1158 +static constexpr unsigned round_error() noexcept { return 0; } +# 1160 +static constexpr inline int min_exponent = 0; +# 1161 +static constexpr inline int min_exponent10 = 0; +# 1162 +static constexpr inline int max_exponent = 0; +# 1163 +static constexpr inline int max_exponent10 = 0; +# 1165 +static constexpr inline bool has_infinity = false; +# 1166 +static constexpr inline bool has_quiet_NaN = false; +# 1167 +static constexpr inline bool has_signaling_NaN = false; +# 1168 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 1170 +static constexpr inline bool has_denorm_loss = false; +# 1173 +static constexpr unsigned infinity() noexcept { return static_cast< unsigned>(0); } +# 1176 +static constexpr unsigned quiet_NaN() noexcept +# 1177 +{ return static_cast< unsigned>(0); } +# 1180 +static constexpr unsigned signaling_NaN() noexcept +# 1181 +{ return static_cast< unsigned>(0); } +# 1184 +static constexpr unsigned denorm_min() noexcept +# 1185 +{ return static_cast< unsigned>(0); } +# 1187 +static constexpr inline bool is_iec559 = false; +# 1188 +static constexpr inline bool is_bounded = true; +# 1189 +static constexpr inline bool is_modulo = true; +# 1191 +static constexpr inline bool traps = true; +# 1192 +static constexpr inline bool tinyness_before = false; +# 1193 +static constexpr inline float_round_style round_style = round_toward_zero; +# 1195 +}; +# 1199 +template<> struct numeric_limits< long> { +# 1201 +static constexpr inline bool is_specialized = true; +# 1204 +static constexpr long min() noexcept { return (-9223372036854775807L) - (1); } +# 1207 +static constexpr long max() noexcept { return 9223372036854775807L; } +# 1211 +static constexpr long lowest() noexcept { return min(); } +# 1214 +static constexpr inline int digits = ((sizeof(long) * (8)) - (((long)(-1)) < (0))); +# 1215 +static constexpr inline int digits10 = ((((sizeof(long) * (8)) - (((long)(-1)) < (0))) * (643L)) / (2136)); +# 1217 +static constexpr inline int max_digits10 = 0; +# 1219 +static constexpr inline bool is_signed = true; +# 1220 +static constexpr inline bool is_integer = true; +# 1221 +static constexpr inline bool is_exact = true; +# 1222 +static constexpr inline int radix = 2; +# 1225 +static constexpr long epsilon() noexcept { return 0; } +# 1228 +static constexpr long round_error() noexcept { return 0; } +# 1230 +static constexpr inline int min_exponent = 0; +# 1231 +static constexpr inline int min_exponent10 = 0; +# 1232 +static constexpr inline int max_exponent = 0; +# 1233 +static constexpr inline int max_exponent10 = 0; +# 1235 +static constexpr inline bool has_infinity = false; +# 1236 +static constexpr inline bool has_quiet_NaN = false; +# 1237 +static constexpr inline bool has_signaling_NaN = false; +# 1238 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 1240 +static constexpr inline bool has_denorm_loss = false; +# 1243 +static constexpr long infinity() noexcept { return static_cast< long>(0); } +# 1246 +static constexpr long quiet_NaN() noexcept { return static_cast< long>(0); } +# 1249 +static constexpr long signaling_NaN() noexcept { return static_cast< long>(0); } +# 1252 +static constexpr long denorm_min() noexcept { return static_cast< long>(0); } +# 1254 +static constexpr inline bool is_iec559 = false; +# 1255 +static constexpr inline bool is_bounded = true; +# 1256 +static constexpr inline bool is_modulo = false; +# 1258 +static constexpr inline bool traps = true; +# 1259 +static constexpr inline bool tinyness_before = false; +# 1260 +static constexpr inline float_round_style round_style = round_toward_zero; +# 1262 +}; +# 1266 +template<> struct numeric_limits< unsigned long> { +# 1268 +static constexpr inline bool is_specialized = true; +# 1271 +static constexpr unsigned long min() noexcept { return 0; } +# 1274 +static constexpr unsigned long max() noexcept { return ((9223372036854775807L) * 2UL) + (1); } +# 1278 +static constexpr unsigned long lowest() noexcept { return min(); } +# 1281 +static constexpr inline int digits = ((sizeof(unsigned long) * (8)) - (((unsigned long)(-1)) < (0))); +# 1283 +static constexpr inline int digits10 = ((((sizeof(unsigned long) * (8)) - (((unsigned long)(-1)) < (0))) * (643L)) / (2136)); +# 1286 +static constexpr inline int max_digits10 = 0; +# 1288 +static constexpr inline bool is_signed = false; +# 1289 +static constexpr inline bool is_integer = true; +# 1290 +static constexpr inline bool is_exact = true; +# 1291 +static constexpr inline int radix = 2; +# 1294 +static constexpr unsigned long epsilon() noexcept { return 0; } +# 1297 +static constexpr unsigned long round_error() noexcept { return 0; } +# 1299 +static constexpr inline int min_exponent = 0; +# 1300 +static constexpr inline int min_exponent10 = 0; +# 1301 +static constexpr inline int max_exponent = 0; +# 1302 +static constexpr inline int max_exponent10 = 0; +# 1304 +static constexpr inline bool has_infinity = false; +# 1305 +static constexpr inline bool has_quiet_NaN = false; +# 1306 +static constexpr inline bool has_signaling_NaN = false; +# 1307 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 1309 +static constexpr inline bool has_denorm_loss = false; +# 1312 +static constexpr unsigned long infinity() noexcept +# 1313 +{ return static_cast< unsigned long>(0); } +# 1316 +static constexpr unsigned long quiet_NaN() noexcept +# 1317 +{ return static_cast< unsigned long>(0); } +# 1320 +static constexpr unsigned long signaling_NaN() noexcept +# 1321 +{ return static_cast< unsigned long>(0); } +# 1324 +static constexpr unsigned long denorm_min() noexcept +# 1325 +{ return static_cast< unsigned long>(0); } +# 1327 +static constexpr inline bool is_iec559 = false; +# 1328 +static constexpr inline bool is_bounded = true; +# 1329 +static constexpr inline bool is_modulo = true; +# 1331 +static constexpr inline bool traps = true; +# 1332 +static constexpr inline bool tinyness_before = false; +# 1333 +static constexpr inline float_round_style round_style = round_toward_zero; +# 1335 +}; +# 1339 +template<> struct numeric_limits< long long> { +# 1341 +static constexpr inline bool is_specialized = true; +# 1344 +static constexpr long long min() noexcept { return (-9223372036854775807LL) - (1); } +# 1347 +static constexpr long long max() noexcept { return 9223372036854775807LL; } +# 1351 +static constexpr long long lowest() noexcept { return min(); } +# 1354 +static constexpr inline int digits = ((sizeof(long long) * (8)) - (((long long)(-1)) < (0))); +# 1356 +static constexpr inline int digits10 = ((((sizeof(long long) * (8)) - (((long long)(-1)) < (0))) * (643L)) / (2136)); +# 1359 +static constexpr inline int max_digits10 = 0; +# 1361 +static constexpr inline bool is_signed = true; +# 1362 +static constexpr inline bool is_integer = true; +# 1363 +static constexpr inline bool is_exact = true; +# 1364 +static constexpr inline int radix = 2; +# 1367 +static constexpr long long epsilon() noexcept { return 0; } +# 1370 +static constexpr long long round_error() noexcept { return 0; } +# 1372 +static constexpr inline int min_exponent = 0; +# 1373 +static constexpr inline int min_exponent10 = 0; +# 1374 +static constexpr inline int max_exponent = 0; +# 1375 +static constexpr inline int max_exponent10 = 0; +# 1377 +static constexpr inline bool has_infinity = false; +# 1378 +static constexpr inline bool has_quiet_NaN = false; +# 1379 +static constexpr inline bool has_signaling_NaN = false; +# 1380 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 1382 +static constexpr inline bool has_denorm_loss = false; +# 1385 +static constexpr long long infinity() noexcept { return static_cast< long long>(0); } +# 1388 +static constexpr long long quiet_NaN() noexcept { return static_cast< long long>(0); } +# 1391 +static constexpr long long signaling_NaN() noexcept +# 1392 +{ return static_cast< long long>(0); } +# 1395 +static constexpr long long denorm_min() noexcept { return static_cast< long long>(0); } +# 1397 +static constexpr inline bool is_iec559 = false; +# 1398 +static constexpr inline bool is_bounded = true; +# 1399 +static constexpr inline bool is_modulo = false; +# 1401 +static constexpr inline bool traps = true; +# 1402 +static constexpr inline bool tinyness_before = false; +# 1403 +static constexpr inline float_round_style round_style = round_toward_zero; +# 1405 +}; +# 1409 +template<> struct numeric_limits< unsigned long long> { +# 1411 +static constexpr inline bool is_specialized = true; +# 1414 +static constexpr unsigned long long min() noexcept { return 0; } +# 1417 +static constexpr unsigned long long max() noexcept { return ((9223372036854775807LL) * 2ULL) + (1); } +# 1421 +static constexpr unsigned long long lowest() noexcept { return min(); } +# 1424 +static constexpr inline int digits = ((sizeof(unsigned long long) * (8)) - (((unsigned long long)(-1)) < (0))); +# 1426 +static constexpr inline int digits10 = ((((sizeof(unsigned long long) * (8)) - (((unsigned long long)(-1)) < (0))) * (643L)) / (2136)); +# 1429 +static constexpr inline int max_digits10 = 0; +# 1431 +static constexpr inline bool is_signed = false; +# 1432 +static constexpr inline bool is_integer = true; +# 1433 +static constexpr inline bool is_exact = true; +# 1434 +static constexpr inline int radix = 2; +# 1437 +static constexpr unsigned long long epsilon() noexcept { return 0; } +# 1440 +static constexpr unsigned long long round_error() noexcept { return 0; } +# 1442 +static constexpr inline int min_exponent = 0; +# 1443 +static constexpr inline int min_exponent10 = 0; +# 1444 +static constexpr inline int max_exponent = 0; +# 1445 +static constexpr inline int max_exponent10 = 0; +# 1447 +static constexpr inline bool has_infinity = false; +# 1448 +static constexpr inline bool has_quiet_NaN = false; +# 1449 +static constexpr inline bool has_signaling_NaN = false; +# 1450 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 1452 +static constexpr inline bool has_denorm_loss = false; +# 1455 +static constexpr unsigned long long infinity() noexcept +# 1456 +{ return static_cast< unsigned long long>(0); } +# 1459 +static constexpr unsigned long long quiet_NaN() noexcept +# 1460 +{ return static_cast< unsigned long long>(0); } +# 1463 +static constexpr unsigned long long signaling_NaN() noexcept +# 1464 +{ return static_cast< unsigned long long>(0); } +# 1467 +static constexpr unsigned long long denorm_min() noexcept +# 1468 +{ return static_cast< unsigned long long>(0); } +# 1470 +static constexpr inline bool is_iec559 = false; +# 1471 +static constexpr inline bool is_bounded = true; +# 1472 +static constexpr inline bool is_modulo = true; +# 1474 +static constexpr inline bool traps = true; +# 1475 +static constexpr inline bool tinyness_before = false; +# 1476 +static constexpr inline float_round_style round_style = round_toward_zero; +# 1478 +}; +# 1637 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +template<> struct numeric_limits< __int128> { static constexpr inline bool is_specialized = true; static constexpr __int128 min() noexcept { return ((((__int128)(-1)) < (0)) ? (-((((__int128)(-1)) < (0)) ? (((((__int128)1) << ((128 - (((__int128)(-1)) < (0))) - 1)) - (1)) << 1) + (1) : (~((__int128)0)))) - (1) : ((__int128)0)); } static constexpr __int128 max() noexcept { return ((((__int128)(-1)) < (0)) ? (((((__int128)1) << ((128 - (((__int128)(-1)) < (0))) - 1)) - (1)) << 1) + (1) : (~((__int128)0))); } static constexpr inline int digits = (128 - 1); static constexpr inline int digits10 = (((128 - 1) * 643L) / (2136)); static constexpr inline bool is_signed = true; static constexpr inline bool is_integer = true; static constexpr inline bool is_exact = true; static constexpr inline int radix = 2; static constexpr __int128 epsilon() noexcept { return 0; } static constexpr __int128 round_error() noexcept { return 0; } static constexpr __int128 lowest() noexcept { return min(); } static constexpr inline int max_digits10 = 0; static constexpr inline int min_exponent = 0; static constexpr inline int min_exponent10 = 0; static constexpr inline int max_exponent = 0; static constexpr inline int max_exponent10 = 0; static constexpr inline bool has_infinity = false; static constexpr inline bool has_quiet_NaN = false; static constexpr inline bool has_signaling_NaN = false; static constexpr inline float_denorm_style has_denorm = denorm_absent; static constexpr inline bool has_denorm_loss = false; static constexpr __int128 infinity() noexcept { return static_cast< __int128>(0); } static constexpr __int128 quiet_NaN() noexcept { return static_cast< __int128>(0); } static constexpr __int128 signaling_NaN() noexcept { return static_cast< __int128>(0); } static constexpr __int128 denorm_min() noexcept { return static_cast< __int128>(0); } static constexpr inline bool is_iec559 = false; static constexpr inline bool is_bounded = true; static constexpr inline bool is_modulo = false; static constexpr inline bool traps = true; static constexpr inline bool tinyness_before = false; static constexpr inline float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits< unsigned __int128> { static constexpr inline bool is_specialized = true; static constexpr unsigned __int128 min() noexcept { return 0; } static constexpr unsigned __int128 max() noexcept { return ((((unsigned __int128)(-1)) < (0)) ? (((((unsigned __int128)1) << ((128 - (((unsigned __int128)(-1)) < (0))) - 1)) - (1)) << 1) + (1) : (~((unsigned __int128)0))); } static constexpr unsigned __int128 lowest() noexcept { return min(); } static constexpr inline int max_digits10 = 0; static constexpr inline int digits = 128; static constexpr inline int digits10 = (((128) * 643L) / (2136)); static constexpr inline bool is_signed = false; static constexpr inline bool is_integer = true; static constexpr inline bool is_exact = true; static constexpr inline int radix = 2; static constexpr unsigned __int128 epsilon() noexcept { return 0; } static constexpr unsigned __int128 round_error() noexcept { return 0; } static constexpr inline int min_exponent = 0; static constexpr inline int min_exponent10 = 0; static constexpr inline int max_exponent = 0; static constexpr inline int max_exponent10 = 0; static constexpr inline bool has_infinity = false; static constexpr inline bool has_quiet_NaN = false; static constexpr inline bool has_signaling_NaN = false; static constexpr inline float_denorm_style has_denorm = denorm_absent; static constexpr inline bool has_denorm_loss = false; static constexpr unsigned __int128 infinity() noexcept { return static_cast< unsigned __int128>(0); } static constexpr unsigned __int128 quiet_NaN() noexcept { return static_cast< unsigned __int128>(0); } static constexpr unsigned __int128 signaling_NaN() noexcept { return static_cast< unsigned __int128>(0); } static constexpr unsigned __int128 denorm_min() noexcept { return static_cast< unsigned __int128>(0); } static constexpr inline bool is_iec559 = false; static constexpr inline bool is_bounded = true; static constexpr inline bool is_modulo = true; static constexpr inline bool traps = true; static constexpr inline bool tinyness_before = false; static constexpr inline float_round_style round_style = round_toward_zero; }; +# 1670 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +template<> struct numeric_limits< float> { +# 1672 +static constexpr inline bool is_specialized = true; +# 1675 +static constexpr float min() noexcept { return (1.1754944E-38F); } +# 1678 +static constexpr float max() noexcept { return (3.4028235E38F); } +# 1682 +static constexpr float lowest() noexcept { return -(3.4028235E38F); } +# 1685 +static constexpr inline int digits = 24; +# 1686 +static constexpr inline int digits10 = 6; +# 1688 +static constexpr inline int max_digits10 = ((2) + (((24) * 643L) / (2136))); +# 1691 +static constexpr inline bool is_signed = true; +# 1692 +static constexpr inline bool is_integer = false; +# 1693 +static constexpr inline bool is_exact = false; +# 1694 +static constexpr inline int radix = 2; +# 1697 +static constexpr float epsilon() noexcept { return (1.1920929E-7F); } +# 1700 +static constexpr float round_error() noexcept { return (0.5F); } +# 1702 +static constexpr inline int min_exponent = (-125); +# 1703 +static constexpr inline int min_exponent10 = (-37); +# 1704 +static constexpr inline int max_exponent = 128; +# 1705 +static constexpr inline int max_exponent10 = 38; +# 1707 +static constexpr inline bool has_infinity = (1); +# 1708 +static constexpr inline bool has_quiet_NaN = (1); +# 1709 +static constexpr inline bool has_signaling_NaN = has_quiet_NaN; +# 1710 +static constexpr inline float_denorm_style has_denorm = (((bool)1) ? denorm_present : denorm_absent); +# 1712 +static constexpr inline bool has_denorm_loss = false; +# 1716 +static constexpr float infinity() noexcept { return __builtin_huge_valf(); } +# 1719 +static constexpr float quiet_NaN() noexcept { return __builtin_nanf(""); } +# 1722 +static constexpr float signaling_NaN() noexcept { return __builtin_nansf(""); } +# 1725 +static constexpr float denorm_min() noexcept { return (1.4E-45F); } +# 1727 +static constexpr inline bool is_iec559 = (has_infinity && has_quiet_NaN && (has_denorm == (denorm_present))); +# 1729 +static constexpr inline bool is_bounded = true; +# 1730 +static constexpr inline bool is_modulo = false; +# 1732 +static constexpr inline bool traps = false; +# 1733 +static constexpr inline bool tinyness_before = false; +# 1735 +static constexpr inline float_round_style round_style = round_to_nearest; +# 1737 +}; +# 1745 +template<> struct numeric_limits< double> { +# 1747 +static constexpr inline bool is_specialized = true; +# 1750 +static constexpr double min() noexcept { return (double)(2.2250738585072013831E-308L); } +# 1753 +static constexpr double max() noexcept { return (double)(1.7976931348623157081E308L); } +# 1757 +static constexpr double lowest() noexcept { return -((double)(1.7976931348623157081E308L)); } +# 1760 +static constexpr inline int digits = 53; +# 1761 +static constexpr inline int digits10 = 15; +# 1763 +static constexpr inline int max_digits10 = ((2) + (((53) * 643L) / (2136))); +# 1766 +static constexpr inline bool is_signed = true; +# 1767 +static constexpr inline bool is_integer = false; +# 1768 +static constexpr inline bool is_exact = false; +# 1769 +static constexpr inline int radix = 2; +# 1772 +static constexpr double epsilon() noexcept { return (double)(2.2204460492503130808E-16L); } +# 1775 +static constexpr double round_error() noexcept { return (0.5); } +# 1777 +static constexpr inline int min_exponent = (-1021); +# 1778 +static constexpr inline int min_exponent10 = (-307); +# 1779 +static constexpr inline int max_exponent = 1024; +# 1780 +static constexpr inline int max_exponent10 = 308; +# 1782 +static constexpr inline bool has_infinity = (1); +# 1783 +static constexpr inline bool has_quiet_NaN = (1); +# 1784 +static constexpr inline bool has_signaling_NaN = has_quiet_NaN; +# 1785 +static constexpr inline float_denorm_style has_denorm = (((bool)1) ? denorm_present : denorm_absent); +# 1787 +static constexpr inline bool has_denorm_loss = false; +# 1791 +static constexpr double infinity() noexcept { return __builtin_huge_val(); } +# 1794 +static constexpr double quiet_NaN() noexcept { return __builtin_nan(""); } +# 1797 +static constexpr double signaling_NaN() noexcept { return __builtin_nans(""); } +# 1800 +static constexpr double denorm_min() noexcept { return (double)(4.940656458412465442E-324L); } +# 1802 +static constexpr inline bool is_iec559 = (has_infinity && has_quiet_NaN && (has_denorm == (denorm_present))); +# 1804 +static constexpr inline bool is_bounded = true; +# 1805 +static constexpr inline bool is_modulo = false; +# 1807 +static constexpr inline bool traps = false; +# 1808 +static constexpr inline bool tinyness_before = false; +# 1810 +static constexpr inline float_round_style round_style = round_to_nearest; +# 1812 +}; +# 1820 +template<> struct numeric_limits< long double> { +# 1822 +static constexpr inline bool is_specialized = true; +# 1825 +static constexpr long double min() noexcept { return (3.3621031431120935063E-4932L); } +# 1828 +static constexpr long double max() noexcept { return (1.189731495357231765E4932L); } +# 1832 +static constexpr long double lowest() noexcept { return -(1.189731495357231765E4932L); } +# 1835 +static constexpr inline int digits = 64; +# 1836 +static constexpr inline int digits10 = 18; +# 1838 +static constexpr inline int max_digits10 = ((2) + (((64) * 643L) / (2136))); +# 1841 +static constexpr inline bool is_signed = true; +# 1842 +static constexpr inline bool is_integer = false; +# 1843 +static constexpr inline bool is_exact = false; +# 1844 +static constexpr inline int radix = 2; +# 1847 +static constexpr long double epsilon() noexcept { return (1.084202172485504434E-19L); } +# 1850 +static constexpr long double round_error() noexcept { return (0.5L); } +# 1852 +static constexpr inline int min_exponent = (-16381); +# 1853 +static constexpr inline int min_exponent10 = (-4931); +# 1854 +static constexpr inline int max_exponent = 16384; +# 1855 +static constexpr inline int max_exponent10 = 4932; +# 1857 +static constexpr inline bool has_infinity = (1); +# 1858 +static constexpr inline bool has_quiet_NaN = (1); +# 1859 +static constexpr inline bool has_signaling_NaN = has_quiet_NaN; +# 1860 +static constexpr inline float_denorm_style has_denorm = (((bool)1) ? denorm_present : denorm_absent); +# 1862 +static constexpr inline bool has_denorm_loss = false; +# 1866 +static constexpr long double infinity() noexcept { return __builtin_huge_vall(); } +# 1869 +static constexpr long double quiet_NaN() noexcept { return __builtin_nanl(""); } +# 1872 +static constexpr long double signaling_NaN() noexcept { return __builtin_nansl(""); } +# 1875 +static constexpr long double denorm_min() noexcept { return (3.6E-4951L); } +# 1877 +static constexpr inline bool is_iec559 = (has_infinity && has_quiet_NaN && (has_denorm == (denorm_present))); +# 1879 +static constexpr inline bool is_bounded = true; +# 1880 +static constexpr inline bool is_modulo = false; +# 1882 +static constexpr inline bool traps = false; +# 1883 +static constexpr inline bool tinyness_before = false; +# 1885 +static constexpr inline float_round_style round_style = round_to_nearest; +# 1887 +}; +# 1989 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +template<> struct numeric_limits< _Float32> { static constexpr inline bool is_specialized = true; static constexpr _Float32 min() noexcept { return (1.1754944E-38f32); } static constexpr _Float32 max() noexcept { return (3.4028235E38f32); } static constexpr _Float32 lowest() noexcept { return -(3.4028235E38f32); } static constexpr inline int digits = 24; static constexpr inline int digits10 = 6; static constexpr inline int max_digits10 = ((2) + (((24) * 643L) / (2136))); static constexpr inline bool is_signed = true; static constexpr inline bool is_integer = false; static constexpr inline bool is_exact = false; static constexpr inline int radix = 2; static constexpr _Float32 epsilon() noexcept { return (1.1920929E-7f32); } static constexpr _Float32 round_error() noexcept { return (0.5f32); } static constexpr inline int min_exponent = (-125); static constexpr inline int min_exponent10 = (-37); static constexpr inline int max_exponent = 128; static constexpr inline int max_exponent10 = 38; static constexpr inline bool has_infinity = (1); static constexpr inline bool has_quiet_NaN = (1); static constexpr inline bool has_signaling_NaN = has_quiet_NaN; static constexpr inline float_denorm_style has_denorm = (((bool)1) ? denorm_present : denorm_absent); static constexpr inline bool has_denorm_loss = false; static constexpr _Float32 infinity() noexcept { return __builtin_huge_valf32(); } static constexpr _Float32 quiet_NaN() noexcept { return __builtin_nanf32(""); } static constexpr _Float32 signaling_NaN() noexcept { return __builtin_nansf32(""); } static constexpr _Float32 denorm_min() noexcept { return (1.4E-45f32); } static constexpr inline bool is_iec559 = (has_infinity && has_quiet_NaN && (has_denorm == (denorm_present))); static constexpr inline bool is_bounded = true; static constexpr inline bool is_modulo = false; static constexpr inline bool traps = false; static constexpr inline bool tinyness_before = false; static constexpr inline float_round_style round_style = round_to_nearest; }; +# 1992 +template<> struct numeric_limits< _Float64> { static constexpr inline bool is_specialized = true; static constexpr _Float64 min() noexcept { return (2.2250738585072014E-308f64); } static constexpr _Float64 max() noexcept { return (1.7976931348623157E308f64); } static constexpr _Float64 lowest() noexcept { return -(1.7976931348623157E308f64); } static constexpr inline int digits = 53; static constexpr inline int digits10 = 15; static constexpr inline int max_digits10 = ((2) + (((53) * 643L) / (2136))); static constexpr inline bool is_signed = true; static constexpr inline bool is_integer = false; static constexpr inline bool is_exact = false; static constexpr inline int radix = 2; static constexpr _Float64 epsilon() noexcept { return (2.220446049250313E-16f64); } static constexpr _Float64 round_error() noexcept { return (0.5f64); } static constexpr inline int min_exponent = (-1021); static constexpr inline int min_exponent10 = (-307); static constexpr inline int max_exponent = 1024; static constexpr inline int max_exponent10 = 308; static constexpr inline bool has_infinity = (1); static constexpr inline bool has_quiet_NaN = (1); static constexpr inline bool has_signaling_NaN = has_quiet_NaN; static constexpr inline float_denorm_style has_denorm = (((bool)1) ? denorm_present : denorm_absent); static constexpr inline bool has_denorm_loss = false; static constexpr _Float64 infinity() noexcept { return __builtin_huge_valf64(); } static constexpr _Float64 quiet_NaN() noexcept { return __builtin_nanf64(""); } static constexpr _Float64 signaling_NaN() noexcept { return __builtin_nansf64(""); } static constexpr _Float64 denorm_min() noexcept { return (4.9E-324f64); } static constexpr inline bool is_iec559 = (has_infinity && has_quiet_NaN && (has_denorm == (denorm_present))); static constexpr inline bool is_bounded = true; static constexpr inline bool is_modulo = false; static constexpr inline bool traps = false; static constexpr inline bool tinyness_before = false; static constexpr inline float_round_style round_style = round_to_nearest; }; +# 1995 +template<> struct numeric_limits< _Float128> { static constexpr inline bool is_specialized = true; static constexpr _Float128 min() noexcept { return (3.3621031431120935062626778173217526E-4932f128); } static constexpr _Float128 max() noexcept { return (1.189731495357231765085759326628007E4932f128); } static constexpr _Float128 lowest() noexcept { return -(1.189731495357231765085759326628007E4932f128); } static constexpr inline int digits = 113; static constexpr inline int digits10 = 33; static constexpr inline int max_digits10 = ((2) + (((113) * 643L) / (2136))); static constexpr inline bool is_signed = true; static constexpr inline bool is_integer = false; static constexpr inline bool is_exact = false; static constexpr inline int radix = 2; static constexpr _Float128 epsilon() noexcept { return (1.9259299443872358530559779425849273E-34f128); } static constexpr _Float128 round_error() noexcept { return (0.5f128); } static constexpr inline int min_exponent = (-16381); static constexpr inline int min_exponent10 = (-4931); static constexpr inline int max_exponent = 16384; static constexpr inline int max_exponent10 = 4932; static constexpr inline bool has_infinity = (1); static constexpr inline bool has_quiet_NaN = (1); static constexpr inline bool has_signaling_NaN = has_quiet_NaN; static constexpr inline float_denorm_style has_denorm = (((bool)1) ? denorm_present : denorm_absent); static constexpr inline bool has_denorm_loss = false; static constexpr _Float128 infinity() noexcept { return __builtin_huge_valf128(); } static constexpr _Float128 quiet_NaN() noexcept { return __builtin_nanf128(""); } static constexpr _Float128 signaling_NaN() noexcept { return __builtin_nansf128(""); } static constexpr _Float128 denorm_min() noexcept { return (6.5E-4966f128); } static constexpr inline bool is_iec559 = (has_infinity && has_quiet_NaN && (has_denorm == (denorm_present))); static constexpr inline bool is_bounded = true; static constexpr inline bool is_modulo = false; static constexpr inline bool traps = false; static constexpr inline bool tinyness_before = false; static constexpr inline float_round_style round_style = round_to_nearest; }; +# 2089 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +template<> struct numeric_limits< __float128> { +# 2091 +static constexpr inline bool is_specialized = true; +# 2094 +static constexpr __float128 min() noexcept +# 2095 +{ +# 2100 +return __extension__ (3.3621031431120935062626778173217526E-4932Q); +# 2102 +} +# 2105 +static constexpr __float128 max() noexcept +# 2106 +{ +# 2114 +return __extension__ (1.189731495357231765085759326628007E4932Q); +# 2116 +} +# 2119 +static constexpr __float128 lowest() noexcept +# 2120 +{ return -max(); } +# 2122 +static constexpr inline int digits = 113; +# 2123 +static constexpr inline int digits10 = 33; +# 2125 +static constexpr inline int max_digits10 = 35; +# 2127 +static constexpr inline bool is_signed = true; +# 2128 +static constexpr inline bool is_integer = false; +# 2129 +static constexpr inline bool is_exact = false; +# 2130 +static constexpr inline int radix = 2; +# 2133 +static constexpr __float128 epsilon() noexcept +# 2134 +{ return (double)(1.925929944387236E-34); } +# 2137 +static constexpr __float128 round_error() noexcept { return (0.5); } +# 2139 +static constexpr inline int min_exponent = (-16381); +# 2140 +static constexpr inline int min_exponent10 = (-4931); +# 2141 +static constexpr inline int max_exponent = 16384; +# 2142 +static constexpr inline int max_exponent10 = 4932; +# 2144 +static constexpr inline bool has_infinity = (1); +# 2145 +static constexpr inline bool has_quiet_NaN = (1); +# 2148 +static constexpr inline bool has_signaling_NaN = true; +# 2152 +static constexpr inline float_denorm_style has_denorm = denorm_present; +# 2154 +static constexpr inline bool has_denorm_loss = false; +# 2157 +static constexpr __float128 infinity() noexcept +# 2158 +{ return __builtin_huge_val(); } +# 2161 +static constexpr __float128 quiet_NaN() noexcept +# 2162 +{ return __builtin_nan(""); } +# 2165 +static constexpr __float128 signaling_NaN() noexcept +# 2166 +{ +# 2168 +return __builtin_nansq(""); +# 2174 +} +# 2177 +static constexpr __float128 denorm_min() noexcept +# 2178 +{ +# 2183 +return __extension__ (6.5E-4966Q); +# 2185 +} +# 2187 +static constexpr inline bool is_iec559 = has_signaling_NaN; +# 2188 +static constexpr inline bool is_bounded = true; +# 2189 +static constexpr inline bool is_modulo = false; +# 2191 +static constexpr inline bool traps = false; +# 2192 +static constexpr inline bool tinyness_before = false; +# 2193 +static constexpr inline float_round_style round_style = round_to_nearest; +# 2218 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +}; +# 2223 +} +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 +namespace __detail { +# 55 +template< class _Tp> +# 56 +struct __floating_point_constant { +# 58 +static const _Tp __value; +# 59 +}; +# 63 +template< class _Tp> +# 64 +struct __numeric_constants { +# 67 +static _Tp __pi() throw() +# 68 +{ return static_cast< _Tp>((3.1415926535897932385L)); } +# 70 +static _Tp __pi_2() throw() +# 71 +{ return static_cast< _Tp>((1.5707963267948966193L)); } +# 73 +static _Tp __pi_3() throw() +# 74 +{ return static_cast< _Tp>((1.0471975511965977461L)); } +# 76 +static _Tp __pi_4() throw() +# 77 +{ return static_cast< _Tp>((0.78539816339744830963L)); } +# 79 +static _Tp __1_pi() throw() +# 80 +{ return static_cast< _Tp>((0.31830988618379067154L)); } +# 82 +static _Tp __2_sqrtpi() throw() +# 83 +{ return static_cast< _Tp>((1.1283791670955125738L)); } +# 85 +static _Tp __sqrt2() throw() +# 86 +{ return static_cast< _Tp>((1.4142135623730950488L)); } +# 88 +static _Tp __sqrt3() throw() +# 89 +{ return static_cast< _Tp>((1.7320508075688772936L)); } +# 91 +static _Tp __sqrtpio2() throw() +# 92 +{ return static_cast< _Tp>((1.2533141373155002512L)); } +# 94 +static _Tp __sqrt1_2() throw() +# 95 +{ return static_cast< _Tp>((0.7071067811865475244L)); } +# 97 +static _Tp __lnpi() throw() +# 98 +{ return static_cast< _Tp>((1.1447298858494001742L)); } +# 100 +static _Tp __gamma_e() throw() +# 101 +{ return static_cast< _Tp>((0.5772156649015328606L)); } +# 103 +static _Tp __euler() throw() +# 104 +{ return static_cast< _Tp>((2.7182818284590452354L)); } +# 105 +}; +# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 +template< class _Tp> inline bool +# 115 +__isnan(_Tp __x) +# 116 +{ return std::isnan(__x); } +# 133 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 +} +# 139 +} +# 51 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +namespace __detail { +# 76 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 78 +__bernoulli_series(unsigned __n) +# 79 +{ +# 81 +static const _Tp __num[28] = {((_Tp)1UL), ((-((_Tp)1UL)) / ((_Tp)2UL)), (((_Tp)1UL) / ((_Tp)6UL)), ((_Tp)0UL), ((-((_Tp)1UL)) / ((_Tp)30UL)), ((_Tp)0UL), (((_Tp)1UL) / ((_Tp)42UL)), ((_Tp)0UL), ((-((_Tp)1UL)) / ((_Tp)30UL)), ((_Tp)0UL), (((_Tp)5UL) / ((_Tp)66UL)), ((_Tp)0UL), ((-((_Tp)691UL)) / ((_Tp)2730UL)), ((_Tp)0UL), (((_Tp)7UL) / ((_Tp)6UL)), ((_Tp)0UL), ((-((_Tp)3617UL)) / ((_Tp)510UL)), ((_Tp)0UL), (((_Tp)43867UL) / ((_Tp)798UL)), ((_Tp)0UL), ((-((_Tp)174611)) / ((_Tp)330UL)), ((_Tp)0UL), (((_Tp)854513UL) / ((_Tp)138UL)), ((_Tp)0UL), ((-((_Tp)236364091UL)) / ((_Tp)2730UL)), ((_Tp)0UL), (((_Tp)8553103UL) / ((_Tp)6UL)), ((_Tp)0UL)}; +# 98 +if (__n == (0)) { +# 99 +return (_Tp)1; } +# 101 +if (__n == (1)) { +# 102 +return (-((_Tp)1)) / ((_Tp)2); } +# 105 +if ((__n % (2)) == (1)) { +# 106 +return (_Tp)0; } +# 109 +if (__n < (28)) { +# 110 +return __num[__n]; } +# 113 +_Tp __fact = ((_Tp)1); +# 114 +if (((__n / (2)) % (2)) == (0)) { +# 115 +__fact *= ((_Tp)(-1)); } +# 116 +for (unsigned __k = (1); __k <= __n; ++__k) { +# 117 +__fact *= (__k / (((_Tp)2) * __numeric_constants< _Tp> ::__pi())); } +# 118 +__fact *= ((_Tp)2); +# 120 +_Tp __sum = ((_Tp)0); +# 121 +for (unsigned __i = (1); __i < (1000); ++__i) +# 122 +{ +# 123 +_Tp __term = std::pow((_Tp)__i, -((_Tp)__n)); +# 124 +if (__term < std::template numeric_limits< _Tp> ::epsilon()) { +# 125 +break; } +# 126 +__sum += __term; +# 127 +} +# 129 +return __fact * __sum; +# 130 +} +# 139 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> inline _Tp +# 141 +__bernoulli(int __n) +# 142 +{ return __bernoulli_series< _Tp> (__n); } +# 153 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 155 +__log_gamma_bernoulli(_Tp __x) +# 156 +{ +# 157 +_Tp __lg = (((__x - ((_Tp)(0.5L))) * std::log(__x)) - __x) + (((_Tp)(0.5L)) * std::log(((_Tp)2) * __numeric_constants< _Tp> ::__pi())); +# 161 +const _Tp __xx = __x * __x; +# 162 +_Tp __help = ((_Tp)1) / __x; +# 163 +for (unsigned __i = (1); __i < (20); ++__i) +# 164 +{ +# 165 +const _Tp __2i = (_Tp)((2) * __i); +# 166 +__help /= ((__2i * (__2i - ((_Tp)1))) * __xx); +# 167 +__lg += (__bernoulli< _Tp> ((2) * __i) * __help); +# 168 +} +# 170 +return __lg; +# 171 +} +# 181 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 183 +__log_gamma_lanczos(_Tp __x) +# 184 +{ +# 185 +const _Tp __xm1 = __x - ((_Tp)1); +# 187 +static const _Tp __lanczos_cheb_7[9] = {((_Tp)(0.99999999999980993226L)), ((_Tp)(676.52036812188509857L)), ((_Tp)(-(1259.1392167224028704L))), ((_Tp)(771.32342877765307887L)), ((_Tp)(-(176.61502916214059906L))), ((_Tp)(12.507343278686904814L)), ((_Tp)(-(0.1385710952657201169L))), ((_Tp)(9.9843695780195708595E-6L)), ((_Tp)(1.5056327351493115584E-7L))}; +# 199 +static const _Tp __LOGROOT2PI = ((_Tp)(0.9189385332046727418L)); +# 202 +_Tp __sum = (__lanczos_cheb_7[0]); +# 203 +for (unsigned __k = (1); __k < (9); ++__k) { +# 204 +__sum += ((__lanczos_cheb_7[__k]) / (__xm1 + __k)); } +# 206 +const _Tp __term1 = (__xm1 + ((_Tp)(0.5L))) * std::log((__xm1 + ((_Tp)(7.5L))) / __numeric_constants< _Tp> ::__euler()); +# 209 +const _Tp __term2 = __LOGROOT2PI + std::log(__sum); +# 210 +const _Tp __result = __term1 + (__term2 - ((_Tp)7)); +# 212 +return __result; +# 213 +} +# 225 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 227 +__log_gamma(_Tp __x) +# 228 +{ +# 229 +if (__x > ((_Tp)(0.5L))) { +# 230 +return __log_gamma_lanczos(__x); } else +# 232 +{ +# 233 +const _Tp __sin_fact = std::abs(std::sin(__numeric_constants< _Tp> ::__pi() * __x)); +# 235 +if (__sin_fact == ((_Tp)0)) { +# 236 +std::__throw_domain_error("Argument is nonpositive integer in __log_gamma"); } +# 238 +return (__numeric_constants< _Tp> ::__lnpi() - std::log(__sin_fact)) - __log_gamma_lanczos(((_Tp)1) - __x); +# 241 +} +# 242 +} +# 252 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 254 +__log_gamma_sign(_Tp __x) +# 255 +{ +# 256 +if (__x > ((_Tp)0)) { +# 257 +return (_Tp)1; } else +# 259 +{ +# 260 +const _Tp __sin_fact = std::sin(__numeric_constants< _Tp> ::__pi() * __x); +# 262 +if (__sin_fact > ((_Tp)0)) { +# 263 +return 1; } else { +# 264 +if (__sin_fact < ((_Tp)0)) { +# 265 +return -((_Tp)1); } else { +# 267 +return (_Tp)0; } } +# 268 +} +# 269 +} +# 283 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 285 +__log_bincoef(unsigned __n, unsigned __k) +# 286 +{ +# 288 +static const _Tp __max_bincoeff = (std::template numeric_limits< _Tp> ::max_exponent10 * std::log((_Tp)10)) - ((_Tp)1); +# 292 +_Tp __coeff = (std::lgamma((_Tp)((1) + __n)) - std::lgamma((_Tp)((1) + __k))) - std::lgamma((_Tp)(((1) + __n) - __k)); +# 300 +} +# 314 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 316 +__bincoef(unsigned __n, unsigned __k) +# 317 +{ +# 319 +static const _Tp __max_bincoeff = (std::template numeric_limits< _Tp> ::max_exponent10 * std::log((_Tp)10)) - ((_Tp)1); +# 323 +const _Tp __log_coeff = __log_bincoef< _Tp> (__n, __k); +# 324 +if (__log_coeff > __max_bincoeff) { +# 325 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 327 +return std::exp(__log_coeff); } +# 328 +} +# 337 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> inline _Tp +# 339 +__gamma(_Tp __x) +# 340 +{ return std::exp(__log_gamma(__x)); } +# 356 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 358 +__psi_series(_Tp __x) +# 359 +{ +# 360 +_Tp __sum = (-__numeric_constants< _Tp> ::__gamma_e()) - (((_Tp)1) / __x); +# 361 +const unsigned __max_iter = (100000); +# 362 +for (unsigned __k = (1); __k < __max_iter; ++__k) +# 363 +{ +# 364 +const _Tp __term = __x / (__k * (__k + __x)); +# 365 +__sum += __term; +# 366 +if (std::abs(__term / __sum) < std::template numeric_limits< _Tp> ::epsilon()) { +# 367 +break; } +# 368 +} +# 369 +return __sum; +# 370 +} +# 386 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 388 +__psi_asymp(_Tp __x) +# 389 +{ +# 390 +_Tp __sum = std::log(__x) - (((_Tp)(0.5L)) / __x); +# 391 +const _Tp __xx = __x * __x; +# 392 +_Tp __xp = __xx; +# 393 +const unsigned __max_iter = (100); +# 394 +for (unsigned __k = (1); __k < __max_iter; ++__k) +# 395 +{ +# 396 +const _Tp __term = __bernoulli< _Tp> ((2) * __k) / (((2) * __k) * __xp); +# 397 +__sum -= __term; +# 398 +if (std::abs(__term / __sum) < std::template numeric_limits< _Tp> ::epsilon()) { +# 399 +break; } +# 400 +__xp *= __xx; +# 401 +} +# 402 +return __sum; +# 403 +} +# 417 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 419 +__psi(_Tp __x) +# 420 +{ +# 421 +const int __n = static_cast< int>(__x + (0.5L)); +# 422 +const _Tp __eps = ((_Tp)4) * std::template numeric_limits< _Tp> ::epsilon(); +# 423 +if ((__n <= 0) && (std::abs(__x - ((_Tp)__n)) < __eps)) { +# 424 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 425 +if (__x < ((_Tp)0)) +# 426 +{ +# 427 +const _Tp __pi = __numeric_constants< _Tp> ::__pi(); +# 428 +return __psi(((_Tp)1) - __x) - ((__pi * std::cos(__pi * __x)) / std::sin(__pi * __x)); +# 430 +} else { +# 431 +if (__x > ((_Tp)100)) { +# 432 +return __psi_asymp(__x); } else { +# 434 +return __psi_series(__x); } } } +# 435 +} +# 446 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 448 +__psi(unsigned __n, _Tp __x) +# 449 +{ +# 450 +if (__x <= ((_Tp)0)) { +# 451 +std::__throw_domain_error("Argument out of range in __psi"); } else { +# 453 +if (__n == (0)) { +# 454 +return __psi(__x); } else +# 456 +{ +# 457 +const _Tp __hzeta = __hurwitz_zeta((_Tp)(__n + (1)), __x); +# 459 +const _Tp __ln_nfact = std::lgamma((_Tp)(__n + (1))); +# 463 +_Tp __result = std::exp(__ln_nfact) * __hzeta; +# 464 +if ((__n % (2)) == (1)) { +# 465 +__result = (-__result); } +# 466 +return __result; +# 467 +} } +# 468 +} +# 469 +} +# 476 +} +# 55 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 71 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +namespace __detail { +# 98 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +template< class _Tp> void +# 100 +__gamma_temme(_Tp __mu, _Tp & +# 101 +__gam1, _Tp &__gam2, _Tp &__gampl, _Tp &__gammi) +# 102 +{ +# 104 +__gampl = (((_Tp)1) / std::tgamma(((_Tp)1) + __mu)); +# 105 +__gammi = (((_Tp)1) / std::tgamma(((_Tp)1) - __mu)); +# 111 +if (std::abs(__mu) < std::template numeric_limits< _Tp> ::epsilon()) { +# 112 +__gam1 = (-((_Tp)__numeric_constants< _Tp> ::__gamma_e())); } else { +# 114 +__gam1 = ((__gammi - __gampl) / (((_Tp)2) * __mu)); } +# 116 +__gam2 = ((__gammi + __gampl) / ((_Tp)2)); +# 119 +} +# 136 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +template< class _Tp> void +# 138 +__bessel_jn(_Tp __nu, _Tp __x, _Tp & +# 139 +__Jnu, _Tp &__Nnu, _Tp &__Jpnu, _Tp &__Npnu) +# 140 +{ +# 141 +if (__x == ((_Tp)0)) +# 142 +{ +# 143 +if (__nu == ((_Tp)0)) +# 144 +{ +# 145 +__Jnu = ((_Tp)1); +# 146 +__Jpnu = ((_Tp)0); +# 147 +} else { +# 148 +if (__nu == ((_Tp)1)) +# 149 +{ +# 150 +__Jnu = ((_Tp)0); +# 151 +__Jpnu = ((_Tp)(0.5L)); +# 152 +} else +# 154 +{ +# 155 +__Jnu = ((_Tp)0); +# 156 +__Jpnu = ((_Tp)0); +# 157 +} } +# 158 +__Nnu = (-std::template numeric_limits< _Tp> ::infinity()); +# 159 +__Npnu = std::template numeric_limits< _Tp> ::infinity(); +# 160 +return; +# 161 +} +# 163 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 168 +const _Tp __fp_min = std::sqrt(std::template numeric_limits< _Tp> ::min()); +# 169 +const int __max_iter = 15000; +# 170 +const _Tp __x_min = ((_Tp)2); +# 172 +const int __nl = (__x < __x_min) ? static_cast< int>(__nu + ((_Tp)(0.5L))) : std::max(0, static_cast< int>((__nu - __x) + ((_Tp)(1.5L)))); +# 176 +const _Tp __mu = __nu - __nl; +# 177 +const _Tp __mu2 = __mu * __mu; +# 178 +const _Tp __xi = ((_Tp)1) / __x; +# 179 +const _Tp __xi2 = ((_Tp)2) * __xi; +# 180 +_Tp __w = __xi2 / __numeric_constants< _Tp> ::__pi(); +# 181 +int __isign = 1; +# 182 +_Tp __h = __nu * __xi; +# 183 +if (__h < __fp_min) { +# 184 +__h = __fp_min; } +# 185 +_Tp __b = __xi2 * __nu; +# 186 +_Tp __d = ((_Tp)0); +# 187 +_Tp __c = __h; +# 188 +int __i; +# 189 +for (__i = 1; __i <= __max_iter; ++__i) +# 190 +{ +# 191 +__b += __xi2; +# 192 +__d = (__b - __d); +# 193 +if (std::abs(__d) < __fp_min) { +# 194 +__d = __fp_min; } +# 195 +__c = (__b - (((_Tp)1) / __c)); +# 196 +if (std::abs(__c) < __fp_min) { +# 197 +__c = __fp_min; } +# 198 +__d = (((_Tp)1) / __d); +# 199 +const _Tp __del = __c * __d; +# 200 +__h *= __del; +# 201 +if (__d < ((_Tp)0)) { +# 202 +__isign = (-__isign); } +# 203 +if (std::abs(__del - ((_Tp)1)) < __eps) { +# 204 +break; } +# 205 +} +# 206 +if (__i > __max_iter) { +# 207 +std::__throw_runtime_error("Argument x too large in __bessel_jn; try asymptotic expansion."); } +# 209 +_Tp __Jnul = __isign * __fp_min; +# 210 +_Tp __Jpnul = __h * __Jnul; +# 211 +_Tp __Jnul1 = __Jnul; +# 212 +_Tp __Jpnu1 = __Jpnul; +# 213 +_Tp __fact = __nu * __xi; +# 214 +for (int __l = __nl; __l >= 1; --__l) +# 215 +{ +# 216 +const _Tp __Jnutemp = (__fact * __Jnul) + __Jpnul; +# 217 +__fact -= __xi; +# 218 +__Jpnul = ((__fact * __Jnutemp) - __Jnul); +# 219 +__Jnul = __Jnutemp; +# 220 +} +# 221 +if (__Jnul == ((_Tp)0)) { +# 222 +__Jnul = __eps; } +# 223 +_Tp __f = __Jpnul / __Jnul; +# 224 +_Tp __Nmu, __Nnu1, __Npmu, __Jmu; +# 225 +if (__x < __x_min) +# 226 +{ +# 227 +const _Tp __x2 = __x / ((_Tp)2); +# 228 +const _Tp __pimu = __numeric_constants< _Tp> ::__pi() * __mu; +# 229 +_Tp __fact = (std::abs(__pimu) < __eps) ? (_Tp)1 : (__pimu / std::sin(__pimu)); +# 231 +_Tp __d = (-std::log(__x2)); +# 232 +_Tp __e = __mu * __d; +# 233 +_Tp __fact2 = (std::abs(__e) < __eps) ? (_Tp)1 : (std::sinh(__e) / __e); +# 235 +_Tp __gam1, __gam2, __gampl, __gammi; +# 236 +__gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi); +# 237 +_Tp __ff = ((((_Tp)2) / __numeric_constants< _Tp> ::__pi()) * __fact) * ((__gam1 * std::cosh(__e)) + ((__gam2 * __fact2) * __d)); +# 239 +__e = std::exp(__e); +# 240 +_Tp __p = __e / (__numeric_constants< _Tp> ::__pi() * __gampl); +# 241 +_Tp __q = ((_Tp)1) / ((__e * __numeric_constants< _Tp> ::__pi()) * __gammi); +# 242 +const _Tp __pimu2 = __pimu / ((_Tp)2); +# 243 +_Tp __fact3 = (std::abs(__pimu2) < __eps) ? (_Tp)1 : (std::sin(__pimu2) / __pimu2); +# 245 +_Tp __r = ((__numeric_constants< _Tp> ::__pi() * __pimu2) * __fact3) * __fact3; +# 246 +_Tp __c = ((_Tp)1); +# 247 +__d = ((-__x2) * __x2); +# 248 +_Tp __sum = __ff + (__r * __q); +# 249 +_Tp __sum1 = __p; +# 250 +for (__i = 1; __i <= __max_iter; ++__i) +# 251 +{ +# 252 +__ff = ((((__i * __ff) + __p) + __q) / ((__i * __i) - __mu2)); +# 253 +__c *= (__d / ((_Tp)__i)); +# 254 +__p /= (((_Tp)__i) - __mu); +# 255 +__q /= (((_Tp)__i) + __mu); +# 256 +const _Tp __del = __c * (__ff + (__r * __q)); +# 257 +__sum += __del; +# 258 +const _Tp __del1 = (__c * __p) - (__i * __del); +# 259 +__sum1 += __del1; +# 260 +if (std::abs(__del) < (__eps * (((_Tp)1) + std::abs(__sum)))) { +# 261 +break; } +# 262 +} +# 263 +if (__i > __max_iter) { +# 264 +std::__throw_runtime_error("Bessel y series failed to converge in __bessel_jn."); } +# 266 +__Nmu = (-__sum); +# 267 +__Nnu1 = ((-__sum1) * __xi2); +# 268 +__Npmu = (((__mu * __xi) * __Nmu) - __Nnu1); +# 269 +__Jmu = (__w / (__Npmu - (__f * __Nmu))); +# 270 +} else +# 272 +{ +# 273 +_Tp __a = ((_Tp)(0.25L)) - __mu2; +# 274 +_Tp __q = ((_Tp)1); +# 275 +_Tp __p = ((-__xi) / ((_Tp)2)); +# 276 +_Tp __br = ((_Tp)2) * __x; +# 277 +_Tp __bi = ((_Tp)2); +# 278 +_Tp __fact = (__a * __xi) / ((__p * __p) + (__q * __q)); +# 279 +_Tp __cr = __br + (__q * __fact); +# 280 +_Tp __ci = __bi + (__p * __fact); +# 281 +_Tp __den = (__br * __br) + (__bi * __bi); +# 282 +_Tp __dr = __br / __den; +# 283 +_Tp __di = (-__bi) / __den; +# 284 +_Tp __dlr = (__cr * __dr) - (__ci * __di); +# 285 +_Tp __dli = (__cr * __di) + (__ci * __dr); +# 286 +_Tp __temp = (__p * __dlr) - (__q * __dli); +# 287 +__q = ((__p * __dli) + (__q * __dlr)); +# 288 +__p = __temp; +# 289 +int __i; +# 290 +for (__i = 2; __i <= __max_iter; ++__i) +# 291 +{ +# 292 +__a += ((_Tp)(2 * (__i - 1))); +# 293 +__bi += ((_Tp)2); +# 294 +__dr = ((__a * __dr) + __br); +# 295 +__di = ((__a * __di) + __bi); +# 296 +if ((std::abs(__dr) + std::abs(__di)) < __fp_min) { +# 297 +__dr = __fp_min; } +# 298 +__fact = (__a / ((__cr * __cr) + (__ci * __ci))); +# 299 +__cr = (__br + (__cr * __fact)); +# 300 +__ci = (__bi - (__ci * __fact)); +# 301 +if ((std::abs(__cr) + std::abs(__ci)) < __fp_min) { +# 302 +__cr = __fp_min; } +# 303 +__den = ((__dr * __dr) + (__di * __di)); +# 304 +__dr /= __den; +# 305 +__di /= (-__den); +# 306 +__dlr = ((__cr * __dr) - (__ci * __di)); +# 307 +__dli = ((__cr * __di) + (__ci * __dr)); +# 308 +__temp = ((__p * __dlr) - (__q * __dli)); +# 309 +__q = ((__p * __dli) + (__q * __dlr)); +# 310 +__p = __temp; +# 311 +if ((std::abs(__dlr - ((_Tp)1)) + std::abs(__dli)) < __eps) { +# 312 +break; } +# 313 +} +# 314 +if (__i > __max_iter) { +# 315 +std::__throw_runtime_error("Lentz\'s method failed in __bessel_jn."); } +# 317 +const _Tp __gam = (__p - __f) / __q; +# 318 +__Jmu = std::sqrt(__w / (((__p - __f) * __gam) + __q)); +# 320 +__Jmu = std::copysign(__Jmu, __Jnul); +# 325 +__Nmu = (__gam * __Jmu); +# 326 +__Npmu = ((__p + (__q / __gam)) * __Nmu); +# 327 +__Nnu1 = (((__mu * __xi) * __Nmu) - __Npmu); +# 328 +} +# 329 +__fact = (__Jmu / __Jnul); +# 330 +__Jnu = (__fact * __Jnul1); +# 331 +__Jpnu = (__fact * __Jpnu1); +# 332 +for (__i = 1; __i <= __nl; ++__i) +# 333 +{ +# 334 +const _Tp __Nnutemp = (((__mu + __i) * __xi2) * __Nnu1) - __Nmu; +# 335 +__Nmu = __Nnu1; +# 336 +__Nnu1 = __Nnutemp; +# 337 +} +# 338 +__Nnu = __Nmu; +# 339 +__Npnu = (((__nu * __xi) * __Nmu) - __Nnu1); +# 342 +} +# 361 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +template< class _Tp> void +# 363 +__cyl_bessel_jn_asymp(_Tp __nu, _Tp __x, _Tp &__Jnu, _Tp &__Nnu) +# 364 +{ +# 365 +const _Tp __mu = (((_Tp)4) * __nu) * __nu; +# 366 +const _Tp __8x = ((_Tp)8) * __x; +# 368 +_Tp __P = ((_Tp)0); +# 369 +_Tp __Q = ((_Tp)0); +# 371 +_Tp __k = ((_Tp)0); +# 372 +_Tp __term = ((_Tp)1); +# 374 +int __epsP = 0; +# 375 +int __epsQ = 0; +# 377 +_Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 379 +do +# 380 +{ +# 381 +__term *= ((__k == 0) ? (_Tp)1 : ((-(__mu - (((2 * __k) - 1) * ((2 * __k) - 1)))) / (__k * __8x))); +# 385 +__epsP = (std::abs(__term) < (__eps * std::abs(__P))); +# 386 +__P += __term; +# 388 +__k++; +# 390 +__term *= ((__mu - (((2 * __k) - 1) * ((2 * __k) - 1))) / (__k * __8x)); +# 391 +__epsQ = (std::abs(__term) < (__eps * std::abs(__Q))); +# 392 +__Q += __term; +# 394 +if (__epsP && __epsQ && (__k > (__nu / (2.0)))) { +# 395 +break; } +# 397 +__k++; +# 398 +} +# 399 +while (__k < 1000); +# 401 +const _Tp __chi = __x - ((__nu + ((_Tp)(0.5L))) * __numeric_constants< _Tp> ::__pi_2()); +# 404 +const _Tp __c = std::cos(__chi); +# 405 +const _Tp __s = std::sin(__chi); +# 407 +const _Tp __coef = std::sqrt(((_Tp)2) / (__numeric_constants< _Tp> ::__pi() * __x)); +# 410 +__Jnu = (__coef * ((__c * __P) - (__s * __Q))); +# 411 +__Nnu = (__coef * ((__s * __P) + (__c * __Q))); +# 414 +} +# 444 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +template< class _Tp> _Tp +# 446 +__cyl_bessel_ij_series(_Tp __nu, _Tp __x, _Tp __sgn, unsigned +# 447 +__max_iter) +# 448 +{ +# 449 +if (__x == ((_Tp)0)) { +# 450 +return (__nu == ((_Tp)0)) ? (_Tp)1 : ((_Tp)0); } +# 452 +const _Tp __x2 = __x / ((_Tp)2); +# 453 +_Tp __fact = __nu * std::log(__x2); +# 455 +__fact -= std::lgamma(__nu + ((_Tp)1)); +# 459 +__fact = std::exp(__fact); +# 460 +const _Tp __xx4 = (__sgn * __x2) * __x2; +# 461 +_Tp __Jn = ((_Tp)1); +# 462 +_Tp __term = ((_Tp)1); +# 464 +for (unsigned __i = (1); __i < __max_iter; ++__i) +# 465 +{ +# 466 +__term *= (__xx4 / (((_Tp)__i) * (__nu + ((_Tp)__i)))); +# 467 +__Jn += __term; +# 468 +if (std::abs(__term / __Jn) < std::template numeric_limits< _Tp> ::epsilon()) { +# 469 +break; } +# 470 +} +# 472 +return __fact * __Jn; +# 473 +} +# 490 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +template< class _Tp> _Tp +# 492 +__cyl_bessel_j(_Tp __nu, _Tp __x) +# 493 +{ +# 494 +if ((__nu < ((_Tp)0)) || (__x < ((_Tp)0))) { +# 495 +std::__throw_domain_error("Bad argument in __cyl_bessel_j."); } else { +# 497 +if (__isnan(__nu) || __isnan(__x)) { +# 498 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 499 +if ((__x * __x) < (((_Tp)10) * (__nu + ((_Tp)1)))) { +# 500 +return __cyl_bessel_ij_series(__nu, __x, -((_Tp)1), 200); } else { +# 501 +if (__x > ((_Tp)1000)) +# 502 +{ +# 503 +_Tp __J_nu, __N_nu; +# 504 +__cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); +# 505 +return __J_nu; +# 506 +} else +# 508 +{ +# 509 +_Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; +# 510 +__bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); +# 511 +return __J_nu; +# 512 +} } } } +# 513 +} +# 532 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +template< class _Tp> _Tp +# 534 +__cyl_neumann_n(_Tp __nu, _Tp __x) +# 535 +{ +# 536 +if ((__nu < ((_Tp)0)) || (__x < ((_Tp)0))) { +# 537 +std::__throw_domain_error("Bad argument in __cyl_neumann_n."); } else { +# 539 +if (__isnan(__nu) || __isnan(__x)) { +# 540 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 541 +if (__x > ((_Tp)1000)) +# 542 +{ +# 543 +_Tp __J_nu, __N_nu; +# 544 +__cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); +# 545 +return __N_nu; +# 546 +} else +# 548 +{ +# 549 +_Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; +# 550 +__bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); +# 551 +return __N_nu; +# 552 +} } } +# 553 +} +# 569 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +template< class _Tp> void +# 571 +__sph_bessel_jn(unsigned __n, _Tp __x, _Tp & +# 572 +__j_n, _Tp &__n_n, _Tp &__jp_n, _Tp &__np_n) +# 573 +{ +# 574 +const _Tp __nu = ((_Tp)__n) + ((_Tp)(0.5L)); +# 576 +_Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; +# 577 +__bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); +# 579 +const _Tp __factor = __numeric_constants< _Tp> ::__sqrtpio2() / std::sqrt(__x); +# 582 +__j_n = (__factor * __J_nu); +# 583 +__n_n = (__factor * __N_nu); +# 584 +__jp_n = ((__factor * __Jp_nu) - (__j_n / (((_Tp)2) * __x))); +# 585 +__np_n = ((__factor * __Np_nu) - (__n_n / (((_Tp)2) * __x))); +# 588 +} +# 604 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +template< class _Tp> _Tp +# 606 +__sph_bessel(unsigned __n, _Tp __x) +# 607 +{ +# 608 +if (__x < ((_Tp)0)) { +# 609 +std::__throw_domain_error("Bad argument in __sph_bessel."); } else { +# 611 +if (__isnan(__x)) { +# 612 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 613 +if (__x == ((_Tp)0)) +# 614 +{ +# 615 +if (__n == (0)) { +# 616 +return (_Tp)1; } else { +# 618 +return (_Tp)0; } +# 619 +} else +# 621 +{ +# 622 +_Tp __j_n, __n_n, __jp_n, __np_n; +# 623 +__sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n); +# 624 +return __j_n; +# 625 +} } } +# 626 +} +# 642 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +template< class _Tp> _Tp +# 644 +__sph_neumann(unsigned __n, _Tp __x) +# 645 +{ +# 646 +if (__x < ((_Tp)0)) { +# 647 +std::__throw_domain_error("Bad argument in __sph_neumann."); } else { +# 649 +if (__isnan(__x)) { +# 650 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 651 +if (__x == ((_Tp)0)) { +# 652 +return -std::template numeric_limits< _Tp> ::infinity(); } else +# 654 +{ +# 655 +_Tp __j_n, __n_n, __jp_n, __np_n; +# 656 +__sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n); +# 657 +return __n_n; +# 658 +} } } +# 659 +} +# 660 +} +# 667 +} +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 +namespace __detail { +# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 +template< class _Tp> _Tp +# 81 +__beta_gamma(_Tp __x, _Tp __y) +# 82 +{ +# 84 +_Tp __bet; +# 86 +if (__x > __y) +# 87 +{ +# 88 +__bet = (std::tgamma(__x) / std::tgamma(__x + __y)); +# 90 +__bet *= std::tgamma(__y); +# 91 +} else +# 93 +{ +# 94 +__bet = (std::tgamma(__y) / std::tgamma(__x + __y)); +# 96 +__bet *= std::tgamma(__x); +# 97 +} +# 111 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 +return __bet; +# 112 +} +# 127 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 +template< class _Tp> _Tp +# 129 +__beta_lgamma(_Tp __x, _Tp __y) +# 130 +{ +# 132 +_Tp __bet = (std::lgamma(__x) + std::lgamma(__y)) - std::lgamma(__x + __y); +# 140 +__bet = std::exp(__bet); +# 141 +return __bet; +# 142 +} +# 158 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 +template< class _Tp> _Tp +# 160 +__beta_product(_Tp __x, _Tp __y) +# 161 +{ +# 163 +_Tp __bet = (__x + __y) / (__x * __y); +# 165 +unsigned __max_iter = (1000000); +# 166 +for (unsigned __k = (1); __k < __max_iter; ++__k) +# 167 +{ +# 168 +_Tp __term = (((_Tp)1) + ((__x + __y) / __k)) / ((((_Tp)1) + (__x / __k)) * (((_Tp)1) + (__y / __k))); +# 170 +__bet *= __term; +# 171 +} +# 173 +return __bet; +# 174 +} +# 189 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 +template< class _Tp> inline _Tp +# 191 +__beta(_Tp __x, _Tp __y) +# 192 +{ +# 193 +if (__isnan(__x) || __isnan(__y)) { +# 194 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 196 +return __beta_lgamma(__x, __y); } +# 197 +} +# 198 +} +# 205 +} +# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +namespace __detail { +# 76 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 78 +__ellint_rf(_Tp __x, _Tp __y, _Tp __z) +# 79 +{ +# 80 +const _Tp __min = std::template numeric_limits< _Tp> ::min(); +# 81 +const _Tp __lolim = ((_Tp)5) * __min; +# 83 +if (((__x < ((_Tp)0)) || (__y < ((_Tp)0))) || (__z < ((_Tp)0))) { +# 84 +std::__throw_domain_error("Argument less than zero in __ellint_rf."); } else { +# 86 +if ((((__x + __y) < __lolim) || ((__x + __z) < __lolim)) || ((__y + __z) < __lolim)) { +# 88 +std::__throw_domain_error("Argument too small in __ellint_rf"); } else +# 90 +{ +# 91 +const _Tp __c0 = (((_Tp)1) / ((_Tp)4)); +# 92 +const _Tp __c1 = (((_Tp)1) / ((_Tp)24)); +# 93 +const _Tp __c2 = (((_Tp)1) / ((_Tp)10)); +# 94 +const _Tp __c3 = (((_Tp)3) / ((_Tp)44)); +# 95 +const _Tp __c4 = (((_Tp)1) / ((_Tp)14)); +# 97 +_Tp __xn = __x; +# 98 +_Tp __yn = __y; +# 99 +_Tp __zn = __z; +# 101 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 102 +const _Tp __errtol = std::pow(__eps, ((_Tp)1) / ((_Tp)6)); +# 103 +_Tp __mu; +# 104 +_Tp __xndev, __yndev, __zndev; +# 106 +const unsigned __max_iter = (100); +# 107 +for (unsigned __iter = (0); __iter < __max_iter; ++__iter) +# 108 +{ +# 109 +__mu = (((__xn + __yn) + __zn) / ((_Tp)3)); +# 110 +__xndev = (2 - ((__mu + __xn) / __mu)); +# 111 +__yndev = (2 - ((__mu + __yn) / __mu)); +# 112 +__zndev = (2 - ((__mu + __zn) / __mu)); +# 113 +_Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); +# 114 +__epsilon = std::max(__epsilon, std::abs(__zndev)); +# 115 +if (__epsilon < __errtol) { +# 116 +break; } +# 117 +const _Tp __xnroot = std::sqrt(__xn); +# 118 +const _Tp __ynroot = std::sqrt(__yn); +# 119 +const _Tp __znroot = std::sqrt(__zn); +# 120 +const _Tp __lambda = (__xnroot * (__ynroot + __znroot)) + (__ynroot * __znroot); +# 122 +__xn = (__c0 * (__xn + __lambda)); +# 123 +__yn = (__c0 * (__yn + __lambda)); +# 124 +__zn = (__c0 * (__zn + __lambda)); +# 125 +} +# 127 +const _Tp __e2 = (__xndev * __yndev) - (__zndev * __zndev); +# 128 +const _Tp __e3 = (__xndev * __yndev) * __zndev; +# 129 +const _Tp __s = (((_Tp)1) + ((((__c1 * __e2) - __c2) - (__c3 * __e3)) * __e2)) + (__c4 * __e3); +# 132 +return __s / std::sqrt(__mu); +# 133 +} } +# 134 +} +# 153 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 155 +__comp_ellint_1_series(_Tp __k) +# 156 +{ +# 158 +const _Tp __kk = __k * __k; +# 160 +_Tp __term = __kk / ((_Tp)4); +# 161 +_Tp __sum = ((_Tp)1) + __term; +# 163 +const unsigned __max_iter = (1000); +# 164 +for (unsigned __i = (2); __i < __max_iter; ++__i) +# 165 +{ +# 166 +__term *= (((((2) * __i) - (1)) * __kk) / ((2) * __i)); +# 167 +if (__term < std::template numeric_limits< _Tp> ::epsilon()) { +# 168 +break; } +# 169 +__sum += __term; +# 170 +} +# 172 +return __numeric_constants< _Tp> ::__pi_2() * __sum; +# 173 +} +# 191 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 193 +__comp_ellint_1(_Tp __k) +# 194 +{ +# 196 +if (__isnan(__k)) { +# 197 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 198 +if (std::abs(__k) >= ((_Tp)1)) { +# 199 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 201 +return __ellint_rf((_Tp)0, ((_Tp)1) - (__k * __k), (_Tp)1); } } +# 202 +} +# 219 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 221 +__ellint_1(_Tp __k, _Tp __phi) +# 222 +{ +# 224 +if (__isnan(__k) || __isnan(__phi)) { +# 225 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 226 +if (std::abs(__k) > ((_Tp)1)) { +# 227 +std::__throw_domain_error("Bad argument in __ellint_1."); } else +# 229 +{ +# 231 +const int __n = std::floor((__phi / __numeric_constants< _Tp> ::__pi()) + ((_Tp)(0.5L))); +# 233 +const _Tp __phi_red = __phi - (__n * __numeric_constants< _Tp> ::__pi()); +# 236 +const _Tp __s = std::sin(__phi_red); +# 237 +const _Tp __c = std::cos(__phi_red); +# 239 +const _Tp __F = __s * __ellint_rf(__c * __c, ((_Tp)1) - (((__k * __k) * __s) * __s), (_Tp)1); +# 243 +if (__n == 0) { +# 244 +return __F; } else { +# 246 +return __F + ((((_Tp)2) * __n) * __comp_ellint_1(__k)); } +# 247 +} } +# 248 +} +# 266 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 268 +__comp_ellint_2_series(_Tp __k) +# 269 +{ +# 271 +const _Tp __kk = __k * __k; +# 273 +_Tp __term = __kk; +# 274 +_Tp __sum = __term; +# 276 +const unsigned __max_iter = (1000); +# 277 +for (unsigned __i = (2); __i < __max_iter; ++__i) +# 278 +{ +# 279 +const _Tp __i2m = ((2) * __i) - (1); +# 280 +const _Tp __i2 = (2) * __i; +# 281 +__term *= (((__i2m * __i2m) * __kk) / (__i2 * __i2)); +# 282 +if (__term < std::template numeric_limits< _Tp> ::epsilon()) { +# 283 +break; } +# 284 +__sum += (__term / __i2m); +# 285 +} +# 287 +return __numeric_constants< _Tp> ::__pi_2() * (((_Tp)1) - __sum); +# 288 +} +# 314 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 316 +__ellint_rd(_Tp __x, _Tp __y, _Tp __z) +# 317 +{ +# 318 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 319 +const _Tp __errtol = std::pow(__eps / ((_Tp)8), ((_Tp)1) / ((_Tp)6)); +# 320 +const _Tp __max = std::template numeric_limits< _Tp> ::max(); +# 321 +const _Tp __lolim = ((_Tp)2) / std::pow(__max, ((_Tp)2) / ((_Tp)3)); +# 323 +if ((__x < ((_Tp)0)) || (__y < ((_Tp)0))) { +# 324 +std::__throw_domain_error("Argument less than zero in __ellint_rd."); } else { +# 326 +if (((__x + __y) < __lolim) || (__z < __lolim)) { +# 327 +std::__throw_domain_error("Argument too small in __ellint_rd."); } else +# 330 +{ +# 331 +const _Tp __c0 = (((_Tp)1) / ((_Tp)4)); +# 332 +const _Tp __c1 = (((_Tp)3) / ((_Tp)14)); +# 333 +const _Tp __c2 = (((_Tp)1) / ((_Tp)6)); +# 334 +const _Tp __c3 = (((_Tp)9) / ((_Tp)22)); +# 335 +const _Tp __c4 = (((_Tp)3) / ((_Tp)26)); +# 337 +_Tp __xn = __x; +# 338 +_Tp __yn = __y; +# 339 +_Tp __zn = __z; +# 340 +_Tp __sigma = ((_Tp)0); +# 341 +_Tp __power4 = ((_Tp)1); +# 343 +_Tp __mu; +# 344 +_Tp __xndev, __yndev, __zndev; +# 346 +const unsigned __max_iter = (100); +# 347 +for (unsigned __iter = (0); __iter < __max_iter; ++__iter) +# 348 +{ +# 349 +__mu = (((__xn + __yn) + (((_Tp)3) * __zn)) / ((_Tp)5)); +# 350 +__xndev = ((__mu - __xn) / __mu); +# 351 +__yndev = ((__mu - __yn) / __mu); +# 352 +__zndev = ((__mu - __zn) / __mu); +# 353 +_Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); +# 354 +__epsilon = std::max(__epsilon, std::abs(__zndev)); +# 355 +if (__epsilon < __errtol) { +# 356 +break; } +# 357 +_Tp __xnroot = std::sqrt(__xn); +# 358 +_Tp __ynroot = std::sqrt(__yn); +# 359 +_Tp __znroot = std::sqrt(__zn); +# 360 +_Tp __lambda = (__xnroot * (__ynroot + __znroot)) + (__ynroot * __znroot); +# 362 +__sigma += (__power4 / (__znroot * (__zn + __lambda))); +# 363 +__power4 *= __c0; +# 364 +__xn = (__c0 * (__xn + __lambda)); +# 365 +__yn = (__c0 * (__yn + __lambda)); +# 366 +__zn = (__c0 * (__zn + __lambda)); +# 367 +} +# 369 +_Tp __ea = __xndev * __yndev; +# 370 +_Tp __eb = __zndev * __zndev; +# 371 +_Tp __ec = __ea - __eb; +# 372 +_Tp __ed = __ea - (((_Tp)6) * __eb); +# 373 +_Tp __ef = (__ed + __ec) + __ec; +# 374 +_Tp __s1 = __ed * (((-__c1) + ((__c3 * __ed) / ((_Tp)3))) - ((((((_Tp)3) * __c4) * __zndev) * __ef) / ((_Tp)2))); +# 377 +_Tp __s2 = __zndev * ((__c2 * __ef) + (__zndev * ((((-__c3) * __ec) - (__zndev * __c4)) - __ea))); +# 381 +return (((_Tp)3) * __sigma) + ((__power4 * ((((_Tp)1) + __s1) + __s2)) / (__mu * std::sqrt(__mu))); +# 383 +} } +# 384 +} +# 399 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 401 +__comp_ellint_2(_Tp __k) +# 402 +{ +# 404 +if (__isnan(__k)) { +# 405 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 406 +if (std::abs(__k) == 1) { +# 407 +return (_Tp)1; } else { +# 408 +if (std::abs(__k) > ((_Tp)1)) { +# 409 +std::__throw_domain_error("Bad argument in __comp_ellint_2."); } else +# 411 +{ +# 412 +const _Tp __kk = __k * __k; +# 414 +return __ellint_rf((_Tp)0, ((_Tp)1) - __kk, (_Tp)1) - ((__kk * __ellint_rd((_Tp)0, ((_Tp)1) - __kk, (_Tp)1)) / ((_Tp)3)); +# 416 +} } } +# 417 +} +# 433 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 435 +__ellint_2(_Tp __k, _Tp __phi) +# 436 +{ +# 438 +if (__isnan(__k) || __isnan(__phi)) { +# 439 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 440 +if (std::abs(__k) > ((_Tp)1)) { +# 441 +std::__throw_domain_error("Bad argument in __ellint_2."); } else +# 443 +{ +# 445 +const int __n = std::floor((__phi / __numeric_constants< _Tp> ::__pi()) + ((_Tp)(0.5L))); +# 447 +const _Tp __phi_red = __phi - (__n * __numeric_constants< _Tp> ::__pi()); +# 450 +const _Tp __kk = __k * __k; +# 451 +const _Tp __s = std::sin(__phi_red); +# 452 +const _Tp __ss = __s * __s; +# 453 +const _Tp __sss = __ss * __s; +# 454 +const _Tp __c = std::cos(__phi_red); +# 455 +const _Tp __cc = __c * __c; +# 457 +const _Tp __E = (__s * __ellint_rf(__cc, ((_Tp)1) - (__kk * __ss), (_Tp)1)) - (((__kk * __sss) * __ellint_rd(__cc, ((_Tp)1) - (__kk * __ss), (_Tp)1)) / ((_Tp)3)); +# 463 +if (__n == 0) { +# 464 +return __E; } else { +# 466 +return __E + ((((_Tp)2) * __n) * __comp_ellint_2(__k)); } +# 467 +} } +# 468 +} +# 492 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 494 +__ellint_rc(_Tp __x, _Tp __y) +# 495 +{ +# 496 +const _Tp __min = std::template numeric_limits< _Tp> ::min(); +# 497 +const _Tp __lolim = ((_Tp)5) * __min; +# 499 +if (((__x < ((_Tp)0)) || (__y < ((_Tp)0))) || ((__x + __y) < __lolim)) { +# 500 +std::__throw_domain_error("Argument less than zero in __ellint_rc."); } else +# 503 +{ +# 504 +const _Tp __c0 = (((_Tp)1) / ((_Tp)4)); +# 505 +const _Tp __c1 = (((_Tp)1) / ((_Tp)7)); +# 506 +const _Tp __c2 = (((_Tp)9) / ((_Tp)22)); +# 507 +const _Tp __c3 = (((_Tp)3) / ((_Tp)10)); +# 508 +const _Tp __c4 = (((_Tp)3) / ((_Tp)8)); +# 510 +_Tp __xn = __x; +# 511 +_Tp __yn = __y; +# 513 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 514 +const _Tp __errtol = std::pow(__eps / ((_Tp)30), ((_Tp)1) / ((_Tp)6)); +# 515 +_Tp __mu; +# 516 +_Tp __sn; +# 518 +const unsigned __max_iter = (100); +# 519 +for (unsigned __iter = (0); __iter < __max_iter; ++__iter) +# 520 +{ +# 521 +__mu = ((__xn + (((_Tp)2) * __yn)) / ((_Tp)3)); +# 522 +__sn = (((__yn + __mu) / __mu) - ((_Tp)2)); +# 523 +if (std::abs(__sn) < __errtol) { +# 524 +break; } +# 525 +const _Tp __lambda = ((((_Tp)2) * std::sqrt(__xn)) * std::sqrt(__yn)) + __yn; +# 527 +__xn = (__c0 * (__xn + __lambda)); +# 528 +__yn = (__c0 * (__yn + __lambda)); +# 529 +} +# 531 +_Tp __s = (__sn * __sn) * (__c3 + (__sn * (__c1 + (__sn * (__c4 + (__sn * __c2)))))); +# 534 +return (((_Tp)1) + __s) / std::sqrt(__mu); +# 535 +} +# 536 +} +# 561 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 563 +__ellint_rj(_Tp __x, _Tp __y, _Tp __z, _Tp __p) +# 564 +{ +# 565 +const _Tp __min = std::template numeric_limits< _Tp> ::min(); +# 566 +const _Tp __lolim = std::pow(((_Tp)5) * __min, ((_Tp)1) / ((_Tp)3)); +# 568 +if (((__x < ((_Tp)0)) || (__y < ((_Tp)0))) || (__z < ((_Tp)0))) { +# 569 +std::__throw_domain_error("Argument less than zero in __ellint_rj."); } else { +# 571 +if (((((__x + __y) < __lolim) || ((__x + __z) < __lolim)) || ((__y + __z) < __lolim)) || (__p < __lolim)) { +# 573 +std::__throw_domain_error("Argument too small in __ellint_rj"); } else +# 576 +{ +# 577 +const _Tp __c0 = (((_Tp)1) / ((_Tp)4)); +# 578 +const _Tp __c1 = (((_Tp)3) / ((_Tp)14)); +# 579 +const _Tp __c2 = (((_Tp)1) / ((_Tp)3)); +# 580 +const _Tp __c3 = (((_Tp)3) / ((_Tp)22)); +# 581 +const _Tp __c4 = (((_Tp)3) / ((_Tp)26)); +# 583 +_Tp __xn = __x; +# 584 +_Tp __yn = __y; +# 585 +_Tp __zn = __z; +# 586 +_Tp __pn = __p; +# 587 +_Tp __sigma = ((_Tp)0); +# 588 +_Tp __power4 = ((_Tp)1); +# 590 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 591 +const _Tp __errtol = std::pow(__eps / ((_Tp)8), ((_Tp)1) / ((_Tp)6)); +# 593 +_Tp __mu; +# 594 +_Tp __xndev, __yndev, __zndev, __pndev; +# 596 +const unsigned __max_iter = (100); +# 597 +for (unsigned __iter = (0); __iter < __max_iter; ++__iter) +# 598 +{ +# 599 +__mu = ((((__xn + __yn) + __zn) + (((_Tp)2) * __pn)) / ((_Tp)5)); +# 600 +__xndev = ((__mu - __xn) / __mu); +# 601 +__yndev = ((__mu - __yn) / __mu); +# 602 +__zndev = ((__mu - __zn) / __mu); +# 603 +__pndev = ((__mu - __pn) / __mu); +# 604 +_Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); +# 605 +__epsilon = std::max(__epsilon, std::abs(__zndev)); +# 606 +__epsilon = std::max(__epsilon, std::abs(__pndev)); +# 607 +if (__epsilon < __errtol) { +# 608 +break; } +# 609 +const _Tp __xnroot = std::sqrt(__xn); +# 610 +const _Tp __ynroot = std::sqrt(__yn); +# 611 +const _Tp __znroot = std::sqrt(__zn); +# 612 +const _Tp __lambda = (__xnroot * (__ynroot + __znroot)) + (__ynroot * __znroot); +# 614 +const _Tp __alpha1 = (__pn * ((__xnroot + __ynroot) + __znroot)) + ((__xnroot * __ynroot) * __znroot); +# 616 +const _Tp __alpha2 = __alpha1 * __alpha1; +# 617 +const _Tp __beta = (__pn * (__pn + __lambda)) * (__pn + __lambda); +# 619 +__sigma += (__power4 * __ellint_rc(__alpha2, __beta)); +# 620 +__power4 *= __c0; +# 621 +__xn = (__c0 * (__xn + __lambda)); +# 622 +__yn = (__c0 * (__yn + __lambda)); +# 623 +__zn = (__c0 * (__zn + __lambda)); +# 624 +__pn = (__c0 * (__pn + __lambda)); +# 625 +} +# 627 +_Tp __ea = (__xndev * (__yndev + __zndev)) + (__yndev * __zndev); +# 628 +_Tp __eb = (__xndev * __yndev) * __zndev; +# 629 +_Tp __ec = __pndev * __pndev; +# 630 +_Tp __e2 = __ea - (((_Tp)3) * __ec); +# 631 +_Tp __e3 = __eb + ((((_Tp)2) * __pndev) * (__ea - __ec)); +# 632 +_Tp __s1 = ((_Tp)1) + (__e2 * (((-__c1) + (((((_Tp)3) * __c3) * __e2) / ((_Tp)4))) - (((((_Tp)3) * __c4) * __e3) / ((_Tp)2)))); +# 634 +_Tp __s2 = __eb * ((__c2 / ((_Tp)2)) + (__pndev * (((-__c3) - __c3) + (__pndev * __c4)))); +# 636 +_Tp __s3 = ((__pndev * __ea) * (__c2 - (__pndev * __c3))) - ((__c2 * __pndev) * __ec); +# 639 +return (((_Tp)3) * __sigma) + ((__power4 * ((__s1 + __s2) + __s3)) / (__mu * std::sqrt(__mu))); +# 641 +} } +# 642 +} +# 661 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 663 +__comp_ellint_3(_Tp __k, _Tp __nu) +# 664 +{ +# 666 +if (__isnan(__k) || __isnan(__nu)) { +# 667 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 668 +if (__nu == ((_Tp)1)) { +# 669 +return std::template numeric_limits< _Tp> ::infinity(); } else { +# 670 +if (std::abs(__k) > ((_Tp)1)) { +# 671 +std::__throw_domain_error("Bad argument in __comp_ellint_3."); } else +# 673 +{ +# 674 +const _Tp __kk = __k * __k; +# 676 +return __ellint_rf((_Tp)0, ((_Tp)1) - __kk, (_Tp)1) + ((__nu * __ellint_rj((_Tp)0, ((_Tp)1) - __kk, (_Tp)1, ((_Tp)1) - __nu)) / ((_Tp)3)); +# 680 +} } } +# 681 +} +# 701 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 703 +__ellint_3(_Tp __k, _Tp __nu, _Tp __phi) +# 704 +{ +# 706 +if ((__isnan(__k) || __isnan(__nu)) || __isnan(__phi)) { +# 707 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 708 +if (std::abs(__k) > ((_Tp)1)) { +# 709 +std::__throw_domain_error("Bad argument in __ellint_3."); } else +# 711 +{ +# 713 +const int __n = std::floor((__phi / __numeric_constants< _Tp> ::__pi()) + ((_Tp)(0.5L))); +# 715 +const _Tp __phi_red = __phi - (__n * __numeric_constants< _Tp> ::__pi()); +# 718 +const _Tp __kk = __k * __k; +# 719 +const _Tp __s = std::sin(__phi_red); +# 720 +const _Tp __ss = __s * __s; +# 721 +const _Tp __sss = __ss * __s; +# 722 +const _Tp __c = std::cos(__phi_red); +# 723 +const _Tp __cc = __c * __c; +# 725 +const _Tp __Pi = (__s * __ellint_rf(__cc, ((_Tp)1) - (__kk * __ss), (_Tp)1)) + (((__nu * __sss) * __ellint_rj(__cc, ((_Tp)1) - (__kk * __ss), (_Tp)1, ((_Tp)1) - (__nu * __ss))) / ((_Tp)3)); +# 731 +if (__n == 0) { +# 732 +return __Pi; } else { +# 734 +return __Pi + ((((_Tp)2) * __n) * __comp_ellint_3(__k, __nu)); } +# 735 +} } +# 736 +} +# 737 +} +# 743 +} +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +namespace __detail { +# 66 +template< class _Tp> _Tp __expint_E1(_Tp); +# 81 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 83 +__expint_E1_series(_Tp __x) +# 84 +{ +# 85 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 86 +_Tp __term = ((_Tp)1); +# 87 +_Tp __esum = ((_Tp)0); +# 88 +_Tp __osum = ((_Tp)0); +# 89 +const unsigned __max_iter = (1000); +# 90 +for (unsigned __i = (1); __i < __max_iter; ++__i) +# 91 +{ +# 92 +__term *= ((-__x) / __i); +# 93 +if (std::abs(__term) < __eps) { +# 94 +break; } +# 95 +if (__term >= ((_Tp)0)) { +# 96 +__esum += (__term / __i); } else { +# 98 +__osum += (__term / __i); } +# 99 +} +# 101 +return (((-__esum) - __osum) - __numeric_constants< _Tp> ::__gamma_e()) - std::log(__x); +# 103 +} +# 118 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 120 +__expint_E1_asymp(_Tp __x) +# 121 +{ +# 122 +_Tp __term = ((_Tp)1); +# 123 +_Tp __esum = ((_Tp)1); +# 124 +_Tp __osum = ((_Tp)0); +# 125 +const unsigned __max_iter = (1000); +# 126 +for (unsigned __i = (1); __i < __max_iter; ++__i) +# 127 +{ +# 128 +_Tp __prev = __term; +# 129 +__term *= ((-__i) / __x); +# 130 +if (std::abs(__term) > std::abs(__prev)) { +# 131 +break; } +# 132 +if (__term >= ((_Tp)0)) { +# 133 +__esum += __term; } else { +# 135 +__osum += __term; } +# 136 +} +# 138 +return (std::exp(-__x) * (__esum + __osum)) / __x; +# 139 +} +# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 157 +__expint_En_series(unsigned __n, _Tp __x) +# 158 +{ +# 159 +const unsigned __max_iter = (1000); +# 160 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 161 +const int __nm1 = __n - (1); +# 162 +_Tp __ans = (__nm1 != 0) ? ((_Tp)1) / __nm1 : ((-std::log(__x)) - __numeric_constants< _Tp> ::__gamma_e()); +# 165 +_Tp __fact = ((_Tp)1); +# 166 +for (int __i = 1; __i <= __max_iter; ++__i) +# 167 +{ +# 168 +__fact *= ((-__x) / ((_Tp)__i)); +# 169 +_Tp __del; +# 170 +if (__i != __nm1) { +# 171 +__del = ((-__fact) / ((_Tp)(__i - __nm1))); } else +# 173 +{ +# 174 +_Tp __psi = (-__numeric_constants< _Tp> ::gamma_e()); +# 175 +for (int __ii = 1; __ii <= __nm1; ++__ii) { +# 176 +__psi += (((_Tp)1) / ((_Tp)__ii)); } +# 177 +__del = (__fact * (__psi - std::log(__x))); +# 178 +} +# 179 +__ans += __del; +# 180 +if (std::abs(__del) < (__eps * std::abs(__ans))) { +# 181 +return __ans; } +# 182 +} +# 183 +std::__throw_runtime_error("Series summation failed in __expint_En_series."); +# 185 +} +# 201 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 203 +__expint_En_cont_frac(unsigned __n, _Tp __x) +# 204 +{ +# 205 +const unsigned __max_iter = (1000); +# 206 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 207 +const _Tp __fp_min = std::template numeric_limits< _Tp> ::min(); +# 208 +const int __nm1 = __n - (1); +# 209 +_Tp __b = __x + ((_Tp)__n); +# 210 +_Tp __c = ((_Tp)1) / __fp_min; +# 211 +_Tp __d = ((_Tp)1) / __b; +# 212 +_Tp __h = __d; +# 213 +for (unsigned __i = (1); __i <= __max_iter; ++__i) +# 214 +{ +# 215 +_Tp __a = (-((_Tp)(__i * (__nm1 + __i)))); +# 216 +__b += ((_Tp)2); +# 217 +__d = (((_Tp)1) / ((__a * __d) + __b)); +# 218 +__c = (__b + (__a / __c)); +# 219 +const _Tp __del = __c * __d; +# 220 +__h *= __del; +# 221 +if (std::abs(__del - ((_Tp)1)) < __eps) +# 222 +{ +# 223 +const _Tp __ans = __h * std::exp(-__x); +# 224 +return __ans; +# 225 +} +# 226 +} +# 227 +std::__throw_runtime_error("Continued fraction failed in __expint_En_cont_frac."); +# 229 +} +# 246 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 248 +__expint_En_recursion(unsigned __n, _Tp __x) +# 249 +{ +# 250 +_Tp __En; +# 251 +_Tp __E1 = __expint_E1(__x); +# 252 +if (__x < ((_Tp)__n)) +# 253 +{ +# 255 +__En = __E1; +# 256 +for (unsigned __j = (2); __j < __n; ++__j) { +# 257 +__En = ((std::exp(-__x) - (__x * __En)) / ((_Tp)(__j - (1)))); } +# 258 +} else +# 260 +{ +# 262 +__En = ((_Tp)1); +# 263 +const int __N = __n + (20); +# 264 +_Tp __save = ((_Tp)0); +# 265 +for (int __j = __N; __j > 0; --__j) +# 266 +{ +# 267 +__En = ((std::exp(-__x) - (__j * __En)) / __x); +# 268 +if (__j == __n) { +# 269 +__save = __En; } +# 270 +} +# 271 +_Tp __norm = __En / __E1; +# 272 +__En /= __norm; +# 273 +} +# 275 +return __En; +# 276 +} +# 290 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 292 +__expint_Ei_series(_Tp __x) +# 293 +{ +# 294 +_Tp __term = ((_Tp)1); +# 295 +_Tp __sum = ((_Tp)0); +# 296 +const unsigned __max_iter = (1000); +# 297 +for (unsigned __i = (1); __i < __max_iter; ++__i) +# 298 +{ +# 299 +__term *= (__x / __i); +# 300 +__sum += (__term / __i); +# 301 +if (__term < (std::template numeric_limits< _Tp> ::epsilon() * __sum)) { +# 302 +break; } +# 303 +} +# 305 +return (__numeric_constants< _Tp> ::__gamma_e() + __sum) + std::log(__x); +# 306 +} +# 321 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 323 +__expint_Ei_asymp(_Tp __x) +# 324 +{ +# 325 +_Tp __term = ((_Tp)1); +# 326 +_Tp __sum = ((_Tp)1); +# 327 +const unsigned __max_iter = (1000); +# 328 +for (unsigned __i = (1); __i < __max_iter; ++__i) +# 329 +{ +# 330 +_Tp __prev = __term; +# 331 +__term *= (__i / __x); +# 332 +if (__term < std::template numeric_limits< _Tp> ::epsilon()) { +# 333 +break; } +# 334 +if (__term >= __prev) { +# 335 +break; } +# 336 +__sum += __term; +# 337 +} +# 339 +return (std::exp(__x) * __sum) / __x; +# 340 +} +# 354 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 356 +__expint_Ei(_Tp __x) +# 357 +{ +# 358 +if (__x < ((_Tp)0)) { +# 359 +return -__expint_E1(-__x); } else { +# 360 +if (__x < (-std::log(std::template numeric_limits< _Tp> ::epsilon()))) { +# 361 +return __expint_Ei_series(__x); } else { +# 363 +return __expint_Ei_asymp(__x); } } +# 364 +} +# 378 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 380 +__expint_E1(_Tp __x) +# 381 +{ +# 382 +if (__x < ((_Tp)0)) { +# 383 +return -__expint_Ei(-__x); } else { +# 384 +if (__x < ((_Tp)1)) { +# 385 +return __expint_E1_series(__x); } else { +# 386 +if (__x < ((_Tp)100)) { +# 387 +return __expint_En_cont_frac(1, __x); } else { +# 389 +return __expint_E1_asymp(__x); } } } +# 390 +} +# 408 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 410 +__expint_asymp(unsigned __n, _Tp __x) +# 411 +{ +# 412 +_Tp __term = ((_Tp)1); +# 413 +_Tp __sum = ((_Tp)1); +# 414 +for (unsigned __i = (1); __i <= __n; ++__i) +# 415 +{ +# 416 +_Tp __prev = __term; +# 417 +__term *= ((-((__n - __i) + (1))) / __x); +# 418 +if (std::abs(__term) > std::abs(__prev)) { +# 419 +break; } +# 420 +__sum += __term; +# 421 +} +# 423 +return (std::exp(-__x) * __sum) / __x; +# 424 +} +# 442 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 444 +__expint_large_n(unsigned __n, _Tp __x) +# 445 +{ +# 446 +const _Tp __xpn = __x + __n; +# 447 +const _Tp __xpn2 = __xpn * __xpn; +# 448 +_Tp __term = ((_Tp)1); +# 449 +_Tp __sum = ((_Tp)1); +# 450 +for (unsigned __i = (1); __i <= __n; ++__i) +# 451 +{ +# 452 +_Tp __prev = __term; +# 453 +__term *= ((__n - (((2) * (__i - (1))) * __x)) / __xpn2); +# 454 +if (std::abs(__term) < std::template numeric_limits< _Tp> ::epsilon()) { +# 455 +break; } +# 456 +__sum += __term; +# 457 +} +# 459 +return (std::exp(-__x) * __sum) / __xpn; +# 460 +} +# 476 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 478 +__expint(unsigned __n, _Tp __x) +# 479 +{ +# 481 +if (__isnan(__x)) { +# 482 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 483 +if ((__n <= (1)) && (__x == ((_Tp)0))) { +# 484 +return std::template numeric_limits< _Tp> ::infinity(); } else +# 486 +{ +# 487 +_Tp __E0 = std::exp(__x) / __x; +# 488 +if (__n == (0)) { +# 489 +return __E0; } +# 491 +_Tp __E1 = __expint_E1(__x); +# 492 +if (__n == (1)) { +# 493 +return __E1; } +# 495 +if (__x == ((_Tp)0)) { +# 496 +return ((_Tp)1) / (static_cast< _Tp>(__n - (1))); } +# 498 +_Tp __En = __expint_En_recursion(__n, __x); +# 500 +return __En; +# 501 +} } +# 502 +} +# 516 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> inline _Tp +# 518 +__expint(_Tp __x) +# 519 +{ +# 520 +if (__isnan(__x)) { +# 521 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 523 +return __expint_Ei(__x); } +# 524 +} +# 525 +} +# 531 +} +# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 +namespace __detail { +# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 +template< class _Tp> _Tp +# 85 +__conf_hyperg_series(_Tp __a, _Tp __c, _Tp __x) +# 86 +{ +# 87 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 89 +_Tp __term = ((_Tp)1); +# 90 +_Tp __Fac = ((_Tp)1); +# 91 +const unsigned __max_iter = (100000); +# 92 +unsigned __i; +# 93 +for (__i = (0); __i < __max_iter; ++__i) +# 94 +{ +# 95 +__term *= (((__a + ((_Tp)__i)) * __x) / ((__c + ((_Tp)__i)) * ((_Tp)((1) + __i)))); +# 97 +if (std::abs(__term) < __eps) +# 98 +{ +# 99 +break; +# 100 +} +# 101 +__Fac += __term; +# 102 +} +# 103 +if (__i == __max_iter) { +# 104 +std::__throw_runtime_error("Series failed to converge in __conf_hyperg_series."); } +# 107 +return __Fac; +# 108 +} +# 120 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 +template< class _Tp> _Tp +# 122 +__conf_hyperg_luke(_Tp __a, _Tp __c, _Tp __xin) +# 123 +{ +# 124 +const _Tp __big = std::pow(std::template numeric_limits< _Tp> ::max(), (_Tp)(0.16L)); +# 125 +const int __nmax = 20000; +# 126 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 127 +const _Tp __x = (-__xin); +# 128 +const _Tp __x3 = (__x * __x) * __x; +# 129 +const _Tp __t0 = __a / __c; +# 130 +const _Tp __t1 = (__a + ((_Tp)1)) / (((_Tp)2) * __c); +# 131 +const _Tp __t2 = (__a + ((_Tp)2)) / (((_Tp)2) * (__c + ((_Tp)1))); +# 132 +_Tp __F = ((_Tp)1); +# 133 +_Tp __prec; +# 135 +_Tp __Bnm3 = ((_Tp)1); +# 136 +_Tp __Bnm2 = ((_Tp)1) + (__t1 * __x); +# 137 +_Tp __Bnm1 = ((_Tp)1) + ((__t2 * __x) * (((_Tp)1) + ((__t1 / ((_Tp)3)) * __x))); +# 139 +_Tp __Anm3 = ((_Tp)1); +# 140 +_Tp __Anm2 = __Bnm2 - (__t0 * __x); +# 141 +_Tp __Anm1 = (__Bnm1 - ((__t0 * (((_Tp)1) + (__t2 * __x))) * __x)) + ((((__t0 * __t1) * (__c / (__c + ((_Tp)1)))) * __x) * __x); +# 144 +int __n = 3; +# 145 +while (1) +# 146 +{ +# 147 +_Tp __npam1 = ((_Tp)(__n - 1)) + __a; +# 148 +_Tp __npcm1 = ((_Tp)(__n - 1)) + __c; +# 149 +_Tp __npam2 = ((_Tp)(__n - 2)) + __a; +# 150 +_Tp __npcm2 = ((_Tp)(__n - 2)) + __c; +# 151 +_Tp __tnm1 = (_Tp)((2 * __n) - 1); +# 152 +_Tp __tnm3 = (_Tp)((2 * __n) - 3); +# 153 +_Tp __tnm5 = (_Tp)((2 * __n) - 5); +# 154 +_Tp __F1 = (((_Tp)(__n - 2)) - __a) / ((((_Tp)2) * __tnm3) * __npcm1); +# 155 +_Tp __F2 = ((((_Tp)__n) + __a) * __npam1) / ((((((_Tp)4) * __tnm1) * __tnm3) * __npcm2) * __npcm1); +# 157 +_Tp __F3 = (((-__npam2) * __npam1) * (((_Tp)(__n - 2)) - __a)) / ((((((((_Tp)8) * __tnm3) * __tnm3) * __tnm5) * (((_Tp)(__n - 3)) + __c)) * __npcm2) * __npcm1); +# 160 +_Tp __E = ((-__npam1) * (((_Tp)(__n - 1)) - __c)) / (((((_Tp)2) * __tnm3) * __npcm2) * __npcm1); +# 163 +_Tp __An = (((((_Tp)1) + (__F1 * __x)) * __Anm1) + (((__E + (__F2 * __x)) * __x) * __Anm2)) + ((__F3 * __x3) * __Anm3); +# 165 +_Tp __Bn = (((((_Tp)1) + (__F1 * __x)) * __Bnm1) + (((__E + (__F2 * __x)) * __x) * __Bnm2)) + ((__F3 * __x3) * __Bnm3); +# 167 +_Tp __r = __An / __Bn; +# 169 +__prec = std::abs((__F - __r) / __F); +# 170 +__F = __r; +# 172 +if ((__prec < __eps) || (__n > __nmax)) { +# 173 +break; } +# 175 +if ((std::abs(__An) > __big) || (std::abs(__Bn) > __big)) +# 176 +{ +# 177 +__An /= __big; +# 178 +__Bn /= __big; +# 179 +__Anm1 /= __big; +# 180 +__Bnm1 /= __big; +# 181 +__Anm2 /= __big; +# 182 +__Bnm2 /= __big; +# 183 +__Anm3 /= __big; +# 184 +__Bnm3 /= __big; +# 185 +} else { +# 186 +if ((std::abs(__An) < (((_Tp)1) / __big)) || (std::abs(__Bn) < (((_Tp)1) / __big))) +# 188 +{ +# 189 +__An *= __big; +# 190 +__Bn *= __big; +# 191 +__Anm1 *= __big; +# 192 +__Bnm1 *= __big; +# 193 +__Anm2 *= __big; +# 194 +__Bnm2 *= __big; +# 195 +__Anm3 *= __big; +# 196 +__Bnm3 *= __big; +# 197 +} } +# 199 +++__n; +# 200 +__Bnm3 = __Bnm2; +# 201 +__Bnm2 = __Bnm1; +# 202 +__Bnm1 = __Bn; +# 203 +__Anm3 = __Anm2; +# 204 +__Anm2 = __Anm1; +# 205 +__Anm1 = __An; +# 206 +} +# 208 +if (__n >= __nmax) { +# 209 +std::__throw_runtime_error("Iteration failed to converge in __conf_hyperg_luke."); } +# 212 +return __F; +# 213 +} +# 227 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 +template< class _Tp> _Tp +# 229 +__conf_hyperg(_Tp __a, _Tp __c, _Tp __x) +# 230 +{ +# 232 +const _Tp __c_nint = std::nearbyint(__c); +# 236 +if ((__isnan(__a) || __isnan(__c)) || __isnan(__x)) { +# 237 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 238 +if ((__c_nint == __c) && (__c_nint <= 0)) { +# 239 +return std::template numeric_limits< _Tp> ::infinity(); } else { +# 240 +if (__a == ((_Tp)0)) { +# 241 +return (_Tp)1; } else { +# 242 +if (__c == __a) { +# 243 +return std::exp(__x); } else { +# 244 +if (__x < ((_Tp)0)) { +# 245 +return __conf_hyperg_luke(__a, __c, __x); } else { +# 247 +return __conf_hyperg_series(__a, __c, __x); } } } } } +# 248 +} +# 271 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 +template< class _Tp> _Tp +# 273 +__hyperg_series(_Tp __a, _Tp __b, _Tp __c, _Tp __x) +# 274 +{ +# 275 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 277 +_Tp __term = ((_Tp)1); +# 278 +_Tp __Fabc = ((_Tp)1); +# 279 +const unsigned __max_iter = (100000); +# 280 +unsigned __i; +# 281 +for (__i = (0); __i < __max_iter; ++__i) +# 282 +{ +# 283 +__term *= ((((__a + ((_Tp)__i)) * (__b + ((_Tp)__i))) * __x) / ((__c + ((_Tp)__i)) * ((_Tp)((1) + __i)))); +# 285 +if (std::abs(__term) < __eps) +# 286 +{ +# 287 +break; +# 288 +} +# 289 +__Fabc += __term; +# 290 +} +# 291 +if (__i == __max_iter) { +# 292 +std::__throw_runtime_error("Series failed to converge in __hyperg_series."); } +# 295 +return __Fabc; +# 296 +} +# 304 +template< class _Tp> _Tp +# 306 +__hyperg_luke(_Tp __a, _Tp __b, _Tp __c, _Tp __xin) +# 307 +{ +# 308 +const _Tp __big = std::pow(std::template numeric_limits< _Tp> ::max(), (_Tp)(0.16L)); +# 309 +const int __nmax = 20000; +# 310 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 311 +const _Tp __x = (-__xin); +# 312 +const _Tp __x3 = (__x * __x) * __x; +# 313 +const _Tp __t0 = (__a * __b) / __c; +# 314 +const _Tp __t1 = ((__a + ((_Tp)1)) * (__b + ((_Tp)1))) / (((_Tp)2) * __c); +# 315 +const _Tp __t2 = ((__a + ((_Tp)2)) * (__b + ((_Tp)2))) / (((_Tp)2) * (__c + ((_Tp)1))); +# 318 +_Tp __F = ((_Tp)1); +# 320 +_Tp __Bnm3 = ((_Tp)1); +# 321 +_Tp __Bnm2 = ((_Tp)1) + (__t1 * __x); +# 322 +_Tp __Bnm1 = ((_Tp)1) + ((__t2 * __x) * (((_Tp)1) + ((__t1 / ((_Tp)3)) * __x))); +# 324 +_Tp __Anm3 = ((_Tp)1); +# 325 +_Tp __Anm2 = __Bnm2 - (__t0 * __x); +# 326 +_Tp __Anm1 = (__Bnm1 - ((__t0 * (((_Tp)1) + (__t2 * __x))) * __x)) + ((((__t0 * __t1) * (__c / (__c + ((_Tp)1)))) * __x) * __x); +# 329 +int __n = 3; +# 330 +while (1) +# 331 +{ +# 332 +const _Tp __npam1 = ((_Tp)(__n - 1)) + __a; +# 333 +const _Tp __npbm1 = ((_Tp)(__n - 1)) + __b; +# 334 +const _Tp __npcm1 = ((_Tp)(__n - 1)) + __c; +# 335 +const _Tp __npam2 = ((_Tp)(__n - 2)) + __a; +# 336 +const _Tp __npbm2 = ((_Tp)(__n - 2)) + __b; +# 337 +const _Tp __npcm2 = ((_Tp)(__n - 2)) + __c; +# 338 +const _Tp __tnm1 = (_Tp)((2 * __n) - 1); +# 339 +const _Tp __tnm3 = (_Tp)((2 * __n) - 3); +# 340 +const _Tp __tnm5 = (_Tp)((2 * __n) - 5); +# 341 +const _Tp __n2 = __n * __n; +# 342 +const _Tp __F1 = (((((((_Tp)3) * __n2) + (((__a + __b) - ((_Tp)6)) * __n)) + ((_Tp)2)) - (__a * __b)) - (((_Tp)2) * (__a + __b))) / ((((_Tp)2) * __tnm3) * __npcm1); +# 345 +const _Tp __F2 = (((-((((((_Tp)3) * __n2) - (((__a + __b) + ((_Tp)6)) * __n)) + ((_Tp)2)) - (__a * __b))) * __npam1) * __npbm1) / ((((((_Tp)4) * __tnm1) * __tnm3) * __npcm2) * __npcm1); +# 348 +const _Tp __F3 = (((((__npam2 * __npam1) * __npbm2) * __npbm1) * (((_Tp)(__n - 2)) - __a)) * (((_Tp)(__n - 2)) - __b)) / ((((((((_Tp)8) * __tnm3) * __tnm3) * __tnm5) * (((_Tp)(__n - 3)) + __c)) * __npcm2) * __npcm1); +# 352 +const _Tp __E = (((-__npam1) * __npbm1) * (((_Tp)(__n - 1)) - __c)) / (((((_Tp)2) * __tnm3) * __npcm2) * __npcm1); +# 355 +_Tp __An = (((((_Tp)1) + (__F1 * __x)) * __Anm1) + (((__E + (__F2 * __x)) * __x) * __Anm2)) + ((__F3 * __x3) * __Anm3); +# 357 +_Tp __Bn = (((((_Tp)1) + (__F1 * __x)) * __Bnm1) + (((__E + (__F2 * __x)) * __x) * __Bnm2)) + ((__F3 * __x3) * __Bnm3); +# 359 +const _Tp __r = __An / __Bn; +# 361 +const _Tp __prec = std::abs((__F - __r) / __F); +# 362 +__F = __r; +# 364 +if ((__prec < __eps) || (__n > __nmax)) { +# 365 +break; } +# 367 +if ((std::abs(__An) > __big) || (std::abs(__Bn) > __big)) +# 368 +{ +# 369 +__An /= __big; +# 370 +__Bn /= __big; +# 371 +__Anm1 /= __big; +# 372 +__Bnm1 /= __big; +# 373 +__Anm2 /= __big; +# 374 +__Bnm2 /= __big; +# 375 +__Anm3 /= __big; +# 376 +__Bnm3 /= __big; +# 377 +} else { +# 378 +if ((std::abs(__An) < (((_Tp)1) / __big)) || (std::abs(__Bn) < (((_Tp)1) / __big))) +# 380 +{ +# 381 +__An *= __big; +# 382 +__Bn *= __big; +# 383 +__Anm1 *= __big; +# 384 +__Bnm1 *= __big; +# 385 +__Anm2 *= __big; +# 386 +__Bnm2 *= __big; +# 387 +__Anm3 *= __big; +# 388 +__Bnm3 *= __big; +# 389 +} } +# 391 +++__n; +# 392 +__Bnm3 = __Bnm2; +# 393 +__Bnm2 = __Bnm1; +# 394 +__Bnm1 = __Bn; +# 395 +__Anm3 = __Anm2; +# 396 +__Anm2 = __Anm1; +# 397 +__Anm1 = __An; +# 398 +} +# 400 +if (__n >= __nmax) { +# 401 +std::__throw_runtime_error("Iteration failed to converge in __hyperg_luke."); } +# 404 +return __F; +# 405 +} +# 438 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 +template< class _Tp> _Tp +# 440 +__hyperg_reflect(_Tp __a, _Tp __b, _Tp __c, _Tp __x) +# 441 +{ +# 442 +const _Tp __d = (__c - __a) - __b; +# 443 +const int __intd = std::floor(__d + ((_Tp)(0.5L))); +# 444 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 445 +const _Tp __toler = ((_Tp)1000) * __eps; +# 446 +const _Tp __log_max = std::log(std::template numeric_limits< _Tp> ::max()); +# 447 +const bool __d_integer = std::abs(__d - __intd) < __toler; +# 449 +if (__d_integer) +# 450 +{ +# 451 +const _Tp __ln_omx = std::log(((_Tp)1) - __x); +# 452 +const _Tp __ad = std::abs(__d); +# 453 +_Tp __F1, __F2; +# 455 +_Tp __d1, __d2; +# 456 +if (__d >= ((_Tp)0)) +# 457 +{ +# 458 +__d1 = __d; +# 459 +__d2 = ((_Tp)0); +# 460 +} else +# 462 +{ +# 463 +__d1 = ((_Tp)0); +# 464 +__d2 = __d; +# 465 +} +# 467 +const _Tp __lng_c = __log_gamma(__c); +# 470 +if (__ad < __eps) +# 471 +{ +# 473 +__F1 = ((_Tp)0); +# 474 +} else +# 476 +{ +# 478 +bool __ok_d1 = true; +# 479 +_Tp __lng_ad, __lng_ad1, __lng_bd1; +# 480 +try +# 481 +{ +# 482 +__lng_ad = __log_gamma(__ad); +# 483 +__lng_ad1 = __log_gamma(__a + __d1); +# 484 +__lng_bd1 = __log_gamma(__b + __d1); +# 485 +} +# 486 +catch (...) +# 487 +{ +# 488 +__ok_d1 = false; +# 489 +} +# 491 +if (__ok_d1) +# 492 +{ +# 496 +_Tp __sum1 = ((_Tp)1); +# 497 +_Tp __term = ((_Tp)1); +# 498 +_Tp __ln_pre1 = (((__lng_ad + __lng_c) + (__d2 * __ln_omx)) - __lng_ad1) - __lng_bd1; +# 503 +for (int __i = 1; __i < __ad; ++__i) +# 504 +{ +# 505 +const int __j = __i - 1; +# 506 +__term *= ((((((__a + __d2) + __j) * ((__b + __d2) + __j)) / ((((_Tp)1) + __d2) + __j)) / __i) * (((_Tp)1) - __x)); +# 508 +__sum1 += __term; +# 509 +} +# 511 +if (__ln_pre1 > __log_max) { +# 512 +std::__throw_runtime_error("Overflow of gamma functions in __hyperg_luke."); } else { +# 515 +__F1 = (std::exp(__ln_pre1) * __sum1); } +# 516 +} else +# 518 +{ +# 521 +__F1 = ((_Tp)0); +# 522 +} +# 523 +} +# 526 +bool __ok_d2 = true; +# 527 +_Tp __lng_ad2, __lng_bd2; +# 528 +try +# 529 +{ +# 530 +__lng_ad2 = __log_gamma(__a + __d2); +# 531 +__lng_bd2 = __log_gamma(__b + __d2); +# 532 +} +# 533 +catch (...) +# 534 +{ +# 535 +__ok_d2 = false; +# 536 +} +# 538 +if (__ok_d2) +# 539 +{ +# 542 +const int __maxiter = 2000; +# 543 +const _Tp __psi_1 = (-__numeric_constants< _Tp> ::__gamma_e()); +# 544 +const _Tp __psi_1pd = __psi(((_Tp)1) + __ad); +# 545 +const _Tp __psi_apd1 = __psi(__a + __d1); +# 546 +const _Tp __psi_bpd1 = __psi(__b + __d1); +# 548 +_Tp __psi_term = (((__psi_1 + __psi_1pd) - __psi_apd1) - __psi_bpd1) - __ln_omx; +# 550 +_Tp __fact = ((_Tp)1); +# 551 +_Tp __sum2 = __psi_term; +# 552 +_Tp __ln_pre2 = ((__lng_c + (__d1 * __ln_omx)) - __lng_ad2) - __lng_bd2; +# 556 +int __j; +# 557 +for (__j = 1; __j < __maxiter; ++__j) +# 558 +{ +# 561 +const _Tp __term1 = (((_Tp)1) / ((_Tp)__j)) + (((_Tp)1) / (__ad + __j)); +# 563 +const _Tp __term2 = (((_Tp)1) / ((__a + __d1) + ((_Tp)(__j - 1)))) + (((_Tp)1) / ((__b + __d1) + ((_Tp)(__j - 1)))); +# 565 +__psi_term += (__term1 - __term2); +# 566 +__fact *= (((((__a + __d1) + ((_Tp)(__j - 1))) * ((__b + __d1) + ((_Tp)(__j - 1)))) / ((__ad + __j) * __j)) * (((_Tp)1) - __x)); +# 569 +const _Tp __delta = __fact * __psi_term; +# 570 +__sum2 += __delta; +# 571 +if (std::abs(__delta) < (__eps * std::abs(__sum2))) { +# 572 +break; } +# 573 +} +# 574 +if (__j == __maxiter) { +# 575 +std::__throw_runtime_error("Sum F2 failed to converge in __hyperg_reflect"); } +# 578 +if (__sum2 == ((_Tp)0)) { +# 579 +__F2 = ((_Tp)0); } else { +# 581 +__F2 = (std::exp(__ln_pre2) * __sum2); } +# 582 +} else +# 584 +{ +# 587 +__F2 = ((_Tp)0); +# 588 +} +# 590 +const _Tp __sgn_2 = (((__intd % 2) == 1) ? -((_Tp)1) : ((_Tp)1)); +# 591 +const _Tp __F = __F1 + (__sgn_2 * __F2); +# 593 +return __F; +# 594 +} else +# 596 +{ +# 601 +bool __ok1 = true; +# 602 +_Tp __sgn_g1ca = ((_Tp)0), __ln_g1ca = ((_Tp)0); +# 603 +_Tp __sgn_g1cb = ((_Tp)0), __ln_g1cb = ((_Tp)0); +# 604 +try +# 605 +{ +# 606 +__sgn_g1ca = __log_gamma_sign(__c - __a); +# 607 +__ln_g1ca = __log_gamma(__c - __a); +# 608 +__sgn_g1cb = __log_gamma_sign(__c - __b); +# 609 +__ln_g1cb = __log_gamma(__c - __b); +# 610 +} +# 611 +catch (...) +# 612 +{ +# 613 +__ok1 = false; +# 614 +} +# 616 +bool __ok2 = true; +# 617 +_Tp __sgn_g2a = ((_Tp)0), __ln_g2a = ((_Tp)0); +# 618 +_Tp __sgn_g2b = ((_Tp)0), __ln_g2b = ((_Tp)0); +# 619 +try +# 620 +{ +# 621 +__sgn_g2a = __log_gamma_sign(__a); +# 622 +__ln_g2a = __log_gamma(__a); +# 623 +__sgn_g2b = __log_gamma_sign(__b); +# 624 +__ln_g2b = __log_gamma(__b); +# 625 +} +# 626 +catch (...) +# 627 +{ +# 628 +__ok2 = false; +# 629 +} +# 631 +const _Tp __sgn_gc = __log_gamma_sign(__c); +# 632 +const _Tp __ln_gc = __log_gamma(__c); +# 633 +const _Tp __sgn_gd = __log_gamma_sign(__d); +# 634 +const _Tp __ln_gd = __log_gamma(__d); +# 635 +const _Tp __sgn_gmd = __log_gamma_sign(-__d); +# 636 +const _Tp __ln_gmd = __log_gamma(-__d); +# 638 +const _Tp __sgn1 = ((__sgn_gc * __sgn_gd) * __sgn_g1ca) * __sgn_g1cb; +# 639 +const _Tp __sgn2 = ((__sgn_gc * __sgn_gmd) * __sgn_g2a) * __sgn_g2b; +# 641 +_Tp __pre1, __pre2; +# 642 +if (__ok1 && __ok2) +# 643 +{ +# 644 +_Tp __ln_pre1 = ((__ln_gc + __ln_gd) - __ln_g1ca) - __ln_g1cb; +# 645 +_Tp __ln_pre2 = (((__ln_gc + __ln_gmd) - __ln_g2a) - __ln_g2b) + (__d * std::log(((_Tp)1) - __x)); +# 647 +if ((__ln_pre1 < __log_max) && (__ln_pre2 < __log_max)) +# 648 +{ +# 649 +__pre1 = std::exp(__ln_pre1); +# 650 +__pre2 = std::exp(__ln_pre2); +# 651 +__pre1 *= __sgn1; +# 652 +__pre2 *= __sgn2; +# 653 +} else +# 655 +{ +# 656 +std::__throw_runtime_error("Overflow of gamma functions in __hyperg_reflect"); +# 658 +} +# 659 +} else { +# 660 +if (__ok1 && (!__ok2)) +# 661 +{ +# 662 +_Tp __ln_pre1 = ((__ln_gc + __ln_gd) - __ln_g1ca) - __ln_g1cb; +# 663 +if (__ln_pre1 < __log_max) +# 664 +{ +# 665 +__pre1 = std::exp(__ln_pre1); +# 666 +__pre1 *= __sgn1; +# 667 +__pre2 = ((_Tp)0); +# 668 +} else +# 670 +{ +# 671 +std::__throw_runtime_error("Overflow of gamma functions in __hyperg_reflect"); +# 673 +} +# 674 +} else { +# 675 +if ((!__ok1) && __ok2) +# 676 +{ +# 677 +_Tp __ln_pre2 = (((__ln_gc + __ln_gmd) - __ln_g2a) - __ln_g2b) + (__d * std::log(((_Tp)1) - __x)); +# 679 +if (__ln_pre2 < __log_max) +# 680 +{ +# 681 +__pre1 = ((_Tp)0); +# 682 +__pre2 = std::exp(__ln_pre2); +# 683 +__pre2 *= __sgn2; +# 684 +} else +# 686 +{ +# 687 +std::__throw_runtime_error("Overflow of gamma functions in __hyperg_reflect"); +# 689 +} +# 690 +} else +# 692 +{ +# 693 +__pre1 = ((_Tp)0); +# 694 +__pre2 = ((_Tp)0); +# 695 +std::__throw_runtime_error("Underflow of gamma functions in __hyperg_reflect"); +# 697 +} } } +# 699 +const _Tp __F1 = __hyperg_series(__a, __b, ((_Tp)1) - __d, ((_Tp)1) - __x); +# 701 +const _Tp __F2 = __hyperg_series(__c - __a, __c - __b, ((_Tp)1) + __d, ((_Tp)1) - __x); +# 704 +const _Tp __F = (__pre1 * __F1) + (__pre2 * __F2); +# 706 +return __F; +# 707 +} +# 708 +} +# 728 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 +template< class _Tp> _Tp +# 730 +__hyperg(_Tp __a, _Tp __b, _Tp __c, _Tp __x) +# 731 +{ +# 733 +const _Tp __a_nint = std::nearbyint(__a); +# 734 +const _Tp __b_nint = std::nearbyint(__b); +# 735 +const _Tp __c_nint = std::nearbyint(__c); +# 741 +const _Tp __toler = ((_Tp)1000) * std::template numeric_limits< _Tp> ::epsilon(); +# 742 +if (std::abs(__x) >= ((_Tp)1)) { +# 743 +std::__throw_domain_error("Argument outside unit circle in __hyperg."); } else { +# 745 +if (((__isnan(__a) || __isnan(__b)) || __isnan(__c)) || __isnan(__x)) { +# 747 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 748 +if ((__c_nint == __c) && (__c_nint <= ((_Tp)0))) { +# 749 +return std::template numeric_limits< _Tp> ::infinity(); } else { +# 750 +if ((std::abs(__c - __b) < __toler) || (std::abs(__c - __a) < __toler)) { +# 751 +return std::pow(((_Tp)1) - __x, (__c - __a) - __b); } else { +# 752 +if ((__a >= ((_Tp)0)) && (__b >= ((_Tp)0)) && (__c >= ((_Tp)0)) && (__x >= ((_Tp)0)) && (__x < ((_Tp)(0.995L)))) { +# 754 +return __hyperg_series(__a, __b, __c, __x); } else { +# 755 +if ((std::abs(__a) < ((_Tp)10)) && (std::abs(__b) < ((_Tp)10))) +# 756 +{ +# 759 +if ((__a < ((_Tp)0)) && (std::abs(__a - __a_nint) < __toler)) { +# 760 +return __hyperg_series(__a_nint, __b, __c, __x); } else { +# 761 +if ((__b < ((_Tp)0)) && (std::abs(__b - __b_nint) < __toler)) { +# 762 +return __hyperg_series(__a, __b_nint, __c, __x); } else { +# 763 +if (__x < (-((_Tp)(0.25L)))) { +# 764 +return __hyperg_luke(__a, __b, __c, __x); } else { +# 765 +if (__x < ((_Tp)(0.5L))) { +# 766 +return __hyperg_series(__a, __b, __c, __x); } else { +# 768 +if (std::abs(__c) > ((_Tp)10)) { +# 769 +return __hyperg_series(__a, __b, __c, __x); } else { +# 771 +return __hyperg_reflect(__a, __b, __c, __x); } } } } } +# 772 +} else { +# 774 +return __hyperg_luke(__a, __b, __c, __x); } } } } } } +# 775 +} +# 776 +} +# 783 +} +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 +namespace __detail { +# 80 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 +template< class _Tp> _Tp +# 82 +__poly_legendre_p(unsigned __l, _Tp __x) +# 83 +{ +# 85 +if (__isnan(__x)) { +# 86 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 87 +if (__x == (+((_Tp)1))) { +# 88 +return +((_Tp)1); } else { +# 89 +if (__x == (-((_Tp)1))) { +# 90 +return (((__l % (2)) == (1)) ? -((_Tp)1) : (+((_Tp)1))); } else +# 92 +{ +# 93 +_Tp __p_lm2 = ((_Tp)1); +# 94 +if (__l == (0)) { +# 95 +return __p_lm2; } +# 97 +_Tp __p_lm1 = __x; +# 98 +if (__l == (1)) { +# 99 +return __p_lm1; } +# 101 +_Tp __p_l = (0); +# 102 +for (unsigned __ll = (2); __ll <= __l; ++__ll) +# 103 +{ +# 106 +__p_l = ((((((_Tp)2) * __x) * __p_lm1) - __p_lm2) - (((__x * __p_lm1) - __p_lm2) / ((_Tp)__ll))); +# 108 +__p_lm2 = __p_lm1; +# 109 +__p_lm1 = __p_l; +# 110 +} +# 112 +return __p_l; +# 113 +} } } +# 114 +} +# 136 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 +template< class _Tp> _Tp +# 138 +__assoc_legendre_p(unsigned __l, unsigned __m, _Tp __x, _Tp +# 139 +__phase = (_Tp)(+1)) +# 140 +{ +# 142 +if (__m > __l) { +# 143 +return (_Tp)0; } else { +# 144 +if (__isnan(__x)) { +# 145 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 146 +if (__m == (0)) { +# 147 +return __poly_legendre_p(__l, __x); } else +# 149 +{ +# 150 +_Tp __p_mm = ((_Tp)1); +# 151 +if (__m > (0)) +# 152 +{ +# 155 +_Tp __root = std::sqrt(((_Tp)1) - __x) * std::sqrt(((_Tp)1) + __x); +# 156 +_Tp __fact = ((_Tp)1); +# 157 +for (unsigned __i = (1); __i <= __m; ++__i) +# 158 +{ +# 159 +__p_mm *= ((__phase * __fact) * __root); +# 160 +__fact += ((_Tp)2); +# 161 +} +# 162 +} +# 163 +if (__l == __m) { +# 164 +return __p_mm; } +# 166 +_Tp __p_mp1m = (((_Tp)(((2) * __m) + (1))) * __x) * __p_mm; +# 167 +if (__l == (__m + (1))) { +# 168 +return __p_mp1m; } +# 170 +_Tp __p_lm2m = __p_mm; +# 171 +_Tp __P_lm1m = __p_mp1m; +# 172 +_Tp __p_lm = ((_Tp)0); +# 173 +for (unsigned __j = __m + (2); __j <= __l; ++__j) +# 174 +{ +# 175 +__p_lm = ((((((_Tp)(((2) * __j) - (1))) * __x) * __P_lm1m) - (((_Tp)((__j + __m) - (1))) * __p_lm2m)) / ((_Tp)(__j - __m))); +# 177 +__p_lm2m = __P_lm1m; +# 178 +__P_lm1m = __p_lm; +# 179 +} +# 181 +return __p_lm; +# 182 +} } } +# 183 +} +# 214 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 +template< class _Tp> _Tp +# 216 +__sph_legendre(unsigned __l, unsigned __m, _Tp __theta) +# 217 +{ +# 218 +if (__isnan(__theta)) { +# 219 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } +# 221 +const _Tp __x = std::cos(__theta); +# 223 +if (__m > __l) { +# 224 +return (_Tp)0; } else { +# 225 +if (__m == (0)) +# 226 +{ +# 227 +_Tp __P = __poly_legendre_p(__l, __x); +# 228 +_Tp __fact = std::sqrt(((_Tp)(((2) * __l) + (1))) / (((_Tp)4) * __numeric_constants< _Tp> ::__pi())); +# 230 +__P *= __fact; +# 231 +return __P; +# 232 +} else { +# 233 +if ((__x == ((_Tp)1)) || (__x == (-((_Tp)1)))) +# 234 +{ +# 236 +return (_Tp)0; +# 237 +} else +# 239 +{ +# 245 +const _Tp __sgn = ((__m % (2)) == (1)) ? -((_Tp)1) : ((_Tp)1); +# 246 +const _Tp __y_mp1m_factor = __x * std::sqrt((_Tp)(((2) * __m) + (3))); +# 248 +const _Tp __lncirc = std::log1p((-__x) * __x); +# 254 +const _Tp __lnpoch = std::lgamma((_Tp)(__m + ((_Tp)(0.5L)))) - std::lgamma((_Tp)__m); +# 260 +const _Tp __lnpre_val = ((-((_Tp)(0.25L))) * __numeric_constants< _Tp> ::__lnpi()) + (((_Tp)(0.5L)) * (__lnpoch + (__m * __lncirc))); +# 263 +const _Tp __sr = std::sqrt((((_Tp)2) + (((_Tp)1) / __m)) / (((_Tp)4) * __numeric_constants< _Tp> ::__pi())); +# 265 +_Tp __y_mm = (__sgn * __sr) * std::exp(__lnpre_val); +# 266 +_Tp __y_mp1m = __y_mp1m_factor * __y_mm; +# 268 +if (__l == __m) { +# 269 +return __y_mm; } else { +# 270 +if (__l == (__m + (1))) { +# 271 +return __y_mp1m; } else +# 273 +{ +# 274 +_Tp __y_lm = ((_Tp)0); +# 277 +for (unsigned __ll = __m + (2); __ll <= __l; ++__ll) +# 278 +{ +# 279 +const _Tp __rat1 = ((_Tp)(__ll - __m)) / ((_Tp)(__ll + __m)); +# 280 +const _Tp __rat2 = ((_Tp)((__ll - __m) - (1))) / ((_Tp)((__ll + __m) - (1))); +# 281 +const _Tp __fact1 = std::sqrt((__rat1 * ((_Tp)(((2) * __ll) + (1)))) * ((_Tp)(((2) * __ll) - (1)))); +# 283 +const _Tp __fact2 = std::sqrt(((__rat1 * __rat2) * ((_Tp)(((2) * __ll) + (1)))) / ((_Tp)(((2) * __ll) - (3)))); +# 285 +__y_lm = ((((__x * __y_mp1m) * __fact1) - ((((__ll + __m) - (1)) * __y_mm) * __fact2)) / ((_Tp)(__ll - __m))); +# 287 +__y_mm = __y_mp1m; +# 288 +__y_mp1m = __y_lm; +# 289 +} +# 291 +return __y_lm; +# 292 +} } +# 293 +} } } +# 294 +} +# 295 +} +# 302 +} +# 51 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 +namespace __detail { +# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 +template< class _Tp> void +# 85 +__bessel_ik(_Tp __nu, _Tp __x, _Tp & +# 86 +__Inu, _Tp &__Knu, _Tp &__Ipnu, _Tp &__Kpnu) +# 87 +{ +# 88 +if (__x == ((_Tp)0)) +# 89 +{ +# 90 +if (__nu == ((_Tp)0)) +# 91 +{ +# 92 +__Inu = ((_Tp)1); +# 93 +__Ipnu = ((_Tp)0); +# 94 +} else { +# 95 +if (__nu == ((_Tp)1)) +# 96 +{ +# 97 +__Inu = ((_Tp)0); +# 98 +__Ipnu = ((_Tp)(0.5L)); +# 99 +} else +# 101 +{ +# 102 +__Inu = ((_Tp)0); +# 103 +__Ipnu = ((_Tp)0); +# 104 +} } +# 105 +__Knu = std::template numeric_limits< _Tp> ::infinity(); +# 106 +__Kpnu = (-std::template numeric_limits< _Tp> ::infinity()); +# 107 +return; +# 108 +} +# 110 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 111 +const _Tp __fp_min = ((_Tp)10) * std::template numeric_limits< _Tp> ::epsilon(); +# 112 +const int __max_iter = 15000; +# 113 +const _Tp __x_min = ((_Tp)2); +# 115 +const int __nl = static_cast< int>(__nu + ((_Tp)(0.5L))); +# 117 +const _Tp __mu = __nu - __nl; +# 118 +const _Tp __mu2 = __mu * __mu; +# 119 +const _Tp __xi = ((_Tp)1) / __x; +# 120 +const _Tp __xi2 = ((_Tp)2) * __xi; +# 121 +_Tp __h = __nu * __xi; +# 122 +if (__h < __fp_min) { +# 123 +__h = __fp_min; } +# 124 +_Tp __b = __xi2 * __nu; +# 125 +_Tp __d = ((_Tp)0); +# 126 +_Tp __c = __h; +# 127 +int __i; +# 128 +for (__i = 1; __i <= __max_iter; ++__i) +# 129 +{ +# 130 +__b += __xi2; +# 131 +__d = (((_Tp)1) / (__b + __d)); +# 132 +__c = (__b + (((_Tp)1) / __c)); +# 133 +const _Tp __del = __c * __d; +# 134 +__h *= __del; +# 135 +if (std::abs(__del - ((_Tp)1)) < __eps) { +# 136 +break; } +# 137 +} +# 138 +if (__i > __max_iter) { +# 139 +std::__throw_runtime_error("Argument x too large in __bessel_ik; try asymptotic expansion."); } +# 142 +_Tp __Inul = __fp_min; +# 143 +_Tp __Ipnul = __h * __Inul; +# 144 +_Tp __Inul1 = __Inul; +# 145 +_Tp __Ipnu1 = __Ipnul; +# 146 +_Tp __fact = __nu * __xi; +# 147 +for (int __l = __nl; __l >= 1; --__l) +# 148 +{ +# 149 +const _Tp __Inutemp = (__fact * __Inul) + __Ipnul; +# 150 +__fact -= __xi; +# 151 +__Ipnul = ((__fact * __Inutemp) + __Inul); +# 152 +__Inul = __Inutemp; +# 153 +} +# 154 +_Tp __f = __Ipnul / __Inul; +# 155 +_Tp __Kmu, __Knu1; +# 156 +if (__x < __x_min) +# 157 +{ +# 158 +const _Tp __x2 = __x / ((_Tp)2); +# 159 +const _Tp __pimu = __numeric_constants< _Tp> ::__pi() * __mu; +# 160 +const _Tp __fact = (std::abs(__pimu) < __eps) ? (_Tp)1 : (__pimu / std::sin(__pimu)); +# 162 +_Tp __d = (-std::log(__x2)); +# 163 +_Tp __e = __mu * __d; +# 164 +const _Tp __fact2 = (std::abs(__e) < __eps) ? (_Tp)1 : (std::sinh(__e) / __e); +# 166 +_Tp __gam1, __gam2, __gampl, __gammi; +# 167 +__gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi); +# 168 +_Tp __ff = __fact * ((__gam1 * std::cosh(__e)) + ((__gam2 * __fact2) * __d)); +# 170 +_Tp __sum = __ff; +# 171 +__e = std::exp(__e); +# 172 +_Tp __p = __e / (((_Tp)2) * __gampl); +# 173 +_Tp __q = ((_Tp)1) / ((((_Tp)2) * __e) * __gammi); +# 174 +_Tp __c = ((_Tp)1); +# 175 +__d = (__x2 * __x2); +# 176 +_Tp __sum1 = __p; +# 177 +int __i; +# 178 +for (__i = 1; __i <= __max_iter; ++__i) +# 179 +{ +# 180 +__ff = ((((__i * __ff) + __p) + __q) / ((__i * __i) - __mu2)); +# 181 +__c *= (__d / __i); +# 182 +__p /= (__i - __mu); +# 183 +__q /= (__i + __mu); +# 184 +const _Tp __del = __c * __ff; +# 185 +__sum += __del; +# 186 +const _Tp __del1 = __c * (__p - (__i * __ff)); +# 187 +__sum1 += __del1; +# 188 +if (std::abs(__del) < (__eps * std::abs(__sum))) { +# 189 +break; } +# 190 +} +# 191 +if (__i > __max_iter) { +# 192 +std::__throw_runtime_error("Bessel k series failed to converge in __bessel_ik."); } +# 194 +__Kmu = __sum; +# 195 +__Knu1 = (__sum1 * __xi2); +# 196 +} else +# 198 +{ +# 199 +_Tp __b = ((_Tp)2) * (((_Tp)1) + __x); +# 200 +_Tp __d = ((_Tp)1) / __b; +# 201 +_Tp __delh = __d; +# 202 +_Tp __h = __delh; +# 203 +_Tp __q1 = ((_Tp)0); +# 204 +_Tp __q2 = ((_Tp)1); +# 205 +_Tp __a1 = ((_Tp)(0.25L)) - __mu2; +# 206 +_Tp __q = __c = __a1; +# 207 +_Tp __a = (-__a1); +# 208 +_Tp __s = ((_Tp)1) + (__q * __delh); +# 209 +int __i; +# 210 +for (__i = 2; __i <= __max_iter; ++__i) +# 211 +{ +# 212 +__a -= (2 * (__i - 1)); +# 213 +__c = (((-__a) * __c) / __i); +# 214 +const _Tp __qnew = (__q1 - (__b * __q2)) / __a; +# 215 +__q1 = __q2; +# 216 +__q2 = __qnew; +# 217 +__q += (__c * __qnew); +# 218 +__b += ((_Tp)2); +# 219 +__d = (((_Tp)1) / (__b + (__a * __d))); +# 220 +__delh = (((__b * __d) - ((_Tp)1)) * __delh); +# 221 +__h += __delh; +# 222 +const _Tp __dels = __q * __delh; +# 223 +__s += __dels; +# 224 +if (std::abs(__dels / __s) < __eps) { +# 225 +break; } +# 226 +} +# 227 +if (__i > __max_iter) { +# 228 +std::__throw_runtime_error("Steed\'s method failed in __bessel_ik."); } +# 230 +__h = (__a1 * __h); +# 231 +__Kmu = ((std::sqrt(__numeric_constants< _Tp> ::__pi() / (((_Tp)2) * __x)) * std::exp(-__x)) / __s); +# 233 +__Knu1 = ((__Kmu * (((__mu + __x) + ((_Tp)(0.5L))) - __h)) * __xi); +# 234 +} +# 236 +_Tp __Kpmu = ((__mu * __xi) * __Kmu) - __Knu1; +# 237 +_Tp __Inumu = __xi / ((__f * __Kmu) - __Kpmu); +# 238 +__Inu = ((__Inumu * __Inul1) / __Inul); +# 239 +__Ipnu = ((__Inumu * __Ipnu1) / __Inul); +# 240 +for (__i = 1; __i <= __nl; ++__i) +# 241 +{ +# 242 +const _Tp __Knutemp = (((__mu + __i) * __xi2) * __Knu1) + __Kmu; +# 243 +__Kmu = __Knu1; +# 244 +__Knu1 = __Knutemp; +# 245 +} +# 246 +__Knu = __Kmu; +# 247 +__Kpnu = (((__nu * __xi) * __Kmu) - __Knu1); +# 250 +} +# 267 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 +template< class _Tp> _Tp +# 269 +__cyl_bessel_i(_Tp __nu, _Tp __x) +# 270 +{ +# 271 +if ((__nu < ((_Tp)0)) || (__x < ((_Tp)0))) { +# 272 +std::__throw_domain_error("Bad argument in __cyl_bessel_i."); } else { +# 274 +if (__isnan(__nu) || __isnan(__x)) { +# 275 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 276 +if ((__x * __x) < (((_Tp)10) * (__nu + ((_Tp)1)))) { +# 277 +return __cyl_bessel_ij_series(__nu, __x, +((_Tp)1), 200); } else +# 279 +{ +# 280 +_Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; +# 281 +__bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); +# 282 +return __I_nu; +# 283 +} } } +# 284 +} +# 303 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 +template< class _Tp> _Tp +# 305 +__cyl_bessel_k(_Tp __nu, _Tp __x) +# 306 +{ +# 307 +if ((__nu < ((_Tp)0)) || (__x < ((_Tp)0))) { +# 308 +std::__throw_domain_error("Bad argument in __cyl_bessel_k."); } else { +# 310 +if (__isnan(__nu) || __isnan(__x)) { +# 311 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else +# 313 +{ +# 314 +_Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; +# 315 +__bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); +# 316 +return __K_nu; +# 317 +} } +# 318 +} +# 337 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 +template< class _Tp> void +# 339 +__sph_bessel_ik(unsigned __n, _Tp __x, _Tp & +# 340 +__i_n, _Tp &__k_n, _Tp &__ip_n, _Tp &__kp_n) +# 341 +{ +# 342 +const _Tp __nu = ((_Tp)__n) + ((_Tp)(0.5L)); +# 344 +_Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu; +# 345 +__bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); +# 347 +const _Tp __factor = __numeric_constants< _Tp> ::__sqrtpio2() / std::sqrt(__x); +# 350 +__i_n = (__factor * __I_nu); +# 351 +__k_n = (__factor * __K_nu); +# 352 +__ip_n = ((__factor * __Ip_nu) - (__i_n / (((_Tp)2) * __x))); +# 353 +__kp_n = ((__factor * __Kp_nu) - (__k_n / (((_Tp)2) * __x))); +# 356 +} +# 373 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 +template< class _Tp> void +# 375 +__airy(_Tp __x, _Tp &__Ai, _Tp &__Bi, _Tp &__Aip, _Tp &__Bip) +# 376 +{ +# 377 +const _Tp __absx = std::abs(__x); +# 378 +const _Tp __rootx = std::sqrt(__absx); +# 379 +const _Tp __z = ((((_Tp)2) * __absx) * __rootx) / ((_Tp)3); +# 380 +const _Tp _S_inf = std::template numeric_limits< _Tp> ::infinity(); +# 382 +if (__isnan(__x)) { +# 383 +__Bip = (__Aip = (__Bi = (__Ai = std::template numeric_limits< _Tp> ::quiet_NaN()))); } else { +# 384 +if (__z == _S_inf) +# 385 +{ +# 386 +__Aip = (__Ai = ((_Tp)0)); +# 387 +__Bip = (__Bi = _S_inf); +# 388 +} else { +# 389 +if (__z == (-_S_inf)) { +# 390 +__Bip = (__Aip = (__Bi = (__Ai = ((_Tp)0)))); } else { +# 391 +if (__x > ((_Tp)0)) +# 392 +{ +# 393 +_Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu; +# 395 +__bessel_ik(((_Tp)1) / ((_Tp)3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu); +# 396 +__Ai = ((__rootx * __K_nu) / (__numeric_constants< _Tp> ::__sqrt3() * __numeric_constants< _Tp> ::__pi())); +# 399 +__Bi = (__rootx * ((__K_nu / __numeric_constants< _Tp> ::__pi()) + ((((_Tp)2) * __I_nu) / __numeric_constants< _Tp> ::__sqrt3()))); +# 402 +__bessel_ik(((_Tp)2) / ((_Tp)3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu); +# 403 +__Aip = (((-__x) * __K_nu) / (__numeric_constants< _Tp> ::__sqrt3() * __numeric_constants< _Tp> ::__pi())); +# 406 +__Bip = (__x * ((__K_nu / __numeric_constants< _Tp> ::__pi()) + ((((_Tp)2) * __I_nu) / __numeric_constants< _Tp> ::__sqrt3()))); +# 409 +} else { +# 410 +if (__x < ((_Tp)0)) +# 411 +{ +# 412 +_Tp __J_nu, __Jp_nu, __N_nu, __Np_nu; +# 414 +__bessel_jn(((_Tp)1) / ((_Tp)3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu); +# 415 +__Ai = ((__rootx * (__J_nu - (__N_nu / __numeric_constants< _Tp> ::__sqrt3()))) / ((_Tp)2)); +# 417 +__Bi = (((-__rootx) * (__N_nu + (__J_nu / __numeric_constants< _Tp> ::__sqrt3()))) / ((_Tp)2)); +# 420 +__bessel_jn(((_Tp)2) / ((_Tp)3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu); +# 421 +__Aip = ((__absx * ((__N_nu / __numeric_constants< _Tp> ::__sqrt3()) + __J_nu)) / ((_Tp)2)); +# 423 +__Bip = ((__absx * ((__J_nu / __numeric_constants< _Tp> ::__sqrt3()) - __N_nu)) / ((_Tp)2)); +# 425 +} else +# 427 +{ +# 431 +__Ai = ((_Tp)(0.35502805388781723926L)); +# 432 +__Bi = (__Ai * __numeric_constants< _Tp> ::__sqrt3()); +# 437 +__Aip = (-((_Tp)(0.2588194037928067984L))); +# 438 +__Bip = ((-__Aip) * __numeric_constants< _Tp> ::__sqrt3()); +# 439 +} } } } } +# 442 +} +# 443 +} +# 449 +} +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 56 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 +namespace __detail { +# 72 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 +template< class _Tp> _Tp +# 74 +__poly_hermite_recursion(unsigned __n, _Tp __x) +# 75 +{ +# 77 +_Tp __H_0 = (1); +# 78 +if (__n == (0)) { +# 79 +return __H_0; } +# 82 +_Tp __H_1 = 2 * __x; +# 83 +if (__n == (1)) { +# 84 +return __H_1; } +# 87 +_Tp __H_n, __H_nm1, __H_nm2; +# 88 +unsigned __i; +# 89 +for (((__H_nm2 = __H_0), (__H_nm1 = __H_1)), (__i = (2)); __i <= __n; ++__i) +# 90 +{ +# 91 +__H_n = (2 * ((__x * __H_nm1) - ((__i - (1)) * __H_nm2))); +# 92 +__H_nm2 = __H_nm1; +# 93 +__H_nm1 = __H_n; +# 94 +} +# 96 +return __H_n; +# 97 +} +# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 +template< class _Tp> inline _Tp +# 116 +__poly_hermite(unsigned __n, _Tp __x) +# 117 +{ +# 118 +if (__isnan(__x)) { +# 119 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 121 +return __poly_hermite_recursion(__n, __x); } +# 122 +} +# 123 +} +# 129 +} +# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 +namespace __detail { +# 75 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 +template< class _Tpa, class _Tp> _Tp +# 77 +__poly_laguerre_large_n(unsigned __n, _Tpa __alpha1, _Tp __x) +# 78 +{ +# 79 +const _Tp __a = (-((_Tp)__n)); +# 80 +const _Tp __b = ((_Tp)__alpha1) + ((_Tp)1); +# 81 +const _Tp __eta = (((_Tp)2) * __b) - (((_Tp)4) * __a); +# 82 +const _Tp __cos2th = __x / __eta; +# 83 +const _Tp __sin2th = ((_Tp)1) - __cos2th; +# 84 +const _Tp __th = std::acos(std::sqrt(__cos2th)); +# 85 +const _Tp __pre_h = ((((__numeric_constants< _Tp> ::__pi_2() * __numeric_constants< _Tp> ::__pi_2()) * __eta) * __eta) * __cos2th) * __sin2th; +# 90 +const _Tp __lg_b = std::lgamma(((_Tp)__n) + __b); +# 91 +const _Tp __lnfact = std::lgamma((_Tp)(__n + (1))); +# 97 +_Tp __pre_term1 = (((_Tp)(0.5L)) * (((_Tp)1) - __b)) * std::log((((_Tp)(0.25L)) * __x) * __eta); +# 99 +_Tp __pre_term2 = ((_Tp)(0.25L)) * std::log(__pre_h); +# 100 +_Tp __lnpre = (((__lg_b - __lnfact) + (((_Tp)(0.5L)) * __x)) + __pre_term1) - __pre_term2; +# 102 +_Tp __ser_term1 = std::sin(__a * __numeric_constants< _Tp> ::__pi()); +# 103 +_Tp __ser_term2 = std::sin(((((_Tp)(0.25L)) * __eta) * ((((_Tp)2) * __th) - std::sin(((_Tp)2) * __th))) + __numeric_constants< _Tp> ::__pi_4()); +# 107 +_Tp __ser = __ser_term1 + __ser_term2; +# 109 +return std::exp(__lnpre) * __ser; +# 110 +} +# 129 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 +template< class _Tpa, class _Tp> _Tp +# 131 +__poly_laguerre_hyperg(unsigned __n, _Tpa __alpha1, _Tp __x) +# 132 +{ +# 133 +const _Tp __b = ((_Tp)__alpha1) + ((_Tp)1); +# 134 +const _Tp __mx = (-__x); +# 135 +const _Tp __tc_sgn = (__x < ((_Tp)0)) ? (_Tp)1 : (((__n % (2)) == (1)) ? -((_Tp)1) : ((_Tp)1)); +# 138 +_Tp __tc = ((_Tp)1); +# 139 +const _Tp __ax = std::abs(__x); +# 140 +for (unsigned __k = (1); __k <= __n; ++__k) { +# 141 +__tc *= (__ax / __k); } +# 143 +_Tp __term = __tc * __tc_sgn; +# 144 +_Tp __sum = __term; +# 145 +for (int __k = ((int)__n) - 1; __k >= 0; --__k) +# 146 +{ +# 147 +__term *= ((((__b + ((_Tp)__k)) / ((_Tp)(((int)__n) - __k))) * ((_Tp)(__k + 1))) / __mx); +# 149 +__sum += __term; +# 150 +} +# 152 +return __sum; +# 153 +} +# 185 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 +template< class _Tpa, class _Tp> _Tp +# 187 +__poly_laguerre_recursion(unsigned __n, _Tpa __alpha1, _Tp __x) +# 188 +{ +# 190 +_Tp __l_0 = ((_Tp)1); +# 191 +if (__n == (0)) { +# 192 +return __l_0; } +# 195 +_Tp __l_1 = ((-__x) + ((_Tp)1)) + ((_Tp)__alpha1); +# 196 +if (__n == (1)) { +# 197 +return __l_1; } +# 200 +_Tp __l_n2 = __l_0; +# 201 +_Tp __l_n1 = __l_1; +# 202 +_Tp __l_n = ((_Tp)0); +# 203 +for (unsigned __nn = (2); __nn <= __n; ++__nn) +# 204 +{ +# 205 +__l_n = (((((((_Tp)(((2) * __nn) - (1))) + ((_Tp)__alpha1)) - __x) * __l_n1) / ((_Tp)__nn)) - (((((_Tp)(__nn - (1))) + ((_Tp)__alpha1)) * __l_n2) / ((_Tp)__nn))); +# 208 +__l_n2 = __l_n1; +# 209 +__l_n1 = __l_n; +# 210 +} +# 212 +return __l_n; +# 213 +} +# 244 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 +template< class _Tpa, class _Tp> _Tp +# 246 +__poly_laguerre(unsigned __n, _Tpa __alpha1, _Tp __x) +# 247 +{ +# 248 +if (__x < ((_Tp)0)) { +# 249 +std::__throw_domain_error("Negative argument in __poly_laguerre."); } else { +# 252 +if (__isnan(__x)) { +# 253 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 254 +if (__n == (0)) { +# 255 +return (_Tp)1; } else { +# 256 +if (__n == (1)) { +# 257 +return (((_Tp)1) + ((_Tp)__alpha1)) - __x; } else { +# 258 +if (__x == ((_Tp)0)) +# 259 +{ +# 260 +_Tp __prod = ((_Tp)__alpha1) + ((_Tp)1); +# 261 +for (unsigned __k = (2); __k <= __n; ++__k) { +# 262 +__prod *= ((((_Tp)__alpha1) + ((_Tp)__k)) / ((_Tp)__k)); } +# 263 +return __prod; +# 264 +} else { +# 265 +if ((__n > (10000000)) && (((_Tp)__alpha1) > (-((_Tp)1))) && (__x < ((((_Tp)2) * (((_Tp)__alpha1) + ((_Tp)1))) + ((_Tp)((4) * __n))))) { +# 267 +return __poly_laguerre_large_n(__n, __alpha1, __x); } else { +# 268 +if ((((_Tp)__alpha1) >= ((_Tp)0)) || ((__x > ((_Tp)0)) && (((_Tp)__alpha1) < (-((_Tp)(__n + (1))))))) { +# 270 +return __poly_laguerre_recursion(__n, __alpha1, __x); } else { +# 272 +return __poly_laguerre_hyperg(__n, __alpha1, __x); } } } } } } } +# 273 +} +# 296 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 +template< class _Tp> inline _Tp +# 298 +__assoc_laguerre(unsigned __n, unsigned __m, _Tp __x) +# 299 +{ return __poly_laguerre< unsigned, _Tp> (__n, __m, __x); } +# 316 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 +template< class _Tp> inline _Tp +# 318 +__laguerre(unsigned __n, _Tp __x) +# 319 +{ return __poly_laguerre< unsigned, _Tp> (__n, 0, __x); } +# 320 +} +# 327 +} +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +namespace __detail { +# 78 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +template< class _Tp> _Tp +# 80 +__riemann_zeta_sum(_Tp __s) +# 81 +{ +# 83 +if (__s < ((_Tp)1)) { +# 84 +std::__throw_domain_error("Bad argument in zeta sum."); } +# 86 +const unsigned max_iter = (10000); +# 87 +_Tp __zeta = ((_Tp)0); +# 88 +for (unsigned __k = (1); __k < max_iter; ++__k) +# 89 +{ +# 90 +_Tp __term = std::pow(static_cast< _Tp>(__k), -__s); +# 91 +if (__term < std::template numeric_limits< _Tp> ::epsilon()) +# 92 +{ +# 93 +break; +# 94 +} +# 95 +__zeta += __term; +# 96 +} +# 98 +return __zeta; +# 99 +} +# 115 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +template< class _Tp> _Tp +# 117 +__riemann_zeta_alt(_Tp __s) +# 118 +{ +# 119 +_Tp __sgn = ((_Tp)1); +# 120 +_Tp __zeta = ((_Tp)0); +# 121 +for (unsigned __i = (1); __i < (10000000); ++__i) +# 122 +{ +# 123 +_Tp __term = __sgn / std::pow(__i, __s); +# 124 +if (std::abs(__term) < std::template numeric_limits< _Tp> ::epsilon()) { +# 125 +break; } +# 126 +__zeta += __term; +# 127 +__sgn *= ((_Tp)(-1)); +# 128 +} +# 129 +__zeta /= (((_Tp)1) - std::pow((_Tp)2, ((_Tp)1) - __s)); +# 131 +return __zeta; +# 132 +} +# 157 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +template< class _Tp> _Tp +# 159 +__riemann_zeta_glob(_Tp __s) +# 160 +{ +# 161 +_Tp __zeta = ((_Tp)0); +# 163 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 165 +const _Tp __max_bincoeff = (std::template numeric_limits< _Tp> ::max_exponent10 * std::log((_Tp)10)) - ((_Tp)1); +# 170 +if (__s < ((_Tp)0)) +# 171 +{ +# 173 +if (std::fmod(__s, (_Tp)2) == ((_Tp)0)) { +# 174 +return (_Tp)0; } else +# 177 +{ +# 178 +_Tp __zeta = __riemann_zeta_glob(((_Tp)1) - __s); +# 179 +__zeta *= (((std::pow(((_Tp)2) * __numeric_constants< _Tp> ::__pi(), __s) * std::sin(__numeric_constants< _Tp> ::__pi_2() * __s)) * std::exp(std::lgamma(((_Tp)1) - __s))) / __numeric_constants< _Tp> ::__pi()); +# 188 +return __zeta; +# 189 +} +# 190 +} +# 192 +_Tp __num = ((_Tp)(0.5L)); +# 193 +const unsigned __maxit = (10000); +# 194 +for (unsigned __i = (0); __i < __maxit; ++__i) +# 195 +{ +# 196 +bool __punt = false; +# 197 +_Tp __sgn = ((_Tp)1); +# 198 +_Tp __term = ((_Tp)0); +# 199 +for (unsigned __j = (0); __j <= __i; ++__j) +# 200 +{ +# 202 +_Tp __bincoeff = (std::lgamma((_Tp)((1) + __i)) - std::lgamma((_Tp)((1) + __j))) - std::lgamma((_Tp)(((1) + __i) - __j)); +# 210 +if (__bincoeff > __max_bincoeff) +# 211 +{ +# 213 +__punt = true; +# 214 +break; +# 215 +} +# 216 +__bincoeff = std::exp(__bincoeff); +# 217 +__term += ((__sgn * __bincoeff) * std::pow((_Tp)((1) + __j), -__s)); +# 218 +__sgn *= ((_Tp)(-1)); +# 219 +} +# 220 +if (__punt) { +# 221 +break; } +# 222 +__term *= __num; +# 223 +__zeta += __term; +# 224 +if (std::abs(__term / __zeta) < __eps) { +# 225 +break; } +# 226 +__num *= ((_Tp)(0.5L)); +# 227 +} +# 229 +__zeta /= (((_Tp)1) - std::pow((_Tp)2, ((_Tp)1) - __s)); +# 231 +return __zeta; +# 232 +} +# 252 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +template< class _Tp> _Tp +# 254 +__riemann_zeta_product(_Tp __s) +# 255 +{ +# 256 +static const _Tp __prime[] = {((_Tp)2), ((_Tp)3), ((_Tp)5), ((_Tp)7), ((_Tp)11), ((_Tp)13), ((_Tp)17), ((_Tp)19), ((_Tp)23), ((_Tp)29), ((_Tp)31), ((_Tp)37), ((_Tp)41), ((_Tp)43), ((_Tp)47), ((_Tp)53), ((_Tp)59), ((_Tp)61), ((_Tp)67), ((_Tp)71), ((_Tp)73), ((_Tp)79), ((_Tp)83), ((_Tp)89), ((_Tp)97), ((_Tp)101), ((_Tp)103), ((_Tp)107), ((_Tp)109)}; +# 262 +static const unsigned __num_primes = (sizeof(__prime) / sizeof(_Tp)); +# 264 +_Tp __zeta = ((_Tp)1); +# 265 +for (unsigned __i = (0); __i < __num_primes; ++__i) +# 266 +{ +# 267 +const _Tp __fact = ((_Tp)1) - std::pow(__prime[__i], -__s); +# 268 +__zeta *= __fact; +# 269 +if ((((_Tp)1) - __fact) < std::template numeric_limits< _Tp> ::epsilon()) { +# 270 +break; } +# 271 +} +# 273 +__zeta = (((_Tp)1) / __zeta); +# 275 +return __zeta; +# 276 +} +# 293 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +template< class _Tp> _Tp +# 295 +__riemann_zeta(_Tp __s) +# 296 +{ +# 297 +if (__isnan(__s)) { +# 298 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 299 +if (__s == ((_Tp)1)) { +# 300 +return std::template numeric_limits< _Tp> ::infinity(); } else { +# 301 +if (__s < (-((_Tp)19))) +# 302 +{ +# 303 +_Tp __zeta = __riemann_zeta_product(((_Tp)1) - __s); +# 304 +__zeta *= (((std::pow(((_Tp)2) * __numeric_constants< _Tp> ::__pi(), __s) * std::sin(__numeric_constants< _Tp> ::__pi_2() * __s)) * std::exp(std::lgamma(((_Tp)1) - __s))) / __numeric_constants< _Tp> ::__pi()); +# 312 +return __zeta; +# 313 +} else { +# 314 +if (__s < ((_Tp)20)) +# 315 +{ +# 317 +bool __glob = true; +# 318 +if (__glob) { +# 319 +return __riemann_zeta_glob(__s); } else +# 321 +{ +# 322 +if (__s > ((_Tp)1)) { +# 323 +return __riemann_zeta_sum(__s); } else +# 325 +{ +# 326 +_Tp __zeta = ((std::pow(((_Tp)2) * __numeric_constants< _Tp> ::__pi(), __s) * std::sin(__numeric_constants< _Tp> ::__pi_2() * __s)) * std::tgamma(((_Tp)1) - __s)) * __riemann_zeta_sum(((_Tp)1) - __s); +# 335 +return __zeta; +# 336 +} +# 337 +} +# 338 +} else { +# 340 +return __riemann_zeta_product(__s); } } } } +# 341 +} +# 365 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +template< class _Tp> _Tp +# 367 +__hurwitz_zeta_glob(_Tp __a, _Tp __s) +# 368 +{ +# 369 +_Tp __zeta = ((_Tp)0); +# 371 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 373 +const _Tp __max_bincoeff = (std::template numeric_limits< _Tp> ::max_exponent10 * std::log((_Tp)10)) - ((_Tp)1); +# 376 +const unsigned __maxit = (10000); +# 377 +for (unsigned __i = (0); __i < __maxit; ++__i) +# 378 +{ +# 379 +bool __punt = false; +# 380 +_Tp __sgn = ((_Tp)1); +# 381 +_Tp __term = ((_Tp)0); +# 382 +for (unsigned __j = (0); __j <= __i; ++__j) +# 383 +{ +# 385 +_Tp __bincoeff = (std::lgamma((_Tp)((1) + __i)) - std::lgamma((_Tp)((1) + __j))) - std::lgamma((_Tp)(((1) + __i) - __j)); +# 393 +if (__bincoeff > __max_bincoeff) +# 394 +{ +# 396 +__punt = true; +# 397 +break; +# 398 +} +# 399 +__bincoeff = std::exp(__bincoeff); +# 400 +__term += ((__sgn * __bincoeff) * std::pow((_Tp)(__a + __j), -__s)); +# 401 +__sgn *= ((_Tp)(-1)); +# 402 +} +# 403 +if (__punt) { +# 404 +break; } +# 405 +__term /= ((_Tp)(__i + (1))); +# 406 +if (std::abs(__term / __zeta) < __eps) { +# 407 +break; } +# 408 +__zeta += __term; +# 409 +} +# 411 +__zeta /= (__s - ((_Tp)1)); +# 413 +return __zeta; +# 414 +} +# 430 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +template< class _Tp> inline _Tp +# 432 +__hurwitz_zeta(_Tp __a, _Tp __s) +# 433 +{ return __hurwitz_zeta_glob(__a, __s); } +# 434 +} +# 441 +} +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 204 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float assoc_laguerref(unsigned __n, unsigned __m, float __x) +# 205 +{ return __detail::__assoc_laguerre< float> (__n, __m, __x); } +# 214 +inline long double assoc_laguerrel(unsigned __n, unsigned __m, long double __x) +# 215 +{ return __detail::__assoc_laguerre< long double> (__n, __m, __x); } +# 248 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 250 +assoc_laguerre(unsigned __n, unsigned __m, _Tp __x) +# 251 +{ +# 252 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 253 +return __detail::__assoc_laguerre< typename __gnu_cxx::__promote< _Tp> ::__type> (__n, __m, __x); +# 254 +} +# 265 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float assoc_legendref(unsigned __l, unsigned __m, float __x) +# 266 +{ return __detail::__assoc_legendre_p< float> (__l, __m, __x); } +# 274 +inline long double assoc_legendrel(unsigned __l, unsigned __m, long double __x) +# 275 +{ return __detail::__assoc_legendre_p< long double> (__l, __m, __x); } +# 294 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 296 +assoc_legendre(unsigned __l, unsigned __m, _Tp __x) +# 297 +{ +# 298 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 299 +return __detail::__assoc_legendre_p< typename __gnu_cxx::__promote< _Tp> ::__type> (__l, __m, __x); +# 300 +} +# 310 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float betaf(float __a, float __b) +# 311 +{ return __detail::__beta< float> (__a, __b); } +# 320 +inline long double betal(long double __a, long double __b) +# 321 +{ return __detail::__beta< long double> (__a, __b); } +# 339 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tpa, class _Tpb> inline typename __gnu_cxx::__promote_2< _Tpa, _Tpb> ::__type +# 341 +beta(_Tpa __a, _Tpb __b) +# 342 +{ +# 343 +typedef typename __gnu_cxx::__promote_2< _Tpa, _Tpb> ::__type __type; +# 344 +return __detail::__beta< typename __gnu_cxx::__promote_2< _Tpa, _Tpb> ::__type> (__a, __b); +# 345 +} +# 356 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float comp_ellint_1f(float __k) +# 357 +{ return __detail::__comp_ellint_1< float> (__k); } +# 366 +inline long double comp_ellint_1l(long double __k) +# 367 +{ return __detail::__comp_ellint_1< long double> (__k); } +# 387 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 389 +comp_ellint_1(_Tp __k) +# 390 +{ +# 391 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 392 +return __detail::__comp_ellint_1< typename __gnu_cxx::__promote< _Tp> ::__type> (__k); +# 393 +} +# 404 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float comp_ellint_2f(float __k) +# 405 +{ return __detail::__comp_ellint_2< float> (__k); } +# 414 +inline long double comp_ellint_2l(long double __k) +# 415 +{ return __detail::__comp_ellint_2< long double> (__k); } +# 434 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 436 +comp_ellint_2(_Tp __k) +# 437 +{ +# 438 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 439 +return __detail::__comp_ellint_2< typename __gnu_cxx::__promote< _Tp> ::__type> (__k); +# 440 +} +# 451 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float comp_ellint_3f(float __k, float __nu) +# 452 +{ return __detail::__comp_ellint_3< float> (__k, __nu); } +# 461 +inline long double comp_ellint_3l(long double __k, long double __nu) +# 462 +{ return __detail::__comp_ellint_3< long double> (__k, __nu); } +# 485 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp, class _Tpn> inline typename __gnu_cxx::__promote_2< _Tp, _Tpn> ::__type +# 487 +comp_ellint_3(_Tp __k, _Tpn __nu) +# 488 +{ +# 489 +typedef typename __gnu_cxx::__promote_2< _Tp, _Tpn> ::__type __type; +# 490 +return __detail::__comp_ellint_3< typename __gnu_cxx::__promote_2< _Tp, _Tpn> ::__type> (__k, __nu); +# 491 +} +# 502 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float cyl_bessel_if(float __nu, float __x) +# 503 +{ return __detail::__cyl_bessel_i< float> (__nu, __x); } +# 512 +inline long double cyl_bessel_il(long double __nu, long double __x) +# 513 +{ return __detail::__cyl_bessel_i< long double> (__nu, __x); } +# 531 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tpnu, class _Tp> inline typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type +# 533 +cyl_bessel_i(_Tpnu __nu, _Tp __x) +# 534 +{ +# 535 +typedef typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type __type; +# 536 +return __detail::__cyl_bessel_i< typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type> (__nu, __x); +# 537 +} +# 548 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float cyl_bessel_jf(float __nu, float __x) +# 549 +{ return __detail::__cyl_bessel_j< float> (__nu, __x); } +# 558 +inline long double cyl_bessel_jl(long double __nu, long double __x) +# 559 +{ return __detail::__cyl_bessel_j< long double> (__nu, __x); } +# 577 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tpnu, class _Tp> inline typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type +# 579 +cyl_bessel_j(_Tpnu __nu, _Tp __x) +# 580 +{ +# 581 +typedef typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type __type; +# 582 +return __detail::__cyl_bessel_j< typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type> (__nu, __x); +# 583 +} +# 594 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float cyl_bessel_kf(float __nu, float __x) +# 595 +{ return __detail::__cyl_bessel_k< float> (__nu, __x); } +# 604 +inline long double cyl_bessel_kl(long double __nu, long double __x) +# 605 +{ return __detail::__cyl_bessel_k< long double> (__nu, __x); } +# 629 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tpnu, class _Tp> inline typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type +# 631 +cyl_bessel_k(_Tpnu __nu, _Tp __x) +# 632 +{ +# 633 +typedef typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type __type; +# 634 +return __detail::__cyl_bessel_k< typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type> (__nu, __x); +# 635 +} +# 646 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float cyl_neumannf(float __nu, float __x) +# 647 +{ return __detail::__cyl_neumann_n< float> (__nu, __x); } +# 656 +inline long double cyl_neumannl(long double __nu, long double __x) +# 657 +{ return __detail::__cyl_neumann_n< long double> (__nu, __x); } +# 677 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tpnu, class _Tp> inline typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type +# 679 +cyl_neumann(_Tpnu __nu, _Tp __x) +# 680 +{ +# 681 +typedef typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type __type; +# 682 +return __detail::__cyl_neumann_n< typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type> (__nu, __x); +# 683 +} +# 694 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float ellint_1f(float __k, float __phi) +# 695 +{ return __detail::__ellint_1< float> (__k, __phi); } +# 704 +inline long double ellint_1l(long double __k, long double __phi) +# 705 +{ return __detail::__ellint_1< long double> (__k, __phi); } +# 725 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp, class _Tpp> inline typename __gnu_cxx::__promote_2< _Tp, _Tpp> ::__type +# 727 +ellint_1(_Tp __k, _Tpp __phi) +# 728 +{ +# 729 +typedef typename __gnu_cxx::__promote_2< _Tp, _Tpp> ::__type __type; +# 730 +return __detail::__ellint_1< typename __gnu_cxx::__promote_2< _Tp, _Tpp> ::__type> (__k, __phi); +# 731 +} +# 742 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float ellint_2f(float __k, float __phi) +# 743 +{ return __detail::__ellint_2< float> (__k, __phi); } +# 752 +inline long double ellint_2l(long double __k, long double __phi) +# 753 +{ return __detail::__ellint_2< long double> (__k, __phi); } +# 773 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp, class _Tpp> inline typename __gnu_cxx::__promote_2< _Tp, _Tpp> ::__type +# 775 +ellint_2(_Tp __k, _Tpp __phi) +# 776 +{ +# 777 +typedef typename __gnu_cxx::__promote_2< _Tp, _Tpp> ::__type __type; +# 778 +return __detail::__ellint_2< typename __gnu_cxx::__promote_2< _Tp, _Tpp> ::__type> (__k, __phi); +# 779 +} +# 790 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float ellint_3f(float __k, float __nu, float __phi) +# 791 +{ return __detail::__ellint_3< float> (__k, __nu, __phi); } +# 800 +inline long double ellint_3l(long double __k, long double __nu, long double __phi) +# 801 +{ return __detail::__ellint_3< long double> (__k, __nu, __phi); } +# 826 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp, class _Tpn, class _Tpp> inline typename __gnu_cxx::__promote_3< _Tp, _Tpn, _Tpp> ::__type +# 828 +ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi) +# 829 +{ +# 830 +typedef typename __gnu_cxx::__promote_3< _Tp, _Tpn, _Tpp> ::__type __type; +# 831 +return __detail::__ellint_3< typename __gnu_cxx::__promote_3< _Tp, _Tpn, _Tpp> ::__type> (__k, __nu, __phi); +# 832 +} +# 842 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float expintf(float __x) +# 843 +{ return __detail::__expint< float> (__x); } +# 852 +inline long double expintl(long double __x) +# 853 +{ return __detail::__expint< long double> (__x); } +# 866 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 868 +expint(_Tp __x) +# 869 +{ +# 870 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 871 +return __detail::__expint< typename __gnu_cxx::__promote< _Tp> ::__type> (__x); +# 872 +} +# 883 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float hermitef(unsigned __n, float __x) +# 884 +{ return __detail::__poly_hermite< float> (__n, __x); } +# 893 +inline long double hermitel(unsigned __n, long double __x) +# 894 +{ return __detail::__poly_hermite< long double> (__n, __x); } +# 914 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 916 +hermite(unsigned __n, _Tp __x) +# 917 +{ +# 918 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 919 +return __detail::__poly_hermite< typename __gnu_cxx::__promote< _Tp> ::__type> (__n, __x); +# 920 +} +# 931 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float laguerref(unsigned __n, float __x) +# 932 +{ return __detail::__laguerre< float> (__n, __x); } +# 941 +inline long double laguerrel(unsigned __n, long double __x) +# 942 +{ return __detail::__laguerre< long double> (__n, __x); } +# 958 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 960 +laguerre(unsigned __n, _Tp __x) +# 961 +{ +# 962 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 963 +return __detail::__laguerre< typename __gnu_cxx::__promote< _Tp> ::__type> (__n, __x); +# 964 +} +# 975 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float legendref(unsigned __l, float __x) +# 976 +{ return __detail::__poly_legendre_p< float> (__l, __x); } +# 985 +inline long double legendrel(unsigned __l, long double __x) +# 986 +{ return __detail::__poly_legendre_p< long double> (__l, __x); } +# 1003 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 1005 +legendre(unsigned __l, _Tp __x) +# 1006 +{ +# 1007 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 1008 +return __detail::__poly_legendre_p< typename __gnu_cxx::__promote< _Tp> ::__type> (__l, __x); +# 1009 +} +# 1020 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float riemann_zetaf(float __s) +# 1021 +{ return __detail::__riemann_zeta< float> (__s); } +# 1030 +inline long double riemann_zetal(long double __s) +# 1031 +{ return __detail::__riemann_zeta< long double> (__s); } +# 1054 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 1056 +riemann_zeta(_Tp __s) +# 1057 +{ +# 1058 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 1059 +return __detail::__riemann_zeta< typename __gnu_cxx::__promote< _Tp> ::__type> (__s); +# 1060 +} +# 1071 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float sph_besself(unsigned __n, float __x) +# 1072 +{ return __detail::__sph_bessel< float> (__n, __x); } +# 1081 +inline long double sph_bessell(unsigned __n, long double __x) +# 1082 +{ return __detail::__sph_bessel< long double> (__n, __x); } +# 1098 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 1100 +sph_bessel(unsigned __n, _Tp __x) +# 1101 +{ +# 1102 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 1103 +return __detail::__sph_bessel< typename __gnu_cxx::__promote< _Tp> ::__type> (__n, __x); +# 1104 +} +# 1115 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float sph_legendref(unsigned __l, unsigned __m, float __theta) +# 1116 +{ return __detail::__sph_legendre< float> (__l, __m, __theta); } +# 1126 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline long double sph_legendrel(unsigned __l, unsigned __m, long double __theta) +# 1127 +{ return __detail::__sph_legendre< long double> (__l, __m, __theta); } +# 1145 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 1147 +sph_legendre(unsigned __l, unsigned __m, _Tp __theta) +# 1148 +{ +# 1149 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 1150 +return __detail::__sph_legendre< typename __gnu_cxx::__promote< _Tp> ::__type> (__l, __m, __theta); +# 1151 +} +# 1162 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float sph_neumannf(unsigned __n, float __x) +# 1163 +{ return __detail::__sph_neumann< float> (__n, __x); } +# 1172 +inline long double sph_neumannl(unsigned __n, long double __x) +# 1173 +{ return __detail::__sph_neumann< long double> (__n, __x); } +# 1189 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 1191 +sph_neumann(unsigned __n, _Tp __x) +# 1192 +{ +# 1193 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 1194 +return __detail::__sph_neumann< typename __gnu_cxx::__promote< _Tp> ::__type> (__n, __x); +# 1195 +} +# 1200 +} +# 1203 +namespace __gnu_cxx __attribute((__visibility__("default"))) { +# 1217 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float airy_aif(float __x) +# 1218 +{ +# 1219 +float __Ai, __Bi, __Aip, __Bip; +# 1220 +std::__detail::__airy< float> (__x, __Ai, __Bi, __Aip, __Bip); +# 1221 +return __Ai; +# 1222 +} +# 1228 +inline long double airy_ail(long double __x) +# 1229 +{ +# 1230 +long double __Ai, __Bi, __Aip, __Bip; +# 1231 +std::__detail::__airy< long double> (__x, __Ai, __Bi, __Aip, __Bip); +# 1232 +return __Ai; +# 1233 +} +# 1238 +template< class _Tp> inline typename __promote< _Tp> ::__type +# 1240 +airy_ai(_Tp __x) +# 1241 +{ +# 1242 +typedef typename __promote< _Tp> ::__type __type; +# 1243 +__type __Ai, __Bi, __Aip, __Bip; +# 1244 +std::__detail::__airy< typename __promote< _Tp> ::__type> (__x, __Ai, __Bi, __Aip, __Bip); +# 1245 +return __Ai; +# 1246 +} +# 1252 +inline float airy_bif(float __x) +# 1253 +{ +# 1254 +float __Ai, __Bi, __Aip, __Bip; +# 1255 +std::__detail::__airy< float> (__x, __Ai, __Bi, __Aip, __Bip); +# 1256 +return __Bi; +# 1257 +} +# 1263 +inline long double airy_bil(long double __x) +# 1264 +{ +# 1265 +long double __Ai, __Bi, __Aip, __Bip; +# 1266 +std::__detail::__airy< long double> (__x, __Ai, __Bi, __Aip, __Bip); +# 1267 +return __Bi; +# 1268 +} +# 1273 +template< class _Tp> inline typename __promote< _Tp> ::__type +# 1275 +airy_bi(_Tp __x) +# 1276 +{ +# 1277 +typedef typename __promote< _Tp> ::__type __type; +# 1278 +__type __Ai, __Bi, __Aip, __Bip; +# 1279 +std::__detail::__airy< typename __promote< _Tp> ::__type> (__x, __Ai, __Bi, __Aip, __Bip); +# 1280 +return __Bi; +# 1281 +} +# 1293 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float conf_hypergf(float __a, float __c, float __x) +# 1294 +{ return std::__detail::__conf_hyperg< float> (__a, __c, __x); } +# 1304 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline long double conf_hypergl(long double __a, long double __c, long double __x) +# 1305 +{ return std::__detail::__conf_hyperg< long double> (__a, __c, __x); } +# 1323 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tpa, class _Tpc, class _Tp> inline typename __promote_3< _Tpa, _Tpc, _Tp> ::__type +# 1325 +conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x) +# 1326 +{ +# 1327 +typedef typename __promote_3< _Tpa, _Tpc, _Tp> ::__type __type; +# 1328 +return std::__detail::__conf_hyperg< typename __promote_3< _Tpa, _Tpc, _Tp> ::__type> (__a, __c, __x); +# 1329 +} +# 1341 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float hypergf(float __a, float __b, float __c, float __x) +# 1342 +{ return std::__detail::__hyperg< float> (__a, __b, __c, __x); } +# 1352 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline long double hypergl(long double __a, long double __b, long double __c, long double __x) +# 1353 +{ return std::__detail::__hyperg< long double> (__a, __b, __c, __x); } +# 1372 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tpa, class _Tpb, class _Tpc, class _Tp> inline typename __promote_4< _Tpa, _Tpb, _Tpc, _Tp> ::__type +# 1374 +hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x) +# 1375 +{ +# 1377 +typedef typename __promote_4< _Tpa, _Tpb, _Tpc, _Tp> ::__type __type; +# 1378 +return std::__detail::__hyperg< typename __promote_4< _Tpa, _Tpb, _Tpc, _Tp> ::__type> (__a, __b, __c, __x); +# 1379 +} +# 1383 +} +# 3909 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +} +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/math.h" 3 +using std::abs; +# 39 +using std::acos; +# 40 +using std::asin; +# 41 +using std::atan; +# 42 +using std::atan2; +# 43 +using std::cos; +# 44 +using std::sin; +# 45 +using std::tan; +# 46 +using std::cosh; +# 47 +using std::sinh; +# 48 +using std::tanh; +# 49 +using std::exp; +# 50 +using std::frexp; +# 51 +using std::ldexp; +# 52 +using std::log; +# 53 +using std::log10; +# 54 +using std::modf; +# 55 +using std::pow; +# 56 +using std::sqrt; +# 57 +using std::ceil; +# 58 +using std::fabs; +# 59 +using std::floor; +# 60 +using std::fmod; +# 63 +using std::fpclassify; +# 64 +using std::isfinite; +# 65 +using std::isinf; +# 66 +using std::isnan; +# 67 +using std::isnormal; +# 68 +using std::signbit; +# 69 +using std::isgreater; +# 70 +using std::isgreaterequal; +# 71 +using std::isless; +# 72 +using std::islessequal; +# 73 +using std::islessgreater; +# 74 +using std::isunordered; +# 78 +using std::acosh; +# 79 +using std::asinh; +# 80 +using std::atanh; +# 81 +using std::cbrt; +# 82 +using std::copysign; +# 83 +using std::erf; +# 84 +using std::erfc; +# 85 +using std::exp2; +# 86 +using std::expm1; +# 87 +using std::fdim; +# 88 +using std::fma; +# 89 +using std::fmax; +# 90 +using std::fmin; +# 91 +using std::hypot; +# 92 +using std::ilogb; +# 93 +using std::lgamma; +# 94 +using std::llrint; +# 95 +using std::llround; +# 96 +using std::log1p; +# 97 +using std::log2; +# 98 +using std::logb; +# 99 +using std::lrint; +# 100 +using std::lround; +# 101 +using std::nearbyint; +# 102 +using std::nextafter; +# 103 +using std::nexttoward; +# 104 +using std::remainder; +# 105 +using std::remquo; +# 106 +using std::rint; +# 107 +using std::round; +# 108 +using std::scalbln; +# 109 +using std::scalbn; +# 110 +using std::tgamma; +# 111 +using std::trunc; +# 4653 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +# 4654 +constexpr bool signbit(float x); +# 4655 +constexpr bool signbit(double x); +# 4656 +constexpr bool signbit(long double x); +# 4657 +constexpr bool isfinite(float x); +# 4658 +constexpr bool isfinite(double x); +# 4659 +constexpr bool isfinite(long double x); +# 4660 +constexpr bool isnan(float x); +# 4665 +constexpr bool isnan(double x); +# 4667 +constexpr bool isnan(long double x); +# 4668 +constexpr bool isinf(float x); +# 4673 +constexpr bool isinf(double x); +# 4675 +constexpr bool isinf(long double x); +# 4676 +} +# 4832 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +# 4834 +template< class T> extern T __pow_helper(T, int); +# 4835 +template< class T> extern T __cmath_power(T, unsigned); +# 4836 +} +# 4838 +using std::abs; +# 4839 +using std::fabs; +# 4840 +using std::ceil; +# 4841 +using std::floor; +# 4842 +using std::sqrt; +# 4844 +using std::pow; +# 4846 +using std::log; +# 4847 +using std::log10; +# 4848 +using std::fmod; +# 4849 +using std::modf; +# 4850 +using std::exp; +# 4851 +using std::frexp; +# 4852 +using std::ldexp; +# 4853 +using std::asin; +# 4854 +using std::sin; +# 4855 +using std::sinh; +# 4856 +using std::acos; +# 4857 +using std::cos; +# 4858 +using std::cosh; +# 4859 +using std::atan; +# 4860 +using std::atan2; +# 4861 +using std::tan; +# 4862 +using std::tanh; +# 5243 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +# 5252 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern inline long long abs(long long); +# 5272 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern inline long abs(long a); +# 5273 +extern constexpr float abs(float); +# 5274 +extern constexpr double abs(double); +# 5275 +extern constexpr float fabs(float); +# 5276 +extern constexpr float ceil(float); +# 5277 +extern constexpr float floor(float); +# 5278 +extern constexpr float sqrt(float); +# 5279 +extern constexpr float pow(float, float); +# 5284 +template< class _Tp, class _Up> extern constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type pow(_Tp, _Up); +# 5294 +extern constexpr float log(float); +# 5295 +extern constexpr float log10(float); +# 5296 +extern constexpr float fmod(float, float); +# 5297 +extern inline float modf(float, float *); +# 5298 +extern constexpr float exp(float); +# 5299 +extern inline float frexp(float, int *); +# 5300 +extern constexpr float ldexp(float, int); +# 5301 +extern constexpr float asin(float); +# 5302 +extern constexpr float sin(float); +# 5303 +extern constexpr float sinh(float); +# 5304 +extern constexpr float acos(float); +# 5305 +extern constexpr float cos(float); +# 5306 +extern constexpr float cosh(float); +# 5307 +extern constexpr float atan(float); +# 5308 +extern constexpr float atan2(float, float); +# 5309 +extern constexpr float tan(float); +# 5310 +extern constexpr float tanh(float); +# 5399 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +} +# 5505 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +# 5506 +constexpr float logb(float a); +# 5507 +constexpr int ilogb(float a); +# 5508 +constexpr float scalbn(float a, int b); +# 5509 +constexpr float scalbln(float a, long b); +# 5510 +constexpr float exp2(float a); +# 5511 +constexpr float expm1(float a); +# 5512 +constexpr float log2(float a); +# 5513 +constexpr float log1p(float a); +# 5514 +constexpr float acosh(float a); +# 5515 +constexpr float asinh(float a); +# 5516 +constexpr float atanh(float a); +# 5517 +constexpr float hypot(float a, float b); +# 5518 +constexpr float cbrt(float a); +# 5519 +constexpr float erf(float a); +# 5520 +constexpr float erfc(float a); +# 5521 +constexpr float lgamma(float a); +# 5522 +constexpr float tgamma(float a); +# 5523 +constexpr float copysign(float a, float b); +# 5524 +constexpr float nextafter(float a, float b); +# 5525 +constexpr float remainder(float a, float b); +# 5526 +inline float remquo(float a, float b, int * quo); +# 5527 +constexpr float round(float a); +# 5528 +constexpr long lround(float a); +# 5529 +constexpr long long llround(float a); +# 5530 +constexpr float trunc(float a); +# 5531 +constexpr float rint(float a); +# 5532 +constexpr long lrint(float a); +# 5533 +constexpr long long llrint(float a); +# 5534 +constexpr float nearbyint(float a); +# 5535 +constexpr float fdim(float a, float b); +# 5536 +constexpr float fma(float a, float b, float c); +# 5537 +constexpr float fmax(float a, float b); +# 5538 +constexpr float fmin(float a, float b); +# 5539 +} +# 5644 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline float exp10(const float a); +# 5646 +static inline float rsqrt(const float a); +# 5648 +static inline float rcbrt(const float a); +# 5650 +static inline float sinpi(const float a); +# 5652 +static inline float cospi(const float a); +# 5654 +static inline void sincospi(const float a, float *const sptr, float *const cptr); +# 5656 +static inline void sincos(const float a, float *const sptr, float *const cptr); +# 5658 +static inline float j0(const float a); +# 5660 +static inline float j1(const float a); +# 5662 +static inline float jn(const int n, const float a); +# 5664 +static inline float y0(const float a); +# 5666 +static inline float y1(const float a); +# 5668 +static inline float yn(const int n, const float a); +# 5670 +__attribute__((unused)) static inline float cyl_bessel_i0(const float a); +# 5672 +__attribute__((unused)) static inline float cyl_bessel_i1(const float a); +# 5674 +static inline float erfinv(const float a); +# 5676 +static inline float erfcinv(const float a); +# 5678 +static inline float normcdfinv(const float a); +# 5680 +static inline float normcdf(const float a); +# 5682 +static inline float erfcx(const float a); +# 5684 +static inline double copysign(const double a, const float b); +# 5686 +static inline double copysign(const float a, const double b); +# 5694 +static inline unsigned min(const unsigned a, const unsigned b); +# 5702 +static inline unsigned min(const int a, const unsigned b); +# 5710 +static inline unsigned min(const unsigned a, const int b); +# 5718 +static inline long min(const long a, const long b); +# 5726 +static inline unsigned long min(const unsigned long a, const unsigned long b); +# 5734 +static inline unsigned long min(const long a, const unsigned long b); +# 5742 +static inline unsigned long min(const unsigned long a, const long b); +# 5750 +static inline long long min(const long long a, const long long b); +# 5758 +static inline unsigned long long min(const unsigned long long a, const unsigned long long b); +# 5766 +static inline unsigned long long min(const long long a, const unsigned long long b); +# 5774 +static inline unsigned long long min(const unsigned long long a, const long long b); +# 5785 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline float min(const float a, const float b); +# 5796 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline double min(const double a, const double b); +# 5806 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline double min(const float a, const double b); +# 5816 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline double min(const double a, const float b); +# 5824 +static inline unsigned max(const unsigned a, const unsigned b); +# 5832 +static inline unsigned max(const int a, const unsigned b); +# 5840 +static inline unsigned max(const unsigned a, const int b); +# 5848 +static inline long max(const long a, const long b); +# 5856 +static inline unsigned long max(const unsigned long a, const unsigned long b); +# 5864 +static inline unsigned long max(const long a, const unsigned long b); +# 5872 +static inline unsigned long max(const unsigned long a, const long b); +# 5880 +static inline long long max(const long long a, const long long b); +# 5888 +static inline unsigned long long max(const unsigned long long a, const unsigned long long b); +# 5896 +static inline unsigned long long max(const long long a, const unsigned long long b); +# 5904 +static inline unsigned long long max(const unsigned long long a, const long long b); +# 5915 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline float max(const float a, const float b); +# 5926 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline double max(const double a, const double b); +# 5936 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline double max(const float a, const double b); +# 5946 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline double max(const double a, const float b); +# 5958 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern "C" { +# 5959 +__attribute__((unused)) inline void *__nv_aligned_device_malloc(size_t size, size_t align) +# 5960 +{int volatile ___ = 1;(void)size;(void)align; +# 5963 +::exit(___);} +#if 0 +# 5960 +{ +# 5961 +__attribute__((unused)) void *__nv_aligned_device_malloc_impl(size_t, size_t); +# 5962 +return __nv_aligned_device_malloc_impl(size, align); +# 5963 +} +#endif +# 5964 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +} +# 758 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +static inline float exp10(const float a) +# 759 +{ +# 760 +return exp10f(a); +# 761 +} +# 763 +static inline float rsqrt(const float a) +# 764 +{ +# 765 +return rsqrtf(a); +# 766 +} +# 768 +static inline float rcbrt(const float a) +# 769 +{ +# 770 +return rcbrtf(a); +# 771 +} +# 773 +static inline float sinpi(const float a) +# 774 +{ +# 775 +return sinpif(a); +# 776 +} +# 778 +static inline float cospi(const float a) +# 779 +{ +# 780 +return cospif(a); +# 781 +} +# 783 +static inline void sincospi(const float a, float *const sptr, float *const cptr) +# 784 +{ +# 785 +sincospif(a, sptr, cptr); +# 786 +} +# 788 +static inline void sincos(const float a, float *const sptr, float *const cptr) +# 789 +{ +# 790 +sincosf(a, sptr, cptr); +# 791 +} +# 793 +static inline float j0(const float a) +# 794 +{ +# 795 +return j0f(a); +# 796 +} +# 798 +static inline float j1(const float a) +# 799 +{ +# 800 +return j1f(a); +# 801 +} +# 803 +static inline float jn(const int n, const float a) +# 804 +{ +# 805 +return jnf(n, a); +# 806 +} +# 808 +static inline float y0(const float a) +# 809 +{ +# 810 +return y0f(a); +# 811 +} +# 813 +static inline float y1(const float a) +# 814 +{ +# 815 +return y1f(a); +# 816 +} +# 818 +static inline float yn(const int n, const float a) +# 819 +{ +# 820 +return ynf(n, a); +# 821 +} +# 823 +__attribute__((unused)) static inline float cyl_bessel_i0(const float a) +# 824 +{int volatile ___ = 1;(void)a; +# 826 +::exit(___);} +#if 0 +# 824 +{ +# 825 +return cyl_bessel_i0f(a); +# 826 +} +#endif +# 828 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +__attribute__((unused)) static inline float cyl_bessel_i1(const float a) +# 829 +{int volatile ___ = 1;(void)a; +# 831 +::exit(___);} +#if 0 +# 829 +{ +# 830 +return cyl_bessel_i1f(a); +# 831 +} +#endif +# 833 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +static inline float erfinv(const float a) +# 834 +{ +# 835 +return erfinvf(a); +# 836 +} +# 838 +static inline float erfcinv(const float a) +# 839 +{ +# 840 +return erfcinvf(a); +# 841 +} +# 843 +static inline float normcdfinv(const float a) +# 844 +{ +# 845 +return normcdfinvf(a); +# 846 +} +# 848 +static inline float normcdf(const float a) +# 849 +{ +# 850 +return normcdff(a); +# 851 +} +# 853 +static inline float erfcx(const float a) +# 854 +{ +# 855 +return erfcxf(a); +# 856 +} +# 858 +static inline double copysign(const double a, const float b) +# 859 +{ +# 860 +return copysign(a, static_cast< double>(b)); +# 861 +} +# 863 +static inline double copysign(const float a, const double b) +# 864 +{ +# 865 +return copysign(static_cast< double>(a), b); +# 866 +} +# 868 +static inline unsigned min(const unsigned a, const unsigned b) +# 869 +{ +# 870 +return umin(a, b); +# 871 +} +# 873 +static inline unsigned min(const int a, const unsigned b) +# 874 +{ +# 875 +return umin(static_cast< unsigned>(a), b); +# 876 +} +# 878 +static inline unsigned min(const unsigned a, const int b) +# 879 +{ +# 880 +return umin(a, static_cast< unsigned>(b)); +# 881 +} +# 883 +static inline long min(const long a, const long b) +# 884 +{ +# 885 +long retval; +# 892 +if (sizeof(long) == sizeof(int)) { +# 896 +retval = (static_cast< long>(min(static_cast< int>(a), static_cast< int>(b)))); +# 897 +} else { +# 898 +retval = (static_cast< long>(llmin(static_cast< long long>(a), static_cast< long long>(b)))); +# 899 +} +# 900 +return retval; +# 901 +} +# 903 +static inline unsigned long min(const unsigned long a, const unsigned long b) +# 904 +{ +# 905 +unsigned long retval; +# 910 +if (sizeof(unsigned long) == sizeof(unsigned)) { +# 914 +retval = (static_cast< unsigned long>(umin(static_cast< unsigned>(a), static_cast< unsigned>(b)))); +# 915 +} else { +# 916 +retval = (static_cast< unsigned long>(ullmin(static_cast< unsigned long long>(a), static_cast< unsigned long long>(b)))); +# 917 +} +# 918 +return retval; +# 919 +} +# 921 +static inline unsigned long min(const long a, const unsigned long b) +# 922 +{ +# 923 +unsigned long retval; +# 928 +if (sizeof(unsigned long) == sizeof(unsigned)) { +# 932 +retval = (static_cast< unsigned long>(umin(static_cast< unsigned>(a), static_cast< unsigned>(b)))); +# 933 +} else { +# 934 +retval = (static_cast< unsigned long>(ullmin(static_cast< unsigned long long>(a), static_cast< unsigned long long>(b)))); +# 935 +} +# 936 +return retval; +# 937 +} +# 939 +static inline unsigned long min(const unsigned long a, const long b) +# 940 +{ +# 941 +unsigned long retval; +# 946 +if (sizeof(unsigned long) == sizeof(unsigned)) { +# 950 +retval = (static_cast< unsigned long>(umin(static_cast< unsigned>(a), static_cast< unsigned>(b)))); +# 951 +} else { +# 952 +retval = (static_cast< unsigned long>(ullmin(static_cast< unsigned long long>(a), static_cast< unsigned long long>(b)))); +# 953 +} +# 954 +return retval; +# 955 +} +# 957 +static inline long long min(const long long a, const long long b) +# 958 +{ +# 959 +return llmin(a, b); +# 960 +} +# 962 +static inline unsigned long long min(const unsigned long long a, const unsigned long long b) +# 963 +{ +# 964 +return ullmin(a, b); +# 965 +} +# 967 +static inline unsigned long long min(const long long a, const unsigned long long b) +# 968 +{ +# 969 +return ullmin(static_cast< unsigned long long>(a), b); +# 970 +} +# 972 +static inline unsigned long long min(const unsigned long long a, const long long b) +# 973 +{ +# 974 +return ullmin(a, static_cast< unsigned long long>(b)); +# 975 +} +# 977 +static inline float min(const float a, const float b) +# 978 +{ +# 979 +return fminf(a, b); +# 980 +} +# 982 +static inline double min(const double a, const double b) +# 983 +{ +# 984 +return fmin(a, b); +# 985 +} +# 987 +static inline double min(const float a, const double b) +# 988 +{ +# 989 +return fmin(static_cast< double>(a), b); +# 990 +} +# 992 +static inline double min(const double a, const float b) +# 993 +{ +# 994 +return fmin(a, static_cast< double>(b)); +# 995 +} +# 997 +static inline unsigned max(const unsigned a, const unsigned b) +# 998 +{ +# 999 +return umax(a, b); +# 1000 +} +# 1002 +static inline unsigned max(const int a, const unsigned b) +# 1003 +{ +# 1004 +return umax(static_cast< unsigned>(a), b); +# 1005 +} +# 1007 +static inline unsigned max(const unsigned a, const int b) +# 1008 +{ +# 1009 +return umax(a, static_cast< unsigned>(b)); +# 1010 +} +# 1012 +static inline long max(const long a, const long b) +# 1013 +{ +# 1014 +long retval; +# 1020 +if (sizeof(long) == sizeof(int)) { +# 1024 +retval = (static_cast< long>(max(static_cast< int>(a), static_cast< int>(b)))); +# 1025 +} else { +# 1026 +retval = (static_cast< long>(llmax(static_cast< long long>(a), static_cast< long long>(b)))); +# 1027 +} +# 1028 +return retval; +# 1029 +} +# 1031 +static inline unsigned long max(const unsigned long a, const unsigned long b) +# 1032 +{ +# 1033 +unsigned long retval; +# 1038 +if (sizeof(unsigned long) == sizeof(unsigned)) { +# 1042 +retval = (static_cast< unsigned long>(umax(static_cast< unsigned>(a), static_cast< unsigned>(b)))); +# 1043 +} else { +# 1044 +retval = (static_cast< unsigned long>(ullmax(static_cast< unsigned long long>(a), static_cast< unsigned long long>(b)))); +# 1045 +} +# 1046 +return retval; +# 1047 +} +# 1049 +static inline unsigned long max(const long a, const unsigned long b) +# 1050 +{ +# 1051 +unsigned long retval; +# 1056 +if (sizeof(unsigned long) == sizeof(unsigned)) { +# 1060 +retval = (static_cast< unsigned long>(umax(static_cast< unsigned>(a), static_cast< unsigned>(b)))); +# 1061 +} else { +# 1062 +retval = (static_cast< unsigned long>(ullmax(static_cast< unsigned long long>(a), static_cast< unsigned long long>(b)))); +# 1063 +} +# 1064 +return retval; +# 1065 +} +# 1067 +static inline unsigned long max(const unsigned long a, const long b) +# 1068 +{ +# 1069 +unsigned long retval; +# 1074 +if (sizeof(unsigned long) == sizeof(unsigned)) { +# 1078 +retval = (static_cast< unsigned long>(umax(static_cast< unsigned>(a), static_cast< unsigned>(b)))); +# 1079 +} else { +# 1080 +retval = (static_cast< unsigned long>(ullmax(static_cast< unsigned long long>(a), static_cast< unsigned long long>(b)))); +# 1081 +} +# 1082 +return retval; +# 1083 +} +# 1085 +static inline long long max(const long long a, const long long b) +# 1086 +{ +# 1087 +return llmax(a, b); +# 1088 +} +# 1090 +static inline unsigned long long max(const unsigned long long a, const unsigned long long b) +# 1091 +{ +# 1092 +return ullmax(a, b); +# 1093 +} +# 1095 +static inline unsigned long long max(const long long a, const unsigned long long b) +# 1096 +{ +# 1097 +return ullmax(static_cast< unsigned long long>(a), b); +# 1098 +} +# 1100 +static inline unsigned long long max(const unsigned long long a, const long long b) +# 1101 +{ +# 1102 +return ullmax(a, static_cast< unsigned long long>(b)); +# 1103 +} +# 1105 +static inline float max(const float a, const float b) +# 1106 +{ +# 1107 +return fmaxf(a, b); +# 1108 +} +# 1110 +static inline double max(const double a, const double b) +# 1111 +{ +# 1112 +return fmax(a, b); +# 1113 +} +# 1115 +static inline double max(const float a, const double b) +# 1116 +{ +# 1117 +return fmax(static_cast< double>(a), b); +# 1118 +} +# 1120 +static inline double max(const double a, const float b) +# 1121 +{ +# 1122 +return fmax(a, static_cast< double>(b)); +# 1123 +} +# 1135 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +inline int min(const int a, const int b) +# 1136 +{ +# 1137 +return (a < b) ? a : b; +# 1138 +} +# 1140 +inline unsigned umin(const unsigned a, const unsigned b) +# 1141 +{ +# 1142 +return (a < b) ? a : b; +# 1143 +} +# 1145 +inline long long llmin(const long long a, const long long b) +# 1146 +{ +# 1147 +return (a < b) ? a : b; +# 1148 +} +# 1150 +inline unsigned long long ullmin(const unsigned long long a, const unsigned long long +# 1151 +b) +# 1152 +{ +# 1153 +return (a < b) ? a : b; +# 1154 +} +# 1156 +inline int max(const int a, const int b) +# 1157 +{ +# 1158 +return (a > b) ? a : b; +# 1159 +} +# 1161 +inline unsigned umax(const unsigned a, const unsigned b) +# 1162 +{ +# 1163 +return (a > b) ? a : b; +# 1164 +} +# 1166 +inline long long llmax(const long long a, const long long b) +# 1167 +{ +# 1168 +return (a > b) ? a : b; +# 1169 +} +# 1171 +inline unsigned long long ullmax(const unsigned long long a, const unsigned long long +# 1172 +b) +# 1173 +{ +# 1174 +return (a > b) ? a : b; +# 1175 +} +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +extern "C" { +# 2497 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __vimax_s32_relu(const int a, const int b); +# 2509 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vimax_s16x2_relu(const unsigned a, const unsigned b); +# 2518 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __vimin_s32_relu(const int a, const int b); +# 2530 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vimin_s16x2_relu(const unsigned a, const unsigned b); +# 2539 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __vimax3_s32(const int a, const int b, const int c); +# 2551 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vimax3_s16x2(const unsigned a, const unsigned b, const unsigned c); +# 2560 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vimax3_u32(const unsigned a, const unsigned b, const unsigned c); +# 2572 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vimax3_u16x2(const unsigned a, const unsigned b, const unsigned c); +# 2581 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __vimin3_s32(const int a, const int b, const int c); +# 2593 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vimin3_s16x2(const unsigned a, const unsigned b, const unsigned c); +# 2602 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vimin3_u32(const unsigned a, const unsigned b, const unsigned c); +# 2614 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vimin3_u16x2(const unsigned a, const unsigned b, const unsigned c); +# 2623 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __vimax3_s32_relu(const int a, const int b, const int c); +# 2635 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vimax3_s16x2_relu(const unsigned a, const unsigned b, const unsigned c); +# 2644 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __vimin3_s32_relu(const int a, const int b, const int c); +# 2656 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vimin3_s16x2_relu(const unsigned a, const unsigned b, const unsigned c); +# 2665 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __viaddmax_s32(const int a, const int b, const int c); +# 2677 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __viaddmax_s16x2(const unsigned a, const unsigned b, const unsigned c); +# 2686 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __viaddmax_u32(const unsigned a, const unsigned b, const unsigned c); +# 2698 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __viaddmax_u16x2(const unsigned a, const unsigned b, const unsigned c); +# 2707 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __viaddmin_s32(const int a, const int b, const int c); +# 2719 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __viaddmin_s16x2(const unsigned a, const unsigned b, const unsigned c); +# 2728 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __viaddmin_u32(const unsigned a, const unsigned b, const unsigned c); +# 2740 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __viaddmin_u16x2(const unsigned a, const unsigned b, const unsigned c); +# 2750 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __viaddmax_s32_relu(const int a, const int b, const int c); +# 2762 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __viaddmax_s16x2_relu(const unsigned a, const unsigned b, const unsigned c); +# 2772 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __viaddmin_s32_relu(const int a, const int b, const int c); +# 2784 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __viaddmin_s16x2_relu(const unsigned a, const unsigned b, const unsigned c); +# 2793 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __vibmax_s32(const int a, const int b, bool *const pred); +# 2802 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vibmax_u32(const unsigned a, const unsigned b, bool *const pred); +# 2811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __vibmin_s32(const int a, const int b, bool *const pred); +# 2820 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vibmin_u32(const unsigned a, const unsigned b, bool *const pred); +# 2834 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vibmax_s16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo); +# 2848 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vibmax_u16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo); +# 2862 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vibmin_s16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo); +# 2876 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vibmin_u16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo); +# 2883 +} +# 116 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +static short __internal_cast_u2s(unsigned short x) +# 117 +{ +# 118 +short res; +# 120 +(void)memcpy(&res, &x, sizeof x); +# 124 +return res; +# 125 +} +# 127 +static inline int __vimax_s32_relu(const int a, const int b) { +# 134 +int ans = max(a, b); +# 136 +return (ans > 0) ? ans : 0; +# 138 +} +# 140 +static inline unsigned __vimax_s16x2_relu(const unsigned a, const unsigned b) { +# 141 +unsigned res; +# 149 +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 150 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 152 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 153 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 156 +short aS_lo = __internal_cast_u2s(aU_lo); +# 157 +short aS_hi = __internal_cast_u2s(aU_hi); +# 159 +short bS_lo = __internal_cast_u2s(bU_lo); +# 160 +short bS_hi = __internal_cast_u2s(bU_hi); +# 163 +int ansI_lo = max(aS_lo, bS_lo); +# 164 +int ansI_hi = max(aS_hi, bS_hi); +# 167 +if (ansI_lo < 0) { ansI_lo = 0; } +# 168 +if (ansI_hi < 0) { ansI_hi = 0; } +# 171 +unsigned ansU_lo = (unsigned)ansI_lo; +# 172 +unsigned ansU_hi = (unsigned)ansI_hi; +# 175 +res = (ansU_lo | (ansU_hi << 16)); +# 178 +return res; +# 179 +} +# 181 +static inline int __vimin_s32_relu(const int a, const int b) { +# 188 +int ans = min(a, b); +# 190 +return (ans > 0) ? ans : 0; +# 192 +} +# 194 +static inline unsigned __vimin_s16x2_relu(const unsigned a, const unsigned b) { +# 195 +unsigned res; +# 203 +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 204 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 206 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 207 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 210 +short aS_lo = __internal_cast_u2s(aU_lo); +# 211 +short aS_hi = __internal_cast_u2s(aU_hi); +# 213 +short bS_lo = __internal_cast_u2s(bU_lo); +# 214 +short bS_hi = __internal_cast_u2s(bU_hi); +# 217 +int ansI_lo = min(aS_lo, bS_lo); +# 218 +int ansI_hi = min(aS_hi, bS_hi); +# 221 +if (ansI_lo < 0) { ansI_lo = 0; } +# 222 +if (ansI_hi < 0) { ansI_hi = 0; } +# 225 +unsigned ansU_lo = (unsigned)ansI_lo; +# 226 +unsigned ansU_hi = (unsigned)ansI_hi; +# 229 +res = (ansU_lo | (ansU_hi << 16)); +# 232 +return res; +# 233 +} +# 235 +static inline int __vimax3_s32(const int a, const int b, const int c) { +# 245 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +return max(max(a, b), c); +# 247 +} +# 249 +static inline unsigned __vimax3_s16x2(const unsigned a, const unsigned b, const unsigned c) { +# 250 +unsigned res; +# 262 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 263 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 265 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 266 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 268 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 269 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 272 +short aS_lo = __internal_cast_u2s(aU_lo); +# 273 +short aS_hi = __internal_cast_u2s(aU_hi); +# 275 +short bS_lo = __internal_cast_u2s(bU_lo); +# 276 +short bS_hi = __internal_cast_u2s(bU_hi); +# 278 +short cS_lo = __internal_cast_u2s(cU_lo); +# 279 +short cS_hi = __internal_cast_u2s(cU_hi); +# 282 +unsigned ansU_lo = (unsigned)max(max(aS_lo, bS_lo), cS_lo); +# 283 +unsigned ansU_hi = (unsigned)max(max(aS_hi, bS_hi), cS_hi); +# 286 +res = ((ansU_lo & 65535U) | (ansU_hi << 16)); +# 288 +return res; +# 289 +} +# 291 +static inline unsigned __vimax3_u32(const unsigned a, const unsigned b, const unsigned c) { +# 301 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +return max(max(a, b), c); +# 303 +} +# 305 +static inline unsigned __vimax3_u16x2(const unsigned a, const unsigned b, const unsigned c) { +# 306 +unsigned res; +# 317 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 318 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 320 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 321 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 323 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 324 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 327 +unsigned short ansU_lo = (unsigned short)max(max(aU_lo, bU_lo), cU_lo); +# 328 +unsigned short ansU_hi = (unsigned short)max(max(aU_hi, bU_hi), cU_hi); +# 331 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 334 +return res; +# 335 +} +# 337 +static inline int __vimin3_s32(const int a, const int b, const int c) { +# 347 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +return min(min(a, b), c); +# 349 +} +# 351 +static inline unsigned __vimin3_s16x2(const unsigned a, const unsigned b, const unsigned c) { +# 352 +unsigned res; +# 363 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 364 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 366 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 367 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 369 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 370 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 373 +short aS_lo = __internal_cast_u2s(aU_lo); +# 374 +short aS_hi = __internal_cast_u2s(aU_hi); +# 376 +short bS_lo = __internal_cast_u2s(bU_lo); +# 377 +short bS_hi = __internal_cast_u2s(bU_hi); +# 379 +short cS_lo = __internal_cast_u2s(cU_lo); +# 380 +short cS_hi = __internal_cast_u2s(cU_hi); +# 383 +unsigned ansU_lo = (unsigned)min(min(aS_lo, bS_lo), cS_lo); +# 384 +unsigned ansU_hi = (unsigned)min(min(aS_hi, bS_hi), cS_hi); +# 387 +res = ((ansU_lo & 65535U) | (ansU_hi << 16)); +# 390 +return res; +# 391 +} +# 393 +static inline unsigned __vimin3_u32(const unsigned a, const unsigned b, const unsigned c) { +# 403 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +return min(min(a, b), c); +# 405 +} +# 407 +static inline unsigned __vimin3_u16x2(const unsigned a, const unsigned b, const unsigned c) { +# 408 +unsigned res; +# 419 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 420 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 422 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 423 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 425 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 426 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 429 +unsigned short ansU_lo = (unsigned short)min(min(aU_lo, bU_lo), cU_lo); +# 430 +unsigned short ansU_hi = (unsigned short)min(min(aU_hi, bU_hi), cU_hi); +# 433 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 436 +return res; +# 437 +} +# 439 +static inline int __vimax3_s32_relu(const int a, const int b, const int c) { +# 449 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +int ans = max(max(a, b), c); +# 451 +return (ans > 0) ? ans : 0; +# 453 +} +# 455 +static inline unsigned __vimax3_s16x2_relu(const unsigned a, const unsigned b, const unsigned c) { +# 456 +unsigned res; +# 467 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 468 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 470 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 471 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 473 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 474 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 477 +short aS_lo = __internal_cast_u2s(aU_lo); +# 478 +short aS_hi = __internal_cast_u2s(aU_hi); +# 480 +short bS_lo = __internal_cast_u2s(bU_lo); +# 481 +short bS_hi = __internal_cast_u2s(bU_hi); +# 483 +short cS_lo = __internal_cast_u2s(cU_lo); +# 484 +short cS_hi = __internal_cast_u2s(cU_hi); +# 487 +unsigned ansU_lo = (unsigned)max(0, max(max(aS_lo, bS_lo), cS_lo)); +# 488 +unsigned ansU_hi = (unsigned)max(0, max(max(aS_hi, bS_hi), cS_hi)); +# 491 +res = (ansU_lo | (ansU_hi << 16)); +# 494 +return res; +# 495 +} +# 497 +static inline int __vimin3_s32_relu(const int a, const int b, const int c) { +# 507 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +int ans = min(min(a, b), c); +# 509 +return (ans > 0) ? ans : 0; +# 511 +} +# 513 +static inline unsigned __vimin3_s16x2_relu(const unsigned a, const unsigned b, const unsigned c) { +# 514 +unsigned res; +# 525 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 526 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 528 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 529 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 531 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 532 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 535 +short aS_lo = __internal_cast_u2s(aU_lo); +# 536 +short aS_hi = __internal_cast_u2s(aU_hi); +# 538 +short bS_lo = __internal_cast_u2s(bU_lo); +# 539 +short bS_hi = __internal_cast_u2s(bU_hi); +# 541 +short cS_lo = __internal_cast_u2s(cU_lo); +# 542 +short cS_hi = __internal_cast_u2s(cU_hi); +# 545 +unsigned ansU_lo = (unsigned)max(0, min(min(aS_lo, bS_lo), cS_lo)); +# 546 +unsigned ansU_hi = (unsigned)max(0, min(min(aS_hi, bS_hi), cS_hi)); +# 549 +res = (ansU_lo | (ansU_hi << 16)); +# 553 +return res; +# 554 +} +# 556 +static inline int __viaddmax_s32(const int a, const int b, const int c) { +# 566 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +return max(a + b, c); +# 568 +} +# 570 +static inline unsigned __viaddmax_s16x2(const unsigned a, const unsigned b, const unsigned c) { +# 571 +unsigned res; +# 582 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 583 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 585 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 586 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 588 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 589 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 591 +aU_lo += bU_lo; +# 592 +aU_hi += bU_hi; +# 595 +short sS_lo = __internal_cast_u2s(aU_lo); +# 596 +short sS_hi = __internal_cast_u2s(aU_hi); +# 598 +short cS_lo = __internal_cast_u2s(cU_lo); +# 599 +short cS_hi = __internal_cast_u2s(cU_hi); +# 602 +unsigned ansU_lo = (unsigned)max(sS_lo, cS_lo); +# 603 +unsigned ansU_hi = (unsigned)max(sS_hi, cS_hi); +# 606 +res = ((ansU_lo & 65535U) | (ansU_hi << 16)); +# 609 +return res; +# 610 +} +# 612 +static inline unsigned __viaddmax_u32(const unsigned a, const unsigned b, const unsigned c) { +# 622 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +return max(a + b, c); +# 624 +} +# 626 +static inline unsigned __viaddmax_u16x2(const unsigned a, const unsigned b, const unsigned c) { +# 627 +unsigned res; +# 638 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 639 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 641 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 642 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 644 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 645 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 648 +unsigned short ansU_lo = (unsigned short)max((unsigned short)(aU_lo + bU_lo), cU_lo); +# 649 +unsigned short ansU_hi = (unsigned short)max((unsigned short)(aU_hi + bU_hi), cU_hi); +# 652 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 655 +return res; +# 656 +} +# 658 +static inline int __viaddmin_s32(const int a, const int b, const int c) { +# 668 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +return min(a + b, c); +# 670 +} +# 672 +static inline unsigned __viaddmin_s16x2(const unsigned a, const unsigned b, const unsigned c) { +# 673 +unsigned res; +# 684 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 685 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 687 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 688 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 690 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 691 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 693 +aU_lo += bU_lo; +# 694 +aU_hi += bU_hi; +# 697 +short sS_lo = __internal_cast_u2s(aU_lo); +# 698 +short sS_hi = __internal_cast_u2s(aU_hi); +# 700 +short cS_lo = __internal_cast_u2s(cU_lo); +# 701 +short cS_hi = __internal_cast_u2s(cU_hi); +# 704 +unsigned ansU_lo = (unsigned)min(sS_lo, cS_lo); +# 705 +unsigned ansU_hi = (unsigned)min(sS_hi, cS_hi); +# 708 +res = ((ansU_lo & 65535U) | (ansU_hi << 16)); +# 711 +return res; +# 712 +} +# 714 +static inline unsigned __viaddmin_u32(const unsigned a, const unsigned b, const unsigned c) { +# 724 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +return min(a + b, c); +# 726 +} +# 728 +static inline unsigned __viaddmin_u16x2(const unsigned a, const unsigned b, const unsigned c) { +# 729 +unsigned res; +# 740 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 741 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 743 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 744 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 746 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 747 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 750 +unsigned short ansU_lo = (unsigned short)min((unsigned short)(aU_lo + bU_lo), cU_lo); +# 751 +unsigned short ansU_hi = (unsigned short)min((unsigned short)(aU_hi + bU_hi), cU_hi); +# 754 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 757 +return res; +# 758 +} +# 760 +static inline int __viaddmax_s32_relu(const int a, const int b, const int c) { +# 770 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +int ans = max(a + b, c); +# 772 +return (ans > 0) ? ans : 0; +# 774 +} +# 776 +static inline unsigned __viaddmax_s16x2_relu(const unsigned a, const unsigned b, const unsigned c) { +# 777 +unsigned res; +# 788 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 789 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 791 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 792 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 794 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 795 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 797 +aU_lo += bU_lo; +# 798 +aU_hi += bU_hi; +# 801 +short sS_lo = __internal_cast_u2s(aU_lo); +# 802 +short sS_hi = __internal_cast_u2s(aU_hi); +# 804 +short cS_lo = __internal_cast_u2s(cU_lo); +# 805 +short cS_hi = __internal_cast_u2s(cU_hi); +# 808 +unsigned ansU_lo = (unsigned)max(0, max(sS_lo, cS_lo)); +# 809 +unsigned ansU_hi = (unsigned)max(0, max(sS_hi, cS_hi)); +# 812 +res = (ansU_lo | (ansU_hi << 16)); +# 815 +return res; +# 816 +} +# 818 +static inline int __viaddmin_s32_relu(const int a, const int b, const int c) { +# 828 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +int ans = min(a + b, c); +# 830 +return (ans > 0) ? ans : 0; +# 832 +} +# 834 +static inline unsigned __viaddmin_s16x2_relu(const unsigned a, const unsigned b, const unsigned c) { +# 835 +unsigned res; +# 846 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 847 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 849 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 850 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 852 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 853 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 855 +aU_lo += bU_lo; +# 856 +aU_hi += bU_hi; +# 859 +short sS_lo = __internal_cast_u2s(aU_lo); +# 860 +short sS_hi = __internal_cast_u2s(aU_hi); +# 862 +short cS_lo = __internal_cast_u2s(cU_lo); +# 863 +short cS_hi = __internal_cast_u2s(cU_hi); +# 866 +unsigned ansU_lo = (unsigned)max(0, min(sS_lo, cS_lo)); +# 867 +unsigned ansU_hi = (unsigned)max(0, min(sS_hi, cS_hi)); +# 870 +res = (ansU_lo | (ansU_hi << 16)); +# 873 +return res; +# 874 +} +# 878 +static inline int __vibmax_s32(const int a, const int b, bool *const pred) { +# 892 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +int ans = max(a, b); +# 894 +(*pred) = (a >= b); +# 895 +return ans; +# 897 +} +# 899 +static inline unsigned __vibmax_u32(const unsigned a, const unsigned b, bool *const pred) { +# 913 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned ans = max(a, b); +# 915 +(*pred) = (a >= b); +# 916 +return ans; +# 918 +} +# 921 +static inline int __vibmin_s32(const int a, const int b, bool *const pred) { +# 935 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +int ans = min(a, b); +# 937 +(*pred) = (a <= b); +# 938 +return ans; +# 940 +} +# 943 +static inline unsigned __vibmin_u32(const unsigned a, const unsigned b, bool *const pred) { +# 957 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned ans = min(a, b); +# 959 +(*pred) = (a <= b); +# 960 +return ans; +# 962 +} +# 964 +static inline unsigned __vibmax_s16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo) { +# 986 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 987 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 989 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 990 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 993 +short aS_lo = __internal_cast_u2s(aU_lo); +# 994 +short aS_hi = __internal_cast_u2s(aU_hi); +# 996 +short bS_lo = __internal_cast_u2s(bU_lo); +# 997 +short bS_hi = __internal_cast_u2s(bU_hi); +# 1000 +unsigned ansU_lo = (unsigned)max(aS_lo, bS_lo); +# 1001 +unsigned ansU_hi = (unsigned)max(aS_hi, bS_hi); +# 1003 +(*pred_hi) = (aS_hi >= bS_hi); +# 1004 +(*pred_lo) = (aS_lo >= bS_lo); +# 1007 +unsigned ans = (ansU_lo & 65535U) | (ansU_hi << 16); +# 1009 +return ans; +# 1011 +} +# 1013 +static inline unsigned __vibmax_u16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo) { +# 1035 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 1036 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 1038 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 1039 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 1042 +unsigned short ansU_lo = (unsigned short)max(aU_lo, bU_lo); +# 1043 +unsigned short ansU_hi = (unsigned short)max(aU_hi, bU_hi); +# 1045 +(*pred_hi) = (aU_hi >= bU_hi); +# 1046 +(*pred_lo) = (aU_lo >= bU_lo); +# 1049 +unsigned ans = ((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16); +# 1051 +return ans; +# 1053 +} +# 1055 +static inline unsigned __vibmin_s16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo) { +# 1077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 1078 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 1080 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 1081 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 1084 +short aS_lo = __internal_cast_u2s(aU_lo); +# 1085 +short aS_hi = __internal_cast_u2s(aU_hi); +# 1087 +short bS_lo = __internal_cast_u2s(bU_lo); +# 1088 +short bS_hi = __internal_cast_u2s(bU_hi); +# 1091 +unsigned ansU_lo = (unsigned)min(aS_lo, bS_lo); +# 1092 +unsigned ansU_hi = (unsigned)min(aS_hi, bS_hi); +# 1094 +(*pred_hi) = (aS_hi <= bS_hi); +# 1095 +(*pred_lo) = (aS_lo <= bS_lo); +# 1098 +unsigned ans = (ansU_lo & 65535U) | (ansU_hi << 16); +# 1100 +return ans; +# 1102 +} +# 1104 +static inline unsigned __vibmin_u16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo) { +# 1126 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 1127 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 1129 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 1130 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 1133 +unsigned short ansU_lo = (unsigned short)min(aU_lo, bU_lo); +# 1134 +unsigned short ansU_hi = (unsigned short)min(aU_hi, bU_hi); +# 1136 +(*pred_hi) = (aU_hi <= bU_hi); +# 1137 +(*pred_lo) = (aU_lo <= bU_lo); +# 1140 +unsigned ans = ((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16); +# 1142 +return ans; +# 1144 +} +# 89 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline int atomicAdd(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 89 +{ } +#endif +# 91 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicAdd(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 91 +{ } +#endif +# 93 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline int atomicSub(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 93 +{ } +#endif +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicSub(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 95 +{ } +#endif +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline int atomicExch(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 97 +{ } +#endif +# 99 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicExch(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 99 +{ } +#endif +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline float atomicExch(float *address, float val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 101 +{ } +#endif +# 103 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline int atomicMin(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 103 +{ } +#endif +# 105 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicMin(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 105 +{ } +#endif +# 107 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline int atomicMax(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 107 +{ } +#endif +# 109 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicMax(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 109 +{ } +#endif +# 111 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicInc(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 111 +{ } +#endif +# 113 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicDec(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 113 +{ } +#endif +# 115 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline int atomicAnd(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 115 +{ } +#endif +# 117 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicAnd(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 117 +{ } +#endif +# 119 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline int atomicOr(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 119 +{ } +#endif +# 121 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicOr(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 121 +{ } +#endif +# 123 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline int atomicXor(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 123 +{ } +#endif +# 125 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicXor(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 125 +{ } +#endif +# 127 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline int atomicCAS(int *address, int compare, int val) {int volatile ___ = 1;(void)address;(void)compare;(void)val;::exit(___);} +#if 0 +# 127 +{ } +#endif +# 129 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicCAS(unsigned *address, unsigned compare, unsigned val) {int volatile ___ = 1;(void)address;(void)compare;(void)val;::exit(___);} +#if 0 +# 129 +{ } +#endif +# 156 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +extern "C" { +# 160 +} +# 169 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicAdd(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 169 +{ } +#endif +# 171 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicExch(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 171 +{ } +#endif +# 173 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicCAS(unsigned long long *address, unsigned long long compare, unsigned long long val) {int volatile ___ = 1;(void)address;(void)compare;(void)val;::exit(___);} +#if 0 +# 173 +{ } +#endif +# 175 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute((deprecated("__any() is deprecated in favor of __any_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppr" "ess this warning)."))) __attribute__((unused)) static inline bool any(bool cond) {int volatile ___ = 1;(void)cond;::exit(___);} +#if 0 +# 175 +{ } +#endif +# 177 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute((deprecated("__all() is deprecated in favor of __all_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppr" "ess this warning)."))) __attribute__((unused)) static inline bool all(bool cond) {int volatile ___ = 1;(void)cond;::exit(___);} +#if 0 +# 177 +{ } +#endif +# 90 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern "C" { +# 1142 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +} +# 1150 +__attribute__((unused)) static inline double fma(double a, double b, double c, cudaRoundMode mode); +# 1154 +__attribute__((unused)) static inline double dmul(double a, double b, cudaRoundMode mode = cudaRoundNearest); +# 1156 +__attribute__((unused)) static inline double dadd(double a, double b, cudaRoundMode mode = cudaRoundNearest); +# 1158 +__attribute__((unused)) static inline double dsub(double a, double b, cudaRoundMode mode = cudaRoundNearest); +# 1160 +__attribute__((unused)) static inline int double2int(double a, cudaRoundMode mode = cudaRoundZero); +# 1162 +__attribute__((unused)) static inline unsigned double2uint(double a, cudaRoundMode mode = cudaRoundZero); +# 1164 +__attribute__((unused)) static inline long long double2ll(double a, cudaRoundMode mode = cudaRoundZero); +# 1166 +__attribute__((unused)) static inline unsigned long long double2ull(double a, cudaRoundMode mode = cudaRoundZero); +# 1168 +__attribute__((unused)) static inline double ll2double(long long a, cudaRoundMode mode = cudaRoundNearest); +# 1170 +__attribute__((unused)) static inline double ull2double(unsigned long long a, cudaRoundMode mode = cudaRoundNearest); +# 1172 +__attribute__((unused)) static inline double int2double(int a, cudaRoundMode mode = cudaRoundNearest); +# 1174 +__attribute__((unused)) static inline double uint2double(unsigned a, cudaRoundMode mode = cudaRoundNearest); +# 1176 +__attribute__((unused)) static inline double float2double(float a, cudaRoundMode mode = cudaRoundNearest); +# 93 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline double fma(double a, double b, double c, cudaRoundMode mode) +# 94 +{int volatile ___ = 1;(void)a;(void)b;(void)c;(void)mode; +# 99 +::exit(___);} +#if 0 +# 94 +{ +# 95 +return (mode == (cudaRoundZero)) ? __fma_rz(a, b, c) : ((mode == (cudaRoundPosInf)) ? __fma_ru(a, b, c) : ((mode == (cudaRoundMinInf)) ? __fma_rd(a, b, c) : __fma_rn(a, b, c))); +# 99 +} +#endif +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline double dmul(double a, double b, cudaRoundMode mode) +# 102 +{int volatile ___ = 1;(void)a;(void)b;(void)mode; +# 107 +::exit(___);} +#if 0 +# 102 +{ +# 103 +return (mode == (cudaRoundZero)) ? __dmul_rz(a, b) : ((mode == (cudaRoundPosInf)) ? __dmul_ru(a, b) : ((mode == (cudaRoundMinInf)) ? __dmul_rd(a, b) : __dmul_rn(a, b))); +# 107 +} +#endif +# 109 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline double dadd(double a, double b, cudaRoundMode mode) +# 110 +{int volatile ___ = 1;(void)a;(void)b;(void)mode; +# 115 +::exit(___);} +#if 0 +# 110 +{ +# 111 +return (mode == (cudaRoundZero)) ? __dadd_rz(a, b) : ((mode == (cudaRoundPosInf)) ? __dadd_ru(a, b) : ((mode == (cudaRoundMinInf)) ? __dadd_rd(a, b) : __dadd_rn(a, b))); +# 115 +} +#endif +# 117 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline double dsub(double a, double b, cudaRoundMode mode) +# 118 +{int volatile ___ = 1;(void)a;(void)b;(void)mode; +# 123 +::exit(___);} +#if 0 +# 118 +{ +# 119 +return (mode == (cudaRoundZero)) ? __dsub_rz(a, b) : ((mode == (cudaRoundPosInf)) ? __dsub_ru(a, b) : ((mode == (cudaRoundMinInf)) ? __dsub_rd(a, b) : __dsub_rn(a, b))); +# 123 +} +#endif +# 125 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline int double2int(double a, cudaRoundMode mode) +# 126 +{int volatile ___ = 1;(void)a;(void)mode; +# 131 +::exit(___);} +#if 0 +# 126 +{ +# 127 +return (mode == (cudaRoundNearest)) ? __double2int_rn(a) : ((mode == (cudaRoundPosInf)) ? __double2int_ru(a) : ((mode == (cudaRoundMinInf)) ? __double2int_rd(a) : __double2int_rz(a))); +# 131 +} +#endif +# 133 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline unsigned double2uint(double a, cudaRoundMode mode) +# 134 +{int volatile ___ = 1;(void)a;(void)mode; +# 139 +::exit(___);} +#if 0 +# 134 +{ +# 135 +return (mode == (cudaRoundNearest)) ? __double2uint_rn(a) : ((mode == (cudaRoundPosInf)) ? __double2uint_ru(a) : ((mode == (cudaRoundMinInf)) ? __double2uint_rd(a) : __double2uint_rz(a))); +# 139 +} +#endif +# 141 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline long long double2ll(double a, cudaRoundMode mode) +# 142 +{int volatile ___ = 1;(void)a;(void)mode; +# 147 +::exit(___);} +#if 0 +# 142 +{ +# 143 +return (mode == (cudaRoundNearest)) ? __double2ll_rn(a) : ((mode == (cudaRoundPosInf)) ? __double2ll_ru(a) : ((mode == (cudaRoundMinInf)) ? __double2ll_rd(a) : __double2ll_rz(a))); +# 147 +} +#endif +# 149 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline unsigned long long double2ull(double a, cudaRoundMode mode) +# 150 +{int volatile ___ = 1;(void)a;(void)mode; +# 155 +::exit(___);} +#if 0 +# 150 +{ +# 151 +return (mode == (cudaRoundNearest)) ? __double2ull_rn(a) : ((mode == (cudaRoundPosInf)) ? __double2ull_ru(a) : ((mode == (cudaRoundMinInf)) ? __double2ull_rd(a) : __double2ull_rz(a))); +# 155 +} +#endif +# 157 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline double ll2double(long long a, cudaRoundMode mode) +# 158 +{int volatile ___ = 1;(void)a;(void)mode; +# 163 +::exit(___);} +#if 0 +# 158 +{ +# 159 +return (mode == (cudaRoundZero)) ? __ll2double_rz(a) : ((mode == (cudaRoundPosInf)) ? __ll2double_ru(a) : ((mode == (cudaRoundMinInf)) ? __ll2double_rd(a) : __ll2double_rn(a))); +# 163 +} +#endif +# 165 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline double ull2double(unsigned long long a, cudaRoundMode mode) +# 166 +{int volatile ___ = 1;(void)a;(void)mode; +# 171 +::exit(___);} +#if 0 +# 166 +{ +# 167 +return (mode == (cudaRoundZero)) ? __ull2double_rz(a) : ((mode == (cudaRoundPosInf)) ? __ull2double_ru(a) : ((mode == (cudaRoundMinInf)) ? __ull2double_rd(a) : __ull2double_rn(a))); +# 171 +} +#endif +# 173 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline double int2double(int a, cudaRoundMode mode) +# 174 +{int volatile ___ = 1;(void)a;(void)mode; +# 176 +::exit(___);} +#if 0 +# 174 +{ +# 175 +return (double)a; +# 176 +} +#endif +# 178 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline double uint2double(unsigned a, cudaRoundMode mode) +# 179 +{int volatile ___ = 1;(void)a;(void)mode; +# 181 +::exit(___);} +#if 0 +# 179 +{ +# 180 +return (double)a; +# 181 +} +#endif +# 183 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline double float2double(float a, cudaRoundMode mode) +# 184 +{int volatile ___ = 1;(void)a;(void)mode; +# 186 +::exit(___);} +#if 0 +# 184 +{ +# 185 +return (double)a; +# 186 +} +#endif +# 88 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_atomic_functions.h" +__attribute__((unused)) static inline float atomicAdd(float *address, float val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 88 +{ } +#endif +# 89 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +__attribute__((unused)) static inline long long atomicMin(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 89 +{ } +#endif +# 91 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +__attribute__((unused)) static inline long long atomicMax(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 91 +{ } +#endif +# 93 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +__attribute__((unused)) static inline long long atomicAnd(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 93 +{ } +#endif +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +__attribute__((unused)) static inline long long atomicOr(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 95 +{ } +#endif +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +__attribute__((unused)) static inline long long atomicXor(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 97 +{ } +#endif +# 99 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicMin(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 99 +{ } +#endif +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicMax(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 101 +{ } +#endif +# 103 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicAnd(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 103 +{ } +#endif +# 105 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicOr(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 105 +{ } +#endif +# 107 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicXor(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 107 +{ } +#endif +# 93 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline double atomicAdd(double *address, double val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 93 +{ } +#endif +# 96 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicAdd_block(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 96 +{ } +#endif +# 99 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicAdd_system(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 99 +{ } +#endif +# 102 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicAdd_block(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 102 +{ } +#endif +# 105 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicAdd_system(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 105 +{ } +#endif +# 108 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicAdd_block(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 108 +{ } +#endif +# 111 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicAdd_system(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 111 +{ } +#endif +# 114 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline float atomicAdd_block(float *address, float val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 114 +{ } +#endif +# 117 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline float atomicAdd_system(float *address, float val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 117 +{ } +#endif +# 120 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline double atomicAdd_block(double *address, double val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 120 +{ } +#endif +# 123 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline double atomicAdd_system(double *address, double val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 123 +{ } +#endif +# 126 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicSub_block(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 126 +{ } +#endif +# 129 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicSub_system(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 129 +{ } +#endif +# 132 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicSub_block(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 132 +{ } +#endif +# 135 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicSub_system(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 135 +{ } +#endif +# 138 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicExch_block(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 138 +{ } +#endif +# 141 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicExch_system(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 141 +{ } +#endif +# 144 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicExch_block(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 144 +{ } +#endif +# 147 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicExch_system(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 147 +{ } +#endif +# 150 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicExch_block(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 150 +{ } +#endif +# 153 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicExch_system(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 153 +{ } +#endif +# 156 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline float atomicExch_block(float *address, float val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 156 +{ } +#endif +# 159 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline float atomicExch_system(float *address, float val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 159 +{ } +#endif +# 162 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicMin_block(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 162 +{ } +#endif +# 165 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicMin_system(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 165 +{ } +#endif +# 168 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline long long atomicMin_block(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 168 +{ } +#endif +# 171 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline long long atomicMin_system(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 171 +{ } +#endif +# 174 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicMin_block(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 174 +{ } +#endif +# 177 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicMin_system(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 177 +{ } +#endif +# 180 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicMin_block(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 180 +{ } +#endif +# 183 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicMin_system(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 183 +{ } +#endif +# 186 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicMax_block(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 186 +{ } +#endif +# 189 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicMax_system(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 189 +{ } +#endif +# 192 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline long long atomicMax_block(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 192 +{ } +#endif +# 195 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline long long atomicMax_system(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 195 +{ } +#endif +# 198 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicMax_block(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 198 +{ } +#endif +# 201 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicMax_system(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 201 +{ } +#endif +# 204 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicMax_block(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 204 +{ } +#endif +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicMax_system(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 207 +{ } +#endif +# 210 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicInc_block(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 210 +{ } +#endif +# 213 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicInc_system(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 213 +{ } +#endif +# 216 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicDec_block(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 216 +{ } +#endif +# 219 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicDec_system(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 219 +{ } +#endif +# 222 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicCAS_block(int *address, int compare, int val) {int volatile ___ = 1;(void)address;(void)compare;(void)val;::exit(___);} +#if 0 +# 222 +{ } +#endif +# 225 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicCAS_system(int *address, int compare, int val) {int volatile ___ = 1;(void)address;(void)compare;(void)val;::exit(___);} +#if 0 +# 225 +{ } +#endif +# 228 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicCAS_block(unsigned *address, unsigned compare, unsigned +# 229 +val) {int volatile ___ = 1;(void)address;(void)compare;(void)val;::exit(___);} +#if 0 +# 229 +{ } +#endif +# 232 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicCAS_system(unsigned *address, unsigned compare, unsigned +# 233 +val) {int volatile ___ = 1;(void)address;(void)compare;(void)val;::exit(___);} +#if 0 +# 233 +{ } +#endif +# 236 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicCAS_block(unsigned long long *address, unsigned long long +# 237 +compare, unsigned long long +# 238 +val) {int volatile ___ = 1;(void)address;(void)compare;(void)val;::exit(___);} +#if 0 +# 238 +{ } +#endif +# 241 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicCAS_system(unsigned long long *address, unsigned long long +# 242 +compare, unsigned long long +# 243 +val) {int volatile ___ = 1;(void)address;(void)compare;(void)val;::exit(___);} +#if 0 +# 243 +{ } +#endif +# 246 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicAnd_block(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 246 +{ } +#endif +# 249 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicAnd_system(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 249 +{ } +#endif +# 252 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline long long atomicAnd_block(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 252 +{ } +#endif +# 255 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline long long atomicAnd_system(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 255 +{ } +#endif +# 258 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicAnd_block(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 258 +{ } +#endif +# 261 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicAnd_system(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 261 +{ } +#endif +# 264 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicAnd_block(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 264 +{ } +#endif +# 267 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicAnd_system(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 267 +{ } +#endif +# 270 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicOr_block(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 270 +{ } +#endif +# 273 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicOr_system(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 273 +{ } +#endif +# 276 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline long long atomicOr_block(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 276 +{ } +#endif +# 279 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline long long atomicOr_system(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 279 +{ } +#endif +# 282 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicOr_block(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 282 +{ } +#endif +# 285 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicOr_system(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 285 +{ } +#endif +# 288 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicOr_block(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 288 +{ } +#endif +# 291 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicOr_system(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 291 +{ } +#endif +# 294 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicXor_block(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 294 +{ } +#endif +# 297 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicXor_system(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 297 +{ } +#endif +# 300 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline long long atomicXor_block(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 300 +{ } +#endif +# 303 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline long long atomicXor_system(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 303 +{ } +#endif +# 306 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicXor_block(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 306 +{ } +#endif +# 309 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicXor_system(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 309 +{ } +#endif +# 312 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicXor_block(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 312 +{ } +#endif +# 315 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicXor_system(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 315 +{ } +#endif +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern "C" { +# 1038 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +} +# 1045 +__attribute((deprecated("__ballot() is deprecated in favor of __ballot_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to" " suppress this warning)."))) __attribute__((unused)) static inline unsigned ballot(bool pred) {int volatile ___ = 1;(void)pred;::exit(___);} +#if 0 +# 1045 +{ } +#endif +# 1047 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline int syncthreads_count(bool pred) {int volatile ___ = 1;(void)pred;::exit(___);} +#if 0 +# 1047 +{ } +#endif +# 1049 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline bool syncthreads_and(bool pred) {int volatile ___ = 1;(void)pred;::exit(___);} +#if 0 +# 1049 +{ } +#endif +# 1051 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline bool syncthreads_or(bool pred) {int volatile ___ = 1;(void)pred;::exit(___);} +#if 0 +# 1051 +{ } +#endif +# 1056 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline unsigned __isGlobal(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1056 +{ } +#endif +# 1057 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline unsigned __isShared(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1057 +{ } +#endif +# 1058 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline unsigned __isConstant(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1058 +{ } +#endif +# 1059 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline unsigned __isLocal(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1059 +{ } +#endif +# 1061 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline unsigned __isGridConstant(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1061 +{ } +#endif +# 1063 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline size_t __cvta_generic_to_global(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1063 +{ } +#endif +# 1064 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline size_t __cvta_generic_to_shared(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1064 +{ } +#endif +# 1065 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline size_t __cvta_generic_to_constant(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1065 +{ } +#endif +# 1066 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline size_t __cvta_generic_to_local(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1066 +{ } +#endif +# 1068 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline size_t __cvta_generic_to_grid_constant(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1068 +{ } +#endif +# 1071 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline void *__cvta_global_to_generic(size_t rawbits) {int volatile ___ = 1;(void)rawbits;::exit(___);} +#if 0 +# 1071 +{ } +#endif +# 1072 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline void *__cvta_shared_to_generic(size_t rawbits) {int volatile ___ = 1;(void)rawbits;::exit(___);} +#if 0 +# 1072 +{ } +#endif +# 1073 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline void *__cvta_constant_to_generic(size_t rawbits) {int volatile ___ = 1;(void)rawbits;::exit(___);} +#if 0 +# 1073 +{ } +#endif +# 1074 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline void *__cvta_local_to_generic(size_t rawbits) {int volatile ___ = 1;(void)rawbits;::exit(___);} +#if 0 +# 1074 +{ } +#endif +# 1076 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline void *__cvta_grid_constant_to_generic(size_t rawbits) {int volatile ___ = 1;(void)rawbits;::exit(___);} +#if 0 +# 1076 +{ } +#endif +# 1090 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +static inline unsigned short __nv_bswap16(unsigned short x) { +# 1092 +return __builtin_bswap16(x); +# 1098 +} +# 1109 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +static inline unsigned __nv_bswap32(unsigned x) { +# 1111 +return __builtin_bswap32(x); +# 1118 +} +# 1129 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +static inline unsigned long long __nv_bswap64(unsigned long long x) { +# 1131 +return __builtin_bswap64(x); +# 1138 +} +# 123 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned __fns(unsigned mask, unsigned base, int offset) {int volatile ___ = 1;(void)mask;(void)base;(void)offset;::exit(___);} +#if 0 +# 123 +{ } +#endif +# 124 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline void __barrier_sync(unsigned id) {int volatile ___ = 1;(void)id;::exit(___);} +#if 0 +# 124 +{ } +#endif +# 125 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline void __barrier_sync_count(unsigned id, unsigned cnt) {int volatile ___ = 1;(void)id;(void)cnt;::exit(___);} +#if 0 +# 125 +{ } +#endif +# 126 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline void __syncwarp(unsigned mask = 4294967295U) {int volatile ___ = 1;(void)mask;::exit(___);} +#if 0 +# 126 +{ } +#endif +# 127 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline int __all_sync(unsigned mask, int pred) {int volatile ___ = 1;(void)mask;(void)pred;::exit(___);} +#if 0 +# 127 +{ } +#endif +# 128 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline int __any_sync(unsigned mask, int pred) {int volatile ___ = 1;(void)mask;(void)pred;::exit(___);} +#if 0 +# 128 +{ } +#endif +# 129 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline int __uni_sync(unsigned mask, int pred) {int volatile ___ = 1;(void)mask;(void)pred;::exit(___);} +#if 0 +# 129 +{ } +#endif +# 130 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned __ballot_sync(unsigned mask, int pred) {int volatile ___ = 1;(void)mask;(void)pred;::exit(___);} +#if 0 +# 130 +{ } +#endif +# 131 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned __activemask() {int volatile ___ = 1;::exit(___);} +#if 0 +# 131 +{ } +#endif +# 140 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl() is deprecated in favor of __shfl_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to sup" "press this warning)."))) __attribute__((unused)) static inline int __shfl(int var, int srcLane, int width = 32) {int volatile ___ = 1;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 140 +{ } +#endif +# 141 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl() is deprecated in favor of __shfl_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to sup" "press this warning)."))) __attribute__((unused)) static inline unsigned __shfl(unsigned var, int srcLane, int width = 32) {int volatile ___ = 1;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 141 +{ } +#endif +# 142 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_up() is deprecated in favor of __shfl_up_sync() and may be removed in a future release (Use -Wno-deprecated-declarations " "to suppress this warning)."))) __attribute__((unused)) static inline int __shfl_up(int var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 142 +{ } +#endif +# 143 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_up() is deprecated in favor of __shfl_up_sync() and may be removed in a future release (Use -Wno-deprecated-declarations " "to suppress this warning)."))) __attribute__((unused)) static inline unsigned __shfl_up(unsigned var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 143 +{ } +#endif +# 144 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_down() is deprecated in favor of __shfl_down_sync() and may be removed in a future release (Use -Wno-deprecated-declarati" "ons to suppress this warning)."))) __attribute__((unused)) static inline int __shfl_down(int var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 144 +{ } +#endif +# 145 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_down() is deprecated in favor of __shfl_down_sync() and may be removed in a future release (Use -Wno-deprecated-declarati" "ons to suppress this warning)."))) __attribute__((unused)) static inline unsigned __shfl_down(unsigned var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 145 +{ } +#endif +# 146 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_xor() is deprecated in favor of __shfl_xor_sync() and may be removed in a future release (Use -Wno-deprecated-declaration" "s to suppress this warning)."))) __attribute__((unused)) static inline int __shfl_xor(int var, int laneMask, int width = 32) {int volatile ___ = 1;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 146 +{ } +#endif +# 147 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_xor() is deprecated in favor of __shfl_xor_sync() and may be removed in a future release (Use -Wno-deprecated-declaration" "s to suppress this warning)."))) __attribute__((unused)) static inline unsigned __shfl_xor(unsigned var, int laneMask, int width = 32) {int volatile ___ = 1;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 147 +{ } +#endif +# 148 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl() is deprecated in favor of __shfl_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to sup" "press this warning)."))) __attribute__((unused)) static inline float __shfl(float var, int srcLane, int width = 32) {int volatile ___ = 1;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 148 +{ } +#endif +# 149 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_up() is deprecated in favor of __shfl_up_sync() and may be removed in a future release (Use -Wno-deprecated-declarations " "to suppress this warning)."))) __attribute__((unused)) static inline float __shfl_up(float var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 149 +{ } +#endif +# 150 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_down() is deprecated in favor of __shfl_down_sync() and may be removed in a future release (Use -Wno-deprecated-declarati" "ons to suppress this warning)."))) __attribute__((unused)) static inline float __shfl_down(float var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 150 +{ } +#endif +# 151 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_xor() is deprecated in favor of __shfl_xor_sync() and may be removed in a future release (Use -Wno-deprecated-declaration" "s to suppress this warning)."))) __attribute__((unused)) static inline float __shfl_xor(float var, int laneMask, int width = 32) {int volatile ___ = 1;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 151 +{ } +#endif +# 154 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline int __shfl_sync(unsigned mask, int var, int srcLane, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 154 +{ } +#endif +# 155 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned __shfl_sync(unsigned mask, unsigned var, int srcLane, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 155 +{ } +#endif +# 156 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline int __shfl_up_sync(unsigned mask, int var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 156 +{ } +#endif +# 157 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned __shfl_up_sync(unsigned mask, unsigned var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 157 +{ } +#endif +# 158 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline int __shfl_down_sync(unsigned mask, int var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 158 +{ } +#endif +# 159 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned __shfl_down_sync(unsigned mask, unsigned var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 159 +{ } +#endif +# 160 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline int __shfl_xor_sync(unsigned mask, int var, int laneMask, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 160 +{ } +#endif +# 161 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned __shfl_xor_sync(unsigned mask, unsigned var, int laneMask, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 161 +{ } +#endif +# 162 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline float __shfl_sync(unsigned mask, float var, int srcLane, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 162 +{ } +#endif +# 163 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline float __shfl_up_sync(unsigned mask, float var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 163 +{ } +#endif +# 164 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline float __shfl_down_sync(unsigned mask, float var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 164 +{ } +#endif +# 165 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline float __shfl_xor_sync(unsigned mask, float var, int laneMask, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 165 +{ } +#endif +# 169 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl() is deprecated in favor of __shfl_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to sup" "press this warning)."))) __attribute__((unused)) static inline unsigned long long __shfl(unsigned long long var, int srcLane, int width = 32) {int volatile ___ = 1;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 169 +{ } +#endif +# 170 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl() is deprecated in favor of __shfl_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to sup" "press this warning)."))) __attribute__((unused)) static inline long long __shfl(long long var, int srcLane, int width = 32) {int volatile ___ = 1;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 170 +{ } +#endif +# 171 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_up() is deprecated in favor of __shfl_up_sync() and may be removed in a future release (Use -Wno-deprecated-declarations " "to suppress this warning)."))) __attribute__((unused)) static inline long long __shfl_up(long long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 171 +{ } +#endif +# 172 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_up() is deprecated in favor of __shfl_up_sync() and may be removed in a future release (Use -Wno-deprecated-declarations " "to suppress this warning)."))) __attribute__((unused)) static inline unsigned long long __shfl_up(unsigned long long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 172 +{ } +#endif +# 173 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_down() is deprecated in favor of __shfl_down_sync() and may be removed in a future release (Use -Wno-deprecated-declarati" "ons to suppress this warning)."))) __attribute__((unused)) static inline long long __shfl_down(long long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 173 +{ } +#endif +# 174 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_down() is deprecated in favor of __shfl_down_sync() and may be removed in a future release (Use -Wno-deprecated-declarati" "ons to suppress this warning)."))) __attribute__((unused)) static inline unsigned long long __shfl_down(unsigned long long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 174 +{ } +#endif +# 175 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_xor() is deprecated in favor of __shfl_xor_sync() and may be removed in a future release (Use -Wno-deprecated-declaration" "s to suppress this warning)."))) __attribute__((unused)) static inline long long __shfl_xor(long long var, int laneMask, int width = 32) {int volatile ___ = 1;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 175 +{ } +#endif +# 176 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_xor() is deprecated in favor of __shfl_xor_sync() and may be removed in a future release (Use -Wno-deprecated-declaration" "s to suppress this warning)."))) __attribute__((unused)) static inline unsigned long long __shfl_xor(unsigned long long var, int laneMask, int width = 32) {int volatile ___ = 1;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 176 +{ } +#endif +# 177 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl() is deprecated in favor of __shfl_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to sup" "press this warning)."))) __attribute__((unused)) static inline double __shfl(double var, int srcLane, int width = 32) {int volatile ___ = 1;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 177 +{ } +#endif +# 178 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_up() is deprecated in favor of __shfl_up_sync() and may be removed in a future release (Use -Wno-deprecated-declarations " "to suppress this warning)."))) __attribute__((unused)) static inline double __shfl_up(double var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 178 +{ } +#endif +# 179 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_down() is deprecated in favor of __shfl_down_sync() and may be removed in a future release (Use -Wno-deprecated-declarati" "ons to suppress this warning)."))) __attribute__((unused)) static inline double __shfl_down(double var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 179 +{ } +#endif +# 180 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_xor() is deprecated in favor of __shfl_xor_sync() and may be removed in a future release (Use -Wno-deprecated-declaration" "s to suppress this warning)."))) __attribute__((unused)) static inline double __shfl_xor(double var, int laneMask, int width = 32) {int volatile ___ = 1;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 180 +{ } +#endif +# 183 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline long long __shfl_sync(unsigned mask, long long var, int srcLane, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 183 +{ } +#endif +# 184 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned long long __shfl_sync(unsigned mask, unsigned long long var, int srcLane, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 184 +{ } +#endif +# 185 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline long long __shfl_up_sync(unsigned mask, long long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 185 +{ } +#endif +# 186 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned long long __shfl_up_sync(unsigned mask, unsigned long long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 186 +{ } +#endif +# 187 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline long long __shfl_down_sync(unsigned mask, long long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 187 +{ } +#endif +# 188 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned long long __shfl_down_sync(unsigned mask, unsigned long long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 188 +{ } +#endif +# 189 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline long long __shfl_xor_sync(unsigned mask, long long var, int laneMask, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 189 +{ } +#endif +# 190 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned long long __shfl_xor_sync(unsigned mask, unsigned long long var, int laneMask, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 190 +{ } +#endif +# 191 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline double __shfl_sync(unsigned mask, double var, int srcLane, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 191 +{ } +#endif +# 192 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline double __shfl_up_sync(unsigned mask, double var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 192 +{ } +#endif +# 193 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline double __shfl_down_sync(unsigned mask, double var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 193 +{ } +#endif +# 194 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline double __shfl_xor_sync(unsigned mask, double var, int laneMask, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 194 +{ } +#endif +# 198 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl() is deprecated in favor of __shfl_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to sup" "press this warning)."))) __attribute__((unused)) static inline long __shfl(long var, int srcLane, int width = 32) {int volatile ___ = 1;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 198 +{ } +#endif +# 199 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl() is deprecated in favor of __shfl_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to sup" "press this warning)."))) __attribute__((unused)) static inline unsigned long __shfl(unsigned long var, int srcLane, int width = 32) {int volatile ___ = 1;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 199 +{ } +#endif +# 200 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_up() is deprecated in favor of __shfl_up_sync() and may be removed in a future release (Use -Wno-deprecated-declarations " "to suppress this warning)."))) __attribute__((unused)) static inline long __shfl_up(long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 200 +{ } +#endif +# 201 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_up() is deprecated in favor of __shfl_up_sync() and may be removed in a future release (Use -Wno-deprecated-declarations " "to suppress this warning)."))) __attribute__((unused)) static inline unsigned long __shfl_up(unsigned long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 201 +{ } +#endif +# 202 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_down() is deprecated in favor of __shfl_down_sync() and may be removed in a future release (Use -Wno-deprecated-declarati" "ons to suppress this warning)."))) __attribute__((unused)) static inline long __shfl_down(long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 202 +{ } +#endif +# 203 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_down() is deprecated in favor of __shfl_down_sync() and may be removed in a future release (Use -Wno-deprecated-declarati" "ons to suppress this warning)."))) __attribute__((unused)) static inline unsigned long __shfl_down(unsigned long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 203 +{ } +#endif +# 204 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_xor() is deprecated in favor of __shfl_xor_sync() and may be removed in a future release (Use -Wno-deprecated-declaration" "s to suppress this warning)."))) __attribute__((unused)) static inline long __shfl_xor(long var, int laneMask, int width = 32) {int volatile ___ = 1;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 204 +{ } +#endif +# 205 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_xor() is deprecated in favor of __shfl_xor_sync() and may be removed in a future release (Use -Wno-deprecated-declaration" "s to suppress this warning)."))) __attribute__((unused)) static inline unsigned long __shfl_xor(unsigned long var, int laneMask, int width = 32) {int volatile ___ = 1;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 205 +{ } +#endif +# 208 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline long __shfl_sync(unsigned mask, long var, int srcLane, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 208 +{ } +#endif +# 209 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned long __shfl_sync(unsigned mask, unsigned long var, int srcLane, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 209 +{ } +#endif +# 210 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline long __shfl_up_sync(unsigned mask, long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 210 +{ } +#endif +# 211 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned long __shfl_up_sync(unsigned mask, unsigned long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 211 +{ } +#endif +# 212 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline long __shfl_down_sync(unsigned mask, long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 212 +{ } +#endif +# 213 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned long __shfl_down_sync(unsigned mask, unsigned long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 213 +{ } +#endif +# 214 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline long __shfl_xor_sync(unsigned mask, long var, int laneMask, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 214 +{ } +#endif +# 215 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned long __shfl_xor_sync(unsigned mask, unsigned long var, int laneMask, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 215 +{ } +#endif +# 91 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long __ldg(const long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 91 +{ } +#endif +# 92 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long __ldg(const unsigned long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 92 +{ } +#endif +# 94 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char __ldg(const char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 94 +{ } +#endif +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline signed char __ldg(const signed char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 95 +{ } +#endif +# 96 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short __ldg(const short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 96 +{ } +#endif +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int __ldg(const int *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 97 +{ } +#endif +# 98 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long long __ldg(const long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 98 +{ } +#endif +# 99 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char2 __ldg(const char2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 99 +{ } +#endif +# 100 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char4 __ldg(const char4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 100 +{ } +#endif +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short2 __ldg(const short2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 101 +{ } +#endif +# 102 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short4 __ldg(const short4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 102 +{ } +#endif +# 103 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int2 __ldg(const int2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 103 +{ } +#endif +# 104 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int4 __ldg(const int4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 104 +{ } +#endif +# 105 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline longlong2 __ldg(const longlong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 105 +{ } +#endif +# 107 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned char __ldg(const unsigned char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 107 +{ } +#endif +# 108 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned short __ldg(const unsigned short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 108 +{ } +#endif +# 109 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned __ldg(const unsigned *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 109 +{ } +#endif +# 110 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long long __ldg(const unsigned long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 110 +{ } +#endif +# 111 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar2 __ldg(const uchar2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 111 +{ } +#endif +# 112 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar4 __ldg(const uchar4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 112 +{ } +#endif +# 113 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort2 __ldg(const ushort2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 113 +{ } +#endif +# 114 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort4 __ldg(const ushort4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 114 +{ } +#endif +# 115 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint2 __ldg(const uint2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 115 +{ } +#endif +# 116 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint4 __ldg(const uint4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 116 +{ } +#endif +# 117 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ulonglong2 __ldg(const ulonglong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 117 +{ } +#endif +# 119 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float __ldg(const float *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 119 +{ } +#endif +# 120 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double __ldg(const double *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 120 +{ } +#endif +# 121 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float2 __ldg(const float2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 121 +{ } +#endif +# 122 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float4 __ldg(const float4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 122 +{ } +#endif +# 123 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double2 __ldg(const double2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 123 +{ } +#endif +# 128 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long __ldcg(const long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 128 +{ } +#endif +# 129 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long __ldcg(const unsigned long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 129 +{ } +#endif +# 131 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char __ldcg(const char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 131 +{ } +#endif +# 132 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline signed char __ldcg(const signed char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 132 +{ } +#endif +# 133 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short __ldcg(const short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 133 +{ } +#endif +# 134 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int __ldcg(const int *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 134 +{ } +#endif +# 135 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long long __ldcg(const long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 135 +{ } +#endif +# 136 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char2 __ldcg(const char2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 136 +{ } +#endif +# 137 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char4 __ldcg(const char4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 137 +{ } +#endif +# 138 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short2 __ldcg(const short2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 138 +{ } +#endif +# 139 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short4 __ldcg(const short4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 139 +{ } +#endif +# 140 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int2 __ldcg(const int2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 140 +{ } +#endif +# 141 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int4 __ldcg(const int4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 141 +{ } +#endif +# 142 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline longlong2 __ldcg(const longlong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 142 +{ } +#endif +# 144 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned char __ldcg(const unsigned char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 144 +{ } +#endif +# 145 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned short __ldcg(const unsigned short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 145 +{ } +#endif +# 146 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned __ldcg(const unsigned *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 146 +{ } +#endif +# 147 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long long __ldcg(const unsigned long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 147 +{ } +#endif +# 148 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar2 __ldcg(const uchar2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 148 +{ } +#endif +# 149 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar4 __ldcg(const uchar4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 149 +{ } +#endif +# 150 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort2 __ldcg(const ushort2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 150 +{ } +#endif +# 151 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort4 __ldcg(const ushort4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 151 +{ } +#endif +# 152 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint2 __ldcg(const uint2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 152 +{ } +#endif +# 153 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint4 __ldcg(const uint4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 153 +{ } +#endif +# 154 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ulonglong2 __ldcg(const ulonglong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 154 +{ } +#endif +# 156 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float __ldcg(const float *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 156 +{ } +#endif +# 157 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double __ldcg(const double *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 157 +{ } +#endif +# 158 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float2 __ldcg(const float2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 158 +{ } +#endif +# 159 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float4 __ldcg(const float4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 159 +{ } +#endif +# 160 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double2 __ldcg(const double2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 160 +{ } +#endif +# 164 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long __ldca(const long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 164 +{ } +#endif +# 165 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long __ldca(const unsigned long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 165 +{ } +#endif +# 167 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char __ldca(const char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 167 +{ } +#endif +# 168 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline signed char __ldca(const signed char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 168 +{ } +#endif +# 169 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short __ldca(const short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 169 +{ } +#endif +# 170 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int __ldca(const int *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 170 +{ } +#endif +# 171 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long long __ldca(const long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 171 +{ } +#endif +# 172 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char2 __ldca(const char2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 172 +{ } +#endif +# 173 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char4 __ldca(const char4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 173 +{ } +#endif +# 174 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short2 __ldca(const short2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 174 +{ } +#endif +# 175 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short4 __ldca(const short4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 175 +{ } +#endif +# 176 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int2 __ldca(const int2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 176 +{ } +#endif +# 177 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int4 __ldca(const int4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 177 +{ } +#endif +# 178 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline longlong2 __ldca(const longlong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 178 +{ } +#endif +# 180 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned char __ldca(const unsigned char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 180 +{ } +#endif +# 181 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned short __ldca(const unsigned short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 181 +{ } +#endif +# 182 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned __ldca(const unsigned *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 182 +{ } +#endif +# 183 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long long __ldca(const unsigned long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 183 +{ } +#endif +# 184 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar2 __ldca(const uchar2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 184 +{ } +#endif +# 185 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar4 __ldca(const uchar4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 185 +{ } +#endif +# 186 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort2 __ldca(const ushort2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 186 +{ } +#endif +# 187 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort4 __ldca(const ushort4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 187 +{ } +#endif +# 188 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint2 __ldca(const uint2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 188 +{ } +#endif +# 189 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint4 __ldca(const uint4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 189 +{ } +#endif +# 190 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ulonglong2 __ldca(const ulonglong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 190 +{ } +#endif +# 192 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float __ldca(const float *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 192 +{ } +#endif +# 193 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double __ldca(const double *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 193 +{ } +#endif +# 194 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float2 __ldca(const float2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 194 +{ } +#endif +# 195 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float4 __ldca(const float4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 195 +{ } +#endif +# 196 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double2 __ldca(const double2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 196 +{ } +#endif +# 200 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long __ldcs(const long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 200 +{ } +#endif +# 201 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long __ldcs(const unsigned long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 201 +{ } +#endif +# 203 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char __ldcs(const char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 203 +{ } +#endif +# 204 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline signed char __ldcs(const signed char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 204 +{ } +#endif +# 205 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short __ldcs(const short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 205 +{ } +#endif +# 206 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int __ldcs(const int *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 206 +{ } +#endif +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long long __ldcs(const long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 207 +{ } +#endif +# 208 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char2 __ldcs(const char2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 208 +{ } +#endif +# 209 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char4 __ldcs(const char4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 209 +{ } +#endif +# 210 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short2 __ldcs(const short2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 210 +{ } +#endif +# 211 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short4 __ldcs(const short4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 211 +{ } +#endif +# 212 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int2 __ldcs(const int2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 212 +{ } +#endif +# 213 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int4 __ldcs(const int4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 213 +{ } +#endif +# 214 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline longlong2 __ldcs(const longlong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 214 +{ } +#endif +# 216 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned char __ldcs(const unsigned char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 216 +{ } +#endif +# 217 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned short __ldcs(const unsigned short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 217 +{ } +#endif +# 218 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned __ldcs(const unsigned *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 218 +{ } +#endif +# 219 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long long __ldcs(const unsigned long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 219 +{ } +#endif +# 220 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar2 __ldcs(const uchar2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 220 +{ } +#endif +# 221 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar4 __ldcs(const uchar4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 221 +{ } +#endif +# 222 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort2 __ldcs(const ushort2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 222 +{ } +#endif +# 223 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort4 __ldcs(const ushort4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 223 +{ } +#endif +# 224 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint2 __ldcs(const uint2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 224 +{ } +#endif +# 225 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint4 __ldcs(const uint4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 225 +{ } +#endif +# 226 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ulonglong2 __ldcs(const ulonglong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 226 +{ } +#endif +# 228 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float __ldcs(const float *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 228 +{ } +#endif +# 229 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double __ldcs(const double *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 229 +{ } +#endif +# 230 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float2 __ldcs(const float2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 230 +{ } +#endif +# 231 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float4 __ldcs(const float4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 231 +{ } +#endif +# 232 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double2 __ldcs(const double2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 232 +{ } +#endif +# 236 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long __ldlu(const long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 236 +{ } +#endif +# 237 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long __ldlu(const unsigned long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 237 +{ } +#endif +# 239 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char __ldlu(const char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 239 +{ } +#endif +# 240 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline signed char __ldlu(const signed char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 240 +{ } +#endif +# 241 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short __ldlu(const short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 241 +{ } +#endif +# 242 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int __ldlu(const int *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 242 +{ } +#endif +# 243 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long long __ldlu(const long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 243 +{ } +#endif +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char2 __ldlu(const char2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 244 +{ } +#endif +# 245 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char4 __ldlu(const char4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 245 +{ } +#endif +# 246 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short2 __ldlu(const short2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 246 +{ } +#endif +# 247 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short4 __ldlu(const short4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 247 +{ } +#endif +# 248 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int2 __ldlu(const int2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 248 +{ } +#endif +# 249 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int4 __ldlu(const int4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 249 +{ } +#endif +# 250 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline longlong2 __ldlu(const longlong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 250 +{ } +#endif +# 252 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned char __ldlu(const unsigned char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 252 +{ } +#endif +# 253 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned short __ldlu(const unsigned short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 253 +{ } +#endif +# 254 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned __ldlu(const unsigned *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 254 +{ } +#endif +# 255 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long long __ldlu(const unsigned long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 255 +{ } +#endif +# 256 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar2 __ldlu(const uchar2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 256 +{ } +#endif +# 257 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar4 __ldlu(const uchar4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 257 +{ } +#endif +# 258 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort2 __ldlu(const ushort2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 258 +{ } +#endif +# 259 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort4 __ldlu(const ushort4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 259 +{ } +#endif +# 260 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint2 __ldlu(const uint2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 260 +{ } +#endif +# 261 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint4 __ldlu(const uint4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 261 +{ } +#endif +# 262 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ulonglong2 __ldlu(const ulonglong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 262 +{ } +#endif +# 264 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float __ldlu(const float *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 264 +{ } +#endif +# 265 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double __ldlu(const double *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 265 +{ } +#endif +# 266 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float2 __ldlu(const float2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 266 +{ } +#endif +# 267 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float4 __ldlu(const float4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 267 +{ } +#endif +# 268 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double2 __ldlu(const double2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 268 +{ } +#endif +# 272 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long __ldcv(const long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 272 +{ } +#endif +# 273 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long __ldcv(const unsigned long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 273 +{ } +#endif +# 275 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char __ldcv(const char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 275 +{ } +#endif +# 276 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline signed char __ldcv(const signed char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 276 +{ } +#endif +# 277 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short __ldcv(const short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 277 +{ } +#endif +# 278 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int __ldcv(const int *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 278 +{ } +#endif +# 279 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long long __ldcv(const long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 279 +{ } +#endif +# 280 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char2 __ldcv(const char2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 280 +{ } +#endif +# 281 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char4 __ldcv(const char4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 281 +{ } +#endif +# 282 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short2 __ldcv(const short2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 282 +{ } +#endif +# 283 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short4 __ldcv(const short4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 283 +{ } +#endif +# 284 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int2 __ldcv(const int2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 284 +{ } +#endif +# 285 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int4 __ldcv(const int4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 285 +{ } +#endif +# 286 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline longlong2 __ldcv(const longlong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 286 +{ } +#endif +# 288 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned char __ldcv(const unsigned char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 288 +{ } +#endif +# 289 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned short __ldcv(const unsigned short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 289 +{ } +#endif +# 290 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned __ldcv(const unsigned *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 290 +{ } +#endif +# 291 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long long __ldcv(const unsigned long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 291 +{ } +#endif +# 292 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar2 __ldcv(const uchar2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 292 +{ } +#endif +# 293 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar4 __ldcv(const uchar4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 293 +{ } +#endif +# 294 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort2 __ldcv(const ushort2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 294 +{ } +#endif +# 295 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort4 __ldcv(const ushort4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 295 +{ } +#endif +# 296 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint2 __ldcv(const uint2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 296 +{ } +#endif +# 297 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint4 __ldcv(const uint4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 297 +{ } +#endif +# 298 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ulonglong2 __ldcv(const ulonglong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 298 +{ } +#endif +# 300 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float __ldcv(const float *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 300 +{ } +#endif +# 301 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double __ldcv(const double *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 301 +{ } +#endif +# 302 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float2 __ldcv(const float2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 302 +{ } +#endif +# 303 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float4 __ldcv(const float4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 303 +{ } +#endif +# 304 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double2 __ldcv(const double2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 304 +{ } +#endif +# 308 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(long *ptr, long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 308 +{ } +#endif +# 309 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(unsigned long *ptr, unsigned long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 309 +{ } +#endif +# 311 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(char *ptr, char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 311 +{ } +#endif +# 312 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(signed char *ptr, signed char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 312 +{ } +#endif +# 313 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(short *ptr, short value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 313 +{ } +#endif +# 314 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(int *ptr, int value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 314 +{ } +#endif +# 315 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(long long *ptr, long long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 315 +{ } +#endif +# 316 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(char2 *ptr, char2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 316 +{ } +#endif +# 317 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(char4 *ptr, char4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 317 +{ } +#endif +# 318 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(short2 *ptr, short2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 318 +{ } +#endif +# 319 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(short4 *ptr, short4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 319 +{ } +#endif +# 320 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(int2 *ptr, int2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 320 +{ } +#endif +# 321 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(int4 *ptr, int4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 321 +{ } +#endif +# 322 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(longlong2 *ptr, longlong2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 322 +{ } +#endif +# 324 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(unsigned char *ptr, unsigned char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 324 +{ } +#endif +# 325 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(unsigned short *ptr, unsigned short value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 325 +{ } +#endif +# 326 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(unsigned *ptr, unsigned value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 326 +{ } +#endif +# 327 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(unsigned long long *ptr, unsigned long long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 327 +{ } +#endif +# 328 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(uchar2 *ptr, uchar2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 328 +{ } +#endif +# 329 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(uchar4 *ptr, uchar4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 329 +{ } +#endif +# 330 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(ushort2 *ptr, ushort2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 330 +{ } +#endif +# 331 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(ushort4 *ptr, ushort4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 331 +{ } +#endif +# 332 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(uint2 *ptr, uint2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 332 +{ } +#endif +# 333 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(uint4 *ptr, uint4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 333 +{ } +#endif +# 334 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(ulonglong2 *ptr, ulonglong2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 334 +{ } +#endif +# 336 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(float *ptr, float value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 336 +{ } +#endif +# 337 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(double *ptr, double value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 337 +{ } +#endif +# 338 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(float2 *ptr, float2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 338 +{ } +#endif +# 339 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(float4 *ptr, float4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 339 +{ } +#endif +# 340 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(double2 *ptr, double2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 340 +{ } +#endif +# 344 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(long *ptr, long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 344 +{ } +#endif +# 345 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(unsigned long *ptr, unsigned long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 345 +{ } +#endif +# 347 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(char *ptr, char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 347 +{ } +#endif +# 348 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(signed char *ptr, signed char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 348 +{ } +#endif +# 349 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(short *ptr, short value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 349 +{ } +#endif +# 350 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(int *ptr, int value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 350 +{ } +#endif +# 351 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(long long *ptr, long long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 351 +{ } +#endif +# 352 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(char2 *ptr, char2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 352 +{ } +#endif +# 353 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(char4 *ptr, char4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 353 +{ } +#endif +# 354 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(short2 *ptr, short2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 354 +{ } +#endif +# 355 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(short4 *ptr, short4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 355 +{ } +#endif +# 356 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(int2 *ptr, int2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 356 +{ } +#endif +# 357 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(int4 *ptr, int4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 357 +{ } +#endif +# 358 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(longlong2 *ptr, longlong2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 358 +{ } +#endif +# 360 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(unsigned char *ptr, unsigned char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 360 +{ } +#endif +# 361 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(unsigned short *ptr, unsigned short value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 361 +{ } +#endif +# 362 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(unsigned *ptr, unsigned value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 362 +{ } +#endif +# 363 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(unsigned long long *ptr, unsigned long long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 363 +{ } +#endif +# 364 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(uchar2 *ptr, uchar2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 364 +{ } +#endif +# 365 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(uchar4 *ptr, uchar4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 365 +{ } +#endif +# 366 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(ushort2 *ptr, ushort2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 366 +{ } +#endif +# 367 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(ushort4 *ptr, ushort4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 367 +{ } +#endif +# 368 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(uint2 *ptr, uint2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 368 +{ } +#endif +# 369 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(uint4 *ptr, uint4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 369 +{ } +#endif +# 370 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(ulonglong2 *ptr, ulonglong2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 370 +{ } +#endif +# 372 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(float *ptr, float value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 372 +{ } +#endif +# 373 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(double *ptr, double value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 373 +{ } +#endif +# 374 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(float2 *ptr, float2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 374 +{ } +#endif +# 375 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(float4 *ptr, float4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 375 +{ } +#endif +# 376 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(double2 *ptr, double2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 376 +{ } +#endif +# 380 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(long *ptr, long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 380 +{ } +#endif +# 381 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(unsigned long *ptr, unsigned long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 381 +{ } +#endif +# 383 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(char *ptr, char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 383 +{ } +#endif +# 384 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(signed char *ptr, signed char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 384 +{ } +#endif +# 385 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(short *ptr, short value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 385 +{ } +#endif +# 386 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(int *ptr, int value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 386 +{ } +#endif +# 387 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(long long *ptr, long long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 387 +{ } +#endif +# 388 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(char2 *ptr, char2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 388 +{ } +#endif +# 389 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(char4 *ptr, char4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 389 +{ } +#endif +# 390 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(short2 *ptr, short2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 390 +{ } +#endif +# 391 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(short4 *ptr, short4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 391 +{ } +#endif +# 392 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(int2 *ptr, int2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 392 +{ } +#endif +# 393 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(int4 *ptr, int4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 393 +{ } +#endif +# 394 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(longlong2 *ptr, longlong2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 394 +{ } +#endif +# 396 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(unsigned char *ptr, unsigned char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 396 +{ } +#endif +# 397 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(unsigned short *ptr, unsigned short value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 397 +{ } +#endif +# 398 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(unsigned *ptr, unsigned value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 398 +{ } +#endif +# 399 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(unsigned long long *ptr, unsigned long long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 399 +{ } +#endif +# 400 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(uchar2 *ptr, uchar2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 400 +{ } +#endif +# 401 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(uchar4 *ptr, uchar4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 401 +{ } +#endif +# 402 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(ushort2 *ptr, ushort2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 402 +{ } +#endif +# 403 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(ushort4 *ptr, ushort4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 403 +{ } +#endif +# 404 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(uint2 *ptr, uint2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 404 +{ } +#endif +# 405 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(uint4 *ptr, uint4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 405 +{ } +#endif +# 406 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(ulonglong2 *ptr, ulonglong2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 406 +{ } +#endif +# 408 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(float *ptr, float value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 408 +{ } +#endif +# 409 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(double *ptr, double value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 409 +{ } +#endif +# 410 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(float2 *ptr, float2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 410 +{ } +#endif +# 411 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(float4 *ptr, float4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 411 +{ } +#endif +# 412 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(double2 *ptr, double2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 412 +{ } +#endif +# 416 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(long *ptr, long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 416 +{ } +#endif +# 417 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(unsigned long *ptr, unsigned long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 417 +{ } +#endif +# 419 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(char *ptr, char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 419 +{ } +#endif +# 420 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(signed char *ptr, signed char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 420 +{ } +#endif +# 421 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(short *ptr, short value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 421 +{ } +#endif +# 422 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(int *ptr, int value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 422 +{ } +#endif +# 423 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(long long *ptr, long long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 423 +{ } +#endif +# 424 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(char2 *ptr, char2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 424 +{ } +#endif +# 425 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(char4 *ptr, char4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 425 +{ } +#endif +# 426 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(short2 *ptr, short2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 426 +{ } +#endif +# 427 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(short4 *ptr, short4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 427 +{ } +#endif +# 428 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(int2 *ptr, int2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 428 +{ } +#endif +# 429 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(int4 *ptr, int4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 429 +{ } +#endif +# 430 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(longlong2 *ptr, longlong2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 430 +{ } +#endif +# 432 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(unsigned char *ptr, unsigned char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 432 +{ } +#endif +# 433 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(unsigned short *ptr, unsigned short value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 433 +{ } +#endif +# 434 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(unsigned *ptr, unsigned value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 434 +{ } +#endif +# 435 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(unsigned long long *ptr, unsigned long long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 435 +{ } +#endif +# 436 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(uchar2 *ptr, uchar2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 436 +{ } +#endif +# 437 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(uchar4 *ptr, uchar4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 437 +{ } +#endif +# 438 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(ushort2 *ptr, ushort2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 438 +{ } +#endif +# 439 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(ushort4 *ptr, ushort4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 439 +{ } +#endif +# 440 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(uint2 *ptr, uint2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 440 +{ } +#endif +# 441 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(uint4 *ptr, uint4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 441 +{ } +#endif +# 442 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(ulonglong2 *ptr, ulonglong2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 442 +{ } +#endif +# 444 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(float *ptr, float value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 444 +{ } +#endif +# 445 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(double *ptr, double value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 445 +{ } +#endif +# 446 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(float2 *ptr, float2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 446 +{ } +#endif +# 447 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(float4 *ptr, float4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 447 +{ } +#endif +# 448 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(double2 *ptr, double2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 448 +{ } +#endif +# 465 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned __funnelshift_l(unsigned lo, unsigned hi, unsigned shift) {int volatile ___ = 1;(void)lo;(void)hi;(void)shift;::exit(___);} +#if 0 +# 465 +{ } +#endif +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned __funnelshift_lc(unsigned lo, unsigned hi, unsigned shift) {int volatile ___ = 1;(void)lo;(void)hi;(void)shift;::exit(___);} +#if 0 +# 477 +{ } +#endif +# 490 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned __funnelshift_r(unsigned lo, unsigned hi, unsigned shift) {int volatile ___ = 1;(void)lo;(void)hi;(void)shift;::exit(___);} +#if 0 +# 490 +{ } +#endif +# 502 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned __funnelshift_rc(unsigned lo, unsigned hi, unsigned shift) {int volatile ___ = 1;(void)lo;(void)hi;(void)shift;::exit(___);} +#if 0 +# 502 +{ } +#endif +# 102 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline int __dp2a_lo(int srcA, int srcB, int c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 102 +{ } +#endif +# 113 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline unsigned __dp2a_lo(unsigned srcA, unsigned srcB, unsigned c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 113 +{ } +#endif +# 125 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline int __dp2a_lo(short2 srcA, char4 srcB, int c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 125 +{ } +#endif +# 136 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline unsigned __dp2a_lo(ushort2 srcA, uchar4 srcB, unsigned c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 136 +{ } +#endif +# 148 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline int __dp2a_hi(int srcA, int srcB, int c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 148 +{ } +#endif +# 159 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline unsigned __dp2a_hi(unsigned srcA, unsigned srcB, unsigned c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 159 +{ } +#endif +# 171 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline int __dp2a_hi(short2 srcA, char4 srcB, int c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 171 +{ } +#endif +# 182 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline unsigned __dp2a_hi(ushort2 srcA, uchar4 srcB, unsigned c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 182 +{ } +#endif +# 197 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline int __dp4a(int srcA, int srcB, int c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 197 +{ } +#endif +# 206 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline unsigned __dp4a(unsigned srcA, unsigned srcB, unsigned c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 206 +{ } +#endif +# 216 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline int __dp4a(char4 srcA, char4 srcB, int c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 216 +{ } +#endif +# 225 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline unsigned __dp4a(uchar4 srcA, uchar4 srcB, unsigned c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 225 +{ } +#endif +# 98 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_any_sync(unsigned mask, unsigned value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 98 +{ } +#endif +# 99 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_any_sync(unsigned mask, int value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 99 +{ } +#endif +# 100 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_any_sync(unsigned mask, unsigned long value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 100 +{ } +#endif +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_any_sync(unsigned mask, long value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 101 +{ } +#endif +# 102 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_any_sync(unsigned mask, unsigned long long value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 102 +{ } +#endif +# 103 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_any_sync(unsigned mask, long long value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 103 +{ } +#endif +# 104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_any_sync(unsigned mask, float value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 104 +{ } +#endif +# 105 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_any_sync(unsigned mask, double value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 105 +{ } +#endif +# 107 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_all_sync(unsigned mask, unsigned value, int *pred) {int volatile ___ = 1;(void)mask;(void)value;(void)pred;::exit(___);} +#if 0 +# 107 +{ } +#endif +# 108 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_all_sync(unsigned mask, int value, int *pred) {int volatile ___ = 1;(void)mask;(void)value;(void)pred;::exit(___);} +#if 0 +# 108 +{ } +#endif +# 109 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_all_sync(unsigned mask, unsigned long value, int *pred) {int volatile ___ = 1;(void)mask;(void)value;(void)pred;::exit(___);} +#if 0 +# 109 +{ } +#endif +# 110 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_all_sync(unsigned mask, long value, int *pred) {int volatile ___ = 1;(void)mask;(void)value;(void)pred;::exit(___);} +#if 0 +# 110 +{ } +#endif +# 111 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_all_sync(unsigned mask, unsigned long long value, int *pred) {int volatile ___ = 1;(void)mask;(void)value;(void)pred;::exit(___);} +#if 0 +# 111 +{ } +#endif +# 112 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_all_sync(unsigned mask, long long value, int *pred) {int volatile ___ = 1;(void)mask;(void)value;(void)pred;::exit(___);} +#if 0 +# 112 +{ } +#endif +# 113 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_all_sync(unsigned mask, float value, int *pred) {int volatile ___ = 1;(void)mask;(void)value;(void)pred;::exit(___);} +#if 0 +# 113 +{ } +#endif +# 114 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_all_sync(unsigned mask, double value, int *pred) {int volatile ___ = 1;(void)mask;(void)value;(void)pred;::exit(___);} +#if 0 +# 114 +{ } +#endif +# 116 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline void __nanosleep(unsigned ns) {int volatile ___ = 1;(void)ns;::exit(___);} +#if 0 +# 116 +{ } +#endif +# 118 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned short atomicCAS(unsigned short *address, unsigned short compare, unsigned short val) {int volatile ___ = 1;(void)address;(void)compare;(void)val;::exit(___);} +#if 0 +# 118 +{ } +#endif +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) static inline unsigned __reduce_add_sync(unsigned mask, unsigned value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 97 +{ } +#endif +# 98 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) static inline unsigned __reduce_min_sync(unsigned mask, unsigned value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 98 +{ } +#endif +# 99 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) static inline unsigned __reduce_max_sync(unsigned mask, unsigned value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 99 +{ } +#endif +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) static inline int __reduce_add_sync(unsigned mask, int value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 101 +{ } +#endif +# 102 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) static inline int __reduce_min_sync(unsigned mask, int value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 102 +{ } +#endif +# 103 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) static inline int __reduce_max_sync(unsigned mask, int value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 103 +{ } +#endif +# 105 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) static inline unsigned __reduce_and_sync(unsigned mask, unsigned value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 105 +{ } +#endif +# 106 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) static inline unsigned __reduce_or_sync(unsigned mask, unsigned value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 106 +{ } +#endif +# 107 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) static inline unsigned __reduce_xor_sync(unsigned mask, unsigned value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 107 +{ } +#endif +# 112 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +extern "C" { +# 113 +__attribute__((unused)) inline void *__nv_associate_access_property(const void *ptr, unsigned long long +# 114 +property) {int volatile ___ = 1;(void)ptr;(void)property; +# 118 +::exit(___);} +#if 0 +# 114 +{ +# 115 +__attribute__((unused)) extern void *__nv_associate_access_property_impl(const void *, unsigned long long); +# 117 +return __nv_associate_access_property_impl(ptr, property); +# 118 +} +#endif +# 120 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) inline void __nv_memcpy_async_shared_global_4(void *dst, const void * +# 121 +src, unsigned +# 122 +src_size) {int volatile ___ = 1;(void)dst;(void)src;(void)src_size; +# 127 +::exit(___);} +#if 0 +# 122 +{ +# 123 +__attribute__((unused)) extern void __nv_memcpy_async_shared_global_4_impl(void *, const void *, unsigned); +# 126 +__nv_memcpy_async_shared_global_4_impl(dst, src, src_size); +# 127 +} +#endif +# 129 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) inline void __nv_memcpy_async_shared_global_8(void *dst, const void * +# 130 +src, unsigned +# 131 +src_size) {int volatile ___ = 1;(void)dst;(void)src;(void)src_size; +# 136 +::exit(___);} +#if 0 +# 131 +{ +# 132 +__attribute__((unused)) extern void __nv_memcpy_async_shared_global_8_impl(void *, const void *, unsigned); +# 135 +__nv_memcpy_async_shared_global_8_impl(dst, src, src_size); +# 136 +} +#endif +# 138 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) inline void __nv_memcpy_async_shared_global_16(void *dst, const void * +# 139 +src, unsigned +# 140 +src_size) {int volatile ___ = 1;(void)dst;(void)src;(void)src_size; +# 145 +::exit(___);} +#if 0 +# 140 +{ +# 141 +__attribute__((unused)) extern void __nv_memcpy_async_shared_global_16_impl(void *, const void *, unsigned); +# 144 +__nv_memcpy_async_shared_global_16_impl(dst, src, src_size); +# 145 +} +#endif +# 147 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +} +# 92 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline unsigned __isCtaShared(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 92 +{ } +#endif +# 93 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline unsigned __isClusterShared(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 93 +{ } +#endif +# 94 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline void *__cluster_map_shared_rank(const void *ptr, unsigned target_block_rank) {int volatile ___ = 1;(void)ptr;(void)target_block_rank;::exit(___);} +#if 0 +# 94 +{ } +#endif +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline unsigned __cluster_query_shared_rank(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 95 +{ } +#endif +# 96 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline uint2 __cluster_map_shared_multicast(const void *ptr, unsigned cluster_cta_mask) {int volatile ___ = 1;(void)ptr;(void)cluster_cta_mask;::exit(___);} +#if 0 +# 96 +{ } +#endif +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline unsigned __clusterDimIsSpecified() {int volatile ___ = 1;::exit(___);} +#if 0 +# 97 +{ } +#endif +# 98 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline dim3 __clusterDim() {int volatile ___ = 1;::exit(___);} +#if 0 +# 98 +{ } +#endif +# 99 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline dim3 __clusterRelativeBlockIdx() {int volatile ___ = 1;::exit(___);} +#if 0 +# 99 +{ } +#endif +# 100 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline dim3 __clusterGridDimInClusters() {int volatile ___ = 1;::exit(___);} +#if 0 +# 100 +{ } +#endif +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline dim3 __clusterIdx() {int volatile ___ = 1;::exit(___);} +#if 0 +# 101 +{ } +#endif +# 102 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline unsigned __clusterRelativeBlockRank() {int volatile ___ = 1;::exit(___);} +#if 0 +# 102 +{ } +#endif +# 103 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline unsigned __clusterSizeInBlocks() {int volatile ___ = 1;::exit(___);} +#if 0 +# 103 +{ } +#endif +# 104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline void __cluster_barrier_arrive() {int volatile ___ = 1;::exit(___);} +#if 0 +# 104 +{ } +#endif +# 105 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline void __cluster_barrier_arrive_relaxed() {int volatile ___ = 1;::exit(___);} +#if 0 +# 105 +{ } +#endif +# 106 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline void __cluster_barrier_wait() {int volatile ___ = 1;::exit(___);} +#if 0 +# 106 +{ } +#endif +# 107 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline void __threadfence_cluster() {int volatile ___ = 1;::exit(___);} +#if 0 +# 107 +{ } +#endif +# 109 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline float2 atomicAdd(float2 *__address, float2 val) {int volatile ___ = 1;(void)__address;(void)val;::exit(___);} +#if 0 +# 109 +{ } +#endif +# 110 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline float2 atomicAdd_block(float2 *__address, float2 val) {int volatile ___ = 1;(void)__address;(void)val;::exit(___);} +#if 0 +# 110 +{ } +#endif +# 111 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline float2 atomicAdd_system(float2 *__address, float2 val) {int volatile ___ = 1;(void)__address;(void)val;::exit(___);} +#if 0 +# 111 +{ } +#endif +# 112 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline float4 atomicAdd(float4 *__address, float4 val) {int volatile ___ = 1;(void)__address;(void)val;::exit(___);} +#if 0 +# 112 +{ } +#endif +# 113 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline float4 atomicAdd_block(float4 *__address, float4 val) {int volatile ___ = 1;(void)__address;(void)val;::exit(___);} +#if 0 +# 113 +{ } +#endif +# 114 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline float4 atomicAdd_system(float4 *__address, float4 val) {int volatile ___ = 1;(void)__address;(void)val;::exit(___);} +#if 0 +# 114 +{ } +#endif +# 125 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +extern "C" { +# 132 +} +# 139 +template< bool __b, class _T> +# 140 +struct __nv_atomic_enable_if { }; +# 142 +template< class _T> +# 143 +struct __nv_atomic_enable_if< true, _T> { typedef _T __type; }; +# 153 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +template< class _T> +# 154 +struct __nv_atomic_triv_cp_helper { +# 161 +static const bool __val = __is_trivially_copyable(_T); +# 166 +}; +# 201 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +template< class _T> __attribute__((unused)) static inline typename __nv_atomic_enable_if< (sizeof(_T) == (16)) && (__alignof__(_T) >= (16)) && __nv_atomic_triv_cp_helper< _T> ::__val, _T> ::__type +# 203 +atomicCAS(_T *__address, _T __compare, _T __val) {int volatile ___ = 1;(void)__address;(void)__compare;(void)__val; +# 210 +::exit(___);} +#if 0 +# 203 +{ +# 204 +union _U { _T __ret; _U() {int *volatile ___ = 0;::free(___);} +#if 0 +# 204 +{ } +#endif +# 204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +}; _U __u; +# 205 +__u128AtomicCAS((void *)__address, (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__compare)))), (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__val)))), (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__u.__ret))))); +# 209 +return __u.__ret; +# 210 +} +#endif +# 212 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +template< class _T> __attribute__((unused)) static inline typename __nv_atomic_enable_if< (sizeof(_T) == (16)) && (__alignof__(_T) >= (16)) && __nv_atomic_triv_cp_helper< _T> ::__val, _T> ::__type +# 214 +atomicCAS_block(_T *__address, _T __compare, _T __val) {int volatile ___ = 1;(void)__address;(void)__compare;(void)__val; +# 221 +::exit(___);} +#if 0 +# 214 +{ +# 215 +union _U { _T __ret; _U() {int *volatile ___ = 0;::free(___);} +#if 0 +# 215 +{ } +#endif +# 215 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +}; _U __u; +# 216 +__u128AtomicCAS_block((void *)__address, (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__compare)))), (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__val)))), (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__u.__ret))))); +# 220 +return __u.__ret; +# 221 +} +#endif +# 223 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +template< class _T> __attribute__((unused)) static inline typename __nv_atomic_enable_if< (sizeof(_T) == (16)) && (__alignof__(_T) >= (16)) && __nv_atomic_triv_cp_helper< _T> ::__val, _T> ::__type +# 225 +atomicCAS_system(_T *__address, _T __compare, _T __val) {int volatile ___ = 1;(void)__address;(void)__compare;(void)__val; +# 232 +::exit(___);} +#if 0 +# 225 +{ +# 226 +union _U { _T __ret; _U() {int *volatile ___ = 0;::free(___);} +#if 0 +# 226 +{ } +#endif +# 226 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +}; _U __u; +# 227 +__u128AtomicCAS_system((void *)__address, (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__compare)))), (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__val)))), (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__u.__ret))))); +# 231 +return __u.__ret; +# 232 +} +#endif +# 234 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +template< class _T> __attribute__((unused)) static inline typename __nv_atomic_enable_if< (sizeof(_T) == (16)) && (__alignof__(_T) >= (16)) && __nv_atomic_triv_cp_helper< _T> ::__val, _T> ::__type +# 236 +atomicExch(_T *__address, _T __val) {int volatile ___ = 1;(void)__address;(void)__val; +# 242 +::exit(___);} +#if 0 +# 236 +{ +# 237 +union _U { _T __ret; _U() {int *volatile ___ = 0;::free(___);} +#if 0 +# 237 +{ } +#endif +# 237 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +}; _U __u; +# 238 +__u128AtomicExch((void *)__address, (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__val)))), (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__u.__ret))))); +# 241 +return __u.__ret; +# 242 +} +#endif +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +template< class _T> __attribute__((unused)) static inline typename __nv_atomic_enable_if< (sizeof(_T) == (16)) && (__alignof__(_T) >= (16)) && __nv_atomic_triv_cp_helper< _T> ::__val, _T> ::__type +# 246 +atomicExch_block(_T *__address, _T __val) {int volatile ___ = 1;(void)__address;(void)__val; +# 252 +::exit(___);} +#if 0 +# 246 +{ +# 247 +union _U { _T __ret; _U() {int *volatile ___ = 0;::free(___);} +#if 0 +# 247 +{ } +#endif +# 247 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +}; _U __u; +# 248 +__u128AtomicExch_block((void *)__address, (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__val)))), (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__u.__ret))))); +# 251 +return __u.__ret; +# 252 +} +#endif +# 254 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +template< class _T> __attribute__((unused)) static inline typename __nv_atomic_enable_if< (sizeof(_T) == (16)) && (__alignof__(_T) >= (16)) && __nv_atomic_triv_cp_helper< _T> ::__val, _T> ::__type +# 256 +atomicExch_system(_T *__address, _T __val) {int volatile ___ = 1;(void)__address;(void)__val; +# 262 +::exit(___);} +#if 0 +# 256 +{ +# 257 +union _U { _T __ret; _U() {int *volatile ___ = 0;::free(___);} +#if 0 +# 257 +{ } +#endif +# 257 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +}; _U __u; +# 258 +__u128AtomicExch_system((void *)__address, (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__val)))), (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__u.__ret))))); +# 261 +return __u.__ret; +# 262 +} +#endif +# 100 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __ffma2_rn(float2 x, float2 y, float2 z) {int volatile ___ = 1;(void)x;(void)y;(void)z;::exit(___);} +#if 0 +# 100 +{ } +#endif +# 112 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __ffma2_rz(float2 x, float2 y, float2 z) {int volatile ___ = 1;(void)x;(void)y;(void)z;::exit(___);} +#if 0 +# 112 +{ } +#endif +# 124 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __ffma2_rd(float2 x, float2 y, float2 z) {int volatile ___ = 1;(void)x;(void)y;(void)z;::exit(___);} +#if 0 +# 124 +{ } +#endif +# 136 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __ffma2_ru(float2 x, float2 y, float2 z) {int volatile ___ = 1;(void)x;(void)y;(void)z;::exit(___);} +#if 0 +# 136 +{ } +#endif +# 149 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __fadd2_rn(float2 x, float2 y) {int volatile ___ = 1;(void)x;(void)y;::exit(___);} +#if 0 +# 149 +{ } +#endif +# 161 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __fadd2_rz(float2 x, float2 y) {int volatile ___ = 1;(void)x;(void)y;::exit(___);} +#if 0 +# 161 +{ } +#endif +# 173 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __fadd2_rd(float2 x, float2 y) {int volatile ___ = 1;(void)x;(void)y;::exit(___);} +#if 0 +# 173 +{ } +#endif +# 185 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __fadd2_ru(float2 x, float2 y) {int volatile ___ = 1;(void)x;(void)y;::exit(___);} +#if 0 +# 185 +{ } +#endif +# 198 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __fmul2_rn(float2 x, float2 y) {int volatile ___ = 1;(void)x;(void)y;::exit(___);} +#if 0 +# 198 +{ } +#endif +# 210 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __fmul2_rz(float2 x, float2 y) {int volatile ___ = 1;(void)x;(void)y;::exit(___);} +#if 0 +# 210 +{ } +#endif +# 222 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __fmul2_rd(float2 x, float2 y) {int volatile ___ = 1;(void)x;(void)y;::exit(___);} +#if 0 +# 222 +{ } +#endif +# 234 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __fmul2_ru(float2 x, float2 y) {int volatile ___ = 1;(void)x;(void)y;::exit(___);} +#if 0 +# 234 +{ } +#endif +# 65 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> struct __nv_itex_trait { }; +# 66 +template<> struct __nv_itex_trait< char> { typedef void type; }; +# 67 +template<> struct __nv_itex_trait< signed char> { typedef void type; }; +# 68 +template<> struct __nv_itex_trait< char1> { typedef void type; }; +# 69 +template<> struct __nv_itex_trait< char2> { typedef void type; }; +# 70 +template<> struct __nv_itex_trait< char4> { typedef void type; }; +# 71 +template<> struct __nv_itex_trait< unsigned char> { typedef void type; }; +# 72 +template<> struct __nv_itex_trait< uchar1> { typedef void type; }; +# 73 +template<> struct __nv_itex_trait< uchar2> { typedef void type; }; +# 74 +template<> struct __nv_itex_trait< uchar4> { typedef void type; }; +# 75 +template<> struct __nv_itex_trait< short> { typedef void type; }; +# 76 +template<> struct __nv_itex_trait< short1> { typedef void type; }; +# 77 +template<> struct __nv_itex_trait< short2> { typedef void type; }; +# 78 +template<> struct __nv_itex_trait< short4> { typedef void type; }; +# 79 +template<> struct __nv_itex_trait< unsigned short> { typedef void type; }; +# 80 +template<> struct __nv_itex_trait< ushort1> { typedef void type; }; +# 81 +template<> struct __nv_itex_trait< ushort2> { typedef void type; }; +# 82 +template<> struct __nv_itex_trait< ushort4> { typedef void type; }; +# 83 +template<> struct __nv_itex_trait< int> { typedef void type; }; +# 84 +template<> struct __nv_itex_trait< int1> { typedef void type; }; +# 85 +template<> struct __nv_itex_trait< int2> { typedef void type; }; +# 86 +template<> struct __nv_itex_trait< int4> { typedef void type; }; +# 87 +template<> struct __nv_itex_trait< unsigned> { typedef void type; }; +# 88 +template<> struct __nv_itex_trait< uint1> { typedef void type; }; +# 89 +template<> struct __nv_itex_trait< uint2> { typedef void type; }; +# 90 +template<> struct __nv_itex_trait< uint4> { typedef void type; }; +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template<> struct __nv_itex_trait< float> { typedef void type; }; +# 102 +template<> struct __nv_itex_trait< float1> { typedef void type; }; +# 103 +template<> struct __nv_itex_trait< float2> { typedef void type; }; +# 104 +template<> struct __nv_itex_trait< float4> { typedef void type; }; +# 108 +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 109 +tex1Dfetch(T *ptr, cudaTextureObject_t obj, int x) +# 110 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x; +# 112 +::exit(___);} +#if 0 +# 110 +{ +# 111 +__nv_tex_surf_handler("__itex1Dfetch", ptr, obj, x); +# 112 +} +#endif +# 114 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 115 +tex1Dfetch(cudaTextureObject_t texObject, int x) +# 116 +{int volatile ___ = 1;(void)texObject;(void)x; +# 120 +::exit(___);} +#if 0 +# 116 +{ +# 117 +T ret; +# 118 +tex1Dfetch(&ret, texObject, x); +# 119 +return ret; +# 120 +} +#endif +# 122 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 123 +tex1D(T *ptr, cudaTextureObject_t obj, float x) +# 124 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x; +# 126 +::exit(___);} +#if 0 +# 124 +{ +# 125 +__nv_tex_surf_handler("__itex1D", ptr, obj, x); +# 126 +} +#endif +# 129 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 130 +tex1D(cudaTextureObject_t texObject, float x) +# 131 +{int volatile ___ = 1;(void)texObject;(void)x; +# 135 +::exit(___);} +#if 0 +# 131 +{ +# 132 +T ret; +# 133 +tex1D(&ret, texObject, x); +# 134 +return ret; +# 135 +} +#endif +# 138 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 139 +tex2D(T *ptr, cudaTextureObject_t obj, float x, float y) +# 140 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y; +# 142 +::exit(___);} +#if 0 +# 140 +{ +# 141 +__nv_tex_surf_handler("__itex2D", ptr, obj, x, y); +# 142 +} +#endif +# 144 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 145 +tex2D(cudaTextureObject_t texObject, float x, float y) +# 146 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y; +# 150 +::exit(___);} +#if 0 +# 146 +{ +# 147 +T ret; +# 148 +tex2D(&ret, texObject, x, y); +# 149 +return ret; +# 150 +} +#endif +# 153 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 154 +tex2D(T *ptr, cudaTextureObject_t obj, float x, float y, bool * +# 155 +isResident) +# 156 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)isResident; +# 160 +::exit(___);} +#if 0 +# 156 +{ +# 157 +unsigned char res; +# 158 +__nv_tex_surf_handler("__itex2D_sparse", ptr, obj, x, y, &res); +# 159 +(*isResident) = (res != 0); +# 160 +} +#endif +# 162 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 163 +tex2D(cudaTextureObject_t texObject, float x, float y, bool *isResident) +# 164 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)isResident; +# 168 +::exit(___);} +#if 0 +# 164 +{ +# 165 +T ret; +# 166 +tex2D(&ret, texObject, x, y, isResident); +# 167 +return ret; +# 168 +} +#endif +# 173 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 174 +tex3D(T *ptr, cudaTextureObject_t obj, float x, float y, float z) +# 175 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z; +# 177 +::exit(___);} +#if 0 +# 175 +{ +# 176 +__nv_tex_surf_handler("__itex3D", ptr, obj, x, y, z); +# 177 +} +#endif +# 179 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 180 +tex3D(cudaTextureObject_t texObject, float x, float y, float z) +# 181 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z; +# 185 +::exit(___);} +#if 0 +# 181 +{ +# 182 +T ret; +# 183 +tex3D(&ret, texObject, x, y, z); +# 184 +return ret; +# 185 +} +#endif +# 188 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 189 +tex3D(T *ptr, cudaTextureObject_t obj, float x, float y, float z, bool * +# 190 +isResident) +# 191 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)isResident; +# 195 +::exit(___);} +#if 0 +# 191 +{ +# 192 +unsigned char res; +# 193 +__nv_tex_surf_handler("__itex3D_sparse", ptr, obj, x, y, z, &res); +# 194 +(*isResident) = (res != 0); +# 195 +} +#endif +# 197 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 198 +tex3D(cudaTextureObject_t texObject, float x, float y, float z, bool *isResident) +# 199 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z;(void)isResident; +# 203 +::exit(___);} +#if 0 +# 199 +{ +# 200 +T ret; +# 201 +tex3D(&ret, texObject, x, y, z, isResident); +# 202 +return ret; +# 203 +} +#endif +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 208 +tex1DLayered(T *ptr, cudaTextureObject_t obj, float x, int layer) +# 209 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)layer; +# 211 +::exit(___);} +#if 0 +# 209 +{ +# 210 +__nv_tex_surf_handler("__itex1DLayered", ptr, obj, x, layer); +# 211 +} +#endif +# 213 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 214 +tex1DLayered(cudaTextureObject_t texObject, float x, int layer) +# 215 +{int volatile ___ = 1;(void)texObject;(void)x;(void)layer; +# 219 +::exit(___);} +#if 0 +# 215 +{ +# 216 +T ret; +# 217 +tex1DLayered(&ret, texObject, x, layer); +# 218 +return ret; +# 219 +} +#endif +# 221 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 222 +tex2DLayered(T *ptr, cudaTextureObject_t obj, float x, float y, int layer) +# 223 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)layer; +# 225 +::exit(___);} +#if 0 +# 223 +{ +# 224 +__nv_tex_surf_handler("__itex2DLayered", ptr, obj, x, y, layer); +# 225 +} +#endif +# 227 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 228 +tex2DLayered(cudaTextureObject_t texObject, float x, float y, int layer) +# 229 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)layer; +# 233 +::exit(___);} +#if 0 +# 229 +{ +# 230 +T ret; +# 231 +tex2DLayered(&ret, texObject, x, y, layer); +# 232 +return ret; +# 233 +} +#endif +# 236 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 237 +tex2DLayered(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, bool *isResident) +# 238 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)layer;(void)isResident; +# 242 +::exit(___);} +#if 0 +# 238 +{ +# 239 +unsigned char res; +# 240 +__nv_tex_surf_handler("__itex2DLayered_sparse", ptr, obj, x, y, layer, &res); +# 241 +(*isResident) = (res != 0); +# 242 +} +#endif +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 245 +tex2DLayered(cudaTextureObject_t texObject, float x, float y, int layer, bool *isResident) +# 246 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)layer;(void)isResident; +# 250 +::exit(___);} +#if 0 +# 246 +{ +# 247 +T ret; +# 248 +tex2DLayered(&ret, texObject, x, y, layer, isResident); +# 249 +return ret; +# 250 +} +#endif +# 254 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 255 +texCubemap(T *ptr, cudaTextureObject_t obj, float x, float y, float z) +# 256 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z; +# 258 +::exit(___);} +#if 0 +# 256 +{ +# 257 +__nv_tex_surf_handler("__itexCubemap", ptr, obj, x, y, z); +# 258 +} +#endif +# 261 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 262 +texCubemap(cudaTextureObject_t texObject, float x, float y, float z) +# 263 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z; +# 267 +::exit(___);} +#if 0 +# 263 +{ +# 264 +T ret; +# 265 +texCubemap(&ret, texObject, x, y, z); +# 266 +return ret; +# 267 +} +#endif +# 270 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 271 +texCubemapLayered(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer) +# 272 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)layer; +# 274 +::exit(___);} +#if 0 +# 272 +{ +# 273 +__nv_tex_surf_handler("__itexCubemapLayered", ptr, obj, x, y, z, layer); +# 274 +} +#endif +# 276 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 277 +texCubemapLayered(cudaTextureObject_t texObject, float x, float y, float z, int layer) +# 278 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z;(void)layer; +# 282 +::exit(___);} +#if 0 +# 278 +{ +# 279 +T ret; +# 280 +texCubemapLayered(&ret, texObject, x, y, z, layer); +# 281 +return ret; +# 282 +} +#endif +# 284 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 285 +tex2Dgather(T *ptr, cudaTextureObject_t obj, float x, float y, int comp = 0) +# 286 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)comp; +# 288 +::exit(___);} +#if 0 +# 286 +{ +# 287 +__nv_tex_surf_handler("__itex2Dgather", ptr, obj, x, y, comp); +# 288 +} +#endif +# 290 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 291 +tex2Dgather(cudaTextureObject_t to, float x, float y, int comp = 0) +# 292 +{int volatile ___ = 1;(void)to;(void)x;(void)y;(void)comp; +# 296 +::exit(___);} +#if 0 +# 292 +{ +# 293 +T ret; +# 294 +tex2Dgather(&ret, to, x, y, comp); +# 295 +return ret; +# 296 +} +#endif +# 299 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 300 +tex2Dgather(T *ptr, cudaTextureObject_t obj, float x, float y, bool *isResident, int comp = 0) +# 301 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)isResident;(void)comp; +# 305 +::exit(___);} +#if 0 +# 301 +{ +# 302 +unsigned char res; +# 303 +__nv_tex_surf_handler("__itex2Dgather_sparse", ptr, obj, x, y, comp, &res); +# 304 +(*isResident) = (res != 0); +# 305 +} +#endif +# 307 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 308 +tex2Dgather(cudaTextureObject_t to, float x, float y, bool *isResident, int comp = 0) +# 309 +{int volatile ___ = 1;(void)to;(void)x;(void)y;(void)isResident;(void)comp; +# 313 +::exit(___);} +#if 0 +# 309 +{ +# 310 +T ret; +# 311 +tex2Dgather(&ret, to, x, y, isResident, comp); +# 312 +return ret; +# 313 +} +#endif +# 317 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 318 +tex1DLod(T *ptr, cudaTextureObject_t obj, float x, float level) +# 319 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)level; +# 321 +::exit(___);} +#if 0 +# 319 +{ +# 320 +__nv_tex_surf_handler("__itex1DLod", ptr, obj, x, level); +# 321 +} +#endif +# 323 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 324 +tex1DLod(cudaTextureObject_t texObject, float x, float level) +# 325 +{int volatile ___ = 1;(void)texObject;(void)x;(void)level; +# 329 +::exit(___);} +#if 0 +# 325 +{ +# 326 +T ret; +# 327 +tex1DLod(&ret, texObject, x, level); +# 328 +return ret; +# 329 +} +#endif +# 332 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 333 +tex2DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float level) +# 334 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)level; +# 336 +::exit(___);} +#if 0 +# 334 +{ +# 335 +__nv_tex_surf_handler("__itex2DLod", ptr, obj, x, y, level); +# 336 +} +#endif +# 338 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 339 +tex2DLod(cudaTextureObject_t texObject, float x, float y, float level) +# 340 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)level; +# 344 +::exit(___);} +#if 0 +# 340 +{ +# 341 +T ret; +# 342 +tex2DLod(&ret, texObject, x, y, level); +# 343 +return ret; +# 344 +} +#endif +# 348 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 349 +tex2DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float level, bool *isResident) +# 350 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)level;(void)isResident; +# 354 +::exit(___);} +#if 0 +# 350 +{ +# 351 +unsigned char res; +# 352 +__nv_tex_surf_handler("__itex2DLod_sparse", ptr, obj, x, y, level, &res); +# 353 +(*isResident) = (res != 0); +# 354 +} +#endif +# 356 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 357 +tex2DLod(cudaTextureObject_t texObject, float x, float y, float level, bool *isResident) +# 358 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)level;(void)isResident; +# 362 +::exit(___);} +#if 0 +# 358 +{ +# 359 +T ret; +# 360 +tex2DLod(&ret, texObject, x, y, level, isResident); +# 361 +return ret; +# 362 +} +#endif +# 367 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 368 +tex3DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level) +# 369 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)level; +# 371 +::exit(___);} +#if 0 +# 369 +{ +# 370 +__nv_tex_surf_handler("__itex3DLod", ptr, obj, x, y, z, level); +# 371 +} +#endif +# 373 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 374 +tex3DLod(cudaTextureObject_t texObject, float x, float y, float z, float level) +# 375 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z;(void)level; +# 379 +::exit(___);} +#if 0 +# 375 +{ +# 376 +T ret; +# 377 +tex3DLod(&ret, texObject, x, y, z, level); +# 378 +return ret; +# 379 +} +#endif +# 382 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 383 +tex3DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level, bool *isResident) +# 384 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)level;(void)isResident; +# 388 +::exit(___);} +#if 0 +# 384 +{ +# 385 +unsigned char res; +# 386 +__nv_tex_surf_handler("__itex3DLod_sparse", ptr, obj, x, y, z, level, &res); +# 387 +(*isResident) = (res != 0); +# 388 +} +#endif +# 390 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 391 +tex3DLod(cudaTextureObject_t texObject, float x, float y, float z, float level, bool *isResident) +# 392 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z;(void)level;(void)isResident; +# 396 +::exit(___);} +#if 0 +# 392 +{ +# 393 +T ret; +# 394 +tex3DLod(&ret, texObject, x, y, z, level, isResident); +# 395 +return ret; +# 396 +} +#endif +# 401 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 402 +tex1DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, int layer, float level) +# 403 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)layer;(void)level; +# 405 +::exit(___);} +#if 0 +# 403 +{ +# 404 +__nv_tex_surf_handler("__itex1DLayeredLod", ptr, obj, x, layer, level); +# 405 +} +#endif +# 407 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 408 +tex1DLayeredLod(cudaTextureObject_t texObject, float x, int layer, float level) +# 409 +{int volatile ___ = 1;(void)texObject;(void)x;(void)layer;(void)level; +# 413 +::exit(___);} +#if 0 +# 409 +{ +# 410 +T ret; +# 411 +tex1DLayeredLod(&ret, texObject, x, layer, level); +# 412 +return ret; +# 413 +} +#endif +# 416 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 417 +tex2DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, float level) +# 418 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)layer;(void)level; +# 420 +::exit(___);} +#if 0 +# 418 +{ +# 419 +__nv_tex_surf_handler("__itex2DLayeredLod", ptr, obj, x, y, layer, level); +# 420 +} +#endif +# 422 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 423 +tex2DLayeredLod(cudaTextureObject_t texObject, float x, float y, int layer, float level) +# 424 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)layer;(void)level; +# 428 +::exit(___);} +#if 0 +# 424 +{ +# 425 +T ret; +# 426 +tex2DLayeredLod(&ret, texObject, x, y, layer, level); +# 427 +return ret; +# 428 +} +#endif +# 431 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 432 +tex2DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, float level, bool *isResident) +# 433 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)layer;(void)level;(void)isResident; +# 437 +::exit(___);} +#if 0 +# 433 +{ +# 434 +unsigned char res; +# 435 +__nv_tex_surf_handler("__itex2DLayeredLod_sparse", ptr, obj, x, y, layer, level, &res); +# 436 +(*isResident) = (res != 0); +# 437 +} +#endif +# 439 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 440 +tex2DLayeredLod(cudaTextureObject_t texObject, float x, float y, int layer, float level, bool *isResident) +# 441 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)layer;(void)level;(void)isResident; +# 445 +::exit(___);} +#if 0 +# 441 +{ +# 442 +T ret; +# 443 +tex2DLayeredLod(&ret, texObject, x, y, layer, level, isResident); +# 444 +return ret; +# 445 +} +#endif +# 448 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 449 +texCubemapLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level) +# 450 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)level; +# 452 +::exit(___);} +#if 0 +# 450 +{ +# 451 +__nv_tex_surf_handler("__itexCubemapLod", ptr, obj, x, y, z, level); +# 452 +} +#endif +# 454 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 455 +texCubemapLod(cudaTextureObject_t texObject, float x, float y, float z, float level) +# 456 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z;(void)level; +# 460 +::exit(___);} +#if 0 +# 456 +{ +# 457 +T ret; +# 458 +texCubemapLod(&ret, texObject, x, y, z, level); +# 459 +return ret; +# 460 +} +#endif +# 463 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 464 +texCubemapGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy) +# 465 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)dPdx;(void)dPdy; +# 467 +::exit(___);} +#if 0 +# 465 +{ +# 466 +__nv_tex_surf_handler("__itexCubemapGrad_v2", ptr, obj, x, y, z, &dPdx, &dPdy); +# 467 +} +#endif +# 469 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 470 +texCubemapGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy) +# 471 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z;(void)dPdx;(void)dPdy; +# 475 +::exit(___);} +#if 0 +# 471 +{ +# 472 +T ret; +# 473 +texCubemapGrad(&ret, texObject, x, y, z, dPdx, dPdy); +# 474 +return ret; +# 475 +} +#endif +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 478 +texCubemapLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer, float level) +# 479 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)layer;(void)level; +# 481 +::exit(___);} +#if 0 +# 479 +{ +# 480 +__nv_tex_surf_handler("__itexCubemapLayeredLod", ptr, obj, x, y, z, layer, level); +# 481 +} +#endif +# 483 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 484 +texCubemapLayeredLod(cudaTextureObject_t texObject, float x, float y, float z, int layer, float level) +# 485 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z;(void)layer;(void)level; +# 489 +::exit(___);} +#if 0 +# 485 +{ +# 486 +T ret; +# 487 +texCubemapLayeredLod(&ret, texObject, x, y, z, layer, level); +# 488 +return ret; +# 489 +} +#endif +# 491 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 492 +tex1DGrad(T *ptr, cudaTextureObject_t obj, float x, float dPdx, float dPdy) +# 493 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)dPdx;(void)dPdy; +# 495 +::exit(___);} +#if 0 +# 493 +{ +# 494 +__nv_tex_surf_handler("__itex1DGrad", ptr, obj, x, dPdx, dPdy); +# 495 +} +#endif +# 497 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 498 +tex1DGrad(cudaTextureObject_t texObject, float x, float dPdx, float dPdy) +# 499 +{int volatile ___ = 1;(void)texObject;(void)x;(void)dPdx;(void)dPdy; +# 503 +::exit(___);} +#if 0 +# 499 +{ +# 500 +T ret; +# 501 +tex1DGrad(&ret, texObject, x, dPdx, dPdy); +# 502 +return ret; +# 503 +} +#endif +# 506 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 507 +tex2DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float2 dPdx, float2 dPdy) +# 508 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)dPdx;(void)dPdy; +# 510 +::exit(___);} +#if 0 +# 508 +{ +# 509 +__nv_tex_surf_handler("__itex2DGrad_v2", ptr, obj, x, y, &dPdx, &dPdy); +# 510 +} +#endif +# 512 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 513 +tex2DGrad(cudaTextureObject_t texObject, float x, float y, float2 dPdx, float2 dPdy) +# 514 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)dPdx;(void)dPdy; +# 518 +::exit(___);} +#if 0 +# 514 +{ +# 515 +T ret; +# 516 +tex2DGrad(&ret, texObject, x, y, dPdx, dPdy); +# 517 +return ret; +# 518 +} +#endif +# 521 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 522 +tex2DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float2 dPdx, float2 dPdy, bool *isResident) +# 523 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)dPdx;(void)dPdy;(void)isResident; +# 527 +::exit(___);} +#if 0 +# 523 +{ +# 524 +unsigned char res; +# 525 +__nv_tex_surf_handler("__itex2DGrad_sparse", ptr, obj, x, y, &dPdx, &dPdy, &res); +# 526 +(*isResident) = (res != 0); +# 527 +} +#endif +# 529 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 530 +tex2DGrad(cudaTextureObject_t texObject, float x, float y, float2 dPdx, float2 dPdy, bool *isResident) +# 531 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)dPdx;(void)dPdy;(void)isResident; +# 535 +::exit(___);} +#if 0 +# 531 +{ +# 532 +T ret; +# 533 +tex2DGrad(&ret, texObject, x, y, dPdx, dPdy, isResident); +# 534 +return ret; +# 535 +} +#endif +# 539 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 540 +tex3DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy) +# 541 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)dPdx;(void)dPdy; +# 543 +::exit(___);} +#if 0 +# 541 +{ +# 542 +__nv_tex_surf_handler("__itex3DGrad_v2", ptr, obj, x, y, z, &dPdx, &dPdy); +# 543 +} +#endif +# 545 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 546 +tex3DGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy) +# 547 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z;(void)dPdx;(void)dPdy; +# 551 +::exit(___);} +#if 0 +# 547 +{ +# 548 +T ret; +# 549 +tex3DGrad(&ret, texObject, x, y, z, dPdx, dPdy); +# 550 +return ret; +# 551 +} +#endif +# 554 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 555 +tex3DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy, bool *isResident) +# 556 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)dPdx;(void)dPdy;(void)isResident; +# 560 +::exit(___);} +#if 0 +# 556 +{ +# 557 +unsigned char res; +# 558 +__nv_tex_surf_handler("__itex3DGrad_sparse", ptr, obj, x, y, z, &dPdx, &dPdy, &res); +# 559 +(*isResident) = (res != 0); +# 560 +} +#endif +# 562 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 563 +tex3DGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy, bool *isResident) +# 564 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z;(void)dPdx;(void)dPdy;(void)isResident; +# 568 +::exit(___);} +#if 0 +# 564 +{ +# 565 +T ret; +# 566 +tex3DGrad(&ret, texObject, x, y, z, dPdx, dPdy, isResident); +# 567 +return ret; +# 568 +} +#endif +# 573 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 574 +tex1DLayeredGrad(T *ptr, cudaTextureObject_t obj, float x, int layer, float dPdx, float dPdy) +# 575 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)layer;(void)dPdx;(void)dPdy; +# 577 +::exit(___);} +#if 0 +# 575 +{ +# 576 +__nv_tex_surf_handler("__itex1DLayeredGrad", ptr, obj, x, layer, dPdx, dPdy); +# 577 +} +#endif +# 579 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 580 +tex1DLayeredGrad(cudaTextureObject_t texObject, float x, int layer, float dPdx, float dPdy) +# 581 +{int volatile ___ = 1;(void)texObject;(void)x;(void)layer;(void)dPdx;(void)dPdy; +# 585 +::exit(___);} +#if 0 +# 581 +{ +# 582 +T ret; +# 583 +tex1DLayeredGrad(&ret, texObject, x, layer, dPdx, dPdy); +# 584 +return ret; +# 585 +} +#endif +# 588 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 589 +tex2DLayeredGrad(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, float2 dPdx, float2 dPdy) +# 590 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)layer;(void)dPdx;(void)dPdy; +# 592 +::exit(___);} +#if 0 +# 590 +{ +# 591 +__nv_tex_surf_handler("__itex2DLayeredGrad_v2", ptr, obj, x, y, layer, &dPdx, &dPdy); +# 592 +} +#endif +# 594 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 595 +tex2DLayeredGrad(cudaTextureObject_t texObject, float x, float y, int layer, float2 dPdx, float2 dPdy) +# 596 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)layer;(void)dPdx;(void)dPdy; +# 600 +::exit(___);} +#if 0 +# 596 +{ +# 597 +T ret; +# 598 +tex2DLayeredGrad(&ret, texObject, x, y, layer, dPdx, dPdy); +# 599 +return ret; +# 600 +} +#endif +# 603 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 604 +tex2DLayeredGrad(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, float2 dPdx, float2 dPdy, bool *isResident) +# 605 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)layer;(void)dPdx;(void)dPdy;(void)isResident; +# 609 +::exit(___);} +#if 0 +# 605 +{ +# 606 +unsigned char res; +# 607 +__nv_tex_surf_handler("__itex2DLayeredGrad_sparse", ptr, obj, x, y, layer, &dPdx, &dPdy, &res); +# 608 +(*isResident) = (res != 0); +# 609 +} +#endif +# 611 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 612 +tex2DLayeredGrad(cudaTextureObject_t texObject, float x, float y, int layer, float2 dPdx, float2 dPdy, bool *isResident) +# 613 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)layer;(void)dPdx;(void)dPdy;(void)isResident; +# 617 +::exit(___);} +#if 0 +# 613 +{ +# 614 +T ret; +# 615 +tex2DLayeredGrad(&ret, texObject, x, y, layer, dPdx, dPdy, isResident); +# 616 +return ret; +# 617 +} +#endif +# 621 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 622 +texCubemapLayeredGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer, float4 dPdx, float4 dPdy) +# 623 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)layer;(void)dPdx;(void)dPdy; +# 625 +::exit(___);} +#if 0 +# 623 +{ +# 624 +__nv_tex_surf_handler("__itexCubemapLayeredGrad_v2", ptr, obj, x, y, z, layer, &dPdx, &dPdy); +# 625 +} +#endif +# 627 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 628 +texCubemapLayeredGrad(cudaTextureObject_t texObject, float x, float y, float z, int layer, float4 dPdx, float4 dPdy) +# 629 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z;(void)layer;(void)dPdx;(void)dPdy; +# 633 +::exit(___);} +#if 0 +# 629 +{ +# 630 +T ret; +# 631 +texCubemapLayeredGrad(&ret, texObject, x, y, z, layer, dPdx, dPdy); +# 632 +return ret; +# 633 +} +#endif +# 58 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> struct __nv_isurf_trait { }; +# 59 +template<> struct __nv_isurf_trait< char> { typedef void type; }; +# 60 +template<> struct __nv_isurf_trait< signed char> { typedef void type; }; +# 61 +template<> struct __nv_isurf_trait< char1> { typedef void type; }; +# 62 +template<> struct __nv_isurf_trait< unsigned char> { typedef void type; }; +# 63 +template<> struct __nv_isurf_trait< uchar1> { typedef void type; }; +# 64 +template<> struct __nv_isurf_trait< short> { typedef void type; }; +# 65 +template<> struct __nv_isurf_trait< short1> { typedef void type; }; +# 66 +template<> struct __nv_isurf_trait< unsigned short> { typedef void type; }; +# 67 +template<> struct __nv_isurf_trait< ushort1> { typedef void type; }; +# 68 +template<> struct __nv_isurf_trait< int> { typedef void type; }; +# 69 +template<> struct __nv_isurf_trait< int1> { typedef void type; }; +# 70 +template<> struct __nv_isurf_trait< unsigned> { typedef void type; }; +# 71 +template<> struct __nv_isurf_trait< uint1> { typedef void type; }; +# 72 +template<> struct __nv_isurf_trait< long long> { typedef void type; }; +# 73 +template<> struct __nv_isurf_trait< longlong1> { typedef void type; }; +# 74 +template<> struct __nv_isurf_trait< unsigned long long> { typedef void type; }; +# 75 +template<> struct __nv_isurf_trait< ulonglong1> { typedef void type; }; +# 76 +template<> struct __nv_isurf_trait< float> { typedef void type; }; +# 77 +template<> struct __nv_isurf_trait< float1> { typedef void type; }; +# 79 +template<> struct __nv_isurf_trait< char2> { typedef void type; }; +# 80 +template<> struct __nv_isurf_trait< uchar2> { typedef void type; }; +# 81 +template<> struct __nv_isurf_trait< short2> { typedef void type; }; +# 82 +template<> struct __nv_isurf_trait< ushort2> { typedef void type; }; +# 83 +template<> struct __nv_isurf_trait< int2> { typedef void type; }; +# 84 +template<> struct __nv_isurf_trait< uint2> { typedef void type; }; +# 85 +template<> struct __nv_isurf_trait< longlong2> { typedef void type; }; +# 86 +template<> struct __nv_isurf_trait< ulonglong2> { typedef void type; }; +# 87 +template<> struct __nv_isurf_trait< float2> { typedef void type; }; +# 89 +template<> struct __nv_isurf_trait< char4> { typedef void type; }; +# 90 +template<> struct __nv_isurf_trait< uchar4> { typedef void type; }; +# 91 +template<> struct __nv_isurf_trait< short4> { typedef void type; }; +# 92 +template<> struct __nv_isurf_trait< ushort4> { typedef void type; }; +# 93 +template<> struct __nv_isurf_trait< int4> { typedef void type; }; +# 94 +template<> struct __nv_isurf_trait< uint4> { typedef void type; }; +# 95 +template<> struct __nv_isurf_trait< float4> { typedef void type; }; +# 98 +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 99 +surf1Dread(T *ptr, cudaSurfaceObject_t obj, int x, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 100 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)mode; +# 102 +::exit(___);} +#if 0 +# 100 +{ +# 101 +__nv_tex_surf_handler("__isurf1Dread", ptr, obj, x, mode); +# 102 +} +#endif +# 104 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 105 +surf1Dread(cudaSurfaceObject_t surfObject, int x, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +# 106 +{int volatile ___ = 1;(void)surfObject;(void)x;(void)boundaryMode; +# 110 +::exit(___);} +#if 0 +# 106 +{ +# 107 +T ret; +# 108 +surf1Dread(&ret, surfObject, x, boundaryMode); +# 109 +return ret; +# 110 +} +#endif +# 112 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 113 +surf2Dread(T *ptr, cudaSurfaceObject_t obj, int x, int y, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 114 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)mode; +# 116 +::exit(___);} +#if 0 +# 114 +{ +# 115 +__nv_tex_surf_handler("__isurf2Dread", ptr, obj, x, y, mode); +# 116 +} +#endif +# 118 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 119 +surf2Dread(cudaSurfaceObject_t surfObject, int x, int y, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +# 120 +{int volatile ___ = 1;(void)surfObject;(void)x;(void)y;(void)boundaryMode; +# 124 +::exit(___);} +#if 0 +# 120 +{ +# 121 +T ret; +# 122 +surf2Dread(&ret, surfObject, x, y, boundaryMode); +# 123 +return ret; +# 124 +} +#endif +# 127 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 128 +surf3Dread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int z, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 129 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)mode; +# 131 +::exit(___);} +#if 0 +# 129 +{ +# 130 +__nv_tex_surf_handler("__isurf3Dread", ptr, obj, x, y, z, mode); +# 131 +} +#endif +# 133 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 134 +surf3Dread(cudaSurfaceObject_t surfObject, int x, int y, int z, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +# 135 +{int volatile ___ = 1;(void)surfObject;(void)x;(void)y;(void)z;(void)boundaryMode; +# 139 +::exit(___);} +#if 0 +# 135 +{ +# 136 +T ret; +# 137 +surf3Dread(&ret, surfObject, x, y, z, boundaryMode); +# 138 +return ret; +# 139 +} +#endif +# 141 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 142 +surf1DLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 143 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)layer;(void)mode; +# 145 +::exit(___);} +#if 0 +# 143 +{ +# 144 +__nv_tex_surf_handler("__isurf1DLayeredread", ptr, obj, x, layer, mode); +# 145 +} +#endif +# 147 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 148 +surf1DLayeredread(cudaSurfaceObject_t surfObject, int x, int layer, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +# 149 +{int volatile ___ = 1;(void)surfObject;(void)x;(void)layer;(void)boundaryMode; +# 153 +::exit(___);} +#if 0 +# 149 +{ +# 150 +T ret; +# 151 +surf1DLayeredread(&ret, surfObject, x, layer, boundaryMode); +# 152 +return ret; +# 153 +} +#endif +# 155 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 156 +surf2DLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 157 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)layer;(void)mode; +# 159 +::exit(___);} +#if 0 +# 157 +{ +# 158 +__nv_tex_surf_handler("__isurf2DLayeredread", ptr, obj, x, y, layer, mode); +# 159 +} +#endif +# 161 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 162 +surf2DLayeredread(cudaSurfaceObject_t surfObject, int x, int y, int layer, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +# 163 +{int volatile ___ = 1;(void)surfObject;(void)x;(void)y;(void)layer;(void)boundaryMode; +# 167 +::exit(___);} +#if 0 +# 163 +{ +# 164 +T ret; +# 165 +surf2DLayeredread(&ret, surfObject, x, y, layer, boundaryMode); +# 166 +return ret; +# 167 +} +#endif +# 169 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 170 +surfCubemapread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int face, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 171 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)face;(void)mode; +# 173 +::exit(___);} +#if 0 +# 171 +{ +# 172 +__nv_tex_surf_handler("__isurfCubemapread", ptr, obj, x, y, face, mode); +# 173 +} +#endif +# 175 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 176 +surfCubemapread(cudaSurfaceObject_t surfObject, int x, int y, int face, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +# 177 +{int volatile ___ = 1;(void)surfObject;(void)x;(void)y;(void)face;(void)boundaryMode; +# 181 +::exit(___);} +#if 0 +# 177 +{ +# 178 +T ret; +# 179 +surfCubemapread(&ret, surfObject, x, y, face, boundaryMode); +# 180 +return ret; +# 181 +} +#endif +# 183 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 184 +surfCubemapLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int layerface, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 185 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)layerface;(void)mode; +# 187 +::exit(___);} +#if 0 +# 185 +{ +# 186 +__nv_tex_surf_handler("__isurfCubemapLayeredread", ptr, obj, x, y, layerface, mode); +# 187 +} +#endif +# 189 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 190 +surfCubemapLayeredread(cudaSurfaceObject_t surfObject, int x, int y, int layerface, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +# 191 +{int volatile ___ = 1;(void)surfObject;(void)x;(void)y;(void)layerface;(void)boundaryMode; +# 195 +::exit(___);} +#if 0 +# 191 +{ +# 192 +T ret; +# 193 +surfCubemapLayeredread(&ret, surfObject, x, y, layerface, boundaryMode); +# 194 +return ret; +# 195 +} +#endif +# 197 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 198 +surf1Dwrite(T val, cudaSurfaceObject_t obj, int x, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 199 +{int volatile ___ = 1;(void)val;(void)obj;(void)x;(void)mode; +# 201 +::exit(___);} +#if 0 +# 199 +{ +# 200 +__nv_tex_surf_handler("__isurf1Dwrite_v2", &val, obj, x, mode); +# 201 +} +#endif +# 203 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 204 +surf2Dwrite(T val, cudaSurfaceObject_t obj, int x, int y, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 205 +{int volatile ___ = 1;(void)val;(void)obj;(void)x;(void)y;(void)mode; +# 207 +::exit(___);} +#if 0 +# 205 +{ +# 206 +__nv_tex_surf_handler("__isurf2Dwrite_v2", &val, obj, x, y, mode); +# 207 +} +#endif +# 209 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 210 +surf3Dwrite(T val, cudaSurfaceObject_t obj, int x, int y, int z, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 211 +{int volatile ___ = 1;(void)val;(void)obj;(void)x;(void)y;(void)z;(void)mode; +# 213 +::exit(___);} +#if 0 +# 211 +{ +# 212 +__nv_tex_surf_handler("__isurf3Dwrite_v2", &val, obj, x, y, z, mode); +# 213 +} +#endif +# 215 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 216 +surf1DLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 217 +{int volatile ___ = 1;(void)val;(void)obj;(void)x;(void)layer;(void)mode; +# 219 +::exit(___);} +#if 0 +# 217 +{ +# 218 +__nv_tex_surf_handler("__isurf1DLayeredwrite_v2", &val, obj, x, layer, mode); +# 219 +} +#endif +# 221 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 222 +surf2DLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int y, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 223 +{int volatile ___ = 1;(void)val;(void)obj;(void)x;(void)y;(void)layer;(void)mode; +# 225 +::exit(___);} +#if 0 +# 223 +{ +# 224 +__nv_tex_surf_handler("__isurf2DLayeredwrite_v2", &val, obj, x, y, layer, mode); +# 225 +} +#endif +# 227 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 228 +surfCubemapwrite(T val, cudaSurfaceObject_t obj, int x, int y, int face, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 229 +{int volatile ___ = 1;(void)val;(void)obj;(void)x;(void)y;(void)face;(void)mode; +# 231 +::exit(___);} +#if 0 +# 229 +{ +# 230 +__nv_tex_surf_handler("__isurfCubemapwrite_v2", &val, obj, x, y, face, mode); +# 231 +} +#endif +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 234 +surfCubemapLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int y, int layerface, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 235 +{int volatile ___ = 1;(void)val;(void)obj;(void)x;(void)y;(void)layerface;(void)mode; +# 237 +::exit(___);} +#if 0 +# 235 +{ +# 236 +__nv_tex_surf_handler("__isurfCubemapLayeredwrite_v2", &val, obj, x, y, layerface, mode); +# 237 +} +#endif +# 2924 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +extern "C" unsigned __cudaPushCallConfiguration(dim3 gridDim, dim3 blockDim, size_t sharedMem = 0, CUstream_st * stream = 0); +# 2969 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +enum { +# 2970 +__NV_ATOMIC_RELAXED, +# 2971 +__NV_ATOMIC_CONSUME, +# 2972 +__NV_ATOMIC_ACQUIRE, +# 2973 +__NV_ATOMIC_RELEASE, +# 2974 +__NV_ATOMIC_ACQ_REL, +# 2975 +__NV_ATOMIC_SEQ_CST +# 2976 +}; +# 2978 +enum { +# 2979 +__NV_THREAD_SCOPE_THREAD, +# 2980 +__NV_THREAD_SCOPE_BLOCK, +# 2981 +__NV_THREAD_SCOPE_CLUSTER, +# 2982 +__NV_THREAD_SCOPE_DEVICE, +# 2983 +__NV_THREAD_SCOPE_SYSTEM +# 2984 +}; +# 68 "/opt/cuda/bin/../targets/x86_64-linux/include/device_launch_parameters.h" +extern "C" { +# 71 +extern const uint3 __device_builtin_variable_threadIdx; +# 72 +extern const uint3 __device_builtin_variable_blockIdx; +# 73 +extern const dim3 __device_builtin_variable_blockDim; +# 74 +extern const dim3 __device_builtin_variable_gridDim; +# 75 +extern const int __device_builtin_variable_warpSize; +# 80 +} +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 66 +namespace rel_ops { +# 86 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 +template< class _Tp> inline bool +# 88 +operator!=(const _Tp &__x, const _Tp &__y) +# 89 +{ return !(__x == __y); } +# 99 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 +template< class _Tp> inline bool +# 101 +operator>(const _Tp &__x, const _Tp &__y) +# 102 +{ return __y < __x; } +# 112 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 +template< class _Tp> inline bool +# 114 +operator<=(const _Tp &__x, const _Tp &__y) +# 115 +{ return !(__y < __x); } +# 125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 +template< class _Tp> inline bool +# 127 +operator>=(const _Tp &__x, const _Tp &__y) +# 128 +{ return !(__x < __y); } +# 129 +} +# 132 +} +# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/initializer_list" 3 +namespace std __attribute((__visibility__("default"))) { +# 44 +template< class _E> +# 45 +class initializer_list { +# 48 +public: typedef _E value_type; +# 49 +typedef const _E &reference; +# 50 +typedef const _E &const_reference; +# 51 +typedef size_t size_type; +# 52 +typedef const _E *iterator; +# 53 +typedef const _E *const_iterator; +# 56 +private: iterator _M_array; +# 57 +size_type _M_len; +# 60 +constexpr initializer_list(const_iterator __a, size_type __l) : _M_array(__a), _M_len(__l) +# 61 +{ } +# 64 +public: constexpr initializer_list() noexcept : _M_array((0)), _M_len((0)) +# 65 +{ } +# 69 +constexpr size_type size() const noexcept { return _M_len; } +# 73 +constexpr const_iterator begin() const noexcept { return _M_array; } +# 77 +constexpr const_iterator end() const noexcept { return begin() + size(); } +# 78 +}; +# 86 +template< class _Tp> constexpr const _Tp * +# 88 +begin(initializer_list< _Tp> __ils) noexcept +# 89 +{ return __ils.begin(); } +# 97 +template< class _Tp> constexpr const _Tp * +# 99 +end(initializer_list< _Tp> __ils) noexcept +# 100 +{ return __ils.end(); } +# 101 +} +# 98 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 +namespace std __attribute((__visibility__("default"))) { +# 104 +template< class _Tp, class _Up = _Tp> inline _Tp +# 107 +exchange(_Tp &__obj, _Up &&__new_val) noexcept(__and_< is_nothrow_move_constructible< _Tp> , is_nothrow_assignable< _Tp &, _Up> > ::value) +# 110 +{ return std::__exchange(__obj, std::forward< _Up> (__new_val)); } +# 114 +template< class _Tp> +# 115 +[[nodiscard]] constexpr add_const_t< _Tp> & +# 117 +as_const(_Tp &__t) noexcept +# 118 +{ return __t; } +# 120 +template < typename _Tp > + void as_const ( const _Tp && ) = delete; +# 231 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 +} +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 208 +cudaLaunchKernel(T * +# 209 +func, dim3 +# 210 +gridDim, dim3 +# 211 +blockDim, void ** +# 212 +args, size_t +# 213 +sharedMem = 0, cudaStream_t +# 214 +stream = 0) +# 216 +{ +# 217 +return ::cudaLaunchKernel((const void *)func, gridDim, blockDim, args, sharedMem, stream); +# 218 +} +# 279 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class ...ExpTypes, class ...ActTypes> static inline cudaError_t +# 280 +cudaLaunchKernelEx(const cudaLaunchConfig_t * +# 281 +config, void (* +# 282 +kernel)(ExpTypes ...), ActTypes &&... +# 283 +args) +# 285 +{ +# 286 +return [&](ExpTypes ...coercedArgs) { +# 287 +void *pArgs[] = {(&coercedArgs)...}; +# 288 +return ::cudaLaunchKernelExC(config, (const void *)(kernel), pArgs); +# 289 +} (std::forward< ActTypes> (args)...); +# 290 +} +# 348 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class ...ActTypes> static inline cudaError_t +# 349 +cudaLaunchKernelEx(const cudaLaunchConfig_t * +# 350 +config, const cudaKernel_t +# 351 +kernel, ActTypes &&... +# 352 +args) +# 354 +{ +# 355 +void *pArgs[] = {(&args)...}; +# 356 +return ::cudaLaunchKernelExC(config, (const void *)kernel, pArgs); +# 357 +} +# 410 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 411 +cudaLaunchCooperativeKernel(T * +# 412 +func, dim3 +# 413 +gridDim, dim3 +# 414 +blockDim, void ** +# 415 +args, size_t +# 416 +sharedMem = 0, cudaStream_t +# 417 +stream = 0) +# 419 +{ +# 420 +return ::cudaLaunchCooperativeKernel((const void *)func, gridDim, blockDim, args, sharedMem, stream); +# 421 +} +# 454 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static inline cudaError_t cudaEventCreate(cudaEvent_t * +# 455 +event, unsigned +# 456 +flags) +# 458 +{ +# 459 +return ::cudaEventCreateWithFlags(event, flags); +# 460 +} +# 498 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static inline cudaError_t cudaGraphInstantiate(cudaGraphExec_t * +# 499 +pGraphExec, cudaGraph_t +# 500 +graph, cudaGraphNode_t * +# 501 +pErrorNode, char * +# 502 +pLogBuffer, size_t +# 503 +bufferSize) +# 505 +{ +# 506 +(void)pErrorNode; +# 507 +(void)pLogBuffer; +# 508 +(void)bufferSize; +# 509 +return ::cudaGraphInstantiate(pGraphExec, graph, 0); +# 510 +} +# 569 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static inline cudaError_t cudaMallocHost(void ** +# 570 +ptr, size_t +# 571 +size, unsigned +# 572 +flags) +# 574 +{ +# 575 +return ::cudaHostAlloc(ptr, size, flags); +# 576 +} +# 578 +template< class T> static inline cudaError_t +# 579 +cudaHostAlloc(T ** +# 580 +ptr, size_t +# 581 +size, unsigned +# 582 +flags) +# 584 +{ +# 585 +return ::cudaHostAlloc((void **)((void *)ptr), size, flags); +# 586 +} +# 588 +template< class T> static inline cudaError_t +# 589 +cudaHostGetDevicePointer(T ** +# 590 +pDevice, void * +# 591 +pHost, unsigned +# 592 +flags) +# 594 +{ +# 595 +return ::cudaHostGetDevicePointer((void **)((void *)pDevice), pHost, flags); +# 596 +} +# 698 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 699 +cudaMallocManaged(T ** +# 700 +devPtr, size_t +# 701 +size, unsigned +# 702 +flags = 1) +# 704 +{ +# 705 +return ::cudaMallocManaged((void **)((void *)devPtr), size, flags); +# 706 +} +# 716 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> cudaError_t +# 717 +cudaMemAdvise(T * +# 718 +devPtr, size_t +# 719 +count, cudaMemoryAdvise +# 720 +advice, cudaMemLocation +# 721 +location) +# 723 +{ +# 724 +return ::cudaMemAdvise_v2((const void *)devPtr, count, advice, location); +# 725 +} +# 727 +template< class T> static inline cudaError_t +# 728 +cudaMemPrefetchAsync(T * +# 729 +devPtr, size_t +# 730 +count, cudaMemLocation +# 731 +location, unsigned +# 732 +flags, cudaStream_t +# 733 +stream = 0) +# 735 +{ +# 736 +return ::cudaMemPrefetchAsync_v2((const void *)devPtr, count, location, flags, stream); +# 737 +} +# 819 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 820 +cudaStreamAttachMemAsync(cudaStream_t +# 821 +stream, T * +# 822 +devPtr, size_t +# 823 +length = 0, unsigned +# 824 +flags = 4) +# 826 +{ +# 827 +return ::cudaStreamAttachMemAsync(stream, (void *)devPtr, length, flags); +# 828 +} +# 830 +template< class T> inline cudaError_t +# 831 +cudaMalloc(T ** +# 832 +devPtr, size_t +# 833 +size) +# 835 +{ +# 836 +return ::cudaMalloc((void **)((void *)devPtr), size); +# 837 +} +# 839 +template< class T> static inline cudaError_t +# 840 +cudaMallocHost(T ** +# 841 +ptr, size_t +# 842 +size, unsigned +# 843 +flags = 0) +# 845 +{ +# 846 +return cudaMallocHost((void **)((void *)ptr), size, flags); +# 847 +} +# 849 +template< class T> static inline cudaError_t +# 850 +cudaMallocPitch(T ** +# 851 +devPtr, size_t * +# 852 +pitch, size_t +# 853 +width, size_t +# 854 +height) +# 856 +{ +# 857 +return ::cudaMallocPitch((void **)((void *)devPtr), pitch, width, height); +# 858 +} +# 869 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static inline cudaError_t cudaMallocAsync(void ** +# 870 +ptr, size_t +# 871 +size, cudaMemPool_t +# 872 +memPool, cudaStream_t +# 873 +stream) +# 875 +{ +# 876 +return ::cudaMallocFromPoolAsync(ptr, size, memPool, stream); +# 877 +} +# 879 +template< class T> static inline cudaError_t +# 880 +cudaMallocAsync(T ** +# 881 +ptr, size_t +# 882 +size, cudaMemPool_t +# 883 +memPool, cudaStream_t +# 884 +stream) +# 886 +{ +# 887 +return ::cudaMallocFromPoolAsync((void **)((void *)ptr), size, memPool, stream); +# 888 +} +# 890 +template< class T> static inline cudaError_t +# 891 +cudaMallocAsync(T ** +# 892 +ptr, size_t +# 893 +size, cudaStream_t +# 894 +stream) +# 896 +{ +# 897 +return ::cudaMallocAsync((void **)((void *)ptr), size, stream); +# 898 +} +# 900 +template< class T> static inline cudaError_t +# 901 +cudaMallocFromPoolAsync(T ** +# 902 +ptr, size_t +# 903 +size, cudaMemPool_t +# 904 +memPool, cudaStream_t +# 905 +stream) +# 907 +{ +# 908 +return ::cudaMallocFromPoolAsync((void **)((void *)ptr), size, memPool, stream); +# 909 +} +# 919 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T, class U> static inline cudaError_t +# 920 +cudaMemcpyBatchAsync(T ** +# 921 +dsts, U **srcs, size_t *sizes, size_t count, cudaMemcpyAttributes *attrs, size_t * +# 922 +attrsIdxs, size_t numAttrs, size_t *failIdx, cudaStream_t hStream) +# 924 +{ +# 925 +return ::cudaMemcpyBatchAsync((void **)dsts, (void **)srcs, sizes, count, attrs, attrsIdxs, numAttrs, failIdx, hStream); +# 926 +} +# 938 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T, class U> static inline cudaError_t +# 939 +cudaMemcpyBatchAsync(T ** +# 940 +dsts, U **srcs, size_t *sizes, size_t count, cudaMemcpyAttributes attr, size_t *failIdx, cudaStream_t hStream) +# 942 +{ +# 943 +size_t attrsIdxs = (0); +# 944 +return ::cudaMemcpyBatchAsync((void **)dsts, (void **)srcs, sizes, count, &attr, &attrsIdxs, 1, failIdx, hStream); +# 945 +} +# 984 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 985 +cudaMemcpyToSymbol(const T & +# 986 +symbol, const void * +# 987 +src, size_t +# 988 +count, size_t +# 989 +offset = 0, cudaMemcpyKind +# 990 +kind = cudaMemcpyHostToDevice) +# 992 +{ +# 993 +return ::cudaMemcpyToSymbol((const void *)(&symbol), src, count, offset, kind); +# 994 +} +# 1038 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1039 +cudaMemcpyToSymbolAsync(const T & +# 1040 +symbol, const void * +# 1041 +src, size_t +# 1042 +count, size_t +# 1043 +offset = 0, cudaMemcpyKind +# 1044 +kind = cudaMemcpyHostToDevice, cudaStream_t +# 1045 +stream = 0) +# 1047 +{ +# 1048 +return ::cudaMemcpyToSymbolAsync((const void *)(&symbol), src, count, offset, kind, stream); +# 1049 +} +# 1086 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1087 +cudaMemcpyFromSymbol(void * +# 1088 +dst, const T & +# 1089 +symbol, size_t +# 1090 +count, size_t +# 1091 +offset = 0, cudaMemcpyKind +# 1092 +kind = cudaMemcpyDeviceToHost) +# 1094 +{ +# 1095 +return ::cudaMemcpyFromSymbol(dst, (const void *)(&symbol), count, offset, kind); +# 1096 +} +# 1140 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1141 +cudaMemcpyFromSymbolAsync(void * +# 1142 +dst, const T & +# 1143 +symbol, size_t +# 1144 +count, size_t +# 1145 +offset = 0, cudaMemcpyKind +# 1146 +kind = cudaMemcpyDeviceToHost, cudaStream_t +# 1147 +stream = 0) +# 1149 +{ +# 1150 +return ::cudaMemcpyFromSymbolAsync(dst, (const void *)(&symbol), count, offset, kind, stream); +# 1151 +} +# 1209 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1210 +cudaGraphAddMemcpyNodeToSymbol(cudaGraphNode_t * +# 1211 +pGraphNode, cudaGraph_t +# 1212 +graph, const cudaGraphNode_t * +# 1213 +pDependencies, size_t +# 1214 +numDependencies, const T & +# 1215 +symbol, const void * +# 1216 +src, size_t +# 1217 +count, size_t +# 1218 +offset, cudaMemcpyKind +# 1219 +kind) +# 1220 +{ +# 1221 +return ::cudaGraphAddMemcpyNodeToSymbol(pGraphNode, graph, pDependencies, numDependencies, (const void *)(&symbol), src, count, offset, kind); +# 1222 +} +# 1280 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1281 +cudaGraphAddMemcpyNodeFromSymbol(cudaGraphNode_t * +# 1282 +pGraphNode, cudaGraph_t +# 1283 +graph, const cudaGraphNode_t * +# 1284 +pDependencies, size_t +# 1285 +numDependencies, void * +# 1286 +dst, const T & +# 1287 +symbol, size_t +# 1288 +count, size_t +# 1289 +offset, cudaMemcpyKind +# 1290 +kind) +# 1291 +{ +# 1292 +return ::cudaGraphAddMemcpyNodeFromSymbol(pGraphNode, graph, pDependencies, numDependencies, dst, (const void *)(&symbol), count, offset, kind); +# 1293 +} +# 1331 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1332 +cudaGraphMemcpyNodeSetParamsToSymbol(cudaGraphNode_t +# 1333 +node, const T & +# 1334 +symbol, const void * +# 1335 +src, size_t +# 1336 +count, size_t +# 1337 +offset, cudaMemcpyKind +# 1338 +kind) +# 1339 +{ +# 1340 +return ::cudaGraphMemcpyNodeSetParamsToSymbol(node, (const void *)(&symbol), src, count, offset, kind); +# 1341 +} +# 1379 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1380 +cudaGraphMemcpyNodeSetParamsFromSymbol(cudaGraphNode_t +# 1381 +node, void * +# 1382 +dst, const T & +# 1383 +symbol, size_t +# 1384 +count, size_t +# 1385 +offset, cudaMemcpyKind +# 1386 +kind) +# 1387 +{ +# 1388 +return ::cudaGraphMemcpyNodeSetParamsFromSymbol(node, dst, (const void *)(&symbol), count, offset, kind); +# 1389 +} +# 1437 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1438 +cudaGraphExecMemcpyNodeSetParamsToSymbol(cudaGraphExec_t +# 1439 +hGraphExec, cudaGraphNode_t +# 1440 +node, const T & +# 1441 +symbol, const void * +# 1442 +src, size_t +# 1443 +count, size_t +# 1444 +offset, cudaMemcpyKind +# 1445 +kind) +# 1446 +{ +# 1447 +return ::cudaGraphExecMemcpyNodeSetParamsToSymbol(hGraphExec, node, (const void *)(&symbol), src, count, offset, kind); +# 1448 +} +# 1496 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1497 +cudaGraphExecMemcpyNodeSetParamsFromSymbol(cudaGraphExec_t +# 1498 +hGraphExec, cudaGraphNode_t +# 1499 +node, void * +# 1500 +dst, const T & +# 1501 +symbol, size_t +# 1502 +count, size_t +# 1503 +offset, cudaMemcpyKind +# 1504 +kind) +# 1505 +{ +# 1506 +return ::cudaGraphExecMemcpyNodeSetParamsFromSymbol(hGraphExec, node, dst, (const void *)(&symbol), count, offset, kind); +# 1507 +} +# 1510 +static inline cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphNode_t *hErrorNode_out, cudaGraphExecUpdateResult *updateResult_out) +# 1511 +{ +# 1512 +cudaGraphExecUpdateResultInfo resultInfo; +# 1513 +cudaError_t status = cudaGraphExecUpdate(hGraphExec, hGraph, &resultInfo); +# 1514 +if (hErrorNode_out) { +# 1515 +(*hErrorNode_out) = (resultInfo.errorNode); +# 1516 +} +# 1517 +if (updateResult_out) { +# 1518 +(*updateResult_out) = (resultInfo.result); +# 1519 +} +# 1520 +return status; +# 1521 +} +# 1549 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1550 +cudaUserObjectCreate(cudaUserObject_t * +# 1551 +object_out, T * +# 1552 +objectToWrap, unsigned +# 1553 +initialRefcount, unsigned +# 1554 +flags) +# 1555 +{ +# 1556 +return ::cudaUserObjectCreate(object_out, objectToWrap, [](void * +# 1559 +vpObj) { delete (reinterpret_cast< T *>(vpObj)); } , initialRefcount, flags); +# 1562 +} +# 1564 +template< class T> static inline cudaError_t +# 1565 +cudaUserObjectCreate(cudaUserObject_t * +# 1566 +object_out, T * +# 1567 +objectToWrap, unsigned +# 1568 +initialRefcount, cudaUserObjectFlags +# 1569 +flags) +# 1570 +{ +# 1571 +return cudaUserObjectCreate(object_out, objectToWrap, initialRefcount, (unsigned)flags); +# 1572 +} +# 1599 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1600 +cudaGetSymbolAddress(void ** +# 1601 +devPtr, const T & +# 1602 +symbol) +# 1604 +{ +# 1605 +return ::cudaGetSymbolAddress(devPtr, (const void *)(&symbol)); +# 1606 +} +# 1631 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1632 +cudaGetSymbolSize(size_t * +# 1633 +size, const T & +# 1634 +symbol) +# 1636 +{ +# 1637 +return ::cudaGetSymbolSize(size, (const void *)(&symbol)); +# 1638 +} +# 1683 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1684 +cudaFuncSetCacheConfig(T * +# 1685 +func, cudaFuncCache +# 1686 +cacheConfig) +# 1688 +{ +# 1689 +return ::cudaFuncSetCacheConfig((const void *)func, cacheConfig); +# 1690 +} +# 1692 +template< class T> +# 1694 +__attribute((deprecated)) static inline cudaError_t +# 1695 +cudaFuncSetSharedMemConfig(T * +# 1696 +func, cudaSharedMemConfig +# 1697 +config) +# 1699 +{ +# 1701 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 1706 +return ::cudaFuncSetSharedMemConfig((const void *)func, config); +# 1708 +#pragma GCC diagnostic pop +# 1710 +} +# 1743 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> inline cudaError_t +# 1744 +cudaOccupancyMaxActiveBlocksPerMultiprocessor(int * +# 1745 +numBlocks, T +# 1746 +func, int +# 1747 +blockSize, size_t +# 1748 +dynamicSMemSize) +# 1749 +{ +# 1750 +return ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, (const void *)func, blockSize, dynamicSMemSize, 0); +# 1751 +} +# 1796 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> inline cudaError_t +# 1797 +cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int * +# 1798 +numBlocks, T +# 1799 +func, int +# 1800 +blockSize, size_t +# 1801 +dynamicSMemSize, unsigned +# 1802 +flags) +# 1803 +{ +# 1804 +return ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, (const void *)func, blockSize, dynamicSMemSize, flags); +# 1805 +} +# 1810 +class __cudaOccupancyB2DHelper { +# 1811 +size_t n; +# 1813 +public: __cudaOccupancyB2DHelper(size_t n_) : n(n_) { } +# 1814 +size_t operator()(int) +# 1815 +{ +# 1816 +return n; +# 1817 +} +# 1818 +}; +# 1866 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class UnaryFunction, class T> static inline cudaError_t +# 1867 +cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(int * +# 1868 +minGridSize, int * +# 1869 +blockSize, T +# 1870 +func, UnaryFunction +# 1871 +blockSizeToDynamicSMemSize, int +# 1872 +blockSizeLimit = 0, unsigned +# 1873 +flags = 0) +# 1874 +{ +# 1875 +cudaError_t status; +# 1878 +int device; +# 1879 +cudaFuncAttributes attr; +# 1882 +int maxThreadsPerMultiProcessor; +# 1883 +int warpSize; +# 1884 +int devMaxThreadsPerBlock; +# 1885 +int multiProcessorCount; +# 1886 +int funcMaxThreadsPerBlock; +# 1887 +int occupancyLimit; +# 1888 +int granularity; +# 1891 +int maxBlockSize = 0; +# 1892 +int numBlocks = 0; +# 1893 +int maxOccupancy = 0; +# 1896 +int blockSizeToTryAligned; +# 1897 +int blockSizeToTry; +# 1898 +int blockSizeLimitAligned; +# 1899 +int occupancyInBlocks; +# 1900 +int occupancyInThreads; +# 1901 +size_t dynamicSMemSize; +# 1907 +if (((!minGridSize) || (!blockSize)) || (!func)) { +# 1908 +return cudaErrorInvalidValue; +# 1909 +} +# 1915 +status = ::cudaGetDevice(&device); +# 1916 +if (status != (cudaSuccess)) { +# 1917 +return status; +# 1918 +} +# 1920 +status = cudaDeviceGetAttribute(&maxThreadsPerMultiProcessor, cudaDevAttrMaxThreadsPerMultiProcessor, device); +# 1924 +if (status != (cudaSuccess)) { +# 1925 +return status; +# 1926 +} +# 1928 +status = cudaDeviceGetAttribute(&warpSize, cudaDevAttrWarpSize, device); +# 1932 +if (status != (cudaSuccess)) { +# 1933 +return status; +# 1934 +} +# 1936 +status = cudaDeviceGetAttribute(&devMaxThreadsPerBlock, cudaDevAttrMaxThreadsPerBlock, device); +# 1940 +if (status != (cudaSuccess)) { +# 1941 +return status; +# 1942 +} +# 1944 +status = cudaDeviceGetAttribute(&multiProcessorCount, cudaDevAttrMultiProcessorCount, device); +# 1948 +if (status != (cudaSuccess)) { +# 1949 +return status; +# 1950 +} +# 1952 +status = cudaFuncGetAttributes(&attr, func); +# 1953 +if (status != (cudaSuccess)) { +# 1954 +return status; +# 1955 +} +# 1957 +funcMaxThreadsPerBlock = (attr.maxThreadsPerBlock); +# 1963 +occupancyLimit = maxThreadsPerMultiProcessor; +# 1964 +granularity = warpSize; +# 1966 +if (blockSizeLimit == 0) { +# 1967 +blockSizeLimit = devMaxThreadsPerBlock; +# 1968 +} +# 1970 +if (devMaxThreadsPerBlock < blockSizeLimit) { +# 1971 +blockSizeLimit = devMaxThreadsPerBlock; +# 1972 +} +# 1974 +if (funcMaxThreadsPerBlock < blockSizeLimit) { +# 1975 +blockSizeLimit = funcMaxThreadsPerBlock; +# 1976 +} +# 1978 +blockSizeLimitAligned = (((blockSizeLimit + (granularity - 1)) / granularity) * granularity); +# 1980 +for (blockSizeToTryAligned = blockSizeLimitAligned; blockSizeToTryAligned > 0; blockSizeToTryAligned -= granularity) { +# 1984 +if (blockSizeLimit < blockSizeToTryAligned) { +# 1985 +blockSizeToTry = blockSizeLimit; +# 1986 +} else { +# 1987 +blockSizeToTry = blockSizeToTryAligned; +# 1988 +} +# 1990 +dynamicSMemSize = blockSizeToDynamicSMemSize(blockSizeToTry); +# 1992 +status = cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(&occupancyInBlocks, func, blockSizeToTry, dynamicSMemSize, flags); +# 1999 +if (status != (cudaSuccess)) { +# 2000 +return status; +# 2001 +} +# 2003 +occupancyInThreads = (blockSizeToTry * occupancyInBlocks); +# 2005 +if (occupancyInThreads > maxOccupancy) { +# 2006 +maxBlockSize = blockSizeToTry; +# 2007 +numBlocks = occupancyInBlocks; +# 2008 +maxOccupancy = occupancyInThreads; +# 2009 +} +# 2013 +if (occupancyLimit == maxOccupancy) { +# 2014 +break; +# 2015 +} +# 2016 +} +# 2024 +(*minGridSize) = (numBlocks * multiProcessorCount); +# 2025 +(*blockSize) = maxBlockSize; +# 2027 +return status; +# 2028 +} +# 2062 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class UnaryFunction, class T> static inline cudaError_t +# 2063 +cudaOccupancyMaxPotentialBlockSizeVariableSMem(int * +# 2064 +minGridSize, int * +# 2065 +blockSize, T +# 2066 +func, UnaryFunction +# 2067 +blockSizeToDynamicSMemSize, int +# 2068 +blockSizeLimit = 0) +# 2069 +{ +# 2070 +return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, blockSizeToDynamicSMemSize, blockSizeLimit, 0); +# 2071 +} +# 2108 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2109 +cudaOccupancyMaxPotentialBlockSize(int * +# 2110 +minGridSize, int * +# 2111 +blockSize, T +# 2112 +func, size_t +# 2113 +dynamicSMemSize = 0, int +# 2114 +blockSizeLimit = 0) +# 2115 +{ +# 2116 +return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, ((__cudaOccupancyB2DHelper)(dynamicSMemSize)), blockSizeLimit, 0); +# 2117 +} +# 2147 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2148 +cudaOccupancyAvailableDynamicSMemPerBlock(size_t * +# 2149 +dynamicSmemSize, T * +# 2150 +func, int +# 2151 +numBlocks, int +# 2152 +blockSize) +# 2153 +{ +# 2154 +return ::cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, (const void *)func, numBlocks, blockSize); +# 2155 +} +# 2206 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2207 +cudaOccupancyMaxPotentialBlockSizeWithFlags(int * +# 2208 +minGridSize, int * +# 2209 +blockSize, T +# 2210 +func, size_t +# 2211 +dynamicSMemSize = 0, int +# 2212 +blockSizeLimit = 0, unsigned +# 2213 +flags = 0) +# 2214 +{ +# 2215 +return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, ((__cudaOccupancyB2DHelper)(dynamicSMemSize)), blockSizeLimit, flags); +# 2216 +} +# 2251 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2252 +cudaOccupancyMaxPotentialClusterSize(int * +# 2253 +clusterSize, T * +# 2254 +func, const cudaLaunchConfig_t * +# 2255 +config) +# 2256 +{ +# 2257 +return ::cudaOccupancyMaxPotentialClusterSize(clusterSize, (const void *)func, config); +# 2258 +} +# 2295 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2296 +cudaOccupancyMaxActiveClusters(int * +# 2297 +numClusters, T * +# 2298 +func, const cudaLaunchConfig_t * +# 2299 +config) +# 2300 +{ +# 2301 +return ::cudaOccupancyMaxActiveClusters(numClusters, (const void *)func, config); +# 2302 +} +# 2336 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> inline cudaError_t +# 2337 +cudaFuncGetAttributes(cudaFuncAttributes * +# 2338 +attr, T * +# 2339 +entry) +# 2341 +{ +# 2342 +return ::cudaFuncGetAttributes(attr, (const void *)entry); +# 2343 +} +# 2402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2403 +cudaFuncSetAttribute(T * +# 2404 +func, cudaFuncAttribute +# 2405 +attr, int +# 2406 +value) +# 2408 +{ +# 2409 +return ::cudaFuncSetAttribute((const void *)func, attr, value); +# 2410 +} +# 2435 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2436 +cudaFuncGetName(const char ** +# 2437 +name, T * +# 2438 +func) +# 2440 +{ +# 2441 +return ::cudaFuncGetName(name, (const void *)func); +# 2442 +} +# 2458 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2459 +cudaGetKernel(cudaKernel_t * +# 2460 +kernelPtr, T * +# 2461 +func) +# 2463 +{ +# 2464 +return ::cudaGetKernel(kernelPtr, (const void *)func); +# 2465 +} +# 2496 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2497 +cudaLibraryGetGlobal(T **dptr, size_t *bytes, cudaLibrary_t library, const char *name) +# 2498 +{ +# 2499 +return ::cudaLibraryGetGlobal((void **)((void *)dptr), bytes, library, name); +# 2500 +} +# 2530 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2531 +cudaLibraryGetManaged(T **dptr, size_t *bytes, cudaLibrary_t library, const char *name) +# 2532 +{ +# 2533 +return ::cudaLibraryGetManaged((void **)((void *)dptr), bytes, library, name); +# 2534 +} +# 2560 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2561 +cudaLibraryGetUnifiedFunction(T **fptr, cudaLibrary_t library, const char *symbol) +# 2562 +{ +# 2563 +return ::cudaLibraryGetUnifiedFunction((void **)((void *)fptr), library, symbol); +# 2564 +} +# 2576 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +#pragma GCC diagnostic pop +# 477 "CMakeCUDACompilerId.cu" +const char *info_compiler = ("INFO:compiler[NVIDIA]"); +# 479 +const char *info_simulate = ("INFO:simulate[GNU]"); +# 790 "CMakeCUDACompilerId.cu" +const char info_version[] = {'I', 'N', 'F', 'O', ':', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '_', 'v', 'e', 'r', 's', 'i', 'o', 'n', '[', (('0') + ((12 / 10000000) % 10)), (('0') + ((12 / 1000000) % 10)), (('0') + ((12 / 100000) % 10)), (('0') + ((12 / 10000) % 10)), (('0') + ((12 / 1000) % 10)), (('0') + ((12 / 100) % 10)), (('0') + ((12 / 10) % 10)), (('0') + (12 % 10)), '.', (('0') + ((8 / 10000000) % 10)), (('0') + ((8 / 1000000) % 10)), (('0') + ((8 / 100000) % 10)), (('0') + ((8 / 10000) % 10)), (('0') + ((8 / 1000) % 10)), (('0') + ((8 / 100) % 10)), (('0') + ((8 / 10) % 10)), (('0') + (8 % 10)), '.', (('0') + ((93 / 10000000) % 10)), (('0') + ((93 / 1000000) % 10)), (('0') + ((93 / 100000) % 10)), (('0') + ((93 / 10000) % 10)), (('0') + ((93 / 1000) % 10)), (('0') + ((93 / 100) % 10)), (('0') + ((93 / 10) % 10)), (('0') + (93 % 10)), ']', '\000'}; +# 819 "CMakeCUDACompilerId.cu" +const char info_simulate_version[] = {'I', 'N', 'F', 'O', ':', 's', 'i', 'm', 'u', 'l', 'a', 't', 'e', '_', 'v', 'e', 'r', 's', 'i', 'o', 'n', '[', (('0') + ((14 / 10000000) % 10)), (('0') + ((14 / 1000000) % 10)), (('0') + ((14 / 100000) % 10)), (('0') + ((14 / 10000) % 10)), (('0') + ((14 / 1000) % 10)), (('0') + ((14 / 100) % 10)), (('0') + ((14 / 10) % 10)), (('0') + (14 % 10)), '.', (('0') + ((2 / 10000000) % 10)), (('0') + ((2 / 1000000) % 10)), (('0') + ((2 / 100000) % 10)), (('0') + ((2 / 10000) % 10)), (('0') + ((2 / 1000) % 10)), (('0') + ((2 / 100) % 10)), (('0') + ((2 / 10) % 10)), (('0') + (2 % 10)), ']', '\000'}; +# 839 +const char *info_platform = ("INFO:platform[Linux]"); +# 840 +const char *info_arch = ("INFO:arch[]"); +# 845 +const char *info_host_compiler = ("INFO:host_compiler[GNU]"); +# 850 +const char info_host_compiler_version[] = {'I', 'N', 'F', 'O', ':', 'h', 'o', 's', 't', '_', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '_', 'v', 'e', 'r', 's', 'i', 'o', 'n', '[', (('0') + ((14 / 10000000) % 10)), (('0') + ((14 / 1000000) % 10)), (('0') + ((14 / 100000) % 10)), (('0') + ((14 / 10000) % 10)), (('0') + ((14 / 1000) % 10)), (('0') + ((14 / 100) % 10)), (('0') + ((14 / 10) % 10)), (('0') + (14 % 10)), '.', (('0') + ((2 / 10000000) % 10)), (('0') + ((2 / 1000000) % 10)), (('0') + ((2 / 100000) % 10)), (('0') + ((2 / 10000) % 10)), (('0') + ((2 / 1000) % 10)), (('0') + ((2 / 100) % 10)), (('0') + ((2 / 10) % 10)), (('0') + (2 % 10)), '.', (('0') + ((1 / 10000000) % 10)), (('0') + ((1 / 1000000) % 10)), (('0') + ((1 / 100000) % 10)), (('0') + ((1 / 10000) % 10)), (('0') + ((1 / 1000) % 10)), (('0') + ((1 / 100) % 10)), (('0') + ((1 / 10) % 10)), (('0') + (1 % 10)), ']', '\000'}; +# 882 "CMakeCUDACompilerId.cu" +const char *info_language_standard_default = ("INFO:standard_default[17]"); +# 900 +const char *info_language_extensions_default = ("INFO:extensions_default[ON]"); +# 911 +int main(int argc, char *argv[]) +# 912 +{ +# 913 +int require = 0; +# 914 +require += (info_compiler[argc]); +# 915 +require += (info_platform[argc]); +# 917 +require += (info_version[argc]); +# 920 +require += (info_simulate[argc]); +# 923 +require += (info_simulate_version[argc]); +# 926 +require += (info_host_compiler[argc]); +# 929 +require += (info_host_compiler_version[argc]); +# 931 +require += (info_language_standard_default[argc]); +# 932 +require += (info_language_extensions_default[argc]); +# 933 +(void)argv; +# 934 +return require; +# 935 +} + +# 1 "CMakeCUDACompilerId.cudafe1.stub.c" +#define _NV_ANON_NAMESPACE _GLOBAL__N__41504697_22_CMakeCUDACompilerId_cu_bd57c623 +#ifdef _NV_ANON_NAMESPACE +#endif +# 1 "CMakeCUDACompilerId.cudafe1.stub.c" +#include "CMakeCUDACompilerId.cudafe1.stub.c" +# 1 "CMakeCUDACompilerId.cudafe1.stub.c" +#undef _NV_ANON_NAMESPACE diff --git a/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.gpu b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.gpu new file mode 100644 index 0000000..8087332 --- /dev/null +++ b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.gpu @@ -0,0 +1,467 @@ +typedef char __nv_bool; +# 214 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 +typedef unsigned long size_t; +#include "crt/device_runtime.h" +# 310 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +typedef unsigned long _ZSt6size_t; +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#include "common_functions.h" +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif diff --git a/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.stub.c b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.stub.c new file mode 100644 index 0000000..2ebe7e6 --- /dev/null +++ b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.stub.c @@ -0,0 +1,15 @@ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-function" +#pragma GCC diagnostic ignored "-Wcast-qual" +#define __NV_CUBIN_HANDLE_STORAGE__ static +#if !defined(__CUDA_INCLUDE_COMPILER_INTERNAL_HEADERS__) +#define __CUDA_INCLUDE_COMPILER_INTERNAL_HEADERS__ +#endif +#include "crt/host_runtime.h" +#include "CMakeCUDACompilerId.fatbin.c" +static void __nv_cudaEntityRegisterCallback(void **); +static void __sti____cudaRegisterAll(void) __attribute__((__constructor__)); +static void __nv_cudaEntityRegisterCallback(void **__T0){__nv_dummy_param_ref(__T0);__nv_save_fatbinhandle_for_managed_rt(__T0);} +static void __sti____cudaRegisterAll(void){__cudaRegisterBinary(__nv_cudaEntityRegisterCallback);} + +#pragma GCC diagnostic pop diff --git a/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.fatbin b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.fatbin new file mode 100644 index 0000000000000000000000000000000000000000..943e39fe1540d752a96861c3283d8831f58ac54c GIT binary patch literal 1096 zcmcIjO;5r=5S=Xord}XkJT@j?mjo+f;-LpM9E{=O(U1z2l0e(+HUzxrAMuZP@E@6Y z^x)U*cD58SF(Gje``(+*o9XVf-Ph}91~q7JfnF9c<{=A9nKpYB7`R3t)(gByAI>i? zEXEG26tv(49t#QYRwiaFL$~aL2W_x$uV4@0GL)%E{aa)P=aWop?8z`1%z#HzK8o&Q zP5S3F#iSN_`Q2 z5`G}cMOys;%B_XmjHz*~j9eG;sN4;q0UDo?u!HP3{}W~W<=@3T`ZV&Inoy$-MOBXK zvrT%BP~9)4CM0v{kl&$*c}Ft|Q%B7K&#>kX$zRJWX2kdmRxqrlXuj{2^t`ZXV0^0l zW VbAK=pfs{Qtx(}R|YvVFyegH@^b~69~ literal 0 HcmV?d00001 diff --git a/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.fatbin.c b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.fatbin.c new file mode 100644 index 0000000..65e4578 --- /dev/null +++ b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.fatbin.c @@ -0,0 +1,60 @@ +#ifndef __SKIP_INTERNAL_FATBINARY_HEADERS +#include "fatbinary_section.h" +#endif +#define __CUDAFATBINSECTION ".nvFatBinSegment" +#define __CUDAFATBINDATASECTION ".nv_fatbin" +asm( +".section .nv_fatbin, \"a\"\n" +".align 8\n" +"fatbinData:\n" +".quad 0x00100001ba55ed50,0x0000000000000438,0x0000004001010002,0x0000000000000368\n" +".quad 0x0000000000000000,0x0000003400010007,0x0000000000000000,0x0000000000000011\n" +".quad 0x0000000000000000,0x0000000000000000,0x33010102464c457f,0x0000000000000007\n" +".quad 0x0000008000be0002,0x0000000000000000,0x00000000000002f8,0x0000000000000178\n" +".quad 0x0038004000340534,0x0001000600400002,0x7472747368732e00,0x747274732e006261\n" +".quad 0x746d79732e006261,0x746d79732e006261,0x78646e68735f6261,0x666e692e766e2e00\n" +".quad 0x61632e766e2e006f,0x0068706172676c6c,0x746f72702e766e2e,0x6e2e00657079746f\n" +".quad 0x63612e6c65722e76,0x732e00006e6f6974,0x0062617472747368,0x006261747274732e\n" +".quad 0x006261746d79732e,0x5f6261746d79732e,0x6e2e0078646e6873,0x2e006f666e692e76\n" +".quad 0x676c6c61632e766e,0x766e2e0068706172,0x79746f746f72702e,0x722e766e2e006570\n" +".quad 0x6f697463612e6c65,0x000000000000006e,0x0000000000000000,0x0000000000000000\n" +".quad 0x0000000000000000,0x0004000300000032,0x0000000000000000,0x0000000000000000\n" +".quad 0x000500030000004e,0x0000000000000000,0x0000000000000000,0xffffffff00000000\n" +".quad 0xfffffffe00000000,0xfffffffd00000000,0xfffffffc00000000,0x0000000000000073\n" +".quad 0x3605002511000000,0x0000000000000000,0x0000000000000000,0x0000000000000000\n" +".quad 0x0000000000000000,0x0000000000000000,0x0000000000000000,0x0000000000000000\n" +".quad 0x0000000000000000,0x0000000300000001,0x0000000000000000,0x0000000000000000\n" +".quad 0x0000000000000040,0x000000000000005d,0x0000000000000000,0x0000000000000001\n" +".quad 0x0000000000000000,0x000000030000000b,0x0000000000000000,0x0000000000000000\n" +".quad 0x000000000000009d,0x000000000000005d,0x0000000000000000,0x0000000000000001\n" +".quad 0x0000000000000000,0x0000000200000013,0x0000000000000000,0x0000000000000000\n" +".quad 0x0000000000000100,0x0000000000000048,0x0000000300000002,0x0000000000000008\n" +".quad 0x0000000000000018,0x7000000100000032,0x0000000000000000,0x0000000000000000\n" +".quad 0x0000000000000148,0x0000000000000020,0x0000000000000003,0x0000000000000004\n" +".quad 0x0000000000000008,0x7000000b0000004e,0x0000000000000000,0x0000000000000000\n" +".quad 0x0000000000000168,0x0000000000000010,0x0000000000000000,0x0000000000000008\n" +".quad 0x0000000000000008,0x0000000500000006,0x00000000000002f8,0x0000000000000000\n" +".quad 0x0000000000000000,0x0000000000000070,0x0000000000000070,0x0000000000000008\n" +".quad 0x0000000500000001,0x00000000000002f8,0x0000000000000000,0x0000000000000000\n" +".quad 0x0000000000000070,0x0000000000000070,0x0000000000000008,0x0000005001010001\n" +".quad 0x0000000000000040,0x0000004000000039,0x0000003400080007,0x0000000000000000\n" +".quad 0x0000000000002011,0x0000000000000000,0x0000000000000044,0x0000000000000048\n" +".quad 0x0000000000000000,0x22f000032f2f0a3c,0x6f69737265762e0a,0x742e0a372e38206e\n" +".quad 0x6d73207465677261,0x6464612e0a32355f,0x7a69735f73736572,0x0a0a0a0a34362065\n" +".quad 0x0000000000000000\n" +".text\n"); +#ifdef __cplusplus +extern "C" { +#endif +extern const unsigned long long fatbinData[137]; +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +static const __fatBinC_Wrapper_t __fatDeviceText __attribute__ ((aligned (8))) __attribute__ ((section (__CUDAFATBINSECTION)))= + { 0x466243b1, 1, fatbinData, 0 }; +#ifdef __cplusplus +} +#endif diff --git a/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.module_id b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.module_id new file mode 100644 index 0000000..6e5fdfe --- /dev/null +++ b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.module_id @@ -0,0 +1 @@ +_41504697_22_CMakeCUDACompilerId_cu_bd57c623 \ No newline at end of file diff --git a/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.o b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.o new file mode 100644 index 0000000000000000000000000000000000000000..b58e715357778e1eddb3f7d0b69eed19a282592f GIT binary patch literal 6912 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 F{y$~r1cm?r literal 0 HcmV?d00001 diff --git a/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.ptx b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.ptx new file mode 100644 index 0000000..eca22bd --- /dev/null +++ b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.ptx @@ -0,0 +1,14 @@ +// +// Generated by NVIDIA NVVM Compiler +// +// Compiler Build ID: CL-35583870 +// Cuda compilation tools, release 12.8, V12.8.93 +// Based on NVVM 7.0.1 +// + +.version 8.7 +.target sm_52 +.address_size 64 + + + diff --git a/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.sm_52.cubin b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.sm_52.cubin new file mode 100644 index 0000000000000000000000000000000000000000..f6416e6f380f5c54e6b5f18685eee88d2e35c83f GIT binary patch literal 872 zcmb<-^>JfjWHe@HfB+_jeGCmyHi-Jc1mRRLLTD3K69xwc3kD`2$;JQ_)GN*?E-5NW zOaiiCbY(7t52oXbGxAa@81(YW^fL3(^1+Pc#GIV;qQrs>Ft4B}za+n;vLF@AD@x7L zOH3}w%+I5-;SdkuAdP_H%nU3TvVLH3Rt#~Fz<(eB(f^?IUnuVdEq98ROdpMwc2`CK; zU!c+gC>Kt7K=ms?MPP1(#RSY8P&@$rfT2GFs$T$ZB7_0c2cy}5!k}1$rEfIlaD!nM L!1RHPCr2LunowYG literal 0 HcmV?d00001 diff --git a/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/a_dlink.fatbin b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/a_dlink.fatbin new file mode 100644 index 0000000000000000000000000000000000000000..0f66675178f63daccb9d3dc1fce92e8dbe0e13f4 GIT binary patch literal 952 zcmcIiy-ve05I(!4t<YD?4O%APT8i1Xmwzx_2S(5LCYs&jf?P`@r&^jv7#4# zjSe6fi`W)v92+BdtzvF?#VEkz6A1%kzvZ8~;;;NJ*74P-dpg1!P1vOx+NaNYkCFZ_ ymKH2)m~eid9r;F?g!G{~;2BzZ!}(#|(G$rDcG0FO%KhFbuN%t-lB4$9P~+;ThNT2C7dzuRp^e!s1~e$-2P$#y@`UKDg)zmar$ z;YUuMsdCgT5j3HWj11h=xIUMWvG*hZ|6%<%>%U0HY4pj{YVw=ZJ)DK(u#Q|O@;Kcp zYf*OZ9ixG9{HOns{~5(`YseHv^F$R!5rcVV*gwS@`%9sHc899M`~oAgMmY(|gL9x7 zM)+;!=Z6`MAw1Dj1mhH?zpe0LVwpgANPigKi*kK=?0#J@moF90T)$cUx-h@smfZP5 zsaU#DEET`iOG4cRo|A%b-+u+hWs*MVe@N^U6|1W}hj;MFKukDbD;VKS}jJr4JHz#wSWX{usQ%%DJdTr!+^dVm2L?duQ zp8%{>e$wXXy=)Qg&`TvE{db=LyGL|Pw-c_@OSV~8wI6PjinUr}v*|DUNqMv02`hfs z>;}q!)i4TLoj3`itDVq~wyQ~}t4Sp@zCte-U%WE#L z`|!P|`g}LR%H1Z4a_e!7Cmdx_!OGPE;g+f6`=GTEgcRH8Z5Si$C4oy#eJ)P?#yT=;Q#z75FfRt9bpoBMwz?8HdNY~2Am^>z4nYd{9WOM zMMjR323O8O`tB>nDtA`6cfy!mxhXXEL>%;rZo_6I}LB^p7+kw!}a$ zF+YpJwqw@`!+o;%uflwLU9x`Uf;^-TIc@%c`4JfjWHe@HfB+_jeGCmyHi-Jc1mRRLLTD3K69xwc3kD`2$;JQ_)GN*?E-5NW zOaiiCbY(7t52oXbGxAa@81(YW^fL3(^1+Pc#GIV;qQrs>Ft4B}za+n;vLF@AD@x7L zOH3}w%+I5-;SdkuAdP_H%nU3TvVLH3Rt#~Fz<(eB(f^?IUnuVdEq98ROdpMwc2`CK; zU!c+gC>Kt7K=ms?MPP1(#RSY8P&@$rfT2GFs$T$ZB7_0c2cy}5!k}1$rEfIlaD!nM L!1RHPCr2LunowYG literal 0 HcmV?d00001 diff --git a/CMakeFiles/4.0.2-dirty/CompilerIdCXX/CMakeCXXCompilerId.cpp b/CMakeFiles/4.0.2-dirty/CompilerIdCXX/CMakeCXXCompilerId.cpp new file mode 100644 index 0000000..94d4310 --- /dev/null +++ b/CMakeFiles/4.0.2-dirty/CompilerIdCXX/CMakeCXXCompilerId.cpp @@ -0,0 +1,920 @@ +/* This source file must have a .cpp extension so that all C++ compilers + recognize the extension without flags. Borland does not know .cxx for + example. */ +#ifndef __cplusplus +# error "A C compiler has been selected for C++." +#endif + +#if !defined(__has_include) +/* If the compiler does not have __has_include, pretend the answer is + always no. */ +# define __has_include(x) 0 +#endif + + +/* Version number components: V=Version, R=Revision, P=Patch + Version date components: YYYY=Year, MM=Month, DD=Day */ + +#if defined(__INTEL_COMPILER) || defined(__ICC) +# define COMPILER_ID "Intel" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# if defined(__GNUC__) +# define SIMULATE_ID "GNU" +# endif + /* __INTEL_COMPILER = VRP prior to 2021, and then VVVV for 2021 and later, + except that a few beta releases use the old format with V=2021. */ +# if __INTEL_COMPILER < 2021 || __INTEL_COMPILER == 202110 || __INTEL_COMPILER == 202111 +# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10) +# if defined(__INTEL_COMPILER_UPDATE) +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE) +# else +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10) +# endif +# else +# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER) +# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER_UPDATE) + /* The third version component from --version is an update index, + but no macro is provided for it. */ +# define COMPILER_VERSION_PATCH DEC(0) +# endif +# if defined(__INTEL_COMPILER_BUILD_DATE) + /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */ +# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE) +# endif +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# if defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# elif defined(__GNUG__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif (defined(__clang__) && defined(__INTEL_CLANG_COMPILER)) || defined(__INTEL_LLVM_COMPILER) +# define COMPILER_ID "IntelLLVM" +#if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +#endif +#if defined(__GNUC__) +# define SIMULATE_ID "GNU" +#endif +/* __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and + * later. Look for 6 digit vs. 8 digit version number to decide encoding. + * VVVV is no smaller than the current year when a version is released. + */ +#if __INTEL_LLVM_COMPILER < 1000000L +# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 10) +#else +# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000) +# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 100) +#endif +#if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +#endif +#if defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +#elif defined(__GNUG__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUG__) +#endif +#if defined(__GNUC_MINOR__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +#endif +#if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +#endif + +#elif defined(__PATHCC__) +# define COMPILER_ID "PathScale" +# define COMPILER_VERSION_MAJOR DEC(__PATHCC__) +# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__) +# if defined(__PATHCC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__) +# endif + +#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__) +# define COMPILER_ID "Embarcadero" +# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF) +# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF) +# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF) + +#elif defined(__BORLANDC__) +# define COMPILER_ID "Borland" + /* __BORLANDC__ = 0xVRR */ +# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8) +# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF) + +#elif defined(__WATCOMC__) && __WATCOMC__ < 1200 +# define COMPILER_ID "Watcom" + /* __WATCOMC__ = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__WATCOMC__) +# define COMPILER_ID "OpenWatcom" + /* __WATCOMC__ = VVRP + 1100 */ +# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__SUNPRO_CC) +# define COMPILER_ID "SunPro" +# if __SUNPRO_CC >= 0x5100 + /* __SUNPRO_CC = 0xVRRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# else + /* __SUNPRO_CC = 0xVRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# endif + +#elif defined(__HP_aCC) +# define COMPILER_ID "HP" + /* __HP_aCC = VVRRPP */ +# define COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000) +# define COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__HP_aCC % 100) + +#elif defined(__DECCXX) +# define COMPILER_ID "Compaq" + /* __DECCXX_VER = VVRRTPPPP */ +# define COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000) +# define COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000 % 100) +# define COMPILER_VERSION_PATCH DEC(__DECCXX_VER % 10000) + +#elif defined(__IBMCPP__) && defined(__COMPILER_VER__) +# define COMPILER_ID "zOS" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__open_xl__) && defined(__clang__) +# define COMPILER_ID "IBMClang" +# define COMPILER_VERSION_MAJOR DEC(__open_xl_version__) +# define COMPILER_VERSION_MINOR DEC(__open_xl_release__) +# define COMPILER_VERSION_PATCH DEC(__open_xl_modification__) +# define COMPILER_VERSION_TWEAK DEC(__open_xl_ptf_fix_level__) +# define COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(__ibmxl__) && defined(__clang__) +# define COMPILER_ID "XLClang" +# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__) +# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__) +# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__) +# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__) + + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800 +# define COMPILER_ID "XL" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800 +# define COMPILER_ID "VisualAge" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__NVCOMPILER) +# define COMPILER_ID "NVHPC" +# define COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__) +# define COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__) +# if defined(__NVCOMPILER_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__) +# endif + +#elif defined(__PGI) +# define COMPILER_ID "PGI" +# define COMPILER_VERSION_MAJOR DEC(__PGIC__) +# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__) +# if defined(__PGIC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__) +# endif + +#elif defined(__clang__) && defined(__cray__) +# define COMPILER_ID "CrayClang" +# define COMPILER_VERSION_MAJOR DEC(__cray_major__) +# define COMPILER_VERSION_MINOR DEC(__cray_minor__) +# define COMPILER_VERSION_PATCH DEC(__cray_patchlevel__) +# define COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(_CRAYC) +# define COMPILER_ID "Cray" +# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR) +# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR) + +#elif defined(__TI_COMPILER_VERSION__) +# define COMPILER_ID "TI" + /* __TI_COMPILER_VERSION__ = VVVRRRPPP */ +# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000) +# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000) +# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000) + +#elif defined(__CLANG_FUJITSU) +# define COMPILER_ID "FujitsuClang" +# define COMPILER_VERSION_MAJOR DEC(__FCC_major__) +# define COMPILER_VERSION_MINOR DEC(__FCC_minor__) +# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__) +# define COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(__FUJITSU) +# define COMPILER_ID "Fujitsu" +# if defined(__FCC_version__) +# define COMPILER_VERSION __FCC_version__ +# elif defined(__FCC_major__) +# define COMPILER_VERSION_MAJOR DEC(__FCC_major__) +# define COMPILER_VERSION_MINOR DEC(__FCC_minor__) +# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__) +# endif +# if defined(__fcc_version) +# define COMPILER_VERSION_INTERNAL DEC(__fcc_version) +# elif defined(__FCC_VERSION) +# define COMPILER_VERSION_INTERNAL DEC(__FCC_VERSION) +# endif + + +#elif defined(__ghs__) +# define COMPILER_ID "GHS" +/* __GHS_VERSION_NUMBER = VVVVRP */ +# ifdef __GHS_VERSION_NUMBER +# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100) +# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10) +# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER % 10) +# endif + +#elif defined(__TASKING__) +# define COMPILER_ID "Tasking" + # define COMPILER_VERSION_MAJOR DEC(__VERSION__/1000) + # define COMPILER_VERSION_MINOR DEC(__VERSION__ % 100) +# define COMPILER_VERSION_INTERNAL DEC(__VERSION__) + +#elif defined(__ORANGEC__) +# define COMPILER_ID "OrangeC" +# define COMPILER_VERSION_MAJOR DEC(__ORANGEC_MAJOR__) +# define COMPILER_VERSION_MINOR DEC(__ORANGEC_MINOR__) +# define COMPILER_VERSION_PATCH DEC(__ORANGEC_PATCHLEVEL__) + +#elif defined(__SCO_VERSION__) +# define COMPILER_ID "SCO" + +#elif defined(__ARMCC_VERSION) && !defined(__clang__) +# define COMPILER_ID "ARMCC" +#if __ARMCC_VERSION >= 1000000 + /* __ARMCC_VERSION = VRRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#else + /* __ARMCC_VERSION = VRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#endif + + +#elif defined(__clang__) && defined(__apple_build_version__) +# define COMPILER_ID "AppleClang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__) + +#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION) +# define COMPILER_ID "ARMClang" + # define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION/100 % 100) +# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION) + +#elif defined(__clang__) && defined(__ti__) +# define COMPILER_ID "TIClang" + # define COMPILER_VERSION_MAJOR DEC(__ti_major__) + # define COMPILER_VERSION_MINOR DEC(__ti_minor__) + # define COMPILER_VERSION_PATCH DEC(__ti_patchlevel__) +# define COMPILER_VERSION_INTERNAL DEC(__ti_version__) + +#elif defined(__clang__) +# define COMPILER_ID "Clang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + +#elif defined(__LCC__) && (defined(__GNUC__) || defined(__GNUG__) || defined(__MCST__)) +# define COMPILER_ID "LCC" +# define COMPILER_VERSION_MAJOR DEC(__LCC__ / 100) +# define COMPILER_VERSION_MINOR DEC(__LCC__ % 100) +# if defined(__LCC_MINOR__) +# define COMPILER_VERSION_PATCH DEC(__LCC_MINOR__) +# endif +# if defined(__GNUC__) && defined(__GNUC_MINOR__) +# define SIMULATE_ID "GNU" +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif +# endif + +#elif defined(__GNUC__) || defined(__GNUG__) +# define COMPILER_ID "GNU" +# if defined(__GNUC__) +# define COMPILER_VERSION_MAJOR DEC(__GNUC__) +# else +# define COMPILER_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(_MSC_VER) +# define COMPILER_ID "MSVC" + /* _MSC_VER = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100) +# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100) +# if defined(_MSC_FULL_VER) +# if _MSC_VER >= 1400 + /* _MSC_FULL_VER = VVRRPPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000) +# else + /* _MSC_FULL_VER = VVRRPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000) +# endif +# endif +# if defined(_MSC_BUILD) +# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD) +# endif + +#elif defined(_ADI_COMPILER) +# define COMPILER_ID "ADSP" +#if defined(__VERSIONNUM__) + /* __VERSIONNUM__ = 0xVVRRPPTT */ +# define COMPILER_VERSION_MAJOR DEC(__VERSIONNUM__ >> 24 & 0xFF) +# define COMPILER_VERSION_MINOR DEC(__VERSIONNUM__ >> 16 & 0xFF) +# define COMPILER_VERSION_PATCH DEC(__VERSIONNUM__ >> 8 & 0xFF) +# define COMPILER_VERSION_TWEAK DEC(__VERSIONNUM__ & 0xFF) +#endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# define COMPILER_ID "IAR" +# if defined(__VER__) && defined(__ICCARM__) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000) +# define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000) +# define COMPILER_VERSION_PATCH DEC((__VER__) % 1000) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__) || defined(__ICCSTM8__)) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 100) +# define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100)) +# define COMPILER_VERSION_PATCH DEC(__SUBVERSION__) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# endif + + +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__hpux) || defined(__hpua) +# define COMPILER_ID "HP" + +#else /* unknown compiler */ +# define COMPILER_ID "" +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#ifdef __QNXNTO__ +char const* qnxnto = "INFO" ":" "qnxnto[]"; +#endif + +#if defined(__CRAYXT_COMPUTE_LINUX_TARGET) +char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]"; +#endif + +#define STRINGIFY_HELPER(X) #X +#define STRINGIFY(X) STRINGIFY_HELPER(X) + +/* Identify known platforms by name. */ +#if defined(__linux) || defined(__linux__) || defined(linux) +# define PLATFORM_ID "Linux" + +#elif defined(__MSYS__) +# define PLATFORM_ID "MSYS" + +#elif defined(__CYGWIN__) +# define PLATFORM_ID "Cygwin" + +#elif defined(__MINGW32__) +# define PLATFORM_ID "MinGW" + +#elif defined(__APPLE__) +# define PLATFORM_ID "Darwin" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +# define PLATFORM_ID "Windows" + +#elif defined(__FreeBSD__) || defined(__FreeBSD) +# define PLATFORM_ID "FreeBSD" + +#elif defined(__NetBSD__) || defined(__NetBSD) +# define PLATFORM_ID "NetBSD" + +#elif defined(__OpenBSD__) || defined(__OPENBSD) +# define PLATFORM_ID "OpenBSD" + +#elif defined(__sun) || defined(sun) +# define PLATFORM_ID "SunOS" + +#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__) +# define PLATFORM_ID "AIX" + +#elif defined(__hpux) || defined(__hpux__) +# define PLATFORM_ID "HP-UX" + +#elif defined(__HAIKU__) +# define PLATFORM_ID "Haiku" + +#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS) +# define PLATFORM_ID "BeOS" + +#elif defined(__QNX__) || defined(__QNXNTO__) +# define PLATFORM_ID "QNX" + +#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__) +# define PLATFORM_ID "Tru64" + +#elif defined(__riscos) || defined(__riscos__) +# define PLATFORM_ID "RISCos" + +#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__) +# define PLATFORM_ID "SINIX" + +#elif defined(__UNIX_SV__) +# define PLATFORM_ID "UNIX_SV" + +#elif defined(__bsdos__) +# define PLATFORM_ID "BSDOS" + +#elif defined(_MPRAS) || defined(MPRAS) +# define PLATFORM_ID "MP-RAS" + +#elif defined(__osf) || defined(__osf__) +# define PLATFORM_ID "OSF1" + +#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv) +# define PLATFORM_ID "SCO_SV" + +#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX) +# define PLATFORM_ID "ULTRIX" + +#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX) +# define PLATFORM_ID "Xenix" + +#elif defined(__WATCOMC__) +# if defined(__LINUX__) +# define PLATFORM_ID "Linux" + +# elif defined(__DOS__) +# define PLATFORM_ID "DOS" + +# elif defined(__OS2__) +# define PLATFORM_ID "OS2" + +# elif defined(__WINDOWS__) +# define PLATFORM_ID "Windows3x" + +# elif defined(__VXWORKS__) +# define PLATFORM_ID "VxWorks" + +# else /* unknown platform */ +# define PLATFORM_ID +# endif + +#elif defined(__INTEGRITY) +# if defined(INT_178B) +# define PLATFORM_ID "Integrity178" + +# else /* regular Integrity */ +# define PLATFORM_ID "Integrity" +# endif + +# elif defined(_ADI_COMPILER) +# define PLATFORM_ID "ADSP" + +#else /* unknown platform */ +# define PLATFORM_ID + +#endif + +/* For windows compilers MSVC and Intel we can determine + the architecture of the compiler being used. This is because + the compilers do not have flags that can change the architecture, + but rather depend on which compiler is being used +*/ +#if defined(_WIN32) && defined(_MSC_VER) +# if defined(_M_IA64) +# define ARCHITECTURE_ID "IA64" + +# elif defined(_M_ARM64EC) +# define ARCHITECTURE_ID "ARM64EC" + +# elif defined(_M_X64) || defined(_M_AMD64) +# define ARCHITECTURE_ID "x64" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# elif defined(_M_ARM64) +# define ARCHITECTURE_ID "ARM64" + +# elif defined(_M_ARM) +# if _M_ARM == 4 +# define ARCHITECTURE_ID "ARMV4I" +# elif _M_ARM == 5 +# define ARCHITECTURE_ID "ARMV5I" +# else +# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM) +# endif + +# elif defined(_M_MIPS) +# define ARCHITECTURE_ID "MIPS" + +# elif defined(_M_SH) +# define ARCHITECTURE_ID "SHx" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__WATCOMC__) +# if defined(_M_I86) +# define ARCHITECTURE_ID "I86" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# if defined(__ICCARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__ICCRX__) +# define ARCHITECTURE_ID "RX" + +# elif defined(__ICCRH850__) +# define ARCHITECTURE_ID "RH850" + +# elif defined(__ICCRL78__) +# define ARCHITECTURE_ID "RL78" + +# elif defined(__ICCRISCV__) +# define ARCHITECTURE_ID "RISCV" + +# elif defined(__ICCAVR__) +# define ARCHITECTURE_ID "AVR" + +# elif defined(__ICC430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__ICCV850__) +# define ARCHITECTURE_ID "V850" + +# elif defined(__ICC8051__) +# define ARCHITECTURE_ID "8051" + +# elif defined(__ICCSTM8__) +# define ARCHITECTURE_ID "STM8" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__ghs__) +# if defined(__PPC64__) +# define ARCHITECTURE_ID "PPC64" + +# elif defined(__ppc__) +# define ARCHITECTURE_ID "PPC" + +# elif defined(__ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__x86_64__) +# define ARCHITECTURE_ID "x64" + +# elif defined(__i386__) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__clang__) && defined(__ti__) +# if defined(__ARM_ARCH) +# define ARCHITECTURE_ID "ARM" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__TI_COMPILER_VERSION__) +# if defined(__TI_ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__MSP430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__TMS320C28XX__) +# define ARCHITECTURE_ID "TMS320C28x" + +# elif defined(__TMS320C6X__) || defined(_TMS320C6X) +# define ARCHITECTURE_ID "TMS320C6x" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +# elif defined(__ADSPSHARC__) +# define ARCHITECTURE_ID "SHARC" + +# elif defined(__ADSPBLACKFIN__) +# define ARCHITECTURE_ID "Blackfin" + +#elif defined(__TASKING__) + +# if defined(__CTC__) || defined(__CPTC__) +# define ARCHITECTURE_ID "TriCore" + +# elif defined(__CMCS__) +# define ARCHITECTURE_ID "MCS" + +# elif defined(__CARM__) || defined(__CPARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__CARC__) +# define ARCHITECTURE_ID "ARC" + +# elif defined(__C51__) +# define ARCHITECTURE_ID "8051" + +# elif defined(__CPCP__) +# define ARCHITECTURE_ID "PCP" + +# else +# define ARCHITECTURE_ID "" +# endif + +#else +# define ARCHITECTURE_ID +#endif + +/* Convert integer to decimal digit literals. */ +#define DEC(n) \ + ('0' + (((n) / 10000000)%10)), \ + ('0' + (((n) / 1000000)%10)), \ + ('0' + (((n) / 100000)%10)), \ + ('0' + (((n) / 10000)%10)), \ + ('0' + (((n) / 1000)%10)), \ + ('0' + (((n) / 100)%10)), \ + ('0' + (((n) / 10)%10)), \ + ('0' + ((n) % 10)) + +/* Convert integer to hex digit literals. */ +#define HEX(n) \ + ('0' + ((n)>>28 & 0xF)), \ + ('0' + ((n)>>24 & 0xF)), \ + ('0' + ((n)>>20 & 0xF)), \ + ('0' + ((n)>>16 & 0xF)), \ + ('0' + ((n)>>12 & 0xF)), \ + ('0' + ((n)>>8 & 0xF)), \ + ('0' + ((n)>>4 & 0xF)), \ + ('0' + ((n) & 0xF)) + +/* Construct a string literal encoding the version number. */ +#ifdef COMPILER_VERSION +char const* info_version = "INFO" ":" "compiler_version[" COMPILER_VERSION "]"; + +/* Construct a string literal encoding the version number components. */ +#elif defined(COMPILER_VERSION_MAJOR) +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + COMPILER_VERSION_MAJOR, +# ifdef COMPILER_VERSION_MINOR + '.', COMPILER_VERSION_MINOR, +# ifdef COMPILER_VERSION_PATCH + '.', COMPILER_VERSION_PATCH, +# ifdef COMPILER_VERSION_TWEAK + '.', COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct a string literal encoding the internal version number. */ +#ifdef COMPILER_VERSION_INTERNAL +char const info_version_internal[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_', + 'i','n','t','e','r','n','a','l','[', + COMPILER_VERSION_INTERNAL,']','\0'}; +#elif defined(COMPILER_VERSION_INTERNAL_STR) +char const* info_version_internal = "INFO" ":" "compiler_version_internal[" COMPILER_VERSION_INTERNAL_STR "]"; +#endif + +/* Construct a string literal encoding the version number components. */ +#ifdef SIMULATE_VERSION_MAJOR +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + SIMULATE_VERSION_MAJOR, +# ifdef SIMULATE_VERSION_MINOR + '.', SIMULATE_VERSION_MINOR, +# ifdef SIMULATE_VERSION_PATCH + '.', SIMULATE_VERSION_PATCH, +# ifdef SIMULATE_VERSION_TWEAK + '.', SIMULATE_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]"; +char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]"; + + + +#define CXX_STD_98 199711L +#define CXX_STD_11 201103L +#define CXX_STD_14 201402L +#define CXX_STD_17 201703L +#define CXX_STD_20 202002L +#define CXX_STD_23 202302L + +#if defined(__INTEL_COMPILER) && defined(_MSVC_LANG) +# if _MSVC_LANG > CXX_STD_17 +# define CXX_STD _MSVC_LANG +# elif _MSVC_LANG == CXX_STD_17 && defined(__cpp_aggregate_paren_init) +# define CXX_STD CXX_STD_20 +# elif _MSVC_LANG > CXX_STD_14 && __cplusplus > CXX_STD_17 +# define CXX_STD CXX_STD_20 +# elif _MSVC_LANG > CXX_STD_14 +# define CXX_STD CXX_STD_17 +# elif defined(__INTEL_CXX11_MODE__) && defined(__cpp_aggregate_nsdmi) +# define CXX_STD CXX_STD_14 +# elif defined(__INTEL_CXX11_MODE__) +# define CXX_STD CXX_STD_11 +# else +# define CXX_STD CXX_STD_98 +# endif +#elif defined(_MSC_VER) && defined(_MSVC_LANG) +# if _MSVC_LANG > __cplusplus +# define CXX_STD _MSVC_LANG +# else +# define CXX_STD __cplusplus +# endif +#elif defined(__NVCOMPILER) +# if __cplusplus == CXX_STD_17 && defined(__cpp_aggregate_paren_init) +# define CXX_STD CXX_STD_20 +# else +# define CXX_STD __cplusplus +# endif +#elif defined(__INTEL_COMPILER) || defined(__PGI) +# if __cplusplus == CXX_STD_11 && defined(__cpp_namespace_attributes) +# define CXX_STD CXX_STD_17 +# elif __cplusplus == CXX_STD_11 && defined(__cpp_aggregate_nsdmi) +# define CXX_STD CXX_STD_14 +# else +# define CXX_STD __cplusplus +# endif +#elif (defined(__IBMCPP__) || defined(__ibmxl__)) && defined(__linux__) +# if __cplusplus == CXX_STD_11 && defined(__cpp_aggregate_nsdmi) +# define CXX_STD CXX_STD_14 +# else +# define CXX_STD __cplusplus +# endif +#elif __cplusplus == 1 && defined(__GXX_EXPERIMENTAL_CXX0X__) +# define CXX_STD CXX_STD_11 +#else +# define CXX_STD __cplusplus +#endif + +const char* info_language_standard_default = "INFO" ":" "standard_default[" +#if CXX_STD > CXX_STD_23 + "26" +#elif CXX_STD > CXX_STD_20 + "23" +#elif CXX_STD > CXX_STD_17 + "20" +#elif CXX_STD > CXX_STD_14 + "17" +#elif CXX_STD > CXX_STD_11 + "14" +#elif CXX_STD >= CXX_STD_11 + "11" +#else + "98" +#endif +"]"; + +const char* info_language_extensions_default = "INFO" ":" "extensions_default[" +#if (defined(__clang__) || defined(__GNUC__) || defined(__xlC__) || \ + defined(__TI_COMPILER_VERSION__)) && \ + !defined(__STRICT_ANSI__) + "ON" +#else + "OFF" +#endif +"]"; + +/*--------------------------------------------------------------------------*/ + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; + require += info_arch[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#if defined(COMPILER_VERSION_INTERNAL) || defined(COMPILER_VERSION_INTERNAL_STR) + require += info_version_internal[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#if defined(__CRAYXT_COMPUTE_LINUX_TARGET) + require += info_cray[argc]; +#endif + require += info_language_standard_default[argc]; + require += info_language_extensions_default[argc]; + (void)argv; + return require; +} diff --git a/CMakeFiles/4.0.2-dirty/CompilerIdCXX/a.out b/CMakeFiles/4.0.2-dirty/CompilerIdCXX/a.out new file mode 100755 index 0000000000000000000000000000000000000000..dba322363de31a68cf74b7be1929aea0fed4a1a5 GIT binary patch literal 15552 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 YFpy{rk=BIu{V(yuH)`7q2SZf<0dg+$2LJ#7 literal 0 HcmV?d00001 diff --git a/CMakeFiles/CMakeConfigureLog.yaml b/CMakeFiles/CMakeConfigureLog.yaml new file mode 100644 index 0000000..321f13b --- /dev/null +++ b/CMakeFiles/CMakeConfigureLog.yaml @@ -0,0 +1,634 @@ + +--- +events: + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineSystem.cmake:205 (message)" + - "CMakeLists.txt:2 (project)" + message: | + The system is: Linux - 6.14.7-arch2-1 - x86_64 + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerId.cmake:17 (message)" + - "/usr/share/cmake/Modules/CMakeDetermineCompilerId.cmake:64 (__determine_compiler_id_test)" + - "/usr/share/cmake/Modules/CMakeDetermineCXXCompiler.cmake:126 (CMAKE_DETERMINE_COMPILER_ID)" + - "CMakeLists.txt:2 (project)" + message: | + Compiling the CXX compiler identification source file "CMakeCXXCompilerId.cpp" succeeded. + Compiler: /usr/bin/c++ + Build flags: + Id flags: + + The output was: + 0 + + + Compilation of the CXX compiler identification source "CMakeCXXCompilerId.cpp" produced "a.out" + + The CXX compiler identification is GNU, found in: + /home/tobli/abo/pprog/Homework-3/CMakeFiles/4.0.2-dirty/CompilerIdCXX/a.out + + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerId.cmake:1284 (message)" + - "/usr/share/cmake/Modules/CMakeDetermineCUDACompiler.cmake:75 (CMAKE_DETERMINE_COMPILER_ID_VENDOR)" + - "CMakeLists.txt:2 (project)" + message: | + Checking whether the CUDA compiler is NVIDIA using "" did not match "nvcc: NVIDIA \\(R\\) Cuda compiler driver": + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerId.cmake:1284 (message)" + - "/usr/share/cmake/Modules/CMakeDetermineCUDACompiler.cmake:75 (CMAKE_DETERMINE_COMPILER_ID_VENDOR)" + - "CMakeLists.txt:2 (project)" + message: | + Checking whether the CUDA compiler is Clang using "" did not match "(clang version)": +... + +--- +events: + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerId.cmake:1271 (message)" + - "/usr/share/cmake/Modules/CMakeDetermineCUDACompiler.cmake:75 (CMAKE_DETERMINE_COMPILER_ID_VENDOR)" + - "CMakeLists.txt:2 (project)" + message: | + Checking whether the CUDA compiler is NVIDIA using "" matched "nvcc: NVIDIA \\(R\\) Cuda compiler driver": + nvcc: NVIDIA (R) Cuda compiler driver + Copyright (c) 2005-2025 NVIDIA Corporation + Built on Fri_Feb_21_20:23:50_PST_2025 + Cuda compilation tools, release 12.8, V12.8.93 + Build cuda_12.8.r12.8/compiler.35583870_0 +... + +--- +events: + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerId.cmake:1271 (message)" + - "/usr/share/cmake/Modules/CMakeDetermineCUDACompiler.cmake:75 (CMAKE_DETERMINE_COMPILER_ID_VENDOR)" + - "CMakeLists.txt:2 (project)" + message: | + Checking whether the CUDA compiler is NVIDIA using "" matched "nvcc: NVIDIA \\(R\\) Cuda compiler driver": + nvcc: NVIDIA (R) Cuda compiler driver + Copyright (c) 2005-2025 NVIDIA Corporation + Built on Fri_Feb_21_20:23:50_PST_2025 + Cuda compilation tools, release 12.8, V12.8.93 + Build cuda_12.8.r12.8/compiler.35583870_0 + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerId.cmake:17 (message)" + - "/usr/share/cmake/Modules/CMakeDetermineCompilerId.cmake:53 (__determine_compiler_id_test)" + - "/usr/share/cmake/Modules/CMakeDetermineCUDACompiler.cmake:136 (CMAKE_DETERMINE_COMPILER_ID)" + - "CMakeLists.txt:2 (project)" + message: | + Compiling the CUDA compiler identification source file "CMakeCUDACompilerId.cu" succeeded. + Compiler: /opt/cuda/bin/nvcc + Build flags: + Id flags: --keep;--keep-dir;tmp -v + + The output was: + 0 + nvcc warning : Support for offline compilation for architectures prior to '_75' will be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning). + #$ _NVVM_BRANCH_=nvvm + #$ _SPACE_= + #$ _CUDART_=cudart + #$ _HERE_=/opt/cuda/bin + #$ _THERE_=/opt/cuda/bin + #$ _TARGET_SIZE_= + #$ _TARGET_DIR_= + #$ _TARGET_DIR_=targets/x86_64-linux + #$ TOP=/opt/cuda/bin/.. + #$ CICC_PATH=/opt/cuda/bin/../nvvm/bin + #$ NVVMIR_LIBRARY_DIR=/opt/cuda/bin/../nvvm/libdevice + #$ LD_LIBRARY_PATH=/opt/cuda/bin/../lib:/opt/cuda/lib64 + #$ PATH=/opt/cuda/bin/../nvvm/bin:/opt/cuda/bin:/opt/cuda/bin/opt/cuda/bin/usr/local/sbin:/usr/local/bin:/usr/bin:/opt/cuda/bin:/opt/cuda/nsight_compute:/opt/cuda/nsight_systems/bin:/usr/lib/jvm/default/bin:/usr/bin/site_perl:/usr/bin/vendor_perl:/usr/bin/core_perl + #$ INCLUDES="-I/opt/cuda/bin/../targets/x86_64-linux/include" + #$ LIBRARIES= "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" + #$ CUDAFE_FLAGS= + #$ PTXAS_FLAGS= + #$ rm tmp/a_dlink.reg.c + #$ "/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -E -x c++ -D__CUDACC__ -D__NVCC__ "-I/opt/cuda/bin/../targets/x86_64-linux/include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=8 -D__CUDACC_VER_BUILD__=93 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=8 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -D__CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp4.ii" + #$ cudafe++ --c++17 --gnu_version=140201 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/tobli/abo/pprog/Homework-3/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/CMakeCUDACompilerId.cu" --allow_managed --m64 --parse_templates --gen_c_file_name "tmp/CMakeCUDACompilerId.cudafe1.cpp" --stub_file_name "CMakeCUDACompilerId.cudafe1.stub.c" --gen_module_id_file --module_id_file_name "tmp/CMakeCUDACompilerId.module_id" "tmp/CMakeCUDACompilerId.cpp4.ii" + #$ "/usr/bin"/g++-14 -D__CUDA_ARCH__=520 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -E -x c++ -DCUDA_DOUBLE_MATH_FUNCTIONS -D__CUDACC__ -D__NVCC__ "-I/opt/cuda/bin/../targets/x86_64-linux/include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=8 -D__CUDACC_VER_BUILD__=93 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=8 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -D__CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp1.ii" + #$ "$CICC_PATH/cicc" --c++17 --gnu_version=140201 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/tobli/abo/pprog/Homework-3/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/CMakeCUDACompilerId.cu" --allow_managed -arch compute_52 -m64 --no-version-ident -ftz=0 -prec_div=1 -prec_sqrt=1 -fmad=1 --include_file_name "CMakeCUDACompilerId.fatbin.c" -tused --module_id_file_name "tmp/CMakeCUDACompilerId.module_id" --gen_c_file_name "tmp/CMakeCUDACompilerId.cudafe1.c" --stub_file_name "tmp/CMakeCUDACompilerId.cudafe1.stub.c" --gen_device_file_name "tmp/CMakeCUDACompilerId.cudafe1.gpu" "tmp/CMakeCUDACompilerId.cpp1.ii" -o "tmp/CMakeCUDACompilerId.ptx" + #$ ptxas -arch=sm_52 -m64 "tmp/CMakeCUDACompilerId.ptx" -o "tmp/CMakeCUDACompilerId.sm_52.cubin" + #$ fatbinary --create="tmp/CMakeCUDACompilerId.fatbin" -64 --cicc-cmdline="-ftz=0 -prec_div=1 -prec_sqrt=1 -fmad=1 " "--image3=kind=elf,sm=52,file=tmp/CMakeCUDACompilerId.sm_52.cubin" "--image3=kind=ptx,sm=52,file=tmp/CMakeCUDACompilerId.ptx" --embedded-fatbin="tmp/CMakeCUDACompilerId.fatbin.c" + #$ "/usr/bin"/g++-14 -D__CUDA_ARCH__=520 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -c -x c++ -DCUDA_DOUBLE_MATH_FUNCTIONS -Wno-psabi "-I/opt/cuda/bin/../targets/x86_64-linux/include" -m64 "tmp/CMakeCUDACompilerId.cudafe1.cpp" -o "tmp/CMakeCUDACompilerId.o" + #$ nvlink -m64 --arch=sm_52 --register-link-binaries="tmp/a_dlink.reg.c" "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" -cpu-arch=X86_64 "tmp/CMakeCUDACompilerId.o" -lcudadevrt -o "tmp/a_dlink.sm_52.cubin" --host-ccbin "/usr/bin/g++-14" + #$ fatbinary --create="tmp/a_dlink.fatbin" -64 --cicc-cmdline="-ftz=0 -prec_div=1 -prec_sqrt=1 -fmad=1 " -link "--image3=kind=elf,sm=52,file=tmp/a_dlink.sm_52.cubin" --embedded-fatbin="tmp/a_dlink.fatbin.c" + #$ "/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -c -x c++ -DFATBINFILE="\\"tmp/a_dlink.fatbin.c\\"" -DREGISTERLINKBINARYFILE="\\"tmp/a_dlink.reg.c\\"" -I. -D__NV_EXTRA_INITIALIZATION= -D__NV_EXTRA_FINALIZATION= -D__CUDA_INCLUDE_COMPILER_INTERNAL_HEADERS__ -Wno-psabi "-I/opt/cuda/bin/../targets/x86_64-linux/include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=8 -D__CUDACC_VER_BUILD__=93 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=8 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -D__CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -m64 "/opt/cuda/bin/crt/link.stub" -o "tmp/a_dlink.o" + #$ "/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" + + + Compilation of the CUDA compiler identification source "CMakeCUDACompilerId.cu" produced "a.out" + + The CUDA compiler identification is NVIDIA, found in: + /home/tobli/abo/pprog/Homework-3/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/a.out + The host compiler identification is GNU + + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/Internal/CMakeNVCCParseImplicitInfo.cmake:128 (message)" + - "/usr/share/cmake/Modules/CMakeDetermineCUDACompiler.cmake:247 (cmake_nvcc_parse_implicit_info)" + - "CMakeLists.txt:2 (project)" + message: | + Parsed CUDA nvcc implicit link information: + found 'PATH=' string: [/opt/cuda/bin/../nvvm/bin:/opt/cuda/bin:/opt/cuda/bin/opt/cuda/bin/usr/local/sbin:/usr/local/bin:/usr/bin:/opt/cuda/bin:/opt/cuda/nsight_compute:/opt/cuda/nsight_systems/bin:/usr/lib/jvm/default/bin:/usr/bin/site_perl:/usr/bin/vendor_perl:/usr/bin/core_perl] + found 'LIBRARIES=' string: ["-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib"] + found 'INCLUDES=' string: ["-I/opt/cuda/bin/../targets/x86_64-linux/include" ] + considering line: [nvcc warning : Support for offline compilation for architectures prior to '_75' will be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning).] + considering line: [rm tmp/a_dlink.reg.c] + considering line: ["/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -E -x c++ -D__CUDACC__ -D__NVCC__ "-I/opt/cuda/bin/../targets/x86_64-linux/include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=8 -D__CUDACC_VER_BUILD__=93 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=8 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -D__CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp4.ii" ] + considering line: [cudafe++ --c++17 --gnu_version=140201 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/tobli/abo/pprog/Homework-3/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/CMakeCUDACompilerId.cu" --allow_managed --m64 --parse_templates --gen_c_file_name "tmp/CMakeCUDACompilerId.cudafe1.cpp" --stub_file_name "CMakeCUDACompilerId.cudafe1.stub.c" --gen_module_id_file --module_id_file_name "tmp/CMakeCUDACompilerId.module_id" "tmp/CMakeCUDACompilerId.cpp4.ii" ] + considering line: ["/usr/bin"/g++-14 -D__CUDA_ARCH__=520 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -E -x c++ -DCUDA_DOUBLE_MATH_FUNCTIONS -D__CUDACC__ -D__NVCC__ "-I/opt/cuda/bin/../targets/x86_64-linux/include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=8 -D__CUDACC_VER_BUILD__=93 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=8 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -D__CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp1.ii" ] + considering line: ["$CICC_PATH/cicc" --c++17 --gnu_version=140201 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/tobli/abo/pprog/Homework-3/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/CMakeCUDACompilerId.cu" --allow_managed -arch compute_52 -m64 --no-version-ident -ftz=0 -prec_div=1 -prec_sqrt=1 -fmad=1 --include_file_name "CMakeCUDACompilerId.fatbin.c" -tused --module_id_file_name "tmp/CMakeCUDACompilerId.module_id" --gen_c_file_name "tmp/CMakeCUDACompilerId.cudafe1.c" --stub_file_name "tmp/CMakeCUDACompilerId.cudafe1.stub.c" --gen_device_file_name "tmp/CMakeCUDACompilerId.cudafe1.gpu" "tmp/CMakeCUDACompilerId.cpp1.ii" -o "tmp/CMakeCUDACompilerId.ptx"] + considering line: [ptxas -arch=sm_52 -m64 "tmp/CMakeCUDACompilerId.ptx" -o "tmp/CMakeCUDACompilerId.sm_52.cubin" ] + considering line: [fatbinary --create="tmp/CMakeCUDACompilerId.fatbin" -64 --cicc-cmdline="-ftz=0 -prec_div=1 -prec_sqrt=1 -fmad=1 " "--image3=kind=elf,sm=52,file=tmp/CMakeCUDACompilerId.sm_52.cubin" "--image3=kind=ptx,sm=52,file=tmp/CMakeCUDACompilerId.ptx" --embedded-fatbin="tmp/CMakeCUDACompilerId.fatbin.c" ] + considering line: ["/usr/bin"/g++-14 -D__CUDA_ARCH__=520 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -c -x c++ -DCUDA_DOUBLE_MATH_FUNCTIONS -Wno-psabi "-I/opt/cuda/bin/../targets/x86_64-linux/include" -m64 "tmp/CMakeCUDACompilerId.cudafe1.cpp" -o "tmp/CMakeCUDACompilerId.o" ] + considering line: [nvlink -m64 --arch=sm_52 --register-link-binaries="tmp/a_dlink.reg.c" "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" -cpu-arch=X86_64 "tmp/CMakeCUDACompilerId.o" -lcudadevrt -o "tmp/a_dlink.sm_52.cubin" --host-ccbin "/usr/bin/g++-14"] + ignoring nvlink line + considering line: [fatbinary --create="tmp/a_dlink.fatbin" -64 --cicc-cmdline="-ftz=0 -prec_div=1 -prec_sqrt=1 -fmad=1 " -link "--image3=kind=elf,sm=52,file=tmp/a_dlink.sm_52.cubin" --embedded-fatbin="tmp/a_dlink.fatbin.c" ] + considering line: ["/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -c -x c++ -DFATBINFILE="\\"tmp/a_dlink.fatbin.c\\"" -DREGISTERLINKBINARYFILE="\\"tmp/a_dlink.reg.c\\"" -I. -D__NV_EXTRA_INITIALIZATION= -D__NV_EXTRA_FINALIZATION= -D__CUDA_INCLUDE_COMPILER_INTERNAL_HEADERS__ -Wno-psabi "-I/opt/cuda/bin/../targets/x86_64-linux/include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=8 -D__CUDACC_VER_BUILD__=93 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=8 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -D__CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -m64 "/opt/cuda/bin/crt/link.stub" -o "tmp/a_dlink.o" ] + considering line: ["/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" ] + extracted link line: ["/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" ] + considering line: [] + extracted link launcher absolute path: [/usr/bin/g++-14] + + link line regex: [^( *|.*[/\\])(ld[0-9]*(|\\.[a-rt-z][a-z]*|\\.s[a-np-z][a-z]*|\\.so[a-z]+)|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\\]+-)?ld|collect2)[^/\\]*( |$)] + link line: [cuda-fake-ld "/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" ] + arg [cuda-fake-ld] ==> ignore + arg [/usr/bin/g++-14] ==> ignore + arg [-D__CUDA_ARCH_LIST__=520] ==> ignore + arg [-D__NV_LEGACY_LAUNCH] ==> ignore + arg [-m64] ==> ignore + arg [-Wl,--start-group] ==> ignore + arg [tmp/a_dlink.o] ==> ignore + arg [tmp/CMakeCUDACompilerId.o] ==> ignore + arg [-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs] ==> dir [/opt/cuda/bin/../targets/x86_64-linux/lib/stubs] + arg [-L/opt/cuda/bin/../targets/x86_64-linux/lib] ==> dir [/opt/cuda/bin/../targets/x86_64-linux/lib] + arg [-lcudadevrt] ==> lib [cudadevrt] + arg [-lcudart_static] ==> lib [cudart_static] + arg [-lrt] ==> lib [rt] + arg [-lpthread] ==> lib [pthread] + arg [-ldl] ==> lib [dl] + arg [-Wl,--end-group] ==> ignore + arg [-o] ==> ignore + arg [a.out] ==> ignore + collapse library dir [/opt/cuda/bin/../targets/x86_64-linux/lib/stubs] ==> [/opt/cuda/targets/x86_64-linux/lib/stubs] + collapse library dir [/opt/cuda/bin/../targets/x86_64-linux/lib] ==> [/opt/cuda/targets/x86_64-linux/lib] + implicit libs: [cudadevrt;cudart_static;rt;pthread;dl] + implicit objs: [] + implicit dirs: [/opt/cuda/targets/x86_64-linux/lib/stubs;/opt/cuda/targets/x86_64-linux/lib] + implicit fwks: [] + + + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/Internal/CMakeNVCCParseImplicitInfo.cmake:146 (message)" + - "/usr/share/cmake/Modules/CMakeDetermineCUDACompiler.cmake:247 (cmake_nvcc_parse_implicit_info)" + - "CMakeLists.txt:2 (project)" + message: | + Parsed CUDA nvcc include information: + found 'PATH=' string: [/opt/cuda/bin/../nvvm/bin:/opt/cuda/bin:/opt/cuda/bin/opt/cuda/bin/usr/local/sbin:/usr/local/bin:/usr/bin:/opt/cuda/bin:/opt/cuda/nsight_compute:/opt/cuda/nsight_systems/bin:/usr/lib/jvm/default/bin:/usr/bin/site_perl:/usr/bin/vendor_perl:/usr/bin/core_perl] + found 'LIBRARIES=' string: ["-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib"] + found 'INCLUDES=' string: ["-I/opt/cuda/bin/../targets/x86_64-linux/include" ] + considering line: [nvcc warning : Support for offline compilation for architectures prior to '_75' will be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning).] + considering line: [rm tmp/a_dlink.reg.c] + considering line: ["/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -E -x c++ -D__CUDACC__ -D__NVCC__ "-I/opt/cuda/bin/../targets/x86_64-linux/include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=8 -D__CUDACC_VER_BUILD__=93 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=8 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -D__CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp4.ii" ] + considering line: [cudafe++ --c++17 --gnu_version=140201 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/tobli/abo/pprog/Homework-3/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/CMakeCUDACompilerId.cu" --allow_managed --m64 --parse_templates --gen_c_file_name "tmp/CMakeCUDACompilerId.cudafe1.cpp" --stub_file_name "CMakeCUDACompilerId.cudafe1.stub.c" --gen_module_id_file --module_id_file_name "tmp/CMakeCUDACompilerId.module_id" "tmp/CMakeCUDACompilerId.cpp4.ii" ] + considering line: ["/usr/bin"/g++-14 -D__CUDA_ARCH__=520 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -E -x c++ -DCUDA_DOUBLE_MATH_FUNCTIONS -D__CUDACC__ -D__NVCC__ "-I/opt/cuda/bin/../targets/x86_64-linux/include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=8 -D__CUDACC_VER_BUILD__=93 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=8 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -D__CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp1.ii" ] + considering line: ["$CICC_PATH/cicc" --c++17 --gnu_version=140201 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/tobli/abo/pprog/Homework-3/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/CMakeCUDACompilerId.cu" --allow_managed -arch compute_52 -m64 --no-version-ident -ftz=0 -prec_div=1 -prec_sqrt=1 -fmad=1 --include_file_name "CMakeCUDACompilerId.fatbin.c" -tused --module_id_file_name "tmp/CMakeCUDACompilerId.module_id" --gen_c_file_name "tmp/CMakeCUDACompilerId.cudafe1.c" --stub_file_name "tmp/CMakeCUDACompilerId.cudafe1.stub.c" --gen_device_file_name "tmp/CMakeCUDACompilerId.cudafe1.gpu" "tmp/CMakeCUDACompilerId.cpp1.ii" -o "tmp/CMakeCUDACompilerId.ptx"] + considering line: [ptxas -arch=sm_52 -m64 "tmp/CMakeCUDACompilerId.ptx" -o "tmp/CMakeCUDACompilerId.sm_52.cubin" ] + considering line: [fatbinary --create="tmp/CMakeCUDACompilerId.fatbin" -64 --cicc-cmdline="-ftz=0 -prec_div=1 -prec_sqrt=1 -fmad=1 " "--image3=kind=elf,sm=52,file=tmp/CMakeCUDACompilerId.sm_52.cubin" "--image3=kind=ptx,sm=52,file=tmp/CMakeCUDACompilerId.ptx" --embedded-fatbin="tmp/CMakeCUDACompilerId.fatbin.c" ] + considering line: ["/usr/bin"/g++-14 -D__CUDA_ARCH__=520 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -c -x c++ -DCUDA_DOUBLE_MATH_FUNCTIONS -Wno-psabi "-I/opt/cuda/bin/../targets/x86_64-linux/include" -m64 "tmp/CMakeCUDACompilerId.cudafe1.cpp" -o "tmp/CMakeCUDACompilerId.o" ] + considering line: [nvlink -m64 --arch=sm_52 --register-link-binaries="tmp/a_dlink.reg.c" "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" -cpu-arch=X86_64 "tmp/CMakeCUDACompilerId.o" -lcudadevrt -o "tmp/a_dlink.sm_52.cubin" --host-ccbin "/usr/bin/g++-14"] + ignoring nvlink line + considering line: [fatbinary --create="tmp/a_dlink.fatbin" -64 --cicc-cmdline="-ftz=0 -prec_div=1 -prec_sqrt=1 -fmad=1 " -link "--image3=kind=elf,sm=52,file=tmp/a_dlink.sm_52.cubin" --embedded-fatbin="tmp/a_dlink.fatbin.c" ] + considering line: ["/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -c -x c++ -DFATBINFILE="\\"tmp/a_dlink.fatbin.c\\"" -DREGISTERLINKBINARYFILE="\\"tmp/a_dlink.reg.c\\"" -I. -D__NV_EXTRA_INITIALIZATION= -D__NV_EXTRA_FINALIZATION= -D__CUDA_INCLUDE_COMPILER_INTERNAL_HEADERS__ -Wno-psabi "-I/opt/cuda/bin/../targets/x86_64-linux/include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=8 -D__CUDACC_VER_BUILD__=93 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=8 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -D__CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -m64 "/opt/cuda/bin/crt/link.stub" -o "tmp/a_dlink.o" ] + considering line: ["/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" ] + extracted link line: ["/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" ] + considering line: [] + extracted link launcher absolute path: [/usr/bin/g++-14] + + link line regex: [^( *|.*[/\\])(ld[0-9]*(|\\.[a-rt-z][a-z]*|\\.s[a-np-z][a-z]*|\\.so[a-z]+)|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\\]+-)?ld|collect2)[^/\\]*( |$)] + link line: [cuda-fake-ld "/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" ] + arg [cuda-fake-ld] ==> ignore + arg [/usr/bin/g++-14] ==> ignore + arg [-D__CUDA_ARCH_LIST__=520] ==> ignore + arg [-D__NV_LEGACY_LAUNCH] ==> ignore + arg [-m64] ==> ignore + arg [-Wl,--start-group] ==> ignore + arg [tmp/a_dlink.o] ==> ignore + arg [tmp/CMakeCUDACompilerId.o] ==> ignore + arg [-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs] ==> dir [/opt/cuda/bin/../targets/x86_64-linux/lib/stubs] + arg [-L/opt/cuda/bin/../targets/x86_64-linux/lib] ==> dir [/opt/cuda/bin/../targets/x86_64-linux/lib] + arg [-lcudadevrt] ==> lib [cudadevrt] + arg [-lcudart_static] ==> lib [cudart_static] + arg [-lrt] ==> lib [rt] + arg [-lpthread] ==> lib [pthread] + arg [-ldl] ==> lib [dl] + arg [-Wl,--end-group] ==> ignore + arg [-o] ==> ignore + arg [a.out] ==> ignore + collapse library dir [/opt/cuda/bin/../targets/x86_64-linux/lib/stubs] ==> [/opt/cuda/targets/x86_64-linux/lib/stubs] + collapse library dir [/opt/cuda/bin/../targets/x86_64-linux/lib] ==> [/opt/cuda/targets/x86_64-linux/lib] + implicit libs: [cudadevrt;cudart_static;rt;pthread;dl] + implicit objs: [] + implicit dirs: [/opt/cuda/targets/x86_64-linux/lib/stubs;/opt/cuda/targets/x86_64-linux/lib] + implicit fwks: [] + + + - + kind: "try_compile-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerABI.cmake:83 (try_compile)" + - "/usr/share/cmake/Modules/CMakeTestCUDACompiler.cmake:19 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + checks: + - "Detecting CUDA compiler ABI info" + directories: + source: "/home/tobli/abo/pprog/Homework-3/CMakeFiles/CMakeScratch/TryCompile-fZUGRz" + binary: "/home/tobli/abo/pprog/Homework-3/CMakeFiles/CMakeScratch/TryCompile-fZUGRz" + cmakeVariables: + CMAKE_CUDA_ARCHITECTURES: "52" + CMAKE_CUDA_FLAGS: "" + CMAKE_CUDA_FLAGS_DEBUG: "-g" + CMAKE_CUDA_RUNTIME_LIBRARY: "Static" + CMAKE_EXE_LINKER_FLAGS: "" + buildResult: + variable: "CMAKE_CUDA_ABI_COMPILED" + cached: true + stdout: | + Change Dir: '/home/tobli/abo/pprog/Homework-3/CMakeFiles/CMakeScratch/TryCompile-fZUGRz' + + Run Build Command(s): /usr/bin/cmake -E env VERBOSE=1 /usr/bin/make -f Makefile cmTC_c9a77/fast + /usr/bin/make -f CMakeFiles/cmTC_c9a77.dir/build.make CMakeFiles/cmTC_c9a77.dir/build + make[1]: Entering directory '/home/tobli/abo/pprog/Homework-3/CMakeFiles/CMakeScratch/TryCompile-fZUGRz' + Building CUDA object CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o + /opt/cuda/bin/nvcc -forward-unknown-to-host-compiler "--generate-code=arch=compute_52,code=[compute_52,sm_52]" -Xcompiler=-v -MD -MT CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o -MF CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o.d -x cu -c /usr/share/cmake/Modules/CMakeCUDACompilerABI.cu -o CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o + nvcc warning : Support for offline compilation for architectures prior to '_75' will be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning). + Using built-in specs. + COLLECT_GCC=/usr/bin/g++-14 + Target: x86_64-pc-linux-gnu + Configured with: /build/gcc14/src/gcc14/configure --enable-languages=c,c++,fortran --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc14/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --disable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror --program-suffix=-14 --enable-version-specific-runtime-libs + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 14.2.1 20250207 (GCC) + COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH__=520' '-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-E' '-D' 'CUDA_DOUBLE_MATH_FUNCTIONS' '-D' '__CUDACC__' '-D' '__NVCC__' '-v' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=8' '-D' '__CUDACC_VER_BUILD__=93' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=8' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-D' '__CUDACC_DEVICE_ATOMIC_BUILTINS__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00002fe7_00000000-7_CMakeCUDACompilerABI.cpp1.ii' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/' + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/cc1plus -E -quiet -v -I /opt/cuda/bin/../targets/x86_64-linux/include -D_GNU_SOURCE -D __CUDA_ARCH__=520 -D __CUDA_ARCH_LIST__=520 -D __NV_LEGACY_LAUNCH -D CUDA_DOUBLE_MATH_FUNCTIONS -D __CUDACC__ -D __NVCC__ -D __CUDACC_VER_MAJOR__=12 -D __CUDACC_VER_MINOR__=8 -D __CUDACC_VER_BUILD__=93 -D __CUDA_API_VER_MAJOR__=12 -D __CUDA_API_VER_MINOR__=8 -D __NVCC_DIAG_PRAGMA_SUPPORT__=1 -D __CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -include cuda_runtime.h /usr/share/cmake/Modules/CMakeCUDACompilerABI.cu -o /tmp/tmpxft_00002fe7_00000000-7_CMakeCUDACompilerABI.cpp1.ii -m64 -mtune=generic -march=x86-64 -dumpdir /tmp/ -dumpbase tmpxft_00002fe7_00000000-7_CMakeCUDACompilerABI.cpp1.cu -dumpbase-ext .cu + ignoring nonexistent directory "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../x86_64-pc-linux-gnu/include" + #include "..." search starts here: + #include <...> search starts here: + /opt/cuda/bin/../targets/x86_64-linux/include + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include + /usr/local/include + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed + /usr/include + End of search list. + COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/ + LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH__=520' '-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-E' '-D' 'CUDA_DOUBLE_MATH_FUNCTIONS' '-D' '__CUDACC__' '-D' '__NVCC__' '-v' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=8' '-D' '__CUDACC_VER_BUILD__=93' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=8' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-D' '__CUDACC_DEVICE_ATOMIC_BUILTINS__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00002fe7_00000000-7_CMakeCUDACompilerABI.cpp1.ii' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/tmpxft_00002fe7_00000000-7_CMakeCUDACompilerABI.cpp1.' + Using built-in specs. + COLLECT_GCC=/usr/bin/g++-14 + Target: x86_64-pc-linux-gnu + Configured with: /build/gcc14/src/gcc14/configure --enable-languages=c,c++,fortran --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc14/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --disable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror --program-suffix=-14 --enable-version-specific-runtime-libs + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 14.2.1 20250207 (GCC) + COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-E' '-D' '__CUDACC__' '-D' '__NVCC__' '-v' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=8' '-D' '__CUDACC_VER_BUILD__=93' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=8' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-D' '__CUDACC_DEVICE_ATOMIC_BUILTINS__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00002fe7_00000000-5_CMakeCUDACompilerABI.cpp4.ii' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/' + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/cc1plus -E -quiet -v -I /opt/cuda/bin/../targets/x86_64-linux/include -D_GNU_SOURCE -D __CUDA_ARCH_LIST__=520 -D __NV_LEGACY_LAUNCH -D __CUDACC__ -D __NVCC__ -D __CUDACC_VER_MAJOR__=12 -D __CUDACC_VER_MINOR__=8 -D __CUDACC_VER_BUILD__=93 -D __CUDA_API_VER_MAJOR__=12 -D __CUDA_API_VER_MINOR__=8 -D __NVCC_DIAG_PRAGMA_SUPPORT__=1 -D __CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -include cuda_runtime.h /usr/share/cmake/Modules/CMakeCUDACompilerABI.cu -o /tmp/tmpxft_00002fe7_00000000-5_CMakeCUDACompilerABI.cpp4.ii -m64 -mtune=generic -march=x86-64 -dumpdir /tmp/ -dumpbase tmpxft_00002fe7_00000000-5_CMakeCUDACompilerABI.cpp4.cu -dumpbase-ext .cu + ignoring nonexistent directory "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../x86_64-pc-linux-gnu/include" + #include "..." search starts here: + #include <...> search starts here: + /opt/cuda/bin/../targets/x86_64-linux/include + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include + /usr/local/include + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed + /usr/include + End of search list. + COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/ + LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-E' '-D' '__CUDACC__' '-D' '__NVCC__' '-v' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=8' '-D' '__CUDACC_VER_BUILD__=93' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=8' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-D' '__CUDACC_DEVICE_ATOMIC_BUILTINS__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00002fe7_00000000-5_CMakeCUDACompilerABI.cpp4.ii' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/tmpxft_00002fe7_00000000-5_CMakeCUDACompilerABI.cpp4.' + Using built-in specs. + COLLECT_GCC=/usr/bin/g++-14 + Target: x86_64-pc-linux-gnu + Configured with: /build/gcc14/src/gcc14/configure --enable-languages=c,c++,fortran --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc14/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --disable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror --program-suffix=-14 --enable-version-specific-runtime-libs + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 14.2.1 20250207 (GCC) + COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH__=520' '-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-c' '-D' 'CUDA_DOUBLE_MATH_FUNCTIONS' '-v' '-Wno-psabi' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-m64' '-o' 'CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_c9a77.dir/' + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/cc1plus -quiet -v -I /opt/cuda/bin/../targets/x86_64-linux/include -D_GNU_SOURCE -D __CUDA_ARCH__=520 -D __CUDA_ARCH_LIST__=520 -D __NV_LEGACY_LAUNCH -D CUDA_DOUBLE_MATH_FUNCTIONS /tmp/tmpxft_00002fe7_00000000-6_CMakeCUDACompilerABI.cudafe1.cpp -quiet -dumpdir CMakeFiles/cmTC_c9a77.dir/ -dumpbase CMakeCUDACompilerABI.cu.cpp -dumpbase-ext .cpp -m64 -mtune=generic -march=x86-64 -Wno-psabi -version -o /tmp/ccQvtD0n.s + GNU C++17 (GCC) version 14.2.1 20250207 (x86_64-pc-linux-gnu) + compiled by GNU C version 14.2.1 20250207, GMP version 6.3.0, MPFR version 4.2.2, MPC version 1.3.1, isl version isl-0.27-GMP + + GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072 + ignoring nonexistent directory "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../x86_64-pc-linux-gnu/include" + #include "..." search starts here: + #include <...> search starts here: + /opt/cuda/bin/../targets/x86_64-linux/include + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include + /usr/local/include + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed + /usr/include + End of search list. + Compiler executable checksum: 419730b4853e824d20fe72cd5c71d7dd + COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH__=520' '-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-c' '-D' 'CUDA_DOUBLE_MATH_FUNCTIONS' '-v' '-Wno-psabi' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-m64' '-o' 'CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_c9a77.dir/' + as -v -I /opt/cuda/bin/../targets/x86_64-linux/include --64 -o CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o /tmp/ccQvtD0n.s + GNU assembler version 2.44.0 (x86_64-pc-linux-gnu) using BFD version (GNU Binutils) 2.44.0 + COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/ + LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH__=520' '-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-c' '-D' 'CUDA_DOUBLE_MATH_FUNCTIONS' '-v' '-Wno-psabi' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-m64' '-o' 'CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.' + Linking CUDA executable cmTC_c9a77 + /usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_c9a77.dir/link.txt --verbose=1 + Using built-in specs. + COLLECT_GCC=/usr/bin/g++-14 + COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper + Target: x86_64-pc-linux-gnu + Configured with: /build/gcc14/src/gcc14/configure --enable-languages=c,c++,fortran --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc14/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --disable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror --program-suffix=-14 --enable-version-specific-runtime-libs + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 14.2.1 20250207 (GCC) + COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/ + LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_c9a77' '-L/opt/cuda/targets/x86_64-linux/lib/stubs' '-L/opt/cuda/targets/x86_64-linux/lib' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_c9a77.' + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/collect2 -plugin /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper -plugin-opt=-fresolution=/tmp/cczvsQ1G.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -o cmTC_c9a77 /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o -L/opt/cuda/targets/x86_64-linux/lib/stubs -L/opt/cuda/targets/x86_64-linux/lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1 -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib -L/lib/../lib -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../.. -v CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o -lcudadevrt -lcudart_static -lrt -lpthread -ldl -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o + collect2 version 14.2.1 20250207 + /usr/bin/ld -plugin /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper -plugin-opt=-fresolution=/tmp/cczvsQ1G.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -o cmTC_c9a77 /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o -L/opt/cuda/targets/x86_64-linux/lib/stubs -L/opt/cuda/targets/x86_64-linux/lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1 -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib -L/lib/../lib -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../.. -v CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o -lcudadevrt -lcudart_static -lrt -lpthread -ldl -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o + GNU ld (GNU Binutils) 2.44.0 + COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_c9a77' '-L/opt/cuda/targets/x86_64-linux/lib/stubs' '-L/opt/cuda/targets/x86_64-linux/lib' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_c9a77.' + /usr/bin/g++-14 -v -Wl,-v CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o -o cmTC_c9a77 -lcudadevrt -lcudart_static -lrt -lpthread -ldl -L"/opt/cuda/targets/x86_64-linux/lib/stubs" -L"/opt/cuda/targets/x86_64-linux/lib" + make[1]: Leaving directory '/home/tobli/abo/pprog/Homework-3/CMakeFiles/CMakeScratch/TryCompile-fZUGRz' + + exitCode: 0 + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerABI.cmake:191 (message)" + - "/usr/share/cmake/Modules/CMakeTestCUDACompiler.cmake:19 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + message: | + Parsed CUDA implicit include dir info: rv=done + found start of include info + found start of implicit include info + add: [/opt/cuda/bin/../targets/x86_64-linux/include] + add: [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++] + add: [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu] + add: [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward] + add: [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include] + add: [/usr/local/include] + add: [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed] + add: [/usr/include] + end of search list found + collapse include dir [/opt/cuda/bin/../targets/x86_64-linux/include] ==> [/opt/cuda/targets/x86_64-linux/include] + collapse include dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++] ==> [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++] + collapse include dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu] ==> [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu] + collapse include dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward] ==> [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward] + collapse include dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include] ==> [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include] + collapse include dir [/usr/local/include] ==> [/usr/local/include] + collapse include dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed] ==> [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed] + collapse include dir [/usr/include] ==> [/usr/include] + implicit include dirs: [/opt/cuda/targets/x86_64-linux/include;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include;/usr/local/include;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed;/usr/include] + + + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerABI.cmake:227 (message)" + - "/usr/share/cmake/Modules/CMakeTestCUDACompiler.cmake:19 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + message: | + Parsed CUDA implicit link information: + link line regex: [^( *|.*[/\\])(ld[0-9]*(|\\.[a-rt-z][a-z]*|\\.s[a-np-z][a-z]*|\\.so[a-z]+)|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\\]+-)?ld|collect2)[^/\\]*( |$)] + linker tool regex: [^[ ]*(->|")?[ ]*(([^"]*[/\\])?(ld[0-9]*(|\\.[a-rt-z][a-z]*|\\.s[a-np-z][a-z]*|\\.so[a-z]+)))("|,| |$)] + ignore line: [Change Dir: '/home/tobli/abo/pprog/Homework-3/CMakeFiles/CMakeScratch/TryCompile-fZUGRz'] + ignore line: [] + ignore line: [Run Build Command(s): /usr/bin/cmake -E env VERBOSE=1 /usr/bin/make -f Makefile cmTC_c9a77/fast] + ignore line: [/usr/bin/make -f CMakeFiles/cmTC_c9a77.dir/build.make CMakeFiles/cmTC_c9a77.dir/build] + ignore line: [make[1]: Entering directory '/home/tobli/abo/pprog/Homework-3/CMakeFiles/CMakeScratch/TryCompile-fZUGRz'] + ignore line: [Building CUDA object CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o] + ignore line: [/opt/cuda/bin/nvcc -forward-unknown-to-host-compiler "--generate-code=arch=compute_52 code=[compute_52 sm_52]" -Xcompiler=-v -MD -MT CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o -MF CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o.d -x cu -c /usr/share/cmake/Modules/CMakeCUDACompilerABI.cu -o CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o] + ignore line: [nvcc warning : Support for offline compilation for architectures prior to '_75' will be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning).] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/g++-14] + ignore line: [Target: x86_64-pc-linux-gnu] + ignore line: [Configured with: /build/gcc14/src/gcc14/configure --enable-languages=c c++ fortran --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc14/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --disable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror --program-suffix=-14 --enable-version-specific-runtime-libs] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 14.2.1 20250207 (GCC) ] + ignore line: [COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH__=520' '-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-E' '-D' 'CUDA_DOUBLE_MATH_FUNCTIONS' '-D' '__CUDACC__' '-D' '__NVCC__' '-v' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=8' '-D' '__CUDACC_VER_BUILD__=93' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=8' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-D' '__CUDACC_DEVICE_ATOMIC_BUILTINS__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00002fe7_00000000-7_CMakeCUDACompilerABI.cpp1.ii' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/'] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/cc1plus -E -quiet -v -I /opt/cuda/bin/../targets/x86_64-linux/include -D_GNU_SOURCE -D __CUDA_ARCH__=520 -D __CUDA_ARCH_LIST__=520 -D __NV_LEGACY_LAUNCH -D CUDA_DOUBLE_MATH_FUNCTIONS -D __CUDACC__ -D __NVCC__ -D __CUDACC_VER_MAJOR__=12 -D __CUDACC_VER_MINOR__=8 -D __CUDACC_VER_BUILD__=93 -D __CUDA_API_VER_MAJOR__=12 -D __CUDA_API_VER_MINOR__=8 -D __NVCC_DIAG_PRAGMA_SUPPORT__=1 -D __CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -include cuda_runtime.h /usr/share/cmake/Modules/CMakeCUDACompilerABI.cu -o /tmp/tmpxft_00002fe7_00000000-7_CMakeCUDACompilerABI.cpp1.ii -m64 -mtune=generic -march=x86-64 -dumpdir /tmp/ -dumpbase tmpxft_00002fe7_00000000-7_CMakeCUDACompilerABI.cpp1.cu -dumpbase-ext .cu] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../x86_64-pc-linux-gnu/include"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /opt/cuda/bin/../targets/x86_64-linux/include] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include] + ignore line: [ /usr/local/include] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed] + ignore line: [ /usr/include] + ignore line: [End of search list.] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH__=520' '-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-E' '-D' 'CUDA_DOUBLE_MATH_FUNCTIONS' '-D' '__CUDACC__' '-D' '__NVCC__' '-v' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=8' '-D' '__CUDACC_VER_BUILD__=93' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=8' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-D' '__CUDACC_DEVICE_ATOMIC_BUILTINS__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00002fe7_00000000-7_CMakeCUDACompilerABI.cpp1.ii' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/tmpxft_00002fe7_00000000-7_CMakeCUDACompilerABI.cpp1.'] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/g++-14] + ignore line: [Target: x86_64-pc-linux-gnu] + ignore line: [Configured with: /build/gcc14/src/gcc14/configure --enable-languages=c c++ fortran --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc14/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --disable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror --program-suffix=-14 --enable-version-specific-runtime-libs] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 14.2.1 20250207 (GCC) ] + ignore line: [COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-E' '-D' '__CUDACC__' '-D' '__NVCC__' '-v' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=8' '-D' '__CUDACC_VER_BUILD__=93' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=8' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-D' '__CUDACC_DEVICE_ATOMIC_BUILTINS__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00002fe7_00000000-5_CMakeCUDACompilerABI.cpp4.ii' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/'] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/cc1plus -E -quiet -v -I /opt/cuda/bin/../targets/x86_64-linux/include -D_GNU_SOURCE -D __CUDA_ARCH_LIST__=520 -D __NV_LEGACY_LAUNCH -D __CUDACC__ -D __NVCC__ -D __CUDACC_VER_MAJOR__=12 -D __CUDACC_VER_MINOR__=8 -D __CUDACC_VER_BUILD__=93 -D __CUDA_API_VER_MAJOR__=12 -D __CUDA_API_VER_MINOR__=8 -D __NVCC_DIAG_PRAGMA_SUPPORT__=1 -D __CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -include cuda_runtime.h /usr/share/cmake/Modules/CMakeCUDACompilerABI.cu -o /tmp/tmpxft_00002fe7_00000000-5_CMakeCUDACompilerABI.cpp4.ii -m64 -mtune=generic -march=x86-64 -dumpdir /tmp/ -dumpbase tmpxft_00002fe7_00000000-5_CMakeCUDACompilerABI.cpp4.cu -dumpbase-ext .cu] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../x86_64-pc-linux-gnu/include"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /opt/cuda/bin/../targets/x86_64-linux/include] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include] + ignore line: [ /usr/local/include] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed] + ignore line: [ /usr/include] + ignore line: [End of search list.] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-E' '-D' '__CUDACC__' '-D' '__NVCC__' '-v' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=8' '-D' '__CUDACC_VER_BUILD__=93' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=8' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-D' '__CUDACC_DEVICE_ATOMIC_BUILTINS__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00002fe7_00000000-5_CMakeCUDACompilerABI.cpp4.ii' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/tmpxft_00002fe7_00000000-5_CMakeCUDACompilerABI.cpp4.'] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/g++-14] + ignore line: [Target: x86_64-pc-linux-gnu] + ignore line: [Configured with: /build/gcc14/src/gcc14/configure --enable-languages=c c++ fortran --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc14/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --disable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror --program-suffix=-14 --enable-version-specific-runtime-libs] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 14.2.1 20250207 (GCC) ] + ignore line: [COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH__=520' '-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-c' '-D' 'CUDA_DOUBLE_MATH_FUNCTIONS' '-v' '-Wno-psabi' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-m64' '-o' 'CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_c9a77.dir/'] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/cc1plus -quiet -v -I /opt/cuda/bin/../targets/x86_64-linux/include -D_GNU_SOURCE -D __CUDA_ARCH__=520 -D __CUDA_ARCH_LIST__=520 -D __NV_LEGACY_LAUNCH -D CUDA_DOUBLE_MATH_FUNCTIONS /tmp/tmpxft_00002fe7_00000000-6_CMakeCUDACompilerABI.cudafe1.cpp -quiet -dumpdir CMakeFiles/cmTC_c9a77.dir/ -dumpbase CMakeCUDACompilerABI.cu.cpp -dumpbase-ext .cpp -m64 -mtune=generic -march=x86-64 -Wno-psabi -version -o /tmp/ccQvtD0n.s] + ignore line: [GNU C++17 (GCC) version 14.2.1 20250207 (x86_64-pc-linux-gnu)] + ignore line: [ compiled by GNU C version 14.2.1 20250207 GMP version 6.3.0 MPFR version 4.2.2 MPC version 1.3.1 isl version isl-0.27-GMP] + ignore line: [] + ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../x86_64-pc-linux-gnu/include"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /opt/cuda/bin/../targets/x86_64-linux/include] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include] + ignore line: [ /usr/local/include] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed] + ignore line: [ /usr/include] + ignore line: [End of search list.] + ignore line: [Compiler executable checksum: 419730b4853e824d20fe72cd5c71d7dd] + ignore line: [COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH__=520' '-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-c' '-D' 'CUDA_DOUBLE_MATH_FUNCTIONS' '-v' '-Wno-psabi' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-m64' '-o' 'CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_c9a77.dir/'] + ignore line: [ as -v -I /opt/cuda/bin/../targets/x86_64-linux/include --64 -o CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o /tmp/ccQvtD0n.s] + ignore line: [GNU assembler version 2.44.0 (x86_64-pc-linux-gnu) using BFD version (GNU Binutils) 2.44.0] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH__=520' '-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-c' '-D' 'CUDA_DOUBLE_MATH_FUNCTIONS' '-v' '-Wno-psabi' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-m64' '-o' 'CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.'] + ignore line: [Linking CUDA executable cmTC_c9a77] + ignore line: [/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_c9a77.dir/link.txt --verbose=1] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/g++-14] + ignore line: [COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper] + ignore line: [Target: x86_64-pc-linux-gnu] + ignore line: [Configured with: /build/gcc14/src/gcc14/configure --enable-languages=c c++ fortran --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc14/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --disable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror --program-suffix=-14 --enable-version-specific-runtime-libs] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 14.2.1 20250207 (GCC) ] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_c9a77' '-L/opt/cuda/targets/x86_64-linux/lib/stubs' '-L/opt/cuda/targets/x86_64-linux/lib' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_c9a77.'] + link line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/collect2 -plugin /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper -plugin-opt=-fresolution=/tmp/cczvsQ1G.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -o cmTC_c9a77 /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o -L/opt/cuda/targets/x86_64-linux/lib/stubs -L/opt/cuda/targets/x86_64-linux/lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1 -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib -L/lib/../lib -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../.. -v CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o -lcudadevrt -lcudart_static -lrt -lpthread -ldl -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o] + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/collect2] ==> ignore + arg [-plugin] ==> ignore + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/liblto_plugin.so] ==> ignore + arg [-plugin-opt=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper] ==> ignore + arg [-plugin-opt=-fresolution=/tmp/cczvsQ1G.res] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc] ==> ignore + arg [-plugin-opt=-pass-through=-lc] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc] ==> ignore + arg [--build-id] ==> ignore + arg [--eh-frame-hdr] ==> ignore + arg [--hash-style=gnu] ==> ignore + arg [-m] ==> ignore + arg [elf_x86_64] ==> ignore + arg [-dynamic-linker] ==> ignore + arg [/lib64/ld-linux-x86-64.so.2] ==> ignore + arg [-pie] ==> ignore + arg [-o] ==> ignore + arg [cmTC_c9a77] ==> ignore + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o] ==> obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o] + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o] ==> obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o] + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o] ==> obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o] + arg [-L/opt/cuda/targets/x86_64-linux/lib/stubs] ==> dir [/opt/cuda/targets/x86_64-linux/lib/stubs] + arg [-L/opt/cuda/targets/x86_64-linux/lib] ==> dir [/opt/cuda/targets/x86_64-linux/lib] + arg [-L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1] ==> dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1] + arg [-L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib] ==> dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib] + arg [-L/lib/../lib] ==> dir [/lib/../lib] + arg [-L/usr/lib/../lib] ==> dir [/usr/lib/../lib] + arg [-L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../..] ==> dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../..] + arg [-v] ==> ignore + arg [CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o] ==> ignore + arg [-lcudadevrt] ==> lib [cudadevrt] + arg [-lcudart_static] ==> lib [cudart_static] + arg [-lrt] ==> lib [rt] + arg [-lpthread] ==> lib [pthread] + arg [-ldl] ==> lib [dl] + arg [-lstdc++] ==> lib [stdc++] + arg [-lm] ==> lib [m] + arg [-lgcc_s] ==> lib [gcc_s] + arg [-lgcc] ==> lib [gcc] + arg [-lc] ==> lib [c] + arg [-lgcc_s] ==> lib [gcc_s] + arg [-lgcc] ==> lib [gcc] + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o] ==> obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o] + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o] ==> obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o] + ignore line: [collect2 version 14.2.1 20250207] + ignore line: [/usr/bin/ld -plugin /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper -plugin-opt=-fresolution=/tmp/cczvsQ1G.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -o cmTC_c9a77 /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o -L/opt/cuda/targets/x86_64-linux/lib/stubs -L/opt/cuda/targets/x86_64-linux/lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1 -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib -L/lib/../lib -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../.. -v CMakeFiles/cmTC_c9a77.dir/CMakeCUDACompilerABI.cu.o -lcudadevrt -lcudart_static -lrt -lpthread -ldl -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o] + linker tool for 'CUDA': /usr/bin/ld + collapse obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o] ==> [/usr/lib/Scrt1.o] + collapse obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o] ==> [/usr/lib/crti.o] + collapse obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o] ==> [/usr/lib/crtn.o] + collapse library dir [/opt/cuda/targets/x86_64-linux/lib/stubs] ==> [/opt/cuda/targets/x86_64-linux/lib/stubs] + collapse library dir [/opt/cuda/targets/x86_64-linux/lib] ==> [/opt/cuda/targets/x86_64-linux/lib] + collapse library dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1] ==> [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1] + collapse library dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib] ==> [/usr/lib] + collapse library dir [/lib/../lib] ==> [/lib] + collapse library dir [/usr/lib/../lib] ==> [/usr/lib] + collapse library dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../..] ==> [/usr/lib] + implicit libs: [cudadevrt;cudart_static;rt;pthread;dl;stdc++;m;gcc_s;gcc;c;gcc_s;gcc] + implicit objs: [/usr/lib/Scrt1.o;/usr/lib/crti.o;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o;/usr/lib/crtn.o] + implicit dirs: [/opt/cuda/targets/x86_64-linux/lib/stubs;/opt/cuda/targets/x86_64-linux/lib;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1;/usr/lib;/lib] + implicit fwks: [] + + + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/Internal/CMakeDetermineLinkerId.cmake:36 (message)" + - "/usr/share/cmake/Modules/CMakeDetermineCompilerABI.cmake:270 (cmake_determine_linker_id)" + - "/usr/share/cmake/Modules/CMakeTestCUDACompiler.cmake:19 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + message: | + Running the CUDA compiler's linker: "/usr/bin/ld" "-v" + GNU ld (GNU Binutils) 2.44.0 + - + kind: "try_compile-v1" + backtrace: + - "/usr/share/cmake/Modules/Internal/CheckSourceCompiles.cmake:104 (try_compile)" + - "/usr/share/cmake/Modules/CheckCXXSourceCompiles.cmake:58 (cmake_check_source_compiles)" + - "/usr/share/cmake/Modules/FindThreads.cmake:99 (check_cxx_source_compiles)" + - "/usr/share/cmake/Modules/FindThreads.cmake:163 (_threads_check_libc)" + - "/usr/share/cmake/Modules/FindCUDAToolkit.cmake:1207 (find_package)" + - "CMakeLists.txt:9 (find_package)" + checks: + - "Performing Test CMAKE_HAVE_LIBC_PTHREAD" + directories: + source: "/home/tobli/abo/pprog/Homework-3/CMakeFiles/CMakeScratch/TryCompile-oSiYVd" + binary: "/home/tobli/abo/pprog/Homework-3/CMakeFiles/CMakeScratch/TryCompile-oSiYVd" + cmakeVariables: + CMAKE_CUDA_ARCHITECTURES: "52" + CMAKE_CXX_FLAGS: "" + CMAKE_CXX_FLAGS_DEBUG: "-g" + CMAKE_EXE_LINKER_FLAGS: "" + buildResult: + variable: "CMAKE_HAVE_LIBC_PTHREAD" + cached: true + stdout: | + Change Dir: '/home/tobli/abo/pprog/Homework-3/CMakeFiles/CMakeScratch/TryCompile-oSiYVd' + + Run Build Command(s): /usr/bin/cmake -E env VERBOSE=1 /usr/bin/make -f Makefile cmTC_e5f5a/fast + /usr/bin/make -f CMakeFiles/cmTC_e5f5a.dir/build.make CMakeFiles/cmTC_e5f5a.dir/build + make[1]: Entering directory '/home/tobli/abo/pprog/Homework-3/CMakeFiles/CMakeScratch/TryCompile-oSiYVd' + Building CXX object CMakeFiles/cmTC_e5f5a.dir/src.cxx.o + /usr/bin/c++ -DCMAKE_HAVE_LIBC_PTHREAD -std=gnu++17 -o CMakeFiles/cmTC_e5f5a.dir/src.cxx.o -c /home/tobli/abo/pprog/Homework-3/CMakeFiles/CMakeScratch/TryCompile-oSiYVd/src.cxx + Linking CXX executable cmTC_e5f5a + /usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_e5f5a.dir/link.txt --verbose=1 + /usr/bin/c++ CMakeFiles/cmTC_e5f5a.dir/src.cxx.o -o cmTC_e5f5a + make[1]: Leaving directory '/home/tobli/abo/pprog/Homework-3/CMakeFiles/CMakeScratch/TryCompile-oSiYVd' + + exitCode: 0 +... diff --git a/CMakeFiles/CMakeDirectoryInformation.cmake b/CMakeFiles/CMakeDirectoryInformation.cmake new file mode 100644 index 0000000..e32e0f3 --- /dev/null +++ b/CMakeFiles/CMakeDirectoryInformation.cmake @@ -0,0 +1,16 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 4.0 + +# Relative path conversion top directories. +set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/tobli/abo/pprog/Homework-3") +set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/tobli/abo/pprog/Homework-3") + +# Force unix paths in dependencies. +set(CMAKE_FORCE_UNIX_PATHS 1) + + +# The C and CXX include file regular expressions for this directory. +set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$") +set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$") +set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN}) +set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN}) diff --git a/CMakeFiles/InstallScripts.json b/CMakeFiles/InstallScripts.json new file mode 100644 index 0000000..374a9d4 --- /dev/null +++ b/CMakeFiles/InstallScripts.json @@ -0,0 +1,7 @@ +{ + "InstallScripts" : + [ + "/home/tobli/abo/pprog/Homework-3/cmake_install.cmake" + ], + "Parallel" : false +} diff --git a/CMakeFiles/Makefile.cmake b/CMakeFiles/Makefile.cmake new file mode 100644 index 0000000..beeae2e --- /dev/null +++ b/CMakeFiles/Makefile.cmake @@ -0,0 +1,57 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 4.0 + +# The generator used is: +set(CMAKE_DEPENDS_GENERATOR "Unix Makefiles") + +# The top level Makefile was generated from the following files: +set(CMAKE_MAKEFILE_DEPENDS + "CMakeCache.txt" + "CMakeFiles/4.0.2-dirty/CMakeCUDACompiler.cmake" + "CMakeFiles/4.0.2-dirty/CMakeCXXCompiler.cmake" + "CMakeFiles/4.0.2-dirty/CMakeSystem.cmake" + "CMakeLists.txt" + "/usr/share/cmake/Modules/CMakeCUDAInformation.cmake" + "/usr/share/cmake/Modules/CMakeCXXInformation.cmake" + "/usr/share/cmake/Modules/CMakeCommonLanguageInclude.cmake" + "/usr/share/cmake/Modules/CMakeGenericSystem.cmake" + "/usr/share/cmake/Modules/CMakeInitializeConfigs.cmake" + "/usr/share/cmake/Modules/CMakeLanguageInformation.cmake" + "/usr/share/cmake/Modules/CMakeSystemSpecificInformation.cmake" + "/usr/share/cmake/Modules/CMakeSystemSpecificInitialize.cmake" + "/usr/share/cmake/Modules/CheckCXXSourceCompiles.cmake" + "/usr/share/cmake/Modules/CheckIncludeFileCXX.cmake" + "/usr/share/cmake/Modules/CheckLibraryExists.cmake" + "/usr/share/cmake/Modules/Compiler/CMakeCommonCompilerMacros.cmake" + "/usr/share/cmake/Modules/Compiler/GNU-CXX.cmake" + "/usr/share/cmake/Modules/Compiler/GNU.cmake" + "/usr/share/cmake/Modules/Compiler/NVIDIA-CUDA.cmake" + "/usr/share/cmake/Modules/Compiler/NVIDIA.cmake" + "/usr/share/cmake/Modules/FindCUDAToolkit.cmake" + "/usr/share/cmake/Modules/FindPackageHandleStandardArgs.cmake" + "/usr/share/cmake/Modules/FindPackageMessage.cmake" + "/usr/share/cmake/Modules/FindThreads.cmake" + "/usr/share/cmake/Modules/Internal/CheckSourceCompiles.cmake" + "/usr/share/cmake/Modules/Platform/Linux-GNU-CXX.cmake" + "/usr/share/cmake/Modules/Platform/Linux-GNU.cmake" + "/usr/share/cmake/Modules/Platform/Linux-Initialize.cmake" + "/usr/share/cmake/Modules/Platform/Linux-NVIDIA-CUDA.cmake" + "/usr/share/cmake/Modules/Platform/Linux.cmake" + "/usr/share/cmake/Modules/Platform/UnixPaths.cmake" + ) + +# The corresponding makefile is: +set(CMAKE_MAKEFILE_OUTPUTS + "Makefile" + "CMakeFiles/cmake.check_cache" + ) + +# Byproducts of CMake generate step: +set(CMAKE_MAKEFILE_PRODUCTS + "CMakeFiles/CMakeDirectoryInformation.cmake" + ) + +# Dependency information for all targets: +set(CMAKE_DEPEND_INFO_FILES + "CMakeFiles/app.dir/DependInfo.cmake" + ) diff --git a/CMakeFiles/Makefile2 b/CMakeFiles/Makefile2 new file mode 100644 index 0000000..41bf300 --- /dev/null +++ b/CMakeFiles/Makefile2 @@ -0,0 +1,122 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 4.0 + +# Default target executed when no arguments are given to make. +default_target: all +.PHONY : default_target + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + +# Disable VCS-based implicit rules. +% : %,v + +# Disable VCS-based implicit rules. +% : RCS/% + +# Disable VCS-based implicit rules. +% : RCS/%,v + +# Disable VCS-based implicit rules. +% : SCCS/s.% + +# Disable VCS-based implicit rules. +% : s.% + +.SUFFIXES: .hpux_make_needs_suffix_list + +# Command-line flag to silence nested $(MAKE). +$(VERBOSE)MAKESILENT = -s + +#Suppress display of executed commands. +$(VERBOSE).SILENT: + +# A target that is always out of date. +cmake_force: +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E rm -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/tobli/abo/pprog/Homework-3 + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/tobli/abo/pprog/Homework-3 + +#============================================================================= +# Directory level rules for the build root directory + +# The main recursive "all" target. +all: CMakeFiles/app.dir/all +.PHONY : all + +# The main recursive "codegen" target. +codegen: CMakeFiles/app.dir/codegen +.PHONY : codegen + +# The main recursive "preinstall" target. +preinstall: +.PHONY : preinstall + +# The main recursive "clean" target. +clean: CMakeFiles/app.dir/clean +.PHONY : clean + +#============================================================================= +# Target rules for target CMakeFiles/app.dir + +# All Build rule for target. +CMakeFiles/app.dir/all: + $(MAKE) $(MAKESILENT) -f CMakeFiles/app.dir/build.make CMakeFiles/app.dir/depend + $(MAKE) $(MAKESILENT) -f CMakeFiles/app.dir/build.make CMakeFiles/app.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/tobli/abo/pprog/Homework-3/CMakeFiles --progress-num=1,2,3 "Built target app" +.PHONY : CMakeFiles/app.dir/all + +# Build rule for subdir invocation for target. +CMakeFiles/app.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/tobli/abo/pprog/Homework-3/CMakeFiles 3 + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/app.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/tobli/abo/pprog/Homework-3/CMakeFiles 0 +.PHONY : CMakeFiles/app.dir/rule + +# Convenience name for target. +app: CMakeFiles/app.dir/rule +.PHONY : app + +# codegen rule for target. +CMakeFiles/app.dir/codegen: + $(MAKE) $(MAKESILENT) -f CMakeFiles/app.dir/build.make CMakeFiles/app.dir/codegen + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/tobli/abo/pprog/Homework-3/CMakeFiles --progress-num=1,2,3 "Finished codegen for target app" +.PHONY : CMakeFiles/app.dir/codegen + +# clean rule for target. +CMakeFiles/app.dir/clean: + $(MAKE) $(MAKESILENT) -f CMakeFiles/app.dir/build.make CMakeFiles/app.dir/clean +.PHONY : CMakeFiles/app.dir/clean + +#============================================================================= +# Special targets to cleanup operation of make. + +# Special rule to run CMake to check the build system integrity. +# No rule that depends on this can have commands that come from listfiles +# because they might be regenerated. +cmake_check_build_system: + $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0 +.PHONY : cmake_check_build_system + diff --git a/CMakeFiles/TargetDirectories.txt b/CMakeFiles/TargetDirectories.txt new file mode 100644 index 0000000..9f0e2c5 --- /dev/null +++ b/CMakeFiles/TargetDirectories.txt @@ -0,0 +1,3 @@ +/home/tobli/abo/pprog/Homework-3/CMakeFiles/app.dir +/home/tobli/abo/pprog/Homework-3/CMakeFiles/edit_cache.dir +/home/tobli/abo/pprog/Homework-3/CMakeFiles/rebuild_cache.dir diff --git a/CMakeFiles/app.dir/DependInfo.cmake b/CMakeFiles/app.dir/DependInfo.cmake new file mode 100644 index 0000000..5ea7155 --- /dev/null +++ b/CMakeFiles/app.dir/DependInfo.cmake @@ -0,0 +1,23 @@ + +# Consider dependencies only in project. +set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF) + +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + ) + +# The set of dependency files which are needed: +set(CMAKE_DEPENDS_DEPENDENCY_FILES + "/home/tobli/abo/pprog/Homework-3/main.cu" "CMakeFiles/app.dir/main.cu.o" "gcc" "CMakeFiles/app.dir/main.cu.o.d" + ) + +# Targets to which this target links which contain Fortran sources. +set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES + ) + +# Targets to which this target links which contain Fortran sources. +set(CMAKE_Fortran_TARGET_FORWARD_LINKED_INFO_FILES + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/CMakeFiles/app.dir/build.make b/CMakeFiles/app.dir/build.make new file mode 100644 index 0000000..cd0eb53 --- /dev/null +++ b/CMakeFiles/app.dir/build.make @@ -0,0 +1,140 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 4.0 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + +# Disable VCS-based implicit rules. +% : %,v + +# Disable VCS-based implicit rules. +% : RCS/% + +# Disable VCS-based implicit rules. +% : RCS/%,v + +# Disable VCS-based implicit rules. +% : SCCS/s.% + +# Disable VCS-based implicit rules. +% : s.% + +.SUFFIXES: .hpux_make_needs_suffix_list + +# Command-line flag to silence nested $(MAKE). +$(VERBOSE)MAKESILENT = -s + +#Suppress display of executed commands. +$(VERBOSE).SILENT: + +# A target that is always out of date. +cmake_force: +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E rm -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/tobli/abo/pprog/Homework-3 + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/tobli/abo/pprog/Homework-3 + +# Include any dependencies generated for this target. +include CMakeFiles/app.dir/depend.make +# Include any dependencies generated by the compiler for this target. +include CMakeFiles/app.dir/compiler_depend.make + +# Include the progress variables for this target. +include CMakeFiles/app.dir/progress.make + +# Include the compile flags for this target's objects. +include CMakeFiles/app.dir/flags.make + +CMakeFiles/app.dir/codegen: +.PHONY : CMakeFiles/app.dir/codegen + +CMakeFiles/app.dir/main.cu.o: CMakeFiles/app.dir/flags.make +CMakeFiles/app.dir/main.cu.o: CMakeFiles/app.dir/includes_CUDA.rsp +CMakeFiles/app.dir/main.cu.o: main.cu +CMakeFiles/app.dir/main.cu.o: CMakeFiles/app.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/tobli/abo/pprog/Homework-3/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CUDA object CMakeFiles/app.dir/main.cu.o" + /opt/cuda/bin/nvcc -forward-unknown-to-host-compiler $(CUDA_DEFINES) $(CUDA_INCLUDES) $(CUDA_FLAGS) -MD -MT CMakeFiles/app.dir/main.cu.o -MF CMakeFiles/app.dir/main.cu.o.d -x cu -rdc=true -c /home/tobli/abo/pprog/Homework-3/main.cu -o CMakeFiles/app.dir/main.cu.o + +CMakeFiles/app.dir/main.cu.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CUDA source to CMakeFiles/app.dir/main.cu.i" + $(CMAKE_COMMAND) -E cmake_unimplemented_variable CMAKE_CUDA_CREATE_PREPROCESSED_SOURCE + +CMakeFiles/app.dir/main.cu.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CUDA source to assembly CMakeFiles/app.dir/main.cu.s" + $(CMAKE_COMMAND) -E cmake_unimplemented_variable CMAKE_CUDA_CREATE_ASSEMBLY_SOURCE + +# Object files for target app +app_OBJECTS = \ +"CMakeFiles/app.dir/main.cu.o" + +# External object files for target app +app_EXTERNAL_OBJECTS = + +CMakeFiles/app.dir/cmake_device_link.o: CMakeFiles/app.dir/main.cu.o +CMakeFiles/app.dir/cmake_device_link.o: CMakeFiles/app.dir/build.make +CMakeFiles/app.dir/cmake_device_link.o: /opt/cuda/targets/x86_64-linux/lib/libcudart.so +CMakeFiles/app.dir/cmake_device_link.o: /usr/lib/librt.a +CMakeFiles/app.dir/cmake_device_link.o: CMakeFiles/app.dir/deviceLinkLibs.rsp +CMakeFiles/app.dir/cmake_device_link.o: CMakeFiles/app.dir/deviceObjects1.rsp +CMakeFiles/app.dir/cmake_device_link.o: CMakeFiles/app.dir/dlink.txt + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --bold --progress-dir=/home/tobli/abo/pprog/Homework-3/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking CUDA device code CMakeFiles/app.dir/cmake_device_link.o" + $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/app.dir/dlink.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +CMakeFiles/app.dir/build: CMakeFiles/app.dir/cmake_device_link.o +.PHONY : CMakeFiles/app.dir/build + +# Object files for target app +app_OBJECTS = \ +"CMakeFiles/app.dir/main.cu.o" + +# External object files for target app +app_EXTERNAL_OBJECTS = + +app: CMakeFiles/app.dir/main.cu.o +app: CMakeFiles/app.dir/build.make +app: /opt/cuda/targets/x86_64-linux/lib/libcudart.so +app: /usr/lib/librt.a +app: CMakeFiles/app.dir/cmake_device_link.o +app: CMakeFiles/app.dir/linkLibs.rsp +app: CMakeFiles/app.dir/objects1.rsp +app: CMakeFiles/app.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --bold --progress-dir=/home/tobli/abo/pprog/Homework-3/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Linking CUDA executable app" + $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/app.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +CMakeFiles/app.dir/build: app +.PHONY : CMakeFiles/app.dir/build + +CMakeFiles/app.dir/clean: + $(CMAKE_COMMAND) -P CMakeFiles/app.dir/cmake_clean.cmake +.PHONY : CMakeFiles/app.dir/clean + +CMakeFiles/app.dir/depend: + cd /home/tobli/abo/pprog/Homework-3 && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/tobli/abo/pprog/Homework-3 /home/tobli/abo/pprog/Homework-3 /home/tobli/abo/pprog/Homework-3 /home/tobli/abo/pprog/Homework-3 /home/tobli/abo/pprog/Homework-3/CMakeFiles/app.dir/DependInfo.cmake "--color=$(COLOR)" +.PHONY : CMakeFiles/app.dir/depend + diff --git a/CMakeFiles/app.dir/cmake_clean.cmake b/CMakeFiles/app.dir/cmake_clean.cmake new file mode 100644 index 0000000..60cdb88 --- /dev/null +++ b/CMakeFiles/app.dir/cmake_clean.cmake @@ -0,0 +1,12 @@ +file(REMOVE_RECURSE + "CMakeFiles/app.dir/cmake_device_link.o" + "CMakeFiles/app.dir/main.cu.o" + "CMakeFiles/app.dir/main.cu.o.d" + "app" + "app.pdb" +) + +# Per-language clean rules from dependency scanning. +foreach(lang CUDA) + include(CMakeFiles/app.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/CMakeFiles/app.dir/cmake_device_link.o b/CMakeFiles/app.dir/cmake_device_link.o new file mode 100644 index 0000000000000000000000000000000000000000..8dd55b9416a0eb5ed6c0944068bc1513e1516550 GIT binary patch literal 12552 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�uoCql0+=6#7j7{Ot#@+d$-Mf6G;b!a_Q14ou| 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 Js2@*~|1aS`!DRpd literal 0 HcmV?d00001 diff --git a/CMakeFiles/app.dir/main.cu.o.d b/CMakeFiles/app.dir/main.cu.o.d new file mode 100644 index 0000000..52533ac --- /dev/null +++ b/CMakeFiles/app.dir/main.cu.o.d @@ -0,0 +1,317 @@ +CMakeFiles/app.dir/main.cu.o : /home/tobli/abo/pprog/Homework-3/main.cu \ + /usr/include/stdc-predef.h \ + /opt/cuda/targets/x86_64-linux/include/cuda_runtime.h \ + /opt/cuda/targets/x86_64-linux/include/crt/host_config.h \ + /usr/include/features.h \ + /usr/include/features-time64.h \ + /usr/include/bits/wordsize.h \ + /usr/include/bits/timesize.h \ + /usr/include/sys/cdefs.h \ + /usr/include/bits/long-double.h \ + /usr/include/gnu/stubs.h \ + /usr/include/gnu/stubs-64.h \ + /opt/cuda/targets/x86_64-linux/include/builtin_types.h \ + /opt/cuda/targets/x86_64-linux/include/device_types.h \ + /opt/cuda/targets/x86_64-linux/include/crt/host_defines.h \ + /usr/include/ctype.h \ + /usr/include/bits/types.h \ + /usr/include/bits/typesizes.h \ + /usr/include/bits/time64.h \ + /usr/include/bits/endian.h \ + /usr/include/bits/endianness.h \ + /usr/include/bits/types/locale_t.h \ + /usr/include/bits/types/__locale_t.h \ + /opt/cuda/targets/x86_64-linux/include/driver_types.h \ + /opt/cuda/targets/x86_64-linux/include/vector_types.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/syslimits.h \ + /usr/include/limits.h \ + /usr/include/bits/libc-header-start.h \ + /usr/include/bits/posix1_lim.h \ + /usr/include/bits/local_lim.h \ + /usr/include/linux/limits.h \ + /usr/include/bits/pthread_stack_min-dynamic.h \ + /usr/include/bits/posix2_lim.h \ + /usr/include/bits/xopen_lim.h \ + /usr/include/bits/uio_lim.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h \ + /opt/cuda/targets/x86_64-linux/include/surface_types.h \ + /opt/cuda/targets/x86_64-linux/include/texture_types.h \ + /opt/cuda/targets/x86_64-linux/include/library_types.h \ + /opt/cuda/targets/x86_64-linux/include/channel_descriptor.h \ + /opt/cuda/targets/x86_64-linux/include/cuda_runtime_api.h \ + /opt/cuda/targets/x86_64-linux/include/cuda_device_runtime_api.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/os_defines.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/cpu_defines.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/pstl/pstl_config.h \ + /usr/include/stdlib.h \ + /usr/include/bits/waitflags.h \ + /usr/include/bits/waitstatus.h \ + /usr/include/bits/floatn.h \ + /usr/include/bits/floatn-common.h \ + /usr/include/sys/types.h \ + /usr/include/bits/types/clock_t.h \ + /usr/include/bits/types/clockid_t.h \ + /usr/include/bits/types/time_t.h \ + /usr/include/bits/types/timer_t.h \ + /usr/include/bits/stdint-intn.h \ + /usr/include/endian.h \ + /usr/include/bits/byteswap.h \ + /usr/include/bits/uintn-identity.h \ + /usr/include/sys/select.h \ + /usr/include/bits/select.h \ + /usr/include/bits/types/sigset_t.h \ + /usr/include/bits/types/__sigset_t.h \ + /usr/include/bits/types/struct_timeval.h \ + /usr/include/bits/types/struct_timespec.h \ + /usr/include/bits/pthreadtypes.h \ + /usr/include/bits/thread-shared-types.h \ + /usr/include/bits/pthreadtypes-arch.h \ + /usr/include/bits/atomic_wide_counter.h \ + /usr/include/bits/struct_mutex.h \ + /usr/include/bits/struct_rwlock.h \ + /usr/include/alloca.h \ + /usr/include/bits/stdlib-float.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h \ + /opt/cuda/targets/x86_64-linux/include/driver_functions.h \ + /opt/cuda/targets/x86_64-linux/include/vector_functions.h \ + /opt/cuda/targets/x86_64-linux/include/vector_functions.hpp \ + /opt/cuda/targets/x86_64-linux/include/crt/common_functions.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/time.h \ + /usr/include/bits/time.h \ + /usr/include/bits/timex.h \ + /usr/include/bits/types/struct_tm.h \ + /usr/include/bits/types/struct_itimerspec.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/new \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/exception.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h \ + /usr/include/stdio.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stdarg.h \ + /usr/include/bits/types/__fpos_t.h \ + /usr/include/bits/types/__mbstate_t.h \ + /usr/include/bits/types/__fpos64_t.h \ + /usr/include/bits/types/__FILE.h \ + /usr/include/bits/types/FILE.h \ + /usr/include/bits/types/struct_FILE.h \ + /usr/include/bits/types/cookie_io_functions_t.h \ + /usr/include/bits/stdio_lim.h \ + /usr/include/assert.h \ + /opt/cuda/targets/x86_64-linux/include/crt/math_functions.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/math.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/requires_hosted.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h \ + /usr/include/math.h \ + /usr/include/bits/math-vector.h \ + /usr/include/bits/libm-simd-decl-stubs.h \ + /usr/include/bits/flt-eval-method.h \ + /usr/include/bits/fp-logb.h \ + /usr/include/bits/fp-fast.h \ + /usr/include/bits/mathcalls-macros.h \ + /usr/include/bits/mathcalls-helper-functions.h \ + /usr/include/bits/mathcalls.h \ + /usr/include/bits/mathcalls-narrow.h \ + /usr/include/bits/iscanonical.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/exception_defines.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/concept_check.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/debug/assertions.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/ptr_traits.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/debug/debug.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/predefined_ops.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/concepts \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc \ + /opt/cuda/targets/x86_64-linux/include/crt/math_functions.hpp \ + /opt/cuda/targets/x86_64-linux/include/crt/device_functions.h \ + /opt/cuda/targets/x86_64-linux/include/crt/device_functions.hpp \ + /opt/cuda/targets/x86_64-linux/include/device_atomic_functions.h \ + /opt/cuda/targets/x86_64-linux/include/device_atomic_functions.hpp \ + /opt/cuda/targets/x86_64-linux/include/crt/device_double_functions.h \ + /opt/cuda/targets/x86_64-linux/include/crt/device_double_functions.hpp \ + /opt/cuda/targets/x86_64-linux/include/sm_20_atomic_functions.h \ + /opt/cuda/targets/x86_64-linux/include/sm_20_atomic_functions.hpp \ + /opt/cuda/targets/x86_64-linux/include/sm_32_atomic_functions.h \ + /opt/cuda/targets/x86_64-linux/include/sm_32_atomic_functions.hpp \ + /opt/cuda/targets/x86_64-linux/include/sm_35_atomic_functions.h \ + /opt/cuda/targets/x86_64-linux/include/sm_60_atomic_functions.h \ + /opt/cuda/targets/x86_64-linux/include/sm_60_atomic_functions.hpp \ + /opt/cuda/targets/x86_64-linux/include/sm_20_intrinsics.h \ + /opt/cuda/targets/x86_64-linux/include/sm_20_intrinsics.hpp \ + /opt/cuda/targets/x86_64-linux/include/sm_30_intrinsics.h \ + /opt/cuda/targets/x86_64-linux/include/sm_30_intrinsics.hpp \ + /opt/cuda/targets/x86_64-linux/include/sm_32_intrinsics.h \ + /opt/cuda/targets/x86_64-linux/include/sm_32_intrinsics.hpp \ + /opt/cuda/targets/x86_64-linux/include/sm_35_intrinsics.h \ + /opt/cuda/targets/x86_64-linux/include/sm_61_intrinsics.h \ + /opt/cuda/targets/x86_64-linux/include/sm_61_intrinsics.hpp \ + /opt/cuda/targets/x86_64-linux/include/crt/sm_70_rt.h \ + /opt/cuda/targets/x86_64-linux/include/crt/sm_70_rt.hpp \ + /opt/cuda/targets/x86_64-linux/include/crt/sm_80_rt.h \ + /opt/cuda/targets/x86_64-linux/include/crt/sm_80_rt.hpp \ + /opt/cuda/targets/x86_64-linux/include/crt/sm_90_rt.h \ + /opt/cuda/targets/x86_64-linux/include/crt/sm_90_rt.hpp \ + /opt/cuda/targets/x86_64-linux/include/crt/sm_100_rt.h \ + /opt/cuda/targets/x86_64-linux/include/crt/sm_100_rt.hpp \ + /opt/cuda/targets/x86_64-linux/include/texture_indirect_functions.h \ + /opt/cuda/targets/x86_64-linux/include/surface_indirect_functions.h \ + /opt/cuda/targets/x86_64-linux/include/crt/cudacc_ext.h \ + /opt/cuda/targets/x86_64-linux/include/device_launch_parameters.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/initializer_list \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/iostream \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ostream \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ios \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/iosfwd \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stringfwd.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/memoryfwd.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/postypes.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cwchar \ + /usr/include/wchar.h \ + /usr/include/bits/wchar.h \ + /usr/include/bits/types/wint_t.h \ + /usr/include/bits/types/mbstate_t.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/exception \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/exception_ptr.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cxxabi_init_exception.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/typeinfo \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/hash_bytes.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/nested_exception.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/char_traits.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/localefwd.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++locale.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/clocale \ + /usr/include/locale.h \ + /usr/include/bits/locale.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cctype \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/ios_base.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/atomicity.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/gthr.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/gthr-default.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/bits/sched.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/types.h \ + /usr/include/asm/types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm/bitsperlong.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/asm/posix_types.h \ + /usr/include/asm/posix_types_64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/bits/types/struct_sched_param.h \ + /usr/include/bits/cpu-set.h \ + /usr/include/bits/setjmp.h \ + /usr/include/bits/types/struct___jmp_buf_tag.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/atomic_word.h \ + /usr/include/sys/single_threaded.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/locale_classes.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/string \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/allocator.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++allocator.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/new_allocator.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/ostream_insert.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cxxabi_forced.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_function.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward/binders.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/refwrap.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/invoke.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/range_access.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/basic_string.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/alloc_traits.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/alloc_traits.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_construct.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/string_view \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functional_hash.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/string_view.tcc \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/string_conversions.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdio \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cerrno \ + /usr/include/errno.h \ + /usr/include/bits/errno.h \ + /usr/include/linux/errno.h \ + /usr/include/asm/errno.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/bits/types/error_t.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/charconv.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/basic_string.tcc \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/memory_resource.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstddef \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/uses_allocator.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/uses_allocator_args.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tuple \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/locale_classes.tcc \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/system_error \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/error_constants.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdexcept \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/streambuf \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/streambuf.tcc \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/basic_ios.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/locale_facets.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cwctype \ + /usr/include/wctype.h \ + /usr/include/bits/wctype-wchar.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/ctype_base.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/streambuf_iterator.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/ctype_inline.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/locale_facets.tcc \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/basic_ios.tcc \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/ostream.tcc \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/istream \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/istream.tcc \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/fstream \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/codecvt.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/basic_file.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++io.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/fstream.tcc \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/vector \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_uninitialized.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_vector.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_bvector.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/vector.tcc \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cassert \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdint \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stdint.h \ + /usr/include/stdint.h \ + /usr/include/bits/stdint-uintn.h \ + /usr/include/bits/stdint-least.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstring \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/chrono \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/chrono.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ratio \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ctime \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/parse_numbers.h diff --git a/CMakeFiles/app.dir/objects1.rsp b/CMakeFiles/app.dir/objects1.rsp new file mode 100644 index 0000000..4a5e780 --- /dev/null +++ b/CMakeFiles/app.dir/objects1.rsp @@ -0,0 +1 @@ +CMakeFiles/app.dir/main.cu.o diff --git a/CMakeFiles/app.dir/progress.make b/CMakeFiles/app.dir/progress.make new file mode 100644 index 0000000..6a9dc74 --- /dev/null +++ b/CMakeFiles/app.dir/progress.make @@ -0,0 +1,4 @@ +CMAKE_PROGRESS_1 = 1 +CMAKE_PROGRESS_2 = 2 +CMAKE_PROGRESS_3 = 3 + diff --git a/CMakeFiles/cmake.check_cache b/CMakeFiles/cmake.check_cache new file mode 100644 index 0000000..3dccd73 --- /dev/null +++ b/CMakeFiles/cmake.check_cache @@ -0,0 +1 @@ +# This file is generated by cmake for dependency checking of the CMakeCache.txt file diff --git a/CMakeFiles/progress.marks b/CMakeFiles/progress.marks new file mode 100644 index 0000000..00750ed --- /dev/null +++ b/CMakeFiles/progress.marks @@ -0,0 +1 @@ +3 diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..229d719 --- /dev/null +++ b/Makefile @@ -0,0 +1,181 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 4.0 + +# Default target executed when no arguments are given to make. +default_target: all +.PHONY : default_target + +# Allow only one "make -f Makefile2" at a time, but pass parallelism. +.NOTPARALLEL: + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + +# Disable VCS-based implicit rules. +% : %,v + +# Disable VCS-based implicit rules. +% : RCS/% + +# Disable VCS-based implicit rules. +% : RCS/%,v + +# Disable VCS-based implicit rules. +% : SCCS/s.% + +# Disable VCS-based implicit rules. +% : s.% + +.SUFFIXES: .hpux_make_needs_suffix_list + +# Command-line flag to silence nested $(MAKE). +$(VERBOSE)MAKESILENT = -s + +#Suppress display of executed commands. +$(VERBOSE).SILENT: + +# A target that is always out of date. +cmake_force: +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E rm -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/tobli/abo/pprog/Homework-3 + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/tobli/abo/pprog/Homework-3 + +#============================================================================= +# Targets provided globally by CMake. + +# Special rule for the target edit_cache +edit_cache: + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake cache editor..." + /usr/bin/ccmake -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) +.PHONY : edit_cache + +# Special rule for the target edit_cache +edit_cache/fast: edit_cache +.PHONY : edit_cache/fast + +# Special rule for the target rebuild_cache +rebuild_cache: + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..." + /usr/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) +.PHONY : rebuild_cache + +# Special rule for the target rebuild_cache +rebuild_cache/fast: rebuild_cache +.PHONY : rebuild_cache/fast + +# The main all target +all: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/tobli/abo/pprog/Homework-3/CMakeFiles /home/tobli/abo/pprog/Homework-3//CMakeFiles/progress.marks + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 all + $(CMAKE_COMMAND) -E cmake_progress_start /home/tobli/abo/pprog/Homework-3/CMakeFiles 0 +.PHONY : all + +# The main clean target +clean: + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 clean +.PHONY : clean + +# The main clean target +clean/fast: clean +.PHONY : clean/fast + +# Prepare targets for installation. +preinstall: all + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 preinstall +.PHONY : preinstall + +# Prepare targets for installation. +preinstall/fast: + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 preinstall +.PHONY : preinstall/fast + +# clear depends +depend: + $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1 +.PHONY : depend + +#============================================================================= +# Target rules for targets named app + +# Build rule for target. +app: cmake_check_build_system + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 app +.PHONY : app + +# fast build rule for target. +app/fast: + $(MAKE) $(MAKESILENT) -f CMakeFiles/app.dir/build.make CMakeFiles/app.dir/build +.PHONY : app/fast + +main.o: main.cu.o +.PHONY : main.o + +# target to build an object file +main.cu.o: + $(MAKE) $(MAKESILENT) -f CMakeFiles/app.dir/build.make CMakeFiles/app.dir/main.cu.o +.PHONY : main.cu.o + +main.i: main.cu.i +.PHONY : main.i + +# target to preprocess a source file +main.cu.i: + $(MAKE) $(MAKESILENT) -f CMakeFiles/app.dir/build.make CMakeFiles/app.dir/main.cu.i +.PHONY : main.cu.i + +main.s: main.cu.s +.PHONY : main.s + +# target to generate assembly for a file +main.cu.s: + $(MAKE) $(MAKESILENT) -f CMakeFiles/app.dir/build.make CMakeFiles/app.dir/main.cu.s +.PHONY : main.cu.s + +# Help Target +help: + @echo "The following are some of the valid targets for this Makefile:" + @echo "... all (the default if no target is provided)" + @echo "... clean" + @echo "... depend" + @echo "... edit_cache" + @echo "... rebuild_cache" + @echo "... app" + @echo "... main.o" + @echo "... main.i" + @echo "... main.s" +.PHONY : help + + + +#============================================================================= +# Special targets to cleanup operation of make. + +# Special rule to run CMake to check the build system integrity. +# No rule that depends on this can have commands that come from listfiles +# because they might be regenerated. +cmake_check_build_system: + $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0 +.PHONY : cmake_check_build_system + diff --git a/app b/app new file mode 100755 index 0000000000000000000000000000000000000000..ef1fae4c388a7ec1b3da29472a7888060237ead4 GIT binary patch literal 80328 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�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


|}g9CyMdlhHn;E-^>`; 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 literal 0 HcmV?d00001 diff --git a/build/CMakeFiles/4.0.2-dirty/CMakeDetermineCompilerABI_CXX.bin b/build/CMakeFiles/4.0.2-dirty/CMakeDetermineCompilerABI_CXX.bin new file mode 100755 index 0000000000000000000000000000000000000000..6e987848d6db676cffd985fd780691cd42a9586f GIT binary patch literal 15456 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 Ll!F05z!d)gjkUMq literal 0 HcmV?d00001 diff --git a/build/CMakeFiles/4.0.2-dirty/CMakeSystem.cmake b/build/CMakeFiles/4.0.2-dirty/CMakeSystem.cmake new file mode 100644 index 0000000..5145244 --- /dev/null +++ b/build/CMakeFiles/4.0.2-dirty/CMakeSystem.cmake @@ -0,0 +1,15 @@ +set(CMAKE_HOST_SYSTEM "Linux-6.14.7-arch2-1") +set(CMAKE_HOST_SYSTEM_NAME "Linux") +set(CMAKE_HOST_SYSTEM_VERSION "6.14.7-arch2-1") +set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64") + + + +set(CMAKE_SYSTEM "Linux-6.14.7-arch2-1") +set(CMAKE_SYSTEM_NAME "Linux") +set(CMAKE_SYSTEM_VERSION "6.14.7-arch2-1") +set(CMAKE_SYSTEM_PROCESSOR "x86_64") + +set(CMAKE_CROSSCOMPILING "FALSE") + +set(CMAKE_SYSTEM_LOADED 1) diff --git a/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/CMakeCUDACompilerId.cu b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/CMakeCUDACompilerId.cu new file mode 100644 index 0000000..4aaeb34 --- /dev/null +++ b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/CMakeCUDACompilerId.cu @@ -0,0 +1,935 @@ +#ifndef __CUDACC__ +# error "A C or C++ compiler has been selected for CUDA" +#endif + + +/* Version number components: V=Version, R=Revision, P=Patch + Version date components: YYYY=Year, MM=Month, DD=Day */ + +#if defined(__NVCC__) +# define COMPILER_ID "NVIDIA" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# elif defined(__clang__) +# define SIMULATE_ID "Clang" +# elif defined(__GNUC__) +# define SIMULATE_ID "GNU" +# endif +# if defined(__CUDACC_VER_MAJOR__) +# define COMPILER_VERSION_MAJOR DEC(__CUDACC_VER_MAJOR__) +# define COMPILER_VERSION_MINOR DEC(__CUDACC_VER_MINOR__) +# define COMPILER_VERSION_PATCH DEC(__CUDACC_VER_BUILD__) +# endif +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# elif defined(__clang__) +# define SIMULATE_VERSION_MAJOR DEC(__clang_major__) +# define SIMULATE_VERSION_MINOR DEC(__clang_minor__) +# elif defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif + +#elif defined(__clang__) +# define COMPILER_ID "Clang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + + +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__hpux) || defined(__hpua) +# define COMPILER_ID "HP" + +#else /* unknown compiler */ +# define COMPILER_ID "" +#endif + +/* Detect host compiler used by NVCC. */ +#ifdef __NVCC__ + +/* Version number components: V=Version, R=Revision, P=Patch + Version date components: YYYY=Year, MM=Month, DD=Day */ + +#if defined(__INTEL_COMPILER) || defined(__ICC) +# define HOST_COMPILER_ID "Intel" +# if defined(_MSC_VER) +# define HOST_SIMULATE_ID "MSVC" +# endif +# if defined(__GNUC__) +# define HOST_SIMULATE_ID "GNU" +# endif + /* __INTEL_COMPILER = VRP prior to 2021, and then VVVV for 2021 and later, + except that a few beta releases use the old format with V=2021. */ +# if __INTEL_COMPILER < 2021 || __INTEL_COMPILER == 202110 || __INTEL_COMPILER == 202111 +# define HOST_COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100) +# define HOST_COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10) +# if defined(__INTEL_COMPILER_UPDATE) +# define HOST_COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE) +# else +# define HOST_COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10) +# endif +# else +# define HOST_COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER) +# define HOST_COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER_UPDATE) + /* The third version component from --version is an update index, + but no macro is provided for it. */ +# define HOST_COMPILER_VERSION_PATCH DEC(0) +# endif +# if defined(__INTEL_COMPILER_BUILD_DATE) + /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */ +# define HOST_COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE) +# endif +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define HOST_SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define HOST_SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# if defined(__GNUC__) +# define HOST_SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# elif defined(__GNUG__) +# define HOST_SIMULATE_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define HOST_SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define HOST_SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif (defined(__clang__) && defined(__INTEL_CLANG_COMPILER)) || defined(__INTEL_LLVM_COMPILER) +# define HOST_COMPILER_ID "IntelLLVM" +#if defined(_MSC_VER) +# define HOST_SIMULATE_ID "MSVC" +#endif +#if defined(__GNUC__) +# define HOST_SIMULATE_ID "GNU" +#endif +/* __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and + * later. Look for 6 digit vs. 8 digit version number to decide encoding. + * VVVV is no smaller than the current year when a version is released. + */ +#if __INTEL_LLVM_COMPILER < 1000000L +# define HOST_COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100) +# define HOST_COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10) +# define HOST_COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 10) +#else +# define HOST_COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000) +# define HOST_COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100) +# define HOST_COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 100) +#endif +#if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define HOST_SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define HOST_SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +#endif +#if defined(__GNUC__) +# define HOST_SIMULATE_VERSION_MAJOR DEC(__GNUC__) +#elif defined(__GNUG__) +# define HOST_SIMULATE_VERSION_MAJOR DEC(__GNUG__) +#endif +#if defined(__GNUC_MINOR__) +# define HOST_SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +#endif +#if defined(__GNUC_PATCHLEVEL__) +# define HOST_SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +#endif + +#elif defined(__PATHCC__) +# define HOST_COMPILER_ID "PathScale" +# define HOST_COMPILER_VERSION_MAJOR DEC(__PATHCC__) +# define HOST_COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__) +# if defined(__PATHCC_PATCHLEVEL__) +# define HOST_COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__) +# endif + +#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__) +# define HOST_COMPILER_ID "Embarcadero" +# define HOST_COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF) +# define HOST_COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF) +# define HOST_COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF) + +#elif defined(__BORLANDC__) +# define HOST_COMPILER_ID "Borland" + /* __BORLANDC__ = 0xVRR */ +# define HOST_COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8) +# define HOST_COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF) + +#elif defined(__WATCOMC__) && __WATCOMC__ < 1200 +# define HOST_COMPILER_ID "Watcom" + /* __WATCOMC__ = VVRR */ +# define HOST_COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100) +# define HOST_COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define HOST_COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__WATCOMC__) +# define HOST_COMPILER_ID "OpenWatcom" + /* __WATCOMC__ = VVRP + 1100 */ +# define HOST_COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100) +# define HOST_COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define HOST_COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__SUNPRO_CC) +# define HOST_COMPILER_ID "SunPro" +# if __SUNPRO_CC >= 0x5100 + /* __SUNPRO_CC = 0xVRRP */ +# define HOST_COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12) +# define HOST_COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF) +# define HOST_COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# else + /* __SUNPRO_CC = 0xVRP */ +# define HOST_COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8) +# define HOST_COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF) +# define HOST_COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# endif + +#elif defined(__HP_aCC) +# define HOST_COMPILER_ID "HP" + /* __HP_aCC = VVRRPP */ +# define HOST_COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000) +# define HOST_COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100) +# define HOST_COMPILER_VERSION_PATCH DEC(__HP_aCC % 100) + +#elif defined(__DECCXX) +# define HOST_COMPILER_ID "Compaq" + /* __DECCXX_VER = VVRRTPPPP */ +# define HOST_COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000) +# define HOST_COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000 % 100) +# define HOST_COMPILER_VERSION_PATCH DEC(__DECCXX_VER % 10000) + +#elif defined(__IBMCPP__) && defined(__COMPILER_VER__) +# define HOST_COMPILER_ID "zOS" + /* __IBMCPP__ = VRP */ +# define HOST_COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define HOST_COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define HOST_COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__open_xl__) && defined(__clang__) +# define HOST_COMPILER_ID "IBMClang" +# define HOST_COMPILER_VERSION_MAJOR DEC(__open_xl_version__) +# define HOST_COMPILER_VERSION_MINOR DEC(__open_xl_release__) +# define HOST_COMPILER_VERSION_PATCH DEC(__open_xl_modification__) +# define HOST_COMPILER_VERSION_TWEAK DEC(__open_xl_ptf_fix_level__) +# define HOST_COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(__ibmxl__) && defined(__clang__) +# define HOST_COMPILER_ID "XLClang" +# define HOST_COMPILER_VERSION_MAJOR DEC(__ibmxl_version__) +# define HOST_COMPILER_VERSION_MINOR DEC(__ibmxl_release__) +# define HOST_COMPILER_VERSION_PATCH DEC(__ibmxl_modification__) +# define HOST_COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__) + + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800 +# define HOST_COMPILER_ID "XL" + /* __IBMCPP__ = VRP */ +# define HOST_COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define HOST_COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define HOST_COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800 +# define HOST_COMPILER_ID "VisualAge" + /* __IBMCPP__ = VRP */ +# define HOST_COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define HOST_COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define HOST_COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__NVCOMPILER) +# define HOST_COMPILER_ID "NVHPC" +# define HOST_COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__) +# define HOST_COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__) +# if defined(__NVCOMPILER_PATCHLEVEL__) +# define HOST_COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__) +# endif + +#elif defined(__PGI) +# define HOST_COMPILER_ID "PGI" +# define HOST_COMPILER_VERSION_MAJOR DEC(__PGIC__) +# define HOST_COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__) +# if defined(__PGIC_PATCHLEVEL__) +# define HOST_COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__) +# endif + +#elif defined(__clang__) && defined(__cray__) +# define HOST_COMPILER_ID "CrayClang" +# define HOST_COMPILER_VERSION_MAJOR DEC(__cray_major__) +# define HOST_COMPILER_VERSION_MINOR DEC(__cray_minor__) +# define HOST_COMPILER_VERSION_PATCH DEC(__cray_patchlevel__) +# define HOST_COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(_CRAYC) +# define HOST_COMPILER_ID "Cray" +# define HOST_COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR) +# define HOST_COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR) + +#elif defined(__TI_COMPILER_VERSION__) +# define HOST_COMPILER_ID "TI" + /* __TI_COMPILER_VERSION__ = VVVRRRPPP */ +# define HOST_COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000) +# define HOST_COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000) +# define HOST_COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000) + +#elif defined(__CLANG_FUJITSU) +# define HOST_COMPILER_ID "FujitsuClang" +# define HOST_COMPILER_VERSION_MAJOR DEC(__FCC_major__) +# define HOST_COMPILER_VERSION_MINOR DEC(__FCC_minor__) +# define HOST_COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__) +# define HOST_COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(__FUJITSU) +# define HOST_COMPILER_ID "Fujitsu" +# if defined(__FCC_version__) +# define HOST_COMPILER_VERSION __FCC_version__ +# elif defined(__FCC_major__) +# define HOST_COMPILER_VERSION_MAJOR DEC(__FCC_major__) +# define HOST_COMPILER_VERSION_MINOR DEC(__FCC_minor__) +# define HOST_COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__) +# endif +# if defined(__fcc_version) +# define HOST_COMPILER_VERSION_INTERNAL DEC(__fcc_version) +# elif defined(__FCC_VERSION) +# define HOST_COMPILER_VERSION_INTERNAL DEC(__FCC_VERSION) +# endif + + +#elif defined(__ghs__) +# define HOST_COMPILER_ID "GHS" +/* __GHS_VERSION_NUMBER = VVVVRP */ +# ifdef __GHS_VERSION_NUMBER +# define HOST_COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100) +# define HOST_COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10) +# define HOST_COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER % 10) +# endif + +#elif defined(__TASKING__) +# define HOST_COMPILER_ID "Tasking" + # define HOST_COMPILER_VERSION_MAJOR DEC(__VERSION__/1000) + # define HOST_COMPILER_VERSION_MINOR DEC(__VERSION__ % 100) +# define HOST_COMPILER_VERSION_INTERNAL DEC(__VERSION__) + +#elif defined(__ORANGEC__) +# define HOST_COMPILER_ID "OrangeC" +# define HOST_COMPILER_VERSION_MAJOR DEC(__ORANGEC_MAJOR__) +# define HOST_COMPILER_VERSION_MINOR DEC(__ORANGEC_MINOR__) +# define HOST_COMPILER_VERSION_PATCH DEC(__ORANGEC_PATCHLEVEL__) + +#elif defined(__SCO_VERSION__) +# define HOST_COMPILER_ID "SCO" + +#elif defined(__ARMCC_VERSION) && !defined(__clang__) +# define HOST_COMPILER_ID "ARMCC" +#if __ARMCC_VERSION >= 1000000 + /* __ARMCC_VERSION = VRRPPPP */ + # define HOST_COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000) + # define HOST_COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100) + # define HOST_COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#else + /* __ARMCC_VERSION = VRPPPP */ + # define HOST_COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000) + # define HOST_COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10) + # define HOST_COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#endif + + +#elif defined(__clang__) && defined(__apple_build_version__) +# define HOST_COMPILER_ID "AppleClang" +# if defined(_MSC_VER) +# define HOST_SIMULATE_ID "MSVC" +# endif +# define HOST_COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define HOST_COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define HOST_COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define HOST_SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define HOST_SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# define HOST_COMPILER_VERSION_TWEAK DEC(__apple_build_version__) + +#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION) +# define HOST_COMPILER_ID "ARMClang" + # define HOST_COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000) + # define HOST_COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100) + # define HOST_COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION/100 % 100) +# define HOST_COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION) + +#elif defined(__clang__) && defined(__ti__) +# define HOST_COMPILER_ID "TIClang" + # define HOST_COMPILER_VERSION_MAJOR DEC(__ti_major__) + # define HOST_COMPILER_VERSION_MINOR DEC(__ti_minor__) + # define HOST_COMPILER_VERSION_PATCH DEC(__ti_patchlevel__) +# define HOST_COMPILER_VERSION_INTERNAL DEC(__ti_version__) + +#elif defined(__clang__) +# define HOST_COMPILER_ID "Clang" +# if defined(_MSC_VER) +# define HOST_SIMULATE_ID "MSVC" +# endif +# define HOST_COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define HOST_COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define HOST_COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define HOST_SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define HOST_SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + +#elif defined(__LCC__) && (defined(__GNUC__) || defined(__GNUG__) || defined(__MCST__)) +# define HOST_COMPILER_ID "LCC" +# define HOST_COMPILER_VERSION_MAJOR DEC(__LCC__ / 100) +# define HOST_COMPILER_VERSION_MINOR DEC(__LCC__ % 100) +# if defined(__LCC_MINOR__) +# define HOST_COMPILER_VERSION_PATCH DEC(__LCC_MINOR__) +# endif +# if defined(__GNUC__) && defined(__GNUC_MINOR__) +# define HOST_SIMULATE_ID "GNU" +# define HOST_SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# define HOST_SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# if defined(__GNUC_PATCHLEVEL__) +# define HOST_SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif +# endif + +#elif defined(__GNUC__) || defined(__GNUG__) +# define HOST_COMPILER_ID "GNU" +# if defined(__GNUC__) +# define HOST_COMPILER_VERSION_MAJOR DEC(__GNUC__) +# else +# define HOST_COMPILER_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define HOST_COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define HOST_COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(_MSC_VER) +# define HOST_COMPILER_ID "MSVC" + /* _MSC_VER = VVRR */ +# define HOST_COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100) +# define HOST_COMPILER_VERSION_MINOR DEC(_MSC_VER % 100) +# if defined(_MSC_FULL_VER) +# if _MSC_VER >= 1400 + /* _MSC_FULL_VER = VVRRPPPPP */ +# define HOST_COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000) +# else + /* _MSC_FULL_VER = VVRRPPPP */ +# define HOST_COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000) +# endif +# endif +# if defined(_MSC_BUILD) +# define HOST_COMPILER_VERSION_TWEAK DEC(_MSC_BUILD) +# endif + +#elif defined(_ADI_COMPILER) +# define HOST_COMPILER_ID "ADSP" +#if defined(__VERSIONNUM__) + /* __VERSIONNUM__ = 0xVVRRPPTT */ +# define HOST_COMPILER_VERSION_MAJOR DEC(__VERSIONNUM__ >> 24 & 0xFF) +# define HOST_COMPILER_VERSION_MINOR DEC(__VERSIONNUM__ >> 16 & 0xFF) +# define HOST_COMPILER_VERSION_PATCH DEC(__VERSIONNUM__ >> 8 & 0xFF) +# define HOST_COMPILER_VERSION_TWEAK DEC(__VERSIONNUM__ & 0xFF) +#endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# define HOST_COMPILER_ID "IAR" +# if defined(__VER__) && defined(__ICCARM__) +# define HOST_COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000) +# define HOST_COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000) +# define HOST_COMPILER_VERSION_PATCH DEC((__VER__) % 1000) +# define HOST_COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__) || defined(__ICCSTM8__)) +# define HOST_COMPILER_VERSION_MAJOR DEC((__VER__) / 100) +# define HOST_COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100)) +# define HOST_COMPILER_VERSION_PATCH DEC(__SUBVERSION__) +# define HOST_COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# endif + + +#endif +#endif /* __NVCC__ */ + + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#define STRINGIFY_HELPER(X) #X +#define STRINGIFY(X) STRINGIFY_HELPER(X) + +/* Identify known platforms by name. */ +#if defined(__linux) || defined(__linux__) || defined(linux) +# define PLATFORM_ID "Linux" + +#elif defined(__MSYS__) +# define PLATFORM_ID "MSYS" + +#elif defined(__CYGWIN__) +# define PLATFORM_ID "Cygwin" + +#elif defined(__MINGW32__) +# define PLATFORM_ID "MinGW" + +#elif defined(__APPLE__) +# define PLATFORM_ID "Darwin" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +# define PLATFORM_ID "Windows" + +#elif defined(__FreeBSD__) || defined(__FreeBSD) +# define PLATFORM_ID "FreeBSD" + +#elif defined(__NetBSD__) || defined(__NetBSD) +# define PLATFORM_ID "NetBSD" + +#elif defined(__OpenBSD__) || defined(__OPENBSD) +# define PLATFORM_ID "OpenBSD" + +#elif defined(__sun) || defined(sun) +# define PLATFORM_ID "SunOS" + +#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__) +# define PLATFORM_ID "AIX" + +#elif defined(__hpux) || defined(__hpux__) +# define PLATFORM_ID "HP-UX" + +#elif defined(__HAIKU__) +# define PLATFORM_ID "Haiku" + +#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS) +# define PLATFORM_ID "BeOS" + +#elif defined(__QNX__) || defined(__QNXNTO__) +# define PLATFORM_ID "QNX" + +#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__) +# define PLATFORM_ID "Tru64" + +#elif defined(__riscos) || defined(__riscos__) +# define PLATFORM_ID "RISCos" + +#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__) +# define PLATFORM_ID "SINIX" + +#elif defined(__UNIX_SV__) +# define PLATFORM_ID "UNIX_SV" + +#elif defined(__bsdos__) +# define PLATFORM_ID "BSDOS" + +#elif defined(_MPRAS) || defined(MPRAS) +# define PLATFORM_ID "MP-RAS" + +#elif defined(__osf) || defined(__osf__) +# define PLATFORM_ID "OSF1" + +#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv) +# define PLATFORM_ID "SCO_SV" + +#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX) +# define PLATFORM_ID "ULTRIX" + +#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX) +# define PLATFORM_ID "Xenix" + +#elif defined(__WATCOMC__) +# if defined(__LINUX__) +# define PLATFORM_ID "Linux" + +# elif defined(__DOS__) +# define PLATFORM_ID "DOS" + +# elif defined(__OS2__) +# define PLATFORM_ID "OS2" + +# elif defined(__WINDOWS__) +# define PLATFORM_ID "Windows3x" + +# elif defined(__VXWORKS__) +# define PLATFORM_ID "VxWorks" + +# else /* unknown platform */ +# define PLATFORM_ID +# endif + +#elif defined(__INTEGRITY) +# if defined(INT_178B) +# define PLATFORM_ID "Integrity178" + +# else /* regular Integrity */ +# define PLATFORM_ID "Integrity" +# endif + +# elif defined(_ADI_COMPILER) +# define PLATFORM_ID "ADSP" + +#else /* unknown platform */ +# define PLATFORM_ID + +#endif + +/* For windows compilers MSVC and Intel we can determine + the architecture of the compiler being used. This is because + the compilers do not have flags that can change the architecture, + but rather depend on which compiler is being used +*/ +#if defined(_WIN32) && defined(_MSC_VER) +# if defined(_M_IA64) +# define ARCHITECTURE_ID "IA64" + +# elif defined(_M_ARM64EC) +# define ARCHITECTURE_ID "ARM64EC" + +# elif defined(_M_X64) || defined(_M_AMD64) +# define ARCHITECTURE_ID "x64" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# elif defined(_M_ARM64) +# define ARCHITECTURE_ID "ARM64" + +# elif defined(_M_ARM) +# if _M_ARM == 4 +# define ARCHITECTURE_ID "ARMV4I" +# elif _M_ARM == 5 +# define ARCHITECTURE_ID "ARMV5I" +# else +# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM) +# endif + +# elif defined(_M_MIPS) +# define ARCHITECTURE_ID "MIPS" + +# elif defined(_M_SH) +# define ARCHITECTURE_ID "SHx" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__WATCOMC__) +# if defined(_M_I86) +# define ARCHITECTURE_ID "I86" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# if defined(__ICCARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__ICCRX__) +# define ARCHITECTURE_ID "RX" + +# elif defined(__ICCRH850__) +# define ARCHITECTURE_ID "RH850" + +# elif defined(__ICCRL78__) +# define ARCHITECTURE_ID "RL78" + +# elif defined(__ICCRISCV__) +# define ARCHITECTURE_ID "RISCV" + +# elif defined(__ICCAVR__) +# define ARCHITECTURE_ID "AVR" + +# elif defined(__ICC430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__ICCV850__) +# define ARCHITECTURE_ID "V850" + +# elif defined(__ICC8051__) +# define ARCHITECTURE_ID "8051" + +# elif defined(__ICCSTM8__) +# define ARCHITECTURE_ID "STM8" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__ghs__) +# if defined(__PPC64__) +# define ARCHITECTURE_ID "PPC64" + +# elif defined(__ppc__) +# define ARCHITECTURE_ID "PPC" + +# elif defined(__ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__x86_64__) +# define ARCHITECTURE_ID "x64" + +# elif defined(__i386__) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__clang__) && defined(__ti__) +# if defined(__ARM_ARCH) +# define ARCHITECTURE_ID "ARM" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__TI_COMPILER_VERSION__) +# if defined(__TI_ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__MSP430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__TMS320C28XX__) +# define ARCHITECTURE_ID "TMS320C28x" + +# elif defined(__TMS320C6X__) || defined(_TMS320C6X) +# define ARCHITECTURE_ID "TMS320C6x" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +# elif defined(__ADSPSHARC__) +# define ARCHITECTURE_ID "SHARC" + +# elif defined(__ADSPBLACKFIN__) +# define ARCHITECTURE_ID "Blackfin" + +#elif defined(__TASKING__) + +# if defined(__CTC__) || defined(__CPTC__) +# define ARCHITECTURE_ID "TriCore" + +# elif defined(__CMCS__) +# define ARCHITECTURE_ID "MCS" + +# elif defined(__CARM__) || defined(__CPARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__CARC__) +# define ARCHITECTURE_ID "ARC" + +# elif defined(__C51__) +# define ARCHITECTURE_ID "8051" + +# elif defined(__CPCP__) +# define ARCHITECTURE_ID "PCP" + +# else +# define ARCHITECTURE_ID "" +# endif + +#else +# define ARCHITECTURE_ID +#endif + +/* Convert integer to decimal digit literals. */ +#define DEC(n) \ + ('0' + (((n) / 10000000)%10)), \ + ('0' + (((n) / 1000000)%10)), \ + ('0' + (((n) / 100000)%10)), \ + ('0' + (((n) / 10000)%10)), \ + ('0' + (((n) / 1000)%10)), \ + ('0' + (((n) / 100)%10)), \ + ('0' + (((n) / 10)%10)), \ + ('0' + ((n) % 10)) + +/* Convert integer to hex digit literals. */ +#define HEX(n) \ + ('0' + ((n)>>28 & 0xF)), \ + ('0' + ((n)>>24 & 0xF)), \ + ('0' + ((n)>>20 & 0xF)), \ + ('0' + ((n)>>16 & 0xF)), \ + ('0' + ((n)>>12 & 0xF)), \ + ('0' + ((n)>>8 & 0xF)), \ + ('0' + ((n)>>4 & 0xF)), \ + ('0' + ((n) & 0xF)) + +/* Construct a string literal encoding the version number. */ +#ifdef COMPILER_VERSION +char const* info_version = "INFO" ":" "compiler_version[" COMPILER_VERSION "]"; + +/* Construct a string literal encoding the version number components. */ +#elif defined(COMPILER_VERSION_MAJOR) +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + COMPILER_VERSION_MAJOR, +# ifdef COMPILER_VERSION_MINOR + '.', COMPILER_VERSION_MINOR, +# ifdef COMPILER_VERSION_PATCH + '.', COMPILER_VERSION_PATCH, +# ifdef COMPILER_VERSION_TWEAK + '.', COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct a string literal encoding the internal version number. */ +#ifdef COMPILER_VERSION_INTERNAL +char const info_version_internal[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_', + 'i','n','t','e','r','n','a','l','[', + COMPILER_VERSION_INTERNAL,']','\0'}; +#elif defined(COMPILER_VERSION_INTERNAL_STR) +char const* info_version_internal = "INFO" ":" "compiler_version_internal[" COMPILER_VERSION_INTERNAL_STR "]"; +#endif + +/* Construct a string literal encoding the version number components. */ +#ifdef SIMULATE_VERSION_MAJOR +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + SIMULATE_VERSION_MAJOR, +# ifdef SIMULATE_VERSION_MINOR + '.', SIMULATE_VERSION_MINOR, +# ifdef SIMULATE_VERSION_PATCH + '.', SIMULATE_VERSION_PATCH, +# ifdef SIMULATE_VERSION_TWEAK + '.', SIMULATE_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]"; +char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]"; + + + +#ifdef HOST_COMPILER_ID +char const* info_host_compiler = "INFO" ":" "host_compiler[" HOST_COMPILER_ID "]"; +#endif +#ifdef HOST_COMPILER_VERSION +char const* info_host_compiler_version = "INFO" ":" "host_compiler_version[" HOST_COMPILER_VERSION "]"; +#elif defined(HOST_COMPILER_VERSION_MAJOR) +char const info_host_compiler_version[] = { + 'I', 'N', 'F', 'O', ':','h','o','s','t','_', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + HOST_COMPILER_VERSION_MAJOR, +# ifdef HOST_COMPILER_VERSION_MINOR + '.', HOST_COMPILER_VERSION_MINOR, +# ifdef HOST_COMPILER_VERSION_PATCH + '.', HOST_COMPILER_VERSION_PATCH, +# ifdef HOST_COMPILER_VERSION_TWEAK + '.', HOST_COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +#define CXX_STD_11 201103L +#define CXX_STD_14 201402L +#define CXX_STD_17 201703L +#define CXX_STD_20 202002L +#define CXX_STD_23 202302L + +#if defined(_MSC_VER) && defined(_MSVC_LANG) +# if _MSVC_LANG > __cplusplus +# define CXX_STD _MSVC_LANG +# else +# define CXX_STD __cplusplus +# endif +#else +# define CXX_STD __cplusplus +#endif + +const char* info_language_standard_default = "INFO" ":" "standard_default[" +#if CXX_STD > CXX_STD_23 + "26" +#elif CXX_STD > CXX_STD_20 + "23" +#elif CXX_STD > CXX_STD_17 + "20" +#elif CXX_STD > CXX_STD_14 + "17" +#elif CXX_STD > CXX_STD_11 + "14" +#elif CXX_STD >= CXX_STD_11 + "11" +#else + "03" +#endif +"]"; + +const char* info_language_extensions_default = "INFO" ":" "extensions_default[" +#if (defined(__clang__) || defined(__GNUC__)) && \ + !defined(__STRICT_ANSI__) + "ON" +#else + "OFF" +#endif +"]"; + +/*--------------------------------------------------------------------------*/ + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#ifdef HOST_COMPILER_ID + require += info_host_compiler[argc]; +#endif +#ifdef HOST_COMPILER_VERSION_MAJOR + require += info_host_compiler_version[argc]; +#endif + require += info_language_standard_default[argc]; + require += info_language_extensions_default[argc]; + (void)argv; + return require; +} diff --git a/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/a.out b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/a.out new file mode 100755 index 0000000000000000000000000000000000000000..160c5d9ee0bb4eaa8c936b4b4d91f75ac42ad2c0 GIT binary patch literal 1000048 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

KG}uZHN&y$sM#au4=UdSArvX0Z=Bi1c>i=f_ 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

RC(+BCc5U3Bi+`|?Tznu5c#|J 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%0DmX8{{F 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℞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

|M~Uz-#uNwLdnUr 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

3WN}la2>u{|#!yCM;6c`_0`;lt&6O}&iWldQ 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

e6^R_Y5A;Q_G#+bKwhPZgOS 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 X+y3@rJC6UAJ9Xvw^40-c-|qb%d+?1) literal 0 HcmV?d00001 diff --git a/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp1.ii b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp1.ii new file mode 100644 index 0000000..c232dbd --- /dev/null +++ b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp1.ii @@ -0,0 +1,36265 @@ +# 0 "CMakeCUDACompilerId.cu" +# 0 "" +# 0 "" +# 1 "/usr/include/stdc-predef.h" 1 3 4 +# 0 "" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 1 +# 61 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +#pragma GCC diagnostic push + + +#pragma GCC diagnostic ignored "-Wunused-function" +# 82 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_config.h" 1 +# 216 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_config.h" +# 1 "/usr/include/features.h" 1 3 4 +# 415 "/usr/include/features.h" 3 4 +# 1 "/usr/include/features-time64.h" 1 3 4 +# 20 "/usr/include/features-time64.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 21 "/usr/include/features-time64.h" 2 3 4 +# 1 "/usr/include/bits/timesize.h" 1 3 4 +# 19 "/usr/include/bits/timesize.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/bits/timesize.h" 2 3 4 +# 22 "/usr/include/features-time64.h" 2 3 4 +# 416 "/usr/include/features.h" 2 3 4 +# 524 "/usr/include/features.h" 3 4 +# 1 "/usr/include/sys/cdefs.h" 1 3 4 +# 730 "/usr/include/sys/cdefs.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 731 "/usr/include/sys/cdefs.h" 2 3 4 +# 1 "/usr/include/bits/long-double.h" 1 3 4 +# 732 "/usr/include/sys/cdefs.h" 2 3 4 +# 525 "/usr/include/features.h" 2 3 4 +# 548 "/usr/include/features.h" 3 4 +# 1 "/usr/include/gnu/stubs.h" 1 3 4 +# 10 "/usr/include/gnu/stubs.h" 3 4 +# 1 "/usr/include/gnu/stubs-64.h" 1 3 4 +# 11 "/usr/include/gnu/stubs.h" 2 3 4 +# 549 "/usr/include/features.h" 2 3 4 +# 217 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_config.h" 2 +# 83 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + + + + + + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 56 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" 1 +# 59 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 64 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" +# 1 "/usr/include/ctype.h" 1 3 4 +# 26 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/bits/types.h" 1 3 4 +# 27 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/bits/types.h" 2 3 4 +# 1 "/usr/include/bits/timesize.h" 1 3 4 +# 19 "/usr/include/bits/timesize.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/bits/timesize.h" 2 3 4 +# 29 "/usr/include/bits/types.h" 2 3 4 + + + +# 31 "/usr/include/bits/types.h" 3 4 +typedef unsigned char __u_char; +typedef unsigned short int __u_short; +typedef unsigned int __u_int; +typedef unsigned long int __u_long; + + +typedef signed char __int8_t; +typedef unsigned char __uint8_t; +typedef signed short int __int16_t; +typedef unsigned short int __uint16_t; +typedef signed int __int32_t; +typedef unsigned int __uint32_t; + +typedef signed long int __int64_t; +typedef unsigned long int __uint64_t; + + + + + + +typedef __int8_t __int_least8_t; +typedef __uint8_t __uint_least8_t; +typedef __int16_t __int_least16_t; +typedef __uint16_t __uint_least16_t; +typedef __int32_t __int_least32_t; +typedef __uint32_t __uint_least32_t; +typedef __int64_t __int_least64_t; +typedef __uint64_t __uint_least64_t; + + + +typedef long int __quad_t; +typedef unsigned long int __u_quad_t; + + + + + + + +typedef long int __intmax_t; +typedef unsigned long int __uintmax_t; +# 141 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/typesizes.h" 1 3 4 +# 142 "/usr/include/bits/types.h" 2 3 4 +# 1 "/usr/include/bits/time64.h" 1 3 4 +# 143 "/usr/include/bits/types.h" 2 3 4 + + +typedef unsigned long int __dev_t; +typedef unsigned int __uid_t; +typedef unsigned int __gid_t; +typedef unsigned long int __ino_t; +typedef unsigned long int __ino64_t; +typedef unsigned int __mode_t; +typedef unsigned long int __nlink_t; +typedef long int __off_t; +typedef long int __off64_t; +typedef int __pid_t; +typedef struct { int __val[2]; } __fsid_t; +typedef long int __clock_t; +typedef unsigned long int __rlim_t; +typedef unsigned long int __rlim64_t; +typedef unsigned int __id_t; +typedef long int __time_t; +typedef unsigned int __useconds_t; +typedef long int __suseconds_t; +typedef long int __suseconds64_t; + +typedef int __daddr_t; +typedef int __key_t; + + +typedef int __clockid_t; + + +typedef void * __timer_t; + + +typedef long int __blksize_t; + + + + +typedef long int __blkcnt_t; +typedef long int __blkcnt64_t; + + +typedef unsigned long int __fsblkcnt_t; +typedef unsigned long int __fsblkcnt64_t; + + +typedef unsigned long int __fsfilcnt_t; +typedef unsigned long int __fsfilcnt64_t; + + +typedef long int __fsword_t; + +typedef long int __ssize_t; + + +typedef long int __syscall_slong_t; + +typedef unsigned long int __syscall_ulong_t; + + + +typedef __off64_t __loff_t; +typedef char *__caddr_t; + + +typedef long int __intptr_t; + + +typedef unsigned int __socklen_t; + + + + +typedef int __sig_atomic_t; +# 27 "/usr/include/ctype.h" 2 3 4 + +extern "C" { +# 39 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/bits/endian.h" 1 3 4 +# 35 "/usr/include/bits/endian.h" 3 4 +# 1 "/usr/include/bits/endianness.h" 1 3 4 +# 36 "/usr/include/bits/endian.h" 2 3 4 +# 40 "/usr/include/ctype.h" 2 3 4 + + + + + + +enum +{ + _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), + _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), + _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), + _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), + _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), + _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), + _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), + _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), + _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), + _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), + _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), + _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8)) +}; +# 79 "/usr/include/ctype.h" 3 4 +extern const unsigned short int **__ctype_b_loc (void) + noexcept (true) __attribute__ ((__const__)); +extern const __int32_t **__ctype_tolower_loc (void) + noexcept (true) __attribute__ ((__const__)); +extern const __int32_t **__ctype_toupper_loc (void) + noexcept (true) __attribute__ ((__const__)); +# 108 "/usr/include/ctype.h" 3 4 +extern int isalnum (int) noexcept (true); +extern int isalpha (int) noexcept (true); +extern int iscntrl (int) noexcept (true); +extern int isdigit (int) noexcept (true); +extern int islower (int) noexcept (true); +extern int isgraph (int) noexcept (true); +extern int isprint (int) noexcept (true); +extern int ispunct (int) noexcept (true); +extern int isspace (int) noexcept (true); +extern int isupper (int) noexcept (true); +extern int isxdigit (int) noexcept (true); + + + +extern int tolower (int __c) noexcept (true); + + +extern int toupper (int __c) noexcept (true); + + + + +extern int isblank (int) noexcept (true); + + + + +extern int isctype (int __c, int __mask) noexcept (true); + + + + + + +extern int isascii (int __c) noexcept (true); + + + +extern int toascii (int __c) noexcept (true); + + + +extern int _toupper (int) noexcept (true); +extern int _tolower (int) noexcept (true); +# 237 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/bits/types/locale_t.h" 1 3 4 +# 22 "/usr/include/bits/types/locale_t.h" 3 4 +# 1 "/usr/include/bits/types/__locale_t.h" 1 3 4 +# 27 "/usr/include/bits/types/__locale_t.h" 3 4 +struct __locale_struct +{ + + struct __locale_data *__locales[13]; + + + const unsigned short int *__ctype_b; + const int *__ctype_tolower; + const int *__ctype_toupper; + + + const char *__names[13]; +}; + +typedef struct __locale_struct *__locale_t; +# 23 "/usr/include/bits/types/locale_t.h" 2 3 4 + +typedef __locale_t locale_t; +# 238 "/usr/include/ctype.h" 2 3 4 +# 251 "/usr/include/ctype.h" 3 4 +extern int isalnum_l (int, locale_t) noexcept (true); +extern int isalpha_l (int, locale_t) noexcept (true); +extern int iscntrl_l (int, locale_t) noexcept (true); +extern int isdigit_l (int, locale_t) noexcept (true); +extern int islower_l (int, locale_t) noexcept (true); +extern int isgraph_l (int, locale_t) noexcept (true); +extern int isprint_l (int, locale_t) noexcept (true); +extern int ispunct_l (int, locale_t) noexcept (true); +extern int isspace_l (int, locale_t) noexcept (true); +extern int isupper_l (int, locale_t) noexcept (true); +extern int isxdigit_l (int, locale_t) noexcept (true); + +extern int isblank_l (int, locale_t) noexcept (true); + + + +extern int __tolower_l (int __c, locale_t __l) noexcept (true); +extern int tolower_l (int __c, locale_t __l) noexcept (true); + + +extern int __toupper_l (int __c, locale_t __l) noexcept (true); +extern int toupper_l (int __c, locale_t __l) noexcept (true); +# 327 "/usr/include/ctype.h" 3 4 +} +# 65 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 2 +# 60 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" 2 +# 68 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" + +# 68 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" +enum __attribute__((device_builtin)) cudaRoundMode +{ + cudaRoundNearest, + cudaRoundZero, + cudaRoundPosInf, + cudaRoundMinInf +}; +# 57 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 1 +# 59 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 60 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" 1 +# 65 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 66 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" 2 +# 104 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +struct __attribute__((device_builtin)) char1 +{ + signed char x; +}; + +struct __attribute__((device_builtin)) uchar1 +{ + unsigned char x; +}; + + +struct __attribute__((device_builtin)) __attribute__((aligned(2))) char2 +{ + signed char x, y; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(2))) uchar2 +{ + unsigned char x, y; +}; + +struct __attribute__((device_builtin)) char3 +{ + signed char x, y, z; +}; + +struct __attribute__((device_builtin)) uchar3 +{ + unsigned char x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(4))) char4 +{ + signed char x, y, z, w; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(4))) uchar4 +{ + unsigned char x, y, z, w; +}; + +struct __attribute__((device_builtin)) short1 +{ + short x; +}; + +struct __attribute__((device_builtin)) ushort1 +{ + unsigned short x; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(4))) short2 +{ + short x, y; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(4))) ushort2 +{ + unsigned short x, y; +}; + +struct __attribute__((device_builtin)) short3 +{ + short x, y, z; +}; + +struct __attribute__((device_builtin)) ushort3 +{ + unsigned short x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(8))) short4 { short x; short y; short z; short w; }; +struct __attribute__((device_builtin)) __attribute__((aligned(8))) ushort4 { unsigned short x; unsigned short y; unsigned short z; unsigned short w; }; + +struct __attribute__((device_builtin)) int1 +{ + int x; +}; + +struct __attribute__((device_builtin)) uint1 +{ + unsigned int x; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(8))) int2 { int x; int y; }; +struct __attribute__((device_builtin)) __attribute__((aligned(8))) uint2 { unsigned int x; unsigned int y; }; + +struct __attribute__((device_builtin)) int3 +{ + int x, y, z; +}; + +struct __attribute__((device_builtin)) uint3 +{ + unsigned int x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) int4 +{ + int x, y, z, w; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) uint4 +{ + unsigned int x, y, z, w; +}; + +struct __attribute__((device_builtin)) long1 +{ + long int x; +}; + +struct __attribute__((device_builtin)) ulong1 +{ + unsigned long x; +}; + + + + + + +struct __attribute__((device_builtin)) __attribute__((aligned(2*sizeof(long int)))) long2 +{ + long int x, y; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(2*sizeof(unsigned long int)))) ulong2 +{ + unsigned long int x, y; +}; + + + +struct __attribute__((device_builtin)) long3 +{ + long int x, y, z; +}; + +struct __attribute__((device_builtin)) ulong3 +{ + unsigned long int x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) long4 +{ + long int x, y, z, w; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) ulong4 +{ + unsigned long int x, y, z, w; +}; + +struct __attribute__((device_builtin)) float1 +{ + float x; +}; +# 280 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +struct __attribute__((device_builtin)) __attribute__((aligned(8))) float2 { float x; float y; }; + + + + +struct __attribute__((device_builtin)) float3 +{ + float x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) float4 +{ + float x, y, z, w; +}; + +struct __attribute__((device_builtin)) longlong1 +{ + long long int x; +}; + +struct __attribute__((device_builtin)) ulonglong1 +{ + unsigned long long int x; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) longlong2 +{ + long long int x, y; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) ulonglong2 +{ + unsigned long long int x, y; +}; + +struct __attribute__((device_builtin)) longlong3 +{ + long long int x, y, z; +}; + +struct __attribute__((device_builtin)) ulonglong3 +{ + unsigned long long int x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) longlong4 +{ + long long int x, y, z ,w; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) ulonglong4 +{ + unsigned long long int x, y, z, w; +}; + +struct __attribute__((device_builtin)) double1 +{ + double x; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) double2 +{ + double x, y; +}; + +struct __attribute__((device_builtin)) double3 +{ + double x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) double4 +{ + double x, y, z, w; +}; +# 367 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +typedef __attribute__((device_builtin)) struct char1 char1; +typedef __attribute__((device_builtin)) struct uchar1 uchar1; +typedef __attribute__((device_builtin)) struct char2 char2; +typedef __attribute__((device_builtin)) struct uchar2 uchar2; +typedef __attribute__((device_builtin)) struct char3 char3; +typedef __attribute__((device_builtin)) struct uchar3 uchar3; +typedef __attribute__((device_builtin)) struct char4 char4; +typedef __attribute__((device_builtin)) struct uchar4 uchar4; +typedef __attribute__((device_builtin)) struct short1 short1; +typedef __attribute__((device_builtin)) struct ushort1 ushort1; +typedef __attribute__((device_builtin)) struct short2 short2; +typedef __attribute__((device_builtin)) struct ushort2 ushort2; +typedef __attribute__((device_builtin)) struct short3 short3; +typedef __attribute__((device_builtin)) struct ushort3 ushort3; +typedef __attribute__((device_builtin)) struct short4 short4; +typedef __attribute__((device_builtin)) struct ushort4 ushort4; +typedef __attribute__((device_builtin)) struct int1 int1; +typedef __attribute__((device_builtin)) struct uint1 uint1; +typedef __attribute__((device_builtin)) struct int2 int2; +typedef __attribute__((device_builtin)) struct uint2 uint2; +typedef __attribute__((device_builtin)) struct int3 int3; +typedef __attribute__((device_builtin)) struct uint3 uint3; +typedef __attribute__((device_builtin)) struct int4 int4; +typedef __attribute__((device_builtin)) struct uint4 uint4; +typedef __attribute__((device_builtin)) struct long1 long1; +typedef __attribute__((device_builtin)) struct ulong1 ulong1; +typedef __attribute__((device_builtin)) struct long2 long2; +typedef __attribute__((device_builtin)) struct ulong2 ulong2; +typedef __attribute__((device_builtin)) struct long3 long3; +typedef __attribute__((device_builtin)) struct ulong3 ulong3; +typedef __attribute__((device_builtin)) struct long4 long4; +typedef __attribute__((device_builtin)) struct ulong4 ulong4; +typedef __attribute__((device_builtin)) struct float1 float1; +typedef __attribute__((device_builtin)) struct float2 float2; +typedef __attribute__((device_builtin)) struct float3 float3; +typedef __attribute__((device_builtin)) struct float4 float4; +typedef __attribute__((device_builtin)) struct longlong1 longlong1; +typedef __attribute__((device_builtin)) struct ulonglong1 ulonglong1; +typedef __attribute__((device_builtin)) struct longlong2 longlong2; +typedef __attribute__((device_builtin)) struct ulonglong2 ulonglong2; +typedef __attribute__((device_builtin)) struct longlong3 longlong3; +typedef __attribute__((device_builtin)) struct ulonglong3 ulonglong3; +typedef __attribute__((device_builtin)) struct longlong4 longlong4; +typedef __attribute__((device_builtin)) struct ulonglong4 ulonglong4; +typedef __attribute__((device_builtin)) struct double1 double1; +typedef __attribute__((device_builtin)) struct double2 double2; +typedef __attribute__((device_builtin)) struct double3 double3; +typedef __attribute__((device_builtin)) struct double4 double4; +# 426 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +struct __attribute__((device_builtin)) dim3 +{ + unsigned int x, y, z; + + + __attribute__((host)) __attribute__((device)) constexpr dim3(unsigned int vx = 1, unsigned int vy = 1, unsigned int vz = 1) : x(vx), y(vy), z(vz) {} + __attribute__((host)) __attribute__((device)) constexpr dim3(uint3 v) : x(v.x), y(v.y), z(v.z) {} + __attribute__((host)) __attribute__((device)) constexpr operator uint3(void) const { return uint3{x, y, z}; } + + + + + + +}; + +typedef __attribute__((device_builtin)) struct dim3 dim3; +# 62 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 2 +# 83 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 1 3 4 +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/syslimits.h" 1 3 4 + + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 1 3 4 +# 210 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 3 4 +# 1 "/usr/include/limits.h" 1 3 4 +# 26 "/usr/include/limits.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/limits.h" 2 3 4 +# 195 "/usr/include/limits.h" 3 4 +# 1 "/usr/include/bits/posix1_lim.h" 1 3 4 +# 27 "/usr/include/bits/posix1_lim.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/bits/posix1_lim.h" 2 3 4 +# 161 "/usr/include/bits/posix1_lim.h" 3 4 +# 1 "/usr/include/bits/local_lim.h" 1 3 4 +# 38 "/usr/include/bits/local_lim.h" 3 4 +# 1 "/usr/include/linux/limits.h" 1 3 4 +# 39 "/usr/include/bits/local_lim.h" 2 3 4 +# 81 "/usr/include/bits/local_lim.h" 3 4 +# 1 "/usr/include/bits/pthread_stack_min-dynamic.h" 1 3 4 +# 23 "/usr/include/bits/pthread_stack_min-dynamic.h" 3 4 + +# 23 "/usr/include/bits/pthread_stack_min-dynamic.h" 3 4 +extern "C" { +extern long int __sysconf (int __name) noexcept (true); +} +# 82 "/usr/include/bits/local_lim.h" 2 3 4 +# 162 "/usr/include/bits/posix1_lim.h" 2 3 4 +# 196 "/usr/include/limits.h" 2 3 4 + + + +# 1 "/usr/include/bits/posix2_lim.h" 1 3 4 +# 200 "/usr/include/limits.h" 2 3 4 + + + +# 1 "/usr/include/bits/xopen_lim.h" 1 3 4 +# 64 "/usr/include/bits/xopen_lim.h" 3 4 +# 1 "/usr/include/bits/uio_lim.h" 1 3 4 +# 65 "/usr/include/bits/xopen_lim.h" 2 3 4 +# 204 "/usr/include/limits.h" 2 3 4 +# 211 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 2 3 4 +# 8 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/syslimits.h" 2 3 4 +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 2 3 4 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 2 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 145 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 4 +typedef long int ptrdiff_t; +# 214 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 4 +typedef long unsigned int size_t; +# 425 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 4 +typedef struct { + long long __max_align_ll __attribute__((__aligned__(__alignof__(long long)))); + long double __max_align_ld __attribute__((__aligned__(__alignof__(long double)))); +# 436 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 4 +} max_align_t; + + + + + + + typedef decltype(nullptr) nullptr_t; +# 85 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 2 +# 205 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + +# 205 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +enum __attribute__((device_builtin)) cudaError +{ + + + + + + cudaSuccess = 0, + + + + + + cudaErrorInvalidValue = 1, + + + + + + cudaErrorMemoryAllocation = 2, + + + + + + cudaErrorInitializationError = 3, + + + + + + + cudaErrorCudartUnloading = 4, + + + + + + + cudaErrorProfilerDisabled = 5, + + + + + + + + cudaErrorProfilerNotInitialized = 6, + + + + + + + cudaErrorProfilerAlreadyStarted = 7, + + + + + + + cudaErrorProfilerAlreadyStopped = 8, + + + + + + + + cudaErrorInvalidConfiguration = 9, + + + + + + cudaErrorInvalidPitchValue = 12, + + + + + + cudaErrorInvalidSymbol = 13, + + + + + + + + cudaErrorInvalidHostPointer = 16, + + + + + + + + cudaErrorInvalidDevicePointer = 17, + + + + + cudaErrorInvalidTexture = 18, + + + + + + cudaErrorInvalidTextureBinding = 19, + + + + + + + cudaErrorInvalidChannelDescriptor = 20, + + + + + + cudaErrorInvalidMemcpyDirection = 21, +# 336 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorAddressOfConstant = 22, +# 345 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorTextureFetchFailed = 23, +# 354 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorTextureNotBound = 24, +# 363 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSynchronizationError = 25, + + + + + cudaErrorInvalidFilterSetting = 26, + + + + + + cudaErrorInvalidNormSetting = 27, + + + + + + + + cudaErrorMixedDeviceExecution = 28, + + + + + + + + cudaErrorNotYetImplemented = 31, +# 399 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorMemoryValueTooLarge = 32, + + + + + + cudaErrorStubLibrary = 34, + + + + + + + cudaErrorInsufficientDriver = 35, + + + + + + + cudaErrorCallRequiresNewerDriver = 36, + + + + + + cudaErrorInvalidSurface = 37, + + + + + + cudaErrorDuplicateVariableName = 43, + + + + + + cudaErrorDuplicateTextureName = 44, + + + + + + cudaErrorDuplicateSurfaceName = 45, +# 453 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorDevicesUnavailable = 46, +# 466 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorIncompatibleDriverContext = 49, + + + + + + cudaErrorMissingConfiguration = 52, +# 481 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorPriorLaunchFailure = 53, + + + + + + cudaErrorLaunchMaxDepthExceeded = 65, + + + + + + + + cudaErrorLaunchFileScopedTex = 66, + + + + + + + + cudaErrorLaunchFileScopedSurf = 67, +# 519 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSyncDepthExceeded = 68, +# 531 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorLaunchPendingCountExceeded = 69, + + + + + + cudaErrorInvalidDeviceFunction = 98, + + + + + + cudaErrorNoDevice = 100, + + + + + + + cudaErrorInvalidDevice = 101, + + + + + cudaErrorDeviceNotLicensed = 102, +# 564 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSoftwareValidityNotEstablished = 103, + + + + + cudaErrorStartupFailure = 127, + + + + + cudaErrorInvalidKernelImage = 200, +# 584 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorDeviceUninitialized = 201, + + + + + cudaErrorMapBufferObjectFailed = 205, + + + + + cudaErrorUnmapBufferObjectFailed = 206, + + + + + + cudaErrorArrayIsMapped = 207, + + + + + cudaErrorAlreadyMapped = 208, + + + + + + + + cudaErrorNoKernelImageForDevice = 209, + + + + + cudaErrorAlreadyAcquired = 210, + + + + + cudaErrorNotMapped = 211, + + + + + + cudaErrorNotMappedAsArray = 212, + + + + + + cudaErrorNotMappedAsPointer = 213, + + + + + + cudaErrorECCUncorrectable = 214, + + + + + + cudaErrorUnsupportedLimit = 215, + + + + + + cudaErrorDeviceAlreadyInUse = 216, + + + + + + cudaErrorPeerAccessUnsupported = 217, + + + + + + cudaErrorInvalidPtx = 218, + + + + + cudaErrorInvalidGraphicsContext = 219, + + + + + + cudaErrorNvlinkUncorrectable = 220, + + + + + + + cudaErrorJitCompilerNotFound = 221, + + + + + + + cudaErrorUnsupportedPtxVersion = 222, + + + + + + + cudaErrorJitCompilationDisabled = 223, + + + + + cudaErrorUnsupportedExecAffinity = 224, + + + + + + cudaErrorUnsupportedDevSideSync = 225, +# 719 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorContained = 226, + + + + + cudaErrorInvalidSource = 300, + + + + + cudaErrorFileNotFound = 301, + + + + + cudaErrorSharedObjectSymbolNotFound = 302, + + + + + cudaErrorSharedObjectInitFailed = 303, + + + + + cudaErrorOperatingSystem = 304, + + + + + + + cudaErrorInvalidResourceHandle = 400, + + + + + + cudaErrorIllegalState = 401, + + + + + + + + cudaErrorLossyQuery = 402, + + + + + + + cudaErrorSymbolNotFound = 500, + + + + + + + + cudaErrorNotReady = 600, + + + + + + + + cudaErrorIllegalAddress = 700, +# 797 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorLaunchOutOfResources = 701, +# 808 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorLaunchTimeout = 702, + + + + + + cudaErrorLaunchIncompatibleTexturing = 703, + + + + + + + cudaErrorPeerAccessAlreadyEnabled = 704, + + + + + + + cudaErrorPeerAccessNotEnabled = 705, +# 841 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSetOnActiveProcess = 708, + + + + + + + cudaErrorContextIsDestroyed = 709, + + + + + + + cudaErrorAssert = 710, + + + + + + + cudaErrorTooManyPeers = 711, + + + + + + cudaErrorHostMemoryAlreadyRegistered = 712, + + + + + + cudaErrorHostMemoryNotRegistered = 713, +# 883 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorHardwareStackError = 714, + + + + + + + + cudaErrorIllegalInstruction = 715, +# 900 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorMisalignedAddress = 716, +# 911 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorInvalidAddressSpace = 717, + + + + + + + + cudaErrorInvalidPc = 718, +# 930 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorLaunchFailure = 719, +# 939 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorCooperativeLaunchTooLarge = 720, + + + + + + + + cudaErrorTensorMemoryLeak = 721, + + + + + cudaErrorNotPermitted = 800, + + + + + + cudaErrorNotSupported = 801, +# 967 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSystemNotReady = 802, + + + + + + + cudaErrorSystemDriverMismatch = 803, +# 983 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorCompatNotSupportedOnDevice = 804, + + + + + cudaErrorMpsConnectionFailed = 805, + + + + + cudaErrorMpsRpcFailure = 806, + + + + + + cudaErrorMpsServerNotReady = 807, + + + + + cudaErrorMpsMaxClientsReached = 808, + + + + + cudaErrorMpsMaxConnectionsReached = 809, + + + + + cudaErrorMpsClientTerminated = 810, + + + + + cudaErrorCdpNotSupported = 811, + + + + + cudaErrorCdpVersionMismatch = 812, + + + + + cudaErrorStreamCaptureUnsupported = 900, + + + + + + cudaErrorStreamCaptureInvalidated = 901, + + + + + + cudaErrorStreamCaptureMerge = 902, + + + + + cudaErrorStreamCaptureUnmatched = 903, + + + + + + cudaErrorStreamCaptureUnjoined = 904, + + + + + + + cudaErrorStreamCaptureIsolation = 905, + + + + + + cudaErrorStreamCaptureImplicit = 906, + + + + + + cudaErrorCapturedEvent = 907, + + + + + + + cudaErrorStreamCaptureWrongThread = 908, + + + + + cudaErrorTimeout = 909, + + + + + + cudaErrorGraphExecUpdateFailure = 910, +# 1099 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorExternalDevice = 911, + + + + + + cudaErrorInvalidClusterSize = 912, + + + + + + cudaErrorFunctionNotLoaded = 913, + + + + + + cudaErrorInvalidResourceType = 914, + + + + + + cudaErrorInvalidResourceConfiguration = 915, + + + + + cudaErrorUnknown = 999 + + + + + + + + , cudaErrorApiFailureBase = 10000 +}; + + + + +enum __attribute__((device_builtin)) cudaChannelFormatKind +{ + cudaChannelFormatKindSigned = 0, + cudaChannelFormatKindUnsigned = 1, + cudaChannelFormatKindFloat = 2, + cudaChannelFormatKindNone = 3, + cudaChannelFormatKindNV12 = 4, + cudaChannelFormatKindUnsignedNormalized8X1 = 5, + cudaChannelFormatKindUnsignedNormalized8X2 = 6, + cudaChannelFormatKindUnsignedNormalized8X4 = 7, + cudaChannelFormatKindUnsignedNormalized16X1 = 8, + cudaChannelFormatKindUnsignedNormalized16X2 = 9, + cudaChannelFormatKindUnsignedNormalized16X4 = 10, + cudaChannelFormatKindSignedNormalized8X1 = 11, + cudaChannelFormatKindSignedNormalized8X2 = 12, + cudaChannelFormatKindSignedNormalized8X4 = 13, + cudaChannelFormatKindSignedNormalized16X1 = 14, + cudaChannelFormatKindSignedNormalized16X2 = 15, + cudaChannelFormatKindSignedNormalized16X4 = 16, + cudaChannelFormatKindUnsignedBlockCompressed1 = 17, + cudaChannelFormatKindUnsignedBlockCompressed1SRGB = 18, + cudaChannelFormatKindUnsignedBlockCompressed2 = 19, + cudaChannelFormatKindUnsignedBlockCompressed2SRGB = 20, + cudaChannelFormatKindUnsignedBlockCompressed3 = 21, + cudaChannelFormatKindUnsignedBlockCompressed3SRGB = 22, + cudaChannelFormatKindUnsignedBlockCompressed4 = 23, + cudaChannelFormatKindSignedBlockCompressed4 = 24, + cudaChannelFormatKindUnsignedBlockCompressed5 = 25, + cudaChannelFormatKindSignedBlockCompressed5 = 26, + cudaChannelFormatKindUnsignedBlockCompressed6H = 27, + cudaChannelFormatKindSignedBlockCompressed6H = 28, + cudaChannelFormatKindUnsignedBlockCompressed7 = 29, + cudaChannelFormatKindUnsignedBlockCompressed7SRGB = 30, + cudaChannelFormatKindUnsignedNormalized1010102 = 31 + +}; + + + + +struct __attribute__((device_builtin)) cudaChannelFormatDesc +{ + int x; + int y; + int z; + int w; + enum cudaChannelFormatKind f; +}; + + + + +typedef struct cudaArray *cudaArray_t; + + + + +typedef const struct cudaArray *cudaArray_const_t; + +struct cudaArray; + + + + +typedef struct cudaMipmappedArray *cudaMipmappedArray_t; + + + + +typedef const struct cudaMipmappedArray *cudaMipmappedArray_const_t; + +struct cudaMipmappedArray; +# 1223 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct __attribute__((device_builtin)) cudaArraySparseProperties { + struct { + unsigned int width; + unsigned int height; + unsigned int depth; + } tileExtent; + unsigned int miptailFirstLevel; + unsigned long long miptailSize; + unsigned int flags; + unsigned int reserved[4]; +}; + + + + +struct __attribute__((device_builtin)) cudaArrayMemoryRequirements { + size_t size; + size_t alignment; + unsigned int reserved[4]; +}; + + + + +enum __attribute__((device_builtin)) cudaMemoryType +{ + cudaMemoryTypeUnregistered = 0, + cudaMemoryTypeHost = 1, + cudaMemoryTypeDevice = 2, + cudaMemoryTypeManaged = 3 +}; + + + + +enum __attribute__((device_builtin)) cudaMemcpyKind +{ + cudaMemcpyHostToHost = 0, + cudaMemcpyHostToDevice = 1, + cudaMemcpyDeviceToHost = 2, + cudaMemcpyDeviceToDevice = 3, + cudaMemcpyDefault = 4 +}; + + + + + + +struct __attribute__((device_builtin)) cudaPitchedPtr +{ + void *ptr; + size_t pitch; + size_t xsize; + size_t ysize; +}; + + + + + + +struct __attribute__((device_builtin)) cudaExtent +{ + size_t width; + size_t height; + size_t depth; +}; + + + + + + +struct __attribute__((device_builtin)) cudaPos +{ + size_t x; + size_t y; + size_t z; +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpy3DParms +{ + cudaArray_t srcArray; + struct cudaPos srcPos; + struct cudaPitchedPtr srcPtr; + + cudaArray_t dstArray; + struct cudaPos dstPos; + struct cudaPitchedPtr dstPtr; + + struct cudaExtent extent; + enum cudaMemcpyKind kind; +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpyNodeParams { + int flags; + int reserved[3]; + struct cudaMemcpy3DParms copyParams; +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpy3DPeerParms +{ + cudaArray_t srcArray; + struct cudaPos srcPos; + struct cudaPitchedPtr srcPtr; + int srcDevice; + + cudaArray_t dstArray; + struct cudaPos dstPos; + struct cudaPitchedPtr dstPtr; + int dstDevice; + + struct cudaExtent extent; +}; + + + + +struct __attribute__((device_builtin)) cudaMemsetParams { + void *dst; + size_t pitch; + unsigned int value; + unsigned int elementSize; + size_t width; + size_t height; +}; + + + + +struct __attribute__((device_builtin)) cudaMemsetParamsV2 { + void *dst; + size_t pitch; + unsigned int value; + unsigned int elementSize; + size_t width; + size_t height; +}; + + + + +enum __attribute__((device_builtin)) cudaAccessProperty { + cudaAccessPropertyNormal = 0, + cudaAccessPropertyStreaming = 1, + cudaAccessPropertyPersisting = 2 +}; +# 1392 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct __attribute__((device_builtin)) cudaAccessPolicyWindow { + void *base_ptr; + size_t num_bytes; + float hitRatio; + enum cudaAccessProperty hitProp; + enum cudaAccessProperty missProp; +}; +# 1410 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef void ( *cudaHostFn_t)(void *userData); + + + + +struct __attribute__((device_builtin)) cudaHostNodeParams { + cudaHostFn_t fn; + void* userData; +}; + + + + +struct __attribute__((device_builtin)) cudaHostNodeParamsV2 { + cudaHostFn_t fn; + void* userData; +}; + + + + +enum __attribute__((device_builtin)) cudaStreamCaptureStatus { + cudaStreamCaptureStatusNone = 0, + cudaStreamCaptureStatusActive = 1, + cudaStreamCaptureStatusInvalidated = 2 + +}; + + + + + +enum __attribute__((device_builtin)) cudaStreamCaptureMode { + cudaStreamCaptureModeGlobal = 0, + cudaStreamCaptureModeThreadLocal = 1, + cudaStreamCaptureModeRelaxed = 2 +}; + +enum __attribute__((device_builtin)) cudaSynchronizationPolicy { + cudaSyncPolicyAuto = 1, + cudaSyncPolicySpin = 2, + cudaSyncPolicyYield = 3, + cudaSyncPolicyBlockingSync = 4 +}; + + + + +enum __attribute__((device_builtin)) cudaClusterSchedulingPolicy { + cudaClusterSchedulingPolicyDefault = 0, + cudaClusterSchedulingPolicySpread = 1, + cudaClusterSchedulingPolicyLoadBalancing = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaStreamUpdateCaptureDependenciesFlags { + cudaStreamAddCaptureDependencies = 0x0, + cudaStreamSetCaptureDependencies = 0x1 +}; + + + + +enum __attribute__((device_builtin)) cudaUserObjectFlags { + cudaUserObjectNoDestructorSync = 0x1 +}; + + + + +enum __attribute__((device_builtin)) cudaUserObjectRetainFlags { + cudaGraphUserObjectMove = 0x1 +}; + + + + +struct cudaGraphicsResource; + + + + +enum __attribute__((device_builtin)) cudaGraphicsRegisterFlags +{ + cudaGraphicsRegisterFlagsNone = 0, + cudaGraphicsRegisterFlagsReadOnly = 1, + cudaGraphicsRegisterFlagsWriteDiscard = 2, + cudaGraphicsRegisterFlagsSurfaceLoadStore = 4, + cudaGraphicsRegisterFlagsTextureGather = 8 +}; + + + + +enum __attribute__((device_builtin)) cudaGraphicsMapFlags +{ + cudaGraphicsMapFlagsNone = 0, + cudaGraphicsMapFlagsReadOnly = 1, + cudaGraphicsMapFlagsWriteDiscard = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaGraphicsCubeFace +{ + cudaGraphicsCubeFacePositiveX = 0x00, + cudaGraphicsCubeFaceNegativeX = 0x01, + cudaGraphicsCubeFacePositiveY = 0x02, + cudaGraphicsCubeFaceNegativeY = 0x03, + cudaGraphicsCubeFacePositiveZ = 0x04, + cudaGraphicsCubeFaceNegativeZ = 0x05 +}; + + + + +enum __attribute__((device_builtin)) cudaResourceType +{ + cudaResourceTypeArray = 0x00, + cudaResourceTypeMipmappedArray = 0x01, + cudaResourceTypeLinear = 0x02, + cudaResourceTypePitch2D = 0x03 +}; + + + + +enum __attribute__((device_builtin)) cudaResourceViewFormat +{ + cudaResViewFormatNone = 0x00, + cudaResViewFormatUnsignedChar1 = 0x01, + cudaResViewFormatUnsignedChar2 = 0x02, + cudaResViewFormatUnsignedChar4 = 0x03, + cudaResViewFormatSignedChar1 = 0x04, + cudaResViewFormatSignedChar2 = 0x05, + cudaResViewFormatSignedChar4 = 0x06, + cudaResViewFormatUnsignedShort1 = 0x07, + cudaResViewFormatUnsignedShort2 = 0x08, + cudaResViewFormatUnsignedShort4 = 0x09, + cudaResViewFormatSignedShort1 = 0x0a, + cudaResViewFormatSignedShort2 = 0x0b, + cudaResViewFormatSignedShort4 = 0x0c, + cudaResViewFormatUnsignedInt1 = 0x0d, + cudaResViewFormatUnsignedInt2 = 0x0e, + cudaResViewFormatUnsignedInt4 = 0x0f, + cudaResViewFormatSignedInt1 = 0x10, + cudaResViewFormatSignedInt2 = 0x11, + cudaResViewFormatSignedInt4 = 0x12, + cudaResViewFormatHalf1 = 0x13, + cudaResViewFormatHalf2 = 0x14, + cudaResViewFormatHalf4 = 0x15, + cudaResViewFormatFloat1 = 0x16, + cudaResViewFormatFloat2 = 0x17, + cudaResViewFormatFloat4 = 0x18, + cudaResViewFormatUnsignedBlockCompressed1 = 0x19, + cudaResViewFormatUnsignedBlockCompressed2 = 0x1a, + cudaResViewFormatUnsignedBlockCompressed3 = 0x1b, + cudaResViewFormatUnsignedBlockCompressed4 = 0x1c, + cudaResViewFormatSignedBlockCompressed4 = 0x1d, + cudaResViewFormatUnsignedBlockCompressed5 = 0x1e, + cudaResViewFormatSignedBlockCompressed5 = 0x1f, + cudaResViewFormatUnsignedBlockCompressed6H = 0x20, + cudaResViewFormatSignedBlockCompressed6H = 0x21, + cudaResViewFormatUnsignedBlockCompressed7 = 0x22 +}; + + + + +struct __attribute__((device_builtin)) cudaResourceDesc { + enum cudaResourceType resType; + + union { + struct { + cudaArray_t array; + } array; + struct { + cudaMipmappedArray_t mipmap; + } mipmap; + struct { + void *devPtr; + struct cudaChannelFormatDesc desc; + size_t sizeInBytes; + } linear; + struct { + void *devPtr; + struct cudaChannelFormatDesc desc; + size_t width; + size_t height; + size_t pitchInBytes; + } pitch2D; + } res; +}; + + + + +struct __attribute__((device_builtin)) cudaResourceViewDesc +{ + enum cudaResourceViewFormat format; + size_t width; + size_t height; + size_t depth; + unsigned int firstMipmapLevel; + unsigned int lastMipmapLevel; + unsigned int firstLayer; + unsigned int lastLayer; +}; + + + + +struct __attribute__((device_builtin)) cudaPointerAttributes +{ + + + + + enum cudaMemoryType type; +# 1642 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + int device; + + + + + + void *devicePointer; +# 1657 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + void *hostPointer; +}; + + + + +struct __attribute__((device_builtin)) cudaFuncAttributes +{ + + + + + + size_t sharedSizeBytes; + + + + + + size_t constSizeBytes; + + + + + size_t localSizeBytes; + + + + + + + int maxThreadsPerBlock; + + + + + int numRegs; + + + + + + + int ptxVersion; + + + + + + + int binaryVersion; + + + + + + int cacheModeCA; + + + + + + + int maxDynamicSharedSizeBytes; +# 1729 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + int preferredShmemCarveout; + + + + + + int clusterDimMustBeSet; +# 1746 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + int requiredClusterWidth; + int requiredClusterHeight; + int requiredClusterDepth; + + + + + + int clusterSchedulingPolicyPreference; +# 1776 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + int nonPortableClusterSizeAllowed; + + + + + int reserved[16]; +}; + + + + +enum __attribute__((device_builtin)) cudaFuncAttribute +{ + cudaFuncAttributeMaxDynamicSharedMemorySize = 8, + cudaFuncAttributePreferredSharedMemoryCarveout = 9, + cudaFuncAttributeClusterDimMustBeSet = 10, + cudaFuncAttributeRequiredClusterWidth = 11, + cudaFuncAttributeRequiredClusterHeight = 12, + cudaFuncAttributeRequiredClusterDepth = 13, + cudaFuncAttributeNonPortableClusterSizeAllowed = 14, + cudaFuncAttributeClusterSchedulingPolicyPreference = 15, + cudaFuncAttributeMax +}; + + + + +enum __attribute__((device_builtin)) cudaFuncCache +{ + cudaFuncCachePreferNone = 0, + cudaFuncCachePreferShared = 1, + cudaFuncCachePreferL1 = 2, + cudaFuncCachePreferEqual = 3 +}; + + + + + +enum __attribute__((device_builtin)) cudaSharedMemConfig +{ + cudaSharedMemBankSizeDefault = 0, + cudaSharedMemBankSizeFourByte = 1, + cudaSharedMemBankSizeEightByte = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaSharedCarveout { + cudaSharedmemCarveoutDefault = -1, + cudaSharedmemCarveoutMaxShared = 100, + cudaSharedmemCarveoutMaxL1 = 0 +}; + + + + +enum __attribute__((device_builtin)) cudaComputeMode +{ + cudaComputeModeDefault = 0, + cudaComputeModeExclusive = 1, + cudaComputeModeProhibited = 2, + cudaComputeModeExclusiveProcess = 3 +}; + + + + +enum __attribute__((device_builtin)) cudaLimit +{ + cudaLimitStackSize = 0x00, + cudaLimitPrintfFifoSize = 0x01, + cudaLimitMallocHeapSize = 0x02, + cudaLimitDevRuntimeSyncDepth = 0x03, + cudaLimitDevRuntimePendingLaunchCount = 0x04, + cudaLimitMaxL2FetchGranularity = 0x05, + cudaLimitPersistingL2CacheSize = 0x06 +}; + + + + +enum __attribute__((device_builtin)) cudaMemoryAdvise +{ + cudaMemAdviseSetReadMostly = 1, + cudaMemAdviseUnsetReadMostly = 2, + cudaMemAdviseSetPreferredLocation = 3, + cudaMemAdviseUnsetPreferredLocation = 4, + cudaMemAdviseSetAccessedBy = 5, + cudaMemAdviseUnsetAccessedBy = 6 +}; + + + + +enum __attribute__((device_builtin)) cudaMemRangeAttribute +{ + cudaMemRangeAttributeReadMostly = 1, + cudaMemRangeAttributePreferredLocation = 2, + cudaMemRangeAttributeAccessedBy = 3, + cudaMemRangeAttributeLastPrefetchLocation = 4 + , cudaMemRangeAttributePreferredLocationType = 5 + , cudaMemRangeAttributePreferredLocationId = 6 + , cudaMemRangeAttributeLastPrefetchLocationType = 7 + , cudaMemRangeAttributeLastPrefetchLocationId = 8 +}; + + + + +enum __attribute__((device_builtin)) cudaFlushGPUDirectRDMAWritesOptions { + cudaFlushGPUDirectRDMAWritesOptionHost = 1<<0, + cudaFlushGPUDirectRDMAWritesOptionMemOps = 1<<1 +}; + + + + +enum __attribute__((device_builtin)) cudaGPUDirectRDMAWritesOrdering { + cudaGPUDirectRDMAWritesOrderingNone = 0, + cudaGPUDirectRDMAWritesOrderingOwner = 100, + cudaGPUDirectRDMAWritesOrderingAllDevices = 200 +}; + + + + +enum __attribute__((device_builtin)) cudaFlushGPUDirectRDMAWritesScope { + cudaFlushGPUDirectRDMAWritesToOwner = 100, + cudaFlushGPUDirectRDMAWritesToAllDevices = 200 +}; + + + + +enum __attribute__((device_builtin)) cudaFlushGPUDirectRDMAWritesTarget { + cudaFlushGPUDirectRDMAWritesTargetCurrentDevice +}; + + + + + +enum __attribute__((device_builtin)) cudaDeviceAttr +{ + cudaDevAttrMaxThreadsPerBlock = 1, + cudaDevAttrMaxBlockDimX = 2, + cudaDevAttrMaxBlockDimY = 3, + cudaDevAttrMaxBlockDimZ = 4, + cudaDevAttrMaxGridDimX = 5, + cudaDevAttrMaxGridDimY = 6, + cudaDevAttrMaxGridDimZ = 7, + cudaDevAttrMaxSharedMemoryPerBlock = 8, + cudaDevAttrTotalConstantMemory = 9, + cudaDevAttrWarpSize = 10, + cudaDevAttrMaxPitch = 11, + cudaDevAttrMaxRegistersPerBlock = 12, + cudaDevAttrClockRate = 13, + cudaDevAttrTextureAlignment = 14, + cudaDevAttrGpuOverlap = 15, + cudaDevAttrMultiProcessorCount = 16, + cudaDevAttrKernelExecTimeout = 17, + cudaDevAttrIntegrated = 18, + cudaDevAttrCanMapHostMemory = 19, + cudaDevAttrComputeMode = 20, + cudaDevAttrMaxTexture1DWidth = 21, + cudaDevAttrMaxTexture2DWidth = 22, + cudaDevAttrMaxTexture2DHeight = 23, + cudaDevAttrMaxTexture3DWidth = 24, + cudaDevAttrMaxTexture3DHeight = 25, + cudaDevAttrMaxTexture3DDepth = 26, + cudaDevAttrMaxTexture2DLayeredWidth = 27, + cudaDevAttrMaxTexture2DLayeredHeight = 28, + cudaDevAttrMaxTexture2DLayeredLayers = 29, + cudaDevAttrSurfaceAlignment = 30, + cudaDevAttrConcurrentKernels = 31, + cudaDevAttrEccEnabled = 32, + cudaDevAttrPciBusId = 33, + cudaDevAttrPciDeviceId = 34, + cudaDevAttrTccDriver = 35, + cudaDevAttrMemoryClockRate = 36, + cudaDevAttrGlobalMemoryBusWidth = 37, + cudaDevAttrL2CacheSize = 38, + cudaDevAttrMaxThreadsPerMultiProcessor = 39, + cudaDevAttrAsyncEngineCount = 40, + cudaDevAttrUnifiedAddressing = 41, + cudaDevAttrMaxTexture1DLayeredWidth = 42, + cudaDevAttrMaxTexture1DLayeredLayers = 43, + cudaDevAttrMaxTexture2DGatherWidth = 45, + cudaDevAttrMaxTexture2DGatherHeight = 46, + cudaDevAttrMaxTexture3DWidthAlt = 47, + cudaDevAttrMaxTexture3DHeightAlt = 48, + cudaDevAttrMaxTexture3DDepthAlt = 49, + cudaDevAttrPciDomainId = 50, + cudaDevAttrTexturePitchAlignment = 51, + cudaDevAttrMaxTextureCubemapWidth = 52, + cudaDevAttrMaxTextureCubemapLayeredWidth = 53, + cudaDevAttrMaxTextureCubemapLayeredLayers = 54, + cudaDevAttrMaxSurface1DWidth = 55, + cudaDevAttrMaxSurface2DWidth = 56, + cudaDevAttrMaxSurface2DHeight = 57, + cudaDevAttrMaxSurface3DWidth = 58, + cudaDevAttrMaxSurface3DHeight = 59, + cudaDevAttrMaxSurface3DDepth = 60, + cudaDevAttrMaxSurface1DLayeredWidth = 61, + cudaDevAttrMaxSurface1DLayeredLayers = 62, + cudaDevAttrMaxSurface2DLayeredWidth = 63, + cudaDevAttrMaxSurface2DLayeredHeight = 64, + cudaDevAttrMaxSurface2DLayeredLayers = 65, + cudaDevAttrMaxSurfaceCubemapWidth = 66, + cudaDevAttrMaxSurfaceCubemapLayeredWidth = 67, + cudaDevAttrMaxSurfaceCubemapLayeredLayers = 68, + cudaDevAttrMaxTexture1DLinearWidth = 69, + cudaDevAttrMaxTexture2DLinearWidth = 70, + cudaDevAttrMaxTexture2DLinearHeight = 71, + cudaDevAttrMaxTexture2DLinearPitch = 72, + cudaDevAttrMaxTexture2DMipmappedWidth = 73, + cudaDevAttrMaxTexture2DMipmappedHeight = 74, + cudaDevAttrComputeCapabilityMajor = 75, + cudaDevAttrComputeCapabilityMinor = 76, + cudaDevAttrMaxTexture1DMipmappedWidth = 77, + cudaDevAttrStreamPrioritiesSupported = 78, + cudaDevAttrGlobalL1CacheSupported = 79, + cudaDevAttrLocalL1CacheSupported = 80, + cudaDevAttrMaxSharedMemoryPerMultiprocessor = 81, + cudaDevAttrMaxRegistersPerMultiprocessor = 82, + cudaDevAttrManagedMemory = 83, + cudaDevAttrIsMultiGpuBoard = 84, + cudaDevAttrMultiGpuBoardGroupID = 85, + cudaDevAttrHostNativeAtomicSupported = 86, + cudaDevAttrSingleToDoublePrecisionPerfRatio = 87, + cudaDevAttrPageableMemoryAccess = 88, + cudaDevAttrConcurrentManagedAccess = 89, + cudaDevAttrComputePreemptionSupported = 90, + cudaDevAttrCanUseHostPointerForRegisteredMem = 91, + cudaDevAttrReserved92 = 92, + cudaDevAttrReserved93 = 93, + cudaDevAttrReserved94 = 94, + cudaDevAttrCooperativeLaunch = 95, + cudaDevAttrCooperativeMultiDeviceLaunch = 96, + cudaDevAttrMaxSharedMemoryPerBlockOptin = 97, + cudaDevAttrCanFlushRemoteWrites = 98, + cudaDevAttrHostRegisterSupported = 99, + cudaDevAttrPageableMemoryAccessUsesHostPageTables = 100, + cudaDevAttrDirectManagedMemAccessFromHost = 101, + cudaDevAttrMaxBlocksPerMultiprocessor = 106, + cudaDevAttrMaxPersistingL2CacheSize = 108, + cudaDevAttrMaxAccessPolicyWindowSize = 109, + cudaDevAttrReservedSharedMemoryPerBlock = 111, + cudaDevAttrSparseCudaArraySupported = 112, + cudaDevAttrHostRegisterReadOnlySupported = 113, + cudaDevAttrTimelineSemaphoreInteropSupported = 114, + cudaDevAttrMaxTimelineSemaphoreInteropSupported = 114, + cudaDevAttrMemoryPoolsSupported = 115, + cudaDevAttrGPUDirectRDMASupported = 116, + cudaDevAttrGPUDirectRDMAFlushWritesOptions = 117, + cudaDevAttrGPUDirectRDMAWritesOrdering = 118, + cudaDevAttrMemoryPoolSupportedHandleTypes = 119, + cudaDevAttrClusterLaunch = 120, + cudaDevAttrDeferredMappingCudaArraySupported = 121, + cudaDevAttrReserved122 = 122, + cudaDevAttrReserved123 = 123, + cudaDevAttrReserved124 = 124, + cudaDevAttrIpcEventSupport = 125, + cudaDevAttrMemSyncDomainCount = 126, + cudaDevAttrReserved127 = 127, + cudaDevAttrReserved128 = 128, + cudaDevAttrReserved129 = 129, + cudaDevAttrNumaConfig = 130, + cudaDevAttrNumaId = 131, + cudaDevAttrReserved132 = 132, + cudaDevAttrMpsEnabled = 133, + cudaDevAttrHostNumaId = 134, + cudaDevAttrD3D12CigSupported = 135, + cudaDevAttrGpuPciDeviceId = 139, + cudaDevAttrGpuPciSubsystemId = 140, + cudaDevAttrHostNumaMultinodeIpcSupported = 143, + cudaDevAttrMax +}; + + + + +enum __attribute__((device_builtin)) cudaMemPoolAttr +{ +# 2070 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaMemPoolReuseFollowEventDependencies = 0x1, + + + + + + + cudaMemPoolReuseAllowOpportunistic = 0x2, + + + + + + + + cudaMemPoolReuseAllowInternalDependencies = 0x3, +# 2096 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaMemPoolAttrReleaseThreshold = 0x4, + + + + + + cudaMemPoolAttrReservedMemCurrent = 0x5, + + + + + + + cudaMemPoolAttrReservedMemHigh = 0x6, + + + + + + cudaMemPoolAttrUsedMemCurrent = 0x7, + + + + + + + cudaMemPoolAttrUsedMemHigh = 0x8 +}; + + + + +enum __attribute__((device_builtin)) cudaMemLocationType { + cudaMemLocationTypeInvalid = 0, + cudaMemLocationTypeDevice = 1 + , cudaMemLocationTypeHost = 2 + , cudaMemLocationTypeHostNuma = 3 + , cudaMemLocationTypeHostNumaCurrent = 4 +}; + + + + + + + +struct __attribute__((device_builtin)) cudaMemLocation { + enum cudaMemLocationType type; + int id; +}; + + + + +enum __attribute__((device_builtin)) cudaMemAccessFlags { + cudaMemAccessFlagsProtNone = 0, + cudaMemAccessFlagsProtRead = 1, + cudaMemAccessFlagsProtReadWrite = 3 +}; + + + + +struct __attribute__((device_builtin)) cudaMemAccessDesc { + struct cudaMemLocation location; + enum cudaMemAccessFlags flags; +}; + + + + +enum __attribute__((device_builtin)) cudaMemAllocationType { + cudaMemAllocationTypeInvalid = 0x0, + + + + cudaMemAllocationTypePinned = 0x1, + cudaMemAllocationTypeMax = 0x7FFFFFFF +}; + + + + +enum __attribute__((device_builtin)) cudaMemAllocationHandleType { + cudaMemHandleTypeNone = 0x0, + cudaMemHandleTypePosixFileDescriptor = 0x1, + cudaMemHandleTypeWin32 = 0x2, + cudaMemHandleTypeWin32Kmt = 0x4, + cudaMemHandleTypeFabric = 0x8 +}; +# 2196 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct __attribute__((device_builtin)) cudaMemPoolProps { + enum cudaMemAllocationType allocType; + enum cudaMemAllocationHandleType handleTypes; + struct cudaMemLocation location; + + + + + + + void *win32SecurityAttributes; + size_t maxSize; + unsigned short usage; + unsigned char reserved[54]; +}; + + + + +struct __attribute__((device_builtin)) cudaMemPoolPtrExportData { + unsigned char reserved[64]; +}; + + + + +struct __attribute__((device_builtin)) cudaMemAllocNodeParams { + + + + + struct cudaMemPoolProps poolProps; + const struct cudaMemAccessDesc *accessDescs; + size_t accessDescCount; + size_t bytesize; + void *dptr; +}; + + + + +struct __attribute__((device_builtin)) cudaMemAllocNodeParamsV2 { + + + + + struct cudaMemPoolProps poolProps; + const struct cudaMemAccessDesc *accessDescs; + size_t accessDescCount; + size_t bytesize; + void *dptr; +}; + + + + +struct __attribute__((device_builtin)) cudaMemFreeNodeParams { + void *dptr; +}; + + + + +enum __attribute__((device_builtin)) cudaGraphMemAttributeType { + + + + + cudaGraphMemAttrUsedMemCurrent = 0x0, + + + + + + + cudaGraphMemAttrUsedMemHigh = 0x1, + + + + + + + cudaGraphMemAttrReservedMemCurrent = 0x2, + + + + + + + cudaGraphMemAttrReservedMemHigh = 0x3 +}; + + + + +enum __attribute__((device_builtin)) cudaMemcpyFlags { + cudaMemcpyFlagDefault = 0x0, + + + + + cudaMemcpyFlagPreferOverlapWithCompute = 0x1 +}; + +enum __attribute__((device_builtin)) cudaMemcpySrcAccessOrder { + + + + cudaMemcpySrcAccessOrderInvalid = 0x0, + + + + + cudaMemcpySrcAccessOrderStream = 0x1, +# 2320 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaMemcpySrcAccessOrderDuringApiCall = 0x2, +# 2329 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaMemcpySrcAccessOrderAny = 0x3, + + cudaMemcpySrcAccessOrderMax = 0x7FFFFFFF +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpyAttributes { + enum cudaMemcpySrcAccessOrder srcAccessOrder; + struct cudaMemLocation srcLocHint; + struct cudaMemLocation dstLocHint; + unsigned int flags; +}; + + + + +enum __attribute__((device_builtin)) cudaMemcpy3DOperandType { + cudaMemcpyOperandTypePointer = 0x1, + cudaMemcpyOperandTypeArray = 0x2, + cudaMemcpyOperandTypeMax = 0x7FFFFFFF +}; + + + + +struct __attribute__((device_builtin)) cudaOffset3D { + size_t x; + size_t y; + size_t z; +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpy3DOperand { + enum cudaMemcpy3DOperandType type; + union { + + + + struct { + void *ptr; + size_t rowLength; + size_t layerHeight; + struct cudaMemLocation locHint; + } ptr; + + + + + struct { + cudaArray_t array; + struct cudaOffset3D offset; + } array; + } op; +}; + +struct __attribute__((device_builtin)) cudaMemcpy3DBatchOp { + struct cudaMemcpy3DOperand src; + struct cudaMemcpy3DOperand dst; + struct cudaExtent extent; + enum cudaMemcpySrcAccessOrder srcAccessOrder; + unsigned int flags; +}; + + + + + +enum __attribute__((device_builtin)) cudaDeviceP2PAttr { + cudaDevP2PAttrPerformanceRank = 1, + cudaDevP2PAttrAccessSupported = 2, + cudaDevP2PAttrNativeAtomicSupported = 3, + cudaDevP2PAttrCudaArrayAccessSupported = 4 +}; + + + + + + +struct __attribute__((device_builtin)) CUuuid_st { + char bytes[16]; +}; +typedef __attribute__((device_builtin)) struct CUuuid_st CUuuid; + +typedef __attribute__((device_builtin)) struct CUuuid_st cudaUUID_t; + + + + +struct __attribute__((device_builtin)) cudaDeviceProp +{ + char name[256]; + cudaUUID_t uuid; + char luid[8]; + unsigned int luidDeviceNodeMask; + size_t totalGlobalMem; + size_t sharedMemPerBlock; + int regsPerBlock; + int warpSize; + size_t memPitch; + int maxThreadsPerBlock; + int maxThreadsDim[3]; + int maxGridSize[3]; + int clockRate; + size_t totalConstMem; + int major; + int minor; + size_t textureAlignment; + size_t texturePitchAlignment; + int deviceOverlap; + int multiProcessorCount; + int kernelExecTimeoutEnabled; + int integrated; + int canMapHostMemory; + int computeMode; + int maxTexture1D; + int maxTexture1DMipmap; + int maxTexture1DLinear; + int maxTexture2D[2]; + int maxTexture2DMipmap[2]; + int maxTexture2DLinear[3]; + int maxTexture2DGather[2]; + int maxTexture3D[3]; + int maxTexture3DAlt[3]; + int maxTextureCubemap; + int maxTexture1DLayered[2]; + int maxTexture2DLayered[3]; + int maxTextureCubemapLayered[2]; + int maxSurface1D; + int maxSurface2D[2]; + int maxSurface3D[3]; + int maxSurface1DLayered[2]; + int maxSurface2DLayered[3]; + int maxSurfaceCubemap; + int maxSurfaceCubemapLayered[2]; + size_t surfaceAlignment; + int concurrentKernels; + int ECCEnabled; + int pciBusID; + int pciDeviceID; + int pciDomainID; + int tccDriver; + int asyncEngineCount; + int unifiedAddressing; + int memoryClockRate; + int memoryBusWidth; + int l2CacheSize; + int persistingL2CacheMaxSize; + int maxThreadsPerMultiProcessor; + int streamPrioritiesSupported; + int globalL1CacheSupported; + int localL1CacheSupported; + size_t sharedMemPerMultiprocessor; + int regsPerMultiprocessor; + int managedMemory; + int isMultiGpuBoard; + int multiGpuBoardGroupID; + int hostNativeAtomicSupported; + int singleToDoublePrecisionPerfRatio; + int pageableMemoryAccess; + int concurrentManagedAccess; + int computePreemptionSupported; + int canUseHostPointerForRegisteredMem; + int cooperativeLaunch; + int cooperativeMultiDeviceLaunch; + size_t sharedMemPerBlockOptin; + int pageableMemoryAccessUsesHostPageTables; + int directManagedMemAccessFromHost; + int maxBlocksPerMultiProcessor; + int accessPolicyMaxWindowSize; + size_t reservedSharedMemPerBlock; + int hostRegisterSupported; + int sparseCudaArraySupported; + int hostRegisterReadOnlySupported; + int timelineSemaphoreInteropSupported; + int memoryPoolsSupported; + int gpuDirectRDMASupported; + unsigned int gpuDirectRDMAFlushWritesOptions; + int gpuDirectRDMAWritesOrdering; + unsigned int memoryPoolSupportedHandleTypes; + int deferredMappingCudaArraySupported; + int ipcEventSupported; + int clusterLaunch; + int unifiedFunctionPointers; + int reserved[63]; +}; +# 2528 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef __attribute__((device_builtin)) struct __attribute__((device_builtin)) cudaIpcEventHandle_st +{ + char reserved[64]; +}cudaIpcEventHandle_t; + + + + +typedef __attribute__((device_builtin)) struct __attribute__((device_builtin)) cudaIpcMemHandle_st +{ + char reserved[64]; +}cudaIpcMemHandle_t; + + + + +typedef __attribute__((device_builtin)) struct __attribute__((device_builtin)) cudaMemFabricHandle_st +{ + char reserved[64]; +}cudaMemFabricHandle_t; + + + + +enum __attribute__((device_builtin)) cudaExternalMemoryHandleType { + + + + cudaExternalMemoryHandleTypeOpaqueFd = 1, + + + + cudaExternalMemoryHandleTypeOpaqueWin32 = 2, + + + + cudaExternalMemoryHandleTypeOpaqueWin32Kmt = 3, + + + + cudaExternalMemoryHandleTypeD3D12Heap = 4, + + + + cudaExternalMemoryHandleTypeD3D12Resource = 5, + + + + cudaExternalMemoryHandleTypeD3D11Resource = 6, + + + + cudaExternalMemoryHandleTypeD3D11ResourceKmt = 7, + + + + cudaExternalMemoryHandleTypeNvSciBuf = 8 +}; +# 2627 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct __attribute__((device_builtin)) cudaExternalMemoryHandleDesc { + + + + enum cudaExternalMemoryHandleType type; + union { + + + + + + int fd; +# 2654 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + + + + void *handle; + + + + + const void *name; + } win32; + + + + + const void *nvSciBufObject; + } handle; + + + + unsigned long long size; + + + + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalMemoryBufferDesc { + + + + unsigned long long offset; + + + + unsigned long long size; + + + + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalMemoryMipmappedArrayDesc { + + + + + unsigned long long offset; + + + + struct cudaChannelFormatDesc formatDesc; + + + + struct cudaExtent extent; + + + + + unsigned int flags; + + + + unsigned int numLevels; +}; + + + + +enum __attribute__((device_builtin)) cudaExternalSemaphoreHandleType { + + + + cudaExternalSemaphoreHandleTypeOpaqueFd = 1, + + + + cudaExternalSemaphoreHandleTypeOpaqueWin32 = 2, + + + + cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3, + + + + cudaExternalSemaphoreHandleTypeD3D12Fence = 4, + + + + cudaExternalSemaphoreHandleTypeD3D11Fence = 5, + + + + cudaExternalSemaphoreHandleTypeNvSciSync = 6, + + + + cudaExternalSemaphoreHandleTypeKeyedMutex = 7, + + + + cudaExternalSemaphoreHandleTypeKeyedMutexKmt = 8, + + + + cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9, + + + + cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10 +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreHandleDesc { + + + + enum cudaExternalSemaphoreHandleType type; + union { + + + + + + + int fd; +# 2804 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + + + + void *handle; + + + + + const void *name; + } win32; + + + + const void* nvSciSyncObj; + } handle; + + + + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalParams_v1 { + struct { + + + + struct { + + + + unsigned long long value; + } fence; + union { + + + + + void *fence; + unsigned long long reserved; + } nvSciSync; + + + + struct { + + + + unsigned long long key; + } keyedMutex; + } params; +# 2868 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitParams_v1 { + struct { + + + + struct { + + + + unsigned long long value; + } fence; + union { + + + + + void *fence; + unsigned long long reserved; + } nvSciSync; + + + + struct { + + + + unsigned long long key; + + + + unsigned int timeoutMs; + } keyedMutex; + } params; +# 2917 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalParams{ + struct { + + + + struct { + + + + unsigned long long value; + } fence; + union { + + + + + void *fence; + unsigned long long reserved; + } nvSciSync; + + + + struct { + + + + unsigned long long key; + } keyedMutex; + unsigned int reserved[12]; + } params; +# 2963 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned int flags; + unsigned int reserved[16]; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitParams { + struct { + + + + struct { + + + + unsigned long long value; + } fence; + union { + + + + + void *fence; + unsigned long long reserved; + } nvSciSync; + + + + struct { + + + + unsigned long long key; + + + + unsigned int timeoutMs; + } keyedMutex; + unsigned int reserved[10]; + } params; +# 3014 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned int flags; + unsigned int reserved[16]; +}; +# 3027 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef __attribute__((device_builtin)) enum cudaError cudaError_t; + + + + +typedef __attribute__((device_builtin)) struct CUstream_st *cudaStream_t; + + + + +typedef __attribute__((device_builtin)) struct CUevent_st *cudaEvent_t; + + + + +typedef __attribute__((device_builtin)) struct cudaGraphicsResource *cudaGraphicsResource_t; + + + + +typedef __attribute__((device_builtin)) struct CUexternalMemory_st *cudaExternalMemory_t; + + + + +typedef __attribute__((device_builtin)) struct CUexternalSemaphore_st *cudaExternalSemaphore_t; + + + + +typedef __attribute__((device_builtin)) struct CUgraph_st *cudaGraph_t; + + + + +typedef __attribute__((device_builtin)) struct CUgraphNode_st *cudaGraphNode_t; + + + + +typedef __attribute__((device_builtin)) struct CUuserObject_st *cudaUserObject_t; + + + + +typedef __attribute__((device_builtin)) unsigned long long cudaGraphConditionalHandle; + + + + +typedef __attribute__((device_builtin)) struct CUfunc_st *cudaFunction_t; + + + + +typedef __attribute__((device_builtin)) struct CUkern_st *cudaKernel_t; + + + + +enum __attribute__((device_builtin)) cudaJitOption +{ + + + + + + cudaJitMaxRegisters = 0, +# 3108 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitThreadsPerBlock = 1, + + + + + + + + cudaJitWallTime = 2, +# 3125 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitInfoLogBuffer = 3, +# 3134 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitInfoLogBufferSizeBytes = 4, +# 3143 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitErrorLogBuffer = 5, +# 3152 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitErrorLogBufferSizeBytes = 6, + + + + + + + + cudaJitOptimizationLevel = 7, + + + + + + + + cudaJitFallbackStrategy = 10, + + + + + + + + cudaJitGenerateDebugInfo = 11, + + + + + + + cudaJitLogVerbose = 12, + + + + + + + cudaJitGenerateLineInfo = 13, + + + + + + + + cudaJitCacheMode = 14, + + + + + + + cudaJitPositionIndependentCode = 30, +# 3218 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitMinCtaPerSm = 31, +# 3231 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitMaxThreadsPerBlock = 32, +# 3241 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitOverrideDirectiveValues = 33, +}; + + + + + +enum __attribute__((device_builtin)) cudaLibraryOption +{ + cudaLibraryHostUniversalFunctionAndDataTable = 0, +# 3261 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaLibraryBinaryIsPreserved = 1, +}; + +struct __attribute__((device_builtin)) cudalibraryHostUniversalFunctionAndDataTable +{ + void *functionTable; + size_t functionWindowSize; + void *dataTable; + size_t dataWindowSize; +}; + + + + +enum __attribute__((device_builtin)) cudaJit_CacheMode +{ + cudaJitCacheOptionNone = 0, + cudaJitCacheOptionCG, + cudaJitCacheOptionCA +}; + + + + +enum __attribute__((device_builtin)) cudaJit_Fallback +{ + cudaPreferPtx = 0, + + cudaPreferBinary +}; + + + + +typedef __attribute__((device_builtin)) struct CUlib_st *cudaLibrary_t; + + + + +typedef __attribute__((device_builtin)) struct CUmemPoolHandle_st *cudaMemPool_t; + + + + +enum __attribute__((device_builtin)) cudaCGScope { + cudaCGScopeInvalid = 0, + cudaCGScopeGrid = 1, + cudaCGScopeMultiGrid = 2 +}; + + + + +struct __attribute__((device_builtin)) cudaLaunchParams +{ + void *func; + dim3 gridDim; + dim3 blockDim; + void **args; + size_t sharedMem; + cudaStream_t stream; +}; + + + + +struct __attribute__((device_builtin)) cudaKernelNodeParams { + void* func; + dim3 gridDim; + dim3 blockDim; + unsigned int sharedMemBytes; + void **kernelParams; + void **extra; +}; + + + + +struct __attribute__((device_builtin)) cudaKernelNodeParamsV2 { + void* func; + + dim3 gridDim; + dim3 blockDim; + + + + + + unsigned int sharedMemBytes; + void **kernelParams; + void **extra; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalNodeParams { + cudaExternalSemaphore_t* extSemArray; + const struct cudaExternalSemaphoreSignalParams* paramsArray; + unsigned int numExtSems; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalNodeParamsV2 { + cudaExternalSemaphore_t* extSemArray; + const struct cudaExternalSemaphoreSignalParams* paramsArray; + unsigned int numExtSems; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitNodeParams { + cudaExternalSemaphore_t* extSemArray; + const struct cudaExternalSemaphoreWaitParams* paramsArray; + unsigned int numExtSems; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitNodeParamsV2 { + cudaExternalSemaphore_t* extSemArray; + const struct cudaExternalSemaphoreWaitParams* paramsArray; + unsigned int numExtSems; +}; + +enum __attribute__((device_builtin)) cudaGraphConditionalHandleFlags { + cudaGraphCondAssignDefault = 1 +}; + + + + +enum __attribute__((device_builtin)) cudaGraphConditionalNodeType { + cudaGraphCondTypeIf = 0, + cudaGraphCondTypeWhile = 1, + cudaGraphCondTypeSwitch = 2, +}; + + + + +struct __attribute__((device_builtin)) cudaConditionalNodeParams { + cudaGraphConditionalHandle handle; + + + enum cudaGraphConditionalNodeType type; + unsigned int size; + + cudaGraph_t *phGraph_out; +# 3432 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +}; + + + + +enum __attribute__((device_builtin)) cudaGraphNodeType { + cudaGraphNodeTypeKernel = 0x00, + cudaGraphNodeTypeMemcpy = 0x01, + cudaGraphNodeTypeMemset = 0x02, + cudaGraphNodeTypeHost = 0x03, + cudaGraphNodeTypeGraph = 0x04, + cudaGraphNodeTypeEmpty = 0x05, + cudaGraphNodeTypeWaitEvent = 0x06, + cudaGraphNodeTypeEventRecord = 0x07, + cudaGraphNodeTypeExtSemaphoreSignal = 0x08, + cudaGraphNodeTypeExtSemaphoreWait = 0x09, + cudaGraphNodeTypeMemAlloc = 0x0a, + cudaGraphNodeTypeMemFree = 0x0b, + cudaGraphNodeTypeConditional = 0x0d, +# 3467 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaGraphNodeTypeCount +}; + + + + +struct __attribute__((device_builtin)) cudaChildGraphNodeParams { + cudaGraph_t graph; + +}; + + + + +struct __attribute__((device_builtin)) cudaEventRecordNodeParams { + cudaEvent_t event; +}; + + + + +struct __attribute__((device_builtin)) cudaEventWaitNodeParams { + cudaEvent_t event; +}; + + + + +struct __attribute__((device_builtin)) cudaGraphNodeParams { + enum cudaGraphNodeType type; + int reserved0[3]; + + union { + long long reserved1[29]; + struct cudaKernelNodeParamsV2 kernel; + struct cudaMemcpyNodeParams memcpy; + struct cudaMemsetParamsV2 memset; + struct cudaHostNodeParamsV2 host; + struct cudaChildGraphNodeParams graph; + struct cudaEventWaitNodeParams eventWait; + struct cudaEventRecordNodeParams eventRecord; + struct cudaExternalSemaphoreSignalNodeParamsV2 extSemSignal; + struct cudaExternalSemaphoreWaitNodeParamsV2 extSemWait; + struct cudaMemAllocNodeParamsV2 alloc; + struct cudaMemFreeNodeParams free; + struct cudaConditionalNodeParams conditional; + }; + + long long reserved2; +}; + + + + +typedef __attribute__((device_builtin)) enum cudaGraphDependencyType_enum { + cudaGraphDependencyTypeDefault = 0, + cudaGraphDependencyTypeProgrammatic = 1 + + + + +} cudaGraphDependencyType; + + + + + + +typedef __attribute__((device_builtin)) struct cudaGraphEdgeData_st { + unsigned char from_port; +# 3546 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned char to_port; + + + + + + + unsigned char type; + + + unsigned char reserved[5]; + +} cudaGraphEdgeData; +# 3579 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef struct CUgraphExec_st* cudaGraphExec_t; + + + + +enum __attribute__((device_builtin)) cudaGraphExecUpdateResult { + cudaGraphExecUpdateSuccess = 0x0, + cudaGraphExecUpdateError = 0x1, + cudaGraphExecUpdateErrorTopologyChanged = 0x2, + cudaGraphExecUpdateErrorNodeTypeChanged = 0x3, + cudaGraphExecUpdateErrorFunctionChanged = 0x4, + cudaGraphExecUpdateErrorParametersChanged = 0x5, + cudaGraphExecUpdateErrorNotSupported = 0x6, + cudaGraphExecUpdateErrorUnsupportedFunctionChange = 0x7, + cudaGraphExecUpdateErrorAttributesChanged = 0x8 +}; + + + + +typedef __attribute__((device_builtin)) enum cudaGraphInstantiateResult { + cudaGraphInstantiateSuccess = 0, + cudaGraphInstantiateError = 1, + cudaGraphInstantiateInvalidStructure = 2, + cudaGraphInstantiateNodeOperationNotSupported = 3, + cudaGraphInstantiateMultipleDevicesNotSupported = 4, + cudaGraphInstantiateConditionalHandleUnused = 5 +} cudaGraphInstantiateResult; + + + + +typedef __attribute__((device_builtin)) struct cudaGraphInstantiateParams_st +{ + unsigned long long flags; + cudaStream_t uploadStream; + cudaGraphNode_t errNode_out; + cudaGraphInstantiateResult result_out; +} cudaGraphInstantiateParams; + + + + +typedef __attribute__((device_builtin)) struct cudaGraphExecUpdateResultInfo_st { + + + + enum cudaGraphExecUpdateResult result; + + + + + + + cudaGraphNode_t errorNode; + + + + + cudaGraphNode_t errorFromNode; +} cudaGraphExecUpdateResultInfo; + + + + +typedef struct CUgraphDeviceUpdatableNode_st* cudaGraphDeviceNode_t; + + + + +enum __attribute__((device_builtin)) cudaGraphKernelNodeField +{ + cudaGraphKernelNodeFieldInvalid = 0, + cudaGraphKernelNodeFieldGridDim, + cudaGraphKernelNodeFieldParam, + cudaGraphKernelNodeFieldEnabled +}; + + + + +struct __attribute__((device_builtin)) cudaGraphKernelNodeUpdate { + cudaGraphDeviceNode_t node; + enum cudaGraphKernelNodeField field; + union { + + dim3 gridDim; + + + + + struct { + const void *pValue; + size_t offset; + size_t size; + } param; + unsigned int isEnabled; + } updateData; +}; + + + + + +enum __attribute__((device_builtin)) cudaGetDriverEntryPointFlags { + cudaEnableDefault = 0x0, + cudaEnableLegacyStream = 0x1, + cudaEnablePerThreadDefaultStream = 0x2 +}; + + + + +enum __attribute__((device_builtin)) cudaDriverEntryPointQueryResult { + cudaDriverEntryPointSuccess = 0, + cudaDriverEntryPointSymbolNotFound = 1, + cudaDriverEntryPointVersionNotSufficent = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaGraphDebugDotFlags { + cudaGraphDebugDotFlagsVerbose = 1<<0, + cudaGraphDebugDotFlagsKernelNodeParams = 1<<2, + cudaGraphDebugDotFlagsMemcpyNodeParams = 1<<3, + cudaGraphDebugDotFlagsMemsetNodeParams = 1<<4, + cudaGraphDebugDotFlagsHostNodeParams = 1<<5, + cudaGraphDebugDotFlagsEventNodeParams = 1<<6, + cudaGraphDebugDotFlagsExtSemasSignalNodeParams = 1<<7, + cudaGraphDebugDotFlagsExtSemasWaitNodeParams = 1<<8, + cudaGraphDebugDotFlagsKernelNodeAttributes = 1<<9, + cudaGraphDebugDotFlagsHandles = 1<<10, + cudaGraphDebugDotFlagsConditionalNodeParams = 1<<15, +}; + + + + +enum __attribute__((device_builtin)) cudaGraphInstantiateFlags { + cudaGraphInstantiateFlagAutoFreeOnLaunch = 1 + , cudaGraphInstantiateFlagUpload = 2 + + + , cudaGraphInstantiateFlagDeviceLaunch = 4 + + + , cudaGraphInstantiateFlagUseNodePriority = 8 + +}; +# 3746 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef __attribute__((device_builtin)) enum cudaLaunchMemSyncDomain { + cudaLaunchMemSyncDomainDefault = 0, + cudaLaunchMemSyncDomainRemote = 1 +} cudaLaunchMemSyncDomain; +# 3762 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef __attribute__((device_builtin)) struct cudaLaunchMemSyncDomainMap_st { + unsigned char default_; + unsigned char remote; +} cudaLaunchMemSyncDomainMap; + + + + +typedef __attribute__((device_builtin)) enum cudaLaunchAttributeID { + cudaLaunchAttributeIgnore = 0 + , cudaLaunchAttributeAccessPolicyWindow = 1 + + , cudaLaunchAttributeCooperative = 2 + + , cudaLaunchAttributeSynchronizationPolicy = 3 + , cudaLaunchAttributeClusterDimension = 4 + + , cudaLaunchAttributeClusterSchedulingPolicyPreference = 5 + + , cudaLaunchAttributeProgrammaticStreamSerialization = 6 +# 3792 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributeProgrammaticEvent = 7 +# 3818 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributePriority = 8 + + , cudaLaunchAttributeMemSyncDomainMap = 9 + + , cudaLaunchAttributeMemSyncDomain = 10 + + , cudaLaunchAttributePreferredClusterDimension = 11 +# 3860 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributeLaunchCompletionEvent = 12 +# 3882 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributeDeviceUpdatableKernelNode = 13 +# 3910 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributePreferredSharedMemoryCarveout = 14 + + + + + + +} cudaLaunchAttributeID; + + + + +typedef __attribute__((device_builtin)) union cudaLaunchAttributeValue { + char pad[64]; + struct cudaAccessPolicyWindow accessPolicyWindow; + int cooperative; + + enum cudaSynchronizationPolicy syncPolicy; +# 3941 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + unsigned int x; + unsigned int y; + unsigned int z; + } clusterDim; + enum cudaClusterSchedulingPolicy clusterSchedulingPolicyPreference; + + + int programmaticStreamSerializationAllowed; +# 3960 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + cudaEvent_t event; + int flags; + int triggerAtBlockStart; + } programmaticEvent; + int priority; + cudaLaunchMemSyncDomainMap memSyncDomainMap; + + + cudaLaunchMemSyncDomain memSyncDomain; +# 3984 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + unsigned int x; + unsigned int y; + unsigned int z; + } preferredClusterDim; +# 3997 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + cudaEvent_t event; + int flags; + } launchCompletionEvent; + + + + + + + + struct { + int deviceUpdatable; + cudaGraphDeviceNode_t devNode; + } deviceUpdatableKernelNode; + unsigned int sharedMemCarveout; +} cudaLaunchAttributeValue; + + + + +typedef __attribute__((device_builtin)) struct cudaLaunchAttribute_st { + cudaLaunchAttributeID id; + char pad[8 - sizeof(cudaLaunchAttributeID)]; + cudaLaunchAttributeValue val; +} cudaLaunchAttribute; + + + + +typedef __attribute__((device_builtin)) struct cudaLaunchConfig_st { + dim3 gridDim; + dim3 blockDim; + size_t dynamicSmemBytes; + cudaStream_t stream; + cudaLaunchAttribute *attrs; + unsigned int numAttrs; +} cudaLaunchConfig_t; +# 4061 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +enum __attribute__((device_builtin)) cudaDeviceNumaConfig { + cudaDeviceNumaConfigNone = 0, + cudaDeviceNumaConfigNumaNode, +}; + + + + +typedef struct cudaAsyncCallbackEntry* cudaAsyncCallbackHandle_t; + +struct cudaAsyncCallbackEntry; + + + + +typedef __attribute__((device_builtin)) enum cudaAsyncNotificationType_enum { + cudaAsyncNotificationTypeOverBudget = 0x1 +} cudaAsyncNotificationType; + + + + +typedef __attribute__((device_builtin)) struct cudaAsyncNotificationInfo +{ + cudaAsyncNotificationType type; + union { + struct { + unsigned long long bytesOverBudget; + } overBudget; + } info; +} cudaAsyncNotificationInfo_t; + +typedef void (*cudaAsyncCallback)(cudaAsyncNotificationInfo_t*, void*, cudaAsyncCallbackHandle_t); +# 60 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_types.h" 1 +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_types.h" +enum __attribute__((device_builtin)) cudaSurfaceBoundaryMode +{ + cudaBoundaryModeZero = 0, + cudaBoundaryModeClamp = 1, + cudaBoundaryModeTrap = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaSurfaceFormatMode +{ + cudaFormatModeForced = 0, + cudaFormatModeAuto = 1 +}; + + + + +typedef __attribute__((device_builtin)) unsigned long long cudaSurfaceObject_t; +# 63 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_types.h" 1 +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_types.h" +enum __attribute__((device_builtin)) cudaTextureAddressMode +{ + cudaAddressModeWrap = 0, + cudaAddressModeClamp = 1, + cudaAddressModeMirror = 2, + cudaAddressModeBorder = 3 +}; + + + + +enum __attribute__((device_builtin)) cudaTextureFilterMode +{ + cudaFilterModePoint = 0, + cudaFilterModeLinear = 1 +}; + + + + +enum __attribute__((device_builtin)) cudaTextureReadMode +{ + cudaReadModeElementType = 0, + cudaReadModeNormalizedFloat = 1 +}; + + + + +struct __attribute__((device_builtin)) cudaTextureDesc +{ + + + + enum cudaTextureAddressMode addressMode[3]; + + + + enum cudaTextureFilterMode filterMode; + + + + enum cudaTextureReadMode readMode; + + + + int sRGB; + + + + float borderColor[4]; + + + + int normalizedCoords; + + + + unsigned int maxAnisotropy; + + + + enum cudaTextureFilterMode mipmapFilterMode; + + + + float mipmapLevelBias; + + + + float minMipmapLevelClamp; + + + + float maxMipmapLevelClamp; + + + + int disableTrilinearOptimization; + + + + int seamlessCubemap; +}; + + + + +typedef __attribute__((device_builtin)) unsigned long long cudaTextureObject_t; +# 64 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 2 +# 91 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/library_types.h" 1 +# 57 "/opt/cuda/bin/../targets/x86_64-linux/include/library_types.h" +typedef enum cudaDataType_t +{ + CUDA_R_16F = 2, + CUDA_C_16F = 6, + CUDA_R_16BF = 14, + CUDA_C_16BF = 15, + CUDA_R_32F = 0, + CUDA_C_32F = 4, + CUDA_R_64F = 1, + CUDA_C_64F = 5, + CUDA_R_4I = 16, + CUDA_C_4I = 17, + CUDA_R_4U = 18, + CUDA_C_4U = 19, + CUDA_R_8I = 3, + CUDA_C_8I = 7, + CUDA_R_8U = 8, + CUDA_C_8U = 9, + CUDA_R_16I = 20, + CUDA_C_16I = 21, + CUDA_R_16U = 22, + CUDA_C_16U = 23, + CUDA_R_32I = 10, + CUDA_C_32I = 11, + CUDA_R_32U = 12, + CUDA_C_32U = 13, + CUDA_R_64I = 24, + CUDA_C_64I = 25, + CUDA_R_64U = 26, + CUDA_C_64U = 27, + CUDA_R_8F_E4M3 = 28, + CUDA_R_8F_UE4M3 = CUDA_R_8F_E4M3, + CUDA_R_8F_E5M2 = 29, + CUDA_R_8F_UE8M0 = 30, + CUDA_R_6F_E2M3 = 31, + CUDA_R_6F_E3M2 = 32, + CUDA_R_4F_E2M1 = 33, +} cudaDataType; + + +typedef enum libraryPropertyType_t +{ + MAJOR_VERSION, + MINOR_VERSION, + PATCH_LEVEL +} libraryPropertyType; +# 92 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" 1 +# 61 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 1 +# 148 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 149 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 151 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" 1 +# 54 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h" 1 3 +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 308 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 + +# 308 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + typedef long unsigned int size_t; + typedef long int ptrdiff_t; + + + typedef decltype(nullptr) nullptr_t; + + +#pragma GCC visibility push(default) + + + extern "C++" __attribute__ ((__noreturn__, __always_inline__)) + inline void __terminate() noexcept + { + void terminate() noexcept __attribute__ ((__noreturn__,__cold__)); + terminate(); + } +#pragma GCC visibility pop +} +# 341 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +namespace __gnu_cxx +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +# 534 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ +#pragma GCC visibility push(default) + + + + + __attribute__((__always_inline__)) + constexpr inline bool + __is_constant_evaluated() noexcept + { + + + + + + return __builtin_is_constant_evaluated(); + + + + } +#pragma GCC visibility pop +} +# 573 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ +#pragma GCC visibility push(default) + + extern "C++" __attribute__ ((__noreturn__)) + void + __glibcxx_assert_fail + (const char* __file, int __line, const char* __function, + const char* __condition) + noexcept; +#pragma GCC visibility pop +} +# 604 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + __attribute__((__always_inline__,__visibility__("default"))) + inline void + __glibcxx_assert_fail() + { } +} +# 683 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3 +# 684 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3 +# 687 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 828 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace __gnu_cxx +{ + typedef __decltype(0.0bf16) __bfloat16_t; +} +# 890 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/pstl/pstl_config.h" 1 3 +# 891 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 2 3 +# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +# 1 "/usr/include/stdlib.h" 1 3 4 +# 26 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/stdlib.h" 2 3 4 + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 33 "/usr/include/stdlib.h" 2 3 4 + +extern "C" { + + + + + +# 1 "/usr/include/bits/waitflags.h" 1 3 4 +# 41 "/usr/include/stdlib.h" 2 3 4 +# 1 "/usr/include/bits/waitstatus.h" 1 3 4 +# 42 "/usr/include/stdlib.h" 2 3 4 +# 56 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/floatn.h" 1 3 4 +# 131 "/usr/include/bits/floatn.h" 3 4 +# 1 "/usr/include/bits/floatn-common.h" 1 3 4 +# 24 "/usr/include/bits/floatn-common.h" 3 4 +# 1 "/usr/include/bits/long-double.h" 1 3 4 +# 25 "/usr/include/bits/floatn-common.h" 2 3 4 +# 132 "/usr/include/bits/floatn.h" 2 3 4 +# 57 "/usr/include/stdlib.h" 2 3 4 + + +typedef struct + { + int quot; + int rem; + } div_t; + + + +typedef struct + { + long int quot; + long int rem; + } ldiv_t; + + + + + +__extension__ typedef struct + { + long long int quot; + long long int rem; + } lldiv_t; +# 98 "/usr/include/stdlib.h" 3 4 +extern size_t __ctype_get_mb_cur_max (void) noexcept (true) ; + + + +extern double atof (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern int atoi (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern long int atol (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +__extension__ extern long long int atoll (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +extern double strtod (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern float strtof (const char *__restrict __nptr, + char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern long double strtold (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 141 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float64 strtof64 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float128 strtof128 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float32x strtof32x (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float64x strtof64x (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 177 "/usr/include/stdlib.h" 3 4 +extern long int strtol (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern unsigned long int strtoul (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern long int strtol (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtol") + + + __attribute__ ((__nonnull__ (1))); +extern unsigned long int strtoul (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoul") + + + + __attribute__ ((__nonnull__ (1))); + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") + + + __attribute__ ((__nonnull__ (1))); +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") + + + + __attribute__ ((__nonnull__ (1))); + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") + + + __attribute__ ((__nonnull__ (1))); +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") + + + + __attribute__ ((__nonnull__ (1))); +# 278 "/usr/include/stdlib.h" 3 4 +extern int strfromd (char *__dest, size_t __size, const char *__format, + double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfromf (char *__dest, size_t __size, const char *__format, + float __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfroml (char *__dest, size_t __size, const char *__format, + long double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 298 "/usr/include/stdlib.h" 3 4 +extern int strfromf32 (char *__dest, size_t __size, const char * __format, + _Float32 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64 (char *__dest, size_t __size, const char * __format, + _Float64 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf128 (char *__dest, size_t __size, const char * __format, + _Float128 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf32x (char *__dest, size_t __size, const char * __format, + _Float32x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64x (char *__dest, size_t __size, const char * __format, + _Float64x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 340 "/usr/include/stdlib.h" 3 4 +extern long int strtol_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +extern unsigned long int strtoul_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + + + + + +extern long int strtol_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtol_l") + + + + __attribute__ ((__nonnull__ (1, 4))); +extern unsigned long int strtoul_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoul_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoll_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoull_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +# 415 "/usr/include/stdlib.h" 3 4 +extern double strtod_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern float strtof_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern long double strtold_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 436 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64 strtof64_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float128 strtof128_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float32x strtof32x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64x strtof64x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 505 "/usr/include/stdlib.h" 3 4 +extern char *l64a (long int __n) noexcept (true) ; + + +extern long int a64l (const char *__s) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + + +# 1 "/usr/include/sys/types.h" 1 3 4 +# 27 "/usr/include/sys/types.h" 3 4 +extern "C" { + + + + + +typedef __u_char u_char; +typedef __u_short u_short; +typedef __u_int u_int; +typedef __u_long u_long; +typedef __quad_t quad_t; +typedef __u_quad_t u_quad_t; +typedef __fsid_t fsid_t; + + +typedef __loff_t loff_t; + + + + +typedef __ino_t ino_t; + + + + + + +typedef __ino64_t ino64_t; + + + + +typedef __dev_t dev_t; + + + + +typedef __gid_t gid_t; + + + + +typedef __mode_t mode_t; + + + + +typedef __nlink_t nlink_t; + + + + +typedef __uid_t uid_t; + + + + + +typedef __off_t off_t; + + + + + + +typedef __off64_t off64_t; + + + + +typedef __pid_t pid_t; + + + + + +typedef __id_t id_t; + + + + +typedef __ssize_t ssize_t; + + + + + +typedef __daddr_t daddr_t; +typedef __caddr_t caddr_t; + + + + + +typedef __key_t key_t; + + + + +# 1 "/usr/include/bits/types/clock_t.h" 1 3 4 + + + + + + +typedef __clock_t clock_t; +# 127 "/usr/include/sys/types.h" 2 3 4 + +# 1 "/usr/include/bits/types/clockid_t.h" 1 3 4 + + + + + + +typedef __clockid_t clockid_t; +# 129 "/usr/include/sys/types.h" 2 3 4 +# 1 "/usr/include/bits/types/time_t.h" 1 3 4 +# 10 "/usr/include/bits/types/time_t.h" 3 4 +typedef __time_t time_t; +# 130 "/usr/include/sys/types.h" 2 3 4 +# 1 "/usr/include/bits/types/timer_t.h" 1 3 4 + + + + + + +typedef __timer_t timer_t; +# 131 "/usr/include/sys/types.h" 2 3 4 + + + +typedef __useconds_t useconds_t; + + + +typedef __suseconds_t suseconds_t; + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 145 "/usr/include/sys/types.h" 2 3 4 + + + +typedef unsigned long int ulong; +typedef unsigned short int ushort; +typedef unsigned int uint; + + + + +# 1 "/usr/include/bits/stdint-intn.h" 1 3 4 +# 24 "/usr/include/bits/stdint-intn.h" 3 4 +typedef __int8_t int8_t; +typedef __int16_t int16_t; +typedef __int32_t int32_t; +typedef __int64_t int64_t; +# 156 "/usr/include/sys/types.h" 2 3 4 + + +typedef __uint8_t u_int8_t; +typedef __uint16_t u_int16_t; +typedef __uint32_t u_int32_t; +typedef __uint64_t u_int64_t; + + +typedef int register_t __attribute__ ((__mode__ (__word__))); +# 176 "/usr/include/sys/types.h" 3 4 +# 1 "/usr/include/endian.h" 1 3 4 +# 35 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/bits/byteswap.h" 1 3 4 +# 33 "/usr/include/bits/byteswap.h" 3 4 +static __inline __uint16_t +__bswap_16 (__uint16_t __bsx) +{ + + return __builtin_bswap16 (__bsx); + + + +} + + + + + + +static __inline __uint32_t +__bswap_32 (__uint32_t __bsx) +{ + + return __builtin_bswap32 (__bsx); + + + +} +# 69 "/usr/include/bits/byteswap.h" 3 4 +__extension__ static __inline __uint64_t +__bswap_64 (__uint64_t __bsx) +{ + + return __builtin_bswap64 (__bsx); + + + +} +# 36 "/usr/include/endian.h" 2 3 4 +# 1 "/usr/include/bits/uintn-identity.h" 1 3 4 +# 32 "/usr/include/bits/uintn-identity.h" 3 4 +static __inline __uint16_t +__uint16_identity (__uint16_t __x) +{ + return __x; +} + +static __inline __uint32_t +__uint32_identity (__uint32_t __x) +{ + return __x; +} + +static __inline __uint64_t +__uint64_identity (__uint64_t __x) +{ + return __x; +} +# 37 "/usr/include/endian.h" 2 3 4 +# 177 "/usr/include/sys/types.h" 2 3 4 + + +# 1 "/usr/include/sys/select.h" 1 3 4 +# 30 "/usr/include/sys/select.h" 3 4 +# 1 "/usr/include/bits/select.h" 1 3 4 +# 31 "/usr/include/sys/select.h" 2 3 4 + + +# 1 "/usr/include/bits/types/sigset_t.h" 1 3 4 + + + +# 1 "/usr/include/bits/types/__sigset_t.h" 1 3 4 + + + + +typedef struct +{ + unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; +} __sigset_t; +# 5 "/usr/include/bits/types/sigset_t.h" 2 3 4 + + +typedef __sigset_t sigset_t; +# 34 "/usr/include/sys/select.h" 2 3 4 + + + +# 1 "/usr/include/bits/types/struct_timeval.h" 1 3 4 + + + + + + + +struct timeval +{ + + + + + __time_t tv_sec; + __suseconds_t tv_usec; + +}; +# 38 "/usr/include/sys/select.h" 2 3 4 + +# 1 "/usr/include/bits/types/struct_timespec.h" 1 3 4 +# 11 "/usr/include/bits/types/struct_timespec.h" 3 4 +struct timespec +{ + + + + __time_t tv_sec; + + + + + __syscall_slong_t tv_nsec; +# 31 "/usr/include/bits/types/struct_timespec.h" 3 4 +}; +# 40 "/usr/include/sys/select.h" 2 3 4 +# 49 "/usr/include/sys/select.h" 3 4 +typedef long int __fd_mask; +# 59 "/usr/include/sys/select.h" 3 4 +typedef struct + { + + + + __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; + + + + + + } fd_set; + + + + + + +typedef __fd_mask fd_mask; +# 91 "/usr/include/sys/select.h" 3 4 +extern "C" { +# 102 "/usr/include/sys/select.h" 3 4 +extern int select (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + struct timeval *__restrict __timeout); +# 127 "/usr/include/sys/select.h" 3 4 +extern int pselect (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + const struct timespec *__restrict __timeout, + const __sigset_t *__restrict __sigmask); +# 153 "/usr/include/sys/select.h" 3 4 +} +# 180 "/usr/include/sys/types.h" 2 3 4 + + + + + +typedef __blksize_t blksize_t; + + + + + + +typedef __blkcnt_t blkcnt_t; + + + +typedef __fsblkcnt_t fsblkcnt_t; + + + +typedef __fsfilcnt_t fsfilcnt_t; +# 219 "/usr/include/sys/types.h" 3 4 +typedef __blkcnt64_t blkcnt64_t; +typedef __fsblkcnt64_t fsblkcnt64_t; +typedef __fsfilcnt64_t fsfilcnt64_t; + + + + + +# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4 +# 23 "/usr/include/bits/pthreadtypes.h" 3 4 +# 1 "/usr/include/bits/thread-shared-types.h" 1 3 4 +# 44 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/pthreadtypes-arch.h" 1 3 4 +# 21 "/usr/include/bits/pthreadtypes-arch.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 22 "/usr/include/bits/pthreadtypes-arch.h" 2 3 4 +# 45 "/usr/include/bits/thread-shared-types.h" 2 3 4 + +# 1 "/usr/include/bits/atomic_wide_counter.h" 1 3 4 +# 25 "/usr/include/bits/atomic_wide_counter.h" 3 4 +typedef union +{ + __extension__ unsigned long long int __value64; + struct + { + unsigned int __low; + unsigned int __high; + } __value32; +} __atomic_wide_counter; +# 47 "/usr/include/bits/thread-shared-types.h" 2 3 4 + + + + +typedef struct __pthread_internal_list +{ + struct __pthread_internal_list *__prev; + struct __pthread_internal_list *__next; +} __pthread_list_t; + +typedef struct __pthread_internal_slist +{ + struct __pthread_internal_slist *__next; +} __pthread_slist_t; +# 76 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/struct_mutex.h" 1 3 4 +# 22 "/usr/include/bits/struct_mutex.h" 3 4 +struct __pthread_mutex_s +{ + int __lock; + unsigned int __count; + int __owner; + + unsigned int __nusers; + + + + int __kind; + + short __spins; + short __elision; + __pthread_list_t __list; +# 53 "/usr/include/bits/struct_mutex.h" 3 4 +}; +# 77 "/usr/include/bits/thread-shared-types.h" 2 3 4 +# 89 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/struct_rwlock.h" 1 3 4 +# 23 "/usr/include/bits/struct_rwlock.h" 3 4 +struct __pthread_rwlock_arch_t +{ + unsigned int __readers; + unsigned int __writers; + unsigned int __wrphase_futex; + unsigned int __writers_futex; + unsigned int __pad3; + unsigned int __pad4; + + int __cur_writer; + int __shared; + signed char __rwelision; + + + + + unsigned char __pad1[7]; + + + unsigned long int __pad2; + + + unsigned int __flags; +# 55 "/usr/include/bits/struct_rwlock.h" 3 4 +}; +# 90 "/usr/include/bits/thread-shared-types.h" 2 3 4 + + + + +struct __pthread_cond_s +{ + __atomic_wide_counter __wseq; + __atomic_wide_counter __g1_start; + unsigned int __g_size[2] ; + unsigned int __g1_orig_size; + unsigned int __wrefs; + unsigned int __g_signals[2]; + unsigned int __unused_initialized_1; + unsigned int __unused_initialized_2; +}; + +typedef unsigned int __tss_t; +typedef unsigned long int __thrd_t; + +typedef struct +{ + int __data ; +} __once_flag; +# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4 + + + +typedef unsigned long int pthread_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_mutexattr_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_condattr_t; + + + +typedef unsigned int pthread_key_t; + + + +typedef int pthread_once_t; + + +union pthread_attr_t +{ + char __size[56]; + long int __align; +}; + +typedef union pthread_attr_t pthread_attr_t; + + + + +typedef union +{ + struct __pthread_mutex_s __data; + char __size[40]; + long int __align; +} pthread_mutex_t; + + +typedef union +{ + struct __pthread_cond_s __data; + char __size[48]; + __extension__ long long int __align; +} pthread_cond_t; + + + + + +typedef union +{ + struct __pthread_rwlock_arch_t __data; + char __size[56]; + long int __align; +} pthread_rwlock_t; + +typedef union +{ + char __size[8]; + long int __align; +} pthread_rwlockattr_t; + + + + + +typedef volatile int pthread_spinlock_t; + + + + +typedef union +{ + char __size[32]; + long int __align; +} pthread_barrier_t; + +typedef union +{ + char __size[4]; + int __align; +} pthread_barrierattr_t; +# 228 "/usr/include/sys/types.h" 2 3 4 + + +} +# 515 "/usr/include/stdlib.h" 2 3 4 + + + + + + +extern long int random (void) noexcept (true); + + +extern void srandom (unsigned int __seed) noexcept (true); + + + + + +extern char *initstate (unsigned int __seed, char *__statebuf, + size_t __statelen) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern char *setstate (char *__statebuf) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + + +struct random_data + { + int32_t *fptr; + int32_t *rptr; + int32_t *state; + int rand_type; + int rand_deg; + int rand_sep; + int32_t *end_ptr; + }; + +extern int random_r (struct random_data *__restrict __buf, + int32_t *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern int srandom_r (unsigned int __seed, struct random_data *__buf) + noexcept (true) __attribute__ ((__nonnull__ (2))); + +extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, + size_t __statelen, + struct random_data *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (2, 4))); + +extern int setstate_r (char *__restrict __statebuf, + struct random_data *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern int rand (void) noexcept (true); + +extern void srand (unsigned int __seed) noexcept (true); + + + +extern int rand_r (unsigned int *__seed) noexcept (true); + + + + + + + +extern double drand48 (void) noexcept (true); +extern double erand48 (unsigned short int __xsubi[3]) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int lrand48 (void) noexcept (true); +extern long int nrand48 (unsigned short int __xsubi[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int mrand48 (void) noexcept (true); +extern long int jrand48 (unsigned short int __xsubi[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void srand48 (long int __seedval) noexcept (true); +extern unsigned short int *seed48 (unsigned short int __seed16v[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); +extern void lcong48 (unsigned short int __param[7]) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +struct drand48_data + { + unsigned short int __x[3]; + unsigned short int __old_x[3]; + unsigned short int __c; + unsigned short int __init; + __extension__ unsigned long long int __a; + + }; + + +extern int drand48_r (struct drand48_data *__restrict __buffer, + double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int erand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int lrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int nrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int mrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int jrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int srand48_r (long int __seedval, struct drand48_data *__buffer) + noexcept (true) __attribute__ ((__nonnull__ (2))); + +extern int seed48_r (unsigned short int __seed16v[3], + struct drand48_data *__buffer) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern int lcong48_r (unsigned short int __param[7], + struct drand48_data *__buffer) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern __uint32_t arc4random (void) + noexcept (true) ; + + +extern void arc4random_buf (void *__buf, size_t __size) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern __uint32_t arc4random_uniform (__uint32_t __upper_bound) + noexcept (true) ; + + + + +extern void *malloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) + __attribute__ ((__alloc_size__ (1))) ; + +extern void *calloc (size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) ; + + + + + + +extern void *realloc (void *__ptr, size_t __size) + noexcept (true) __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2))); + + +extern void free (void *__ptr) noexcept (true); + + + + + + + +extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__warn_unused_result__)) + __attribute__ ((__alloc_size__ (2, 3))) + __attribute__ ((__malloc__ (__builtin_free, 1))); + + +extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__malloc__ (reallocarray, 1))); + + + +# 1 "/usr/include/alloca.h" 1 3 4 +# 24 "/usr/include/alloca.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 25 "/usr/include/alloca.h" 2 3 4 + +extern "C" { + + + + + +extern void *alloca (size_t __size) noexcept (true); + + + + + +} +# 707 "/usr/include/stdlib.h" 2 3 4 + + + + + +extern void *valloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) + __attribute__ ((__alloc_size__ (1))) ; + + + + +extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) + noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + +extern void *aligned_alloc (size_t __alignment, size_t __size) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_align__ (1))) + __attribute__ ((__alloc_size__ (2))) ; + + + +extern void abort (void) noexcept (true) __attribute__ ((__noreturn__)) __attribute__ ((__cold__)); + + + +extern int atexit (void (*__func) (void)) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern "C++" int at_quick_exit (void (*__func) (void)) + noexcept (true) __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1))); +# 749 "/usr/include/stdlib.h" 3 4 +extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern void exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + + +extern void quick_exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + + +extern void _Exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + +extern char *getenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + +extern char *secure_getenv (const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + + + +extern int putenv (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern int setenv (const char *__name, const char *__value, int __replace) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + +extern int unsetenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern int clearenv (void) noexcept (true); +# 814 "/usr/include/stdlib.h" 3 4 +extern char *mktemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))); +# 827 "/usr/include/stdlib.h" 3 4 +extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 837 "/usr/include/stdlib.h" 3 4 +extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 849 "/usr/include/stdlib.h" 3 4 +extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; +# 859 "/usr/include/stdlib.h" 3 4 +extern int mkstemps64 (char *__template, int __suffixlen) + __attribute__ ((__nonnull__ (1))) ; +# 870 "/usr/include/stdlib.h" 3 4 +extern char *mkdtemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))) ; +# 881 "/usr/include/stdlib.h" 3 4 +extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 891 "/usr/include/stdlib.h" 3 4 +extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 901 "/usr/include/stdlib.h" 3 4 +extern int mkostemps (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 913 "/usr/include/stdlib.h" 3 4 +extern int mkostemps64 (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 923 "/usr/include/stdlib.h" 3 4 +extern int system (const char *__command) ; + + + + + +extern char *canonicalize_file_name (const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__malloc__)) + __attribute__ ((__malloc__ (__builtin_free, 1))) ; +# 940 "/usr/include/stdlib.h" 3 4 +extern char *realpath (const char *__restrict __name, + char *__restrict __resolved) noexcept (true) ; + + + + + + +typedef int (*__compar_fn_t) (const void *, const void *); + + +typedef __compar_fn_t comparison_fn_t; + + + +typedef int (*__compar_d_fn_t) (const void *, const void *, void *); + + + + +extern void *bsearch (const void *__key, const void *__base, + size_t __nmemb, size_t __size, __compar_fn_t __compar) + __attribute__ ((__nonnull__ (1, 2, 5))) ; + + + + + + + +extern void qsort (void *__base, size_t __nmemb, size_t __size, + __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4))); + +extern void qsort_r (void *__base, size_t __nmemb, size_t __size, + __compar_d_fn_t __compar, void *__arg) + __attribute__ ((__nonnull__ (1, 4))); + + + + +extern int abs (int __x) noexcept (true) __attribute__ ((__const__)) ; +extern long int labs (long int __x) noexcept (true) __attribute__ ((__const__)) ; + + +__extension__ extern long long int llabs (long long int __x) + noexcept (true) __attribute__ ((__const__)) ; + + + + + + +extern div_t div (int __numer, int __denom) + noexcept (true) __attribute__ ((__const__)) ; +extern ldiv_t ldiv (long int __numer, long int __denom) + noexcept (true) __attribute__ ((__const__)) ; + + +__extension__ extern lldiv_t lldiv (long long int __numer, + long long int __denom) + noexcept (true) __attribute__ ((__const__)) ; +# 1012 "/usr/include/stdlib.h" 3 4 +extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *gcvt (double __value, int __ndigit, char *__buf) + noexcept (true) __attribute__ ((__nonnull__ (3))) ; + + + + +extern char *qecvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qfcvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qgcvt (long double __value, int __ndigit, char *__buf) + noexcept (true) __attribute__ ((__nonnull__ (3))) ; + + + + +extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); +extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); + +extern int qecvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); +extern int qfcvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); + + + + + +extern int mblen (const char *__s, size_t __n) noexcept (true); + + +extern int mbtowc (wchar_t *__restrict __pwc, + const char *__restrict __s, size_t __n) noexcept (true); + + +extern int wctomb (char *__s, wchar_t __wchar) noexcept (true); + + + +extern size_t mbstowcs (wchar_t *__restrict __pwcs, + const char *__restrict __s, size_t __n) noexcept (true) + __attribute__ ((__access__ (__read_only__, 2))); + +extern size_t wcstombs (char *__restrict __s, + const wchar_t *__restrict __pwcs, size_t __n) + noexcept (true) + __attribute__ ((__access__ (__write_only__, 1, 3))) + __attribute__ ((__access__ (__read_only__, 2))); + + + + + + +extern int rpmatch (const char *__response) noexcept (true) __attribute__ ((__nonnull__ (1))) ; +# 1099 "/usr/include/stdlib.h" 3 4 +extern int getsubopt (char **__restrict __optionp, + char *const *__restrict __tokens, + char **__restrict __valuep) + noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))) ; + + + + + + + +extern int posix_openpt (int __oflag) ; + + + + + + + +extern int grantpt (int __fd) noexcept (true); + + + +extern int unlockpt (int __fd) noexcept (true); + + + + +extern char *ptsname (int __fd) noexcept (true) ; + + + + + + +extern int ptsname_r (int __fd, char *__buf, size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3))); + + +extern int getpt (void); + + + + + + +extern int getloadavg (double __loadavg[], int __nelem) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 1155 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/stdlib-float.h" 1 3 4 +# 1156 "/usr/include/stdlib.h" 2 3 4 +# 1167 "/usr/include/stdlib.h" 3 4 +} +# 80 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 2 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 +# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::abs; + + + inline long + abs(long __i) { return __builtin_labs(__i); } + + + + inline long long + abs(long long __x) { return __builtin_llabs (__x); } +# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 + inline constexpr double + abs(double __x) + { return __builtin_fabs(__x); } + + inline constexpr float + abs(float __x) + { return __builtin_fabsf(__x); } + + inline constexpr long double + abs(long double __x) + { return __builtin_fabsl(__x); } + + + + __extension__ inline constexpr __int128 + abs(__int128 __x) { return __x >= 0 ? __x : -__x; } +# 135 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 + __extension__ inline constexpr + __float128 + abs(__float128 __x) + { + + + + return __builtin_fabsf128(__x); + + + + + } + + + +} +} +# 82 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 2 3 +# 125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::div_t; + using ::ldiv_t; + + using ::abort; + + using ::aligned_alloc; + + using ::atexit; + + + using ::at_quick_exit; + + + using ::atof; + using ::atoi; + using ::atol; + using ::bsearch; + using ::calloc; + using ::div; + using ::exit; + using ::free; + using ::getenv; + using ::labs; + using ::ldiv; + using ::malloc; + + using ::mblen; + using ::mbstowcs; + using ::mbtowc; + + using ::qsort; + + + using ::quick_exit; + + + using ::rand; + using ::realloc; + using ::srand; + using ::strtod; + using ::strtol; + using ::strtoul; + using ::system; + + using ::wcstombs; + using ::wctomb; + + + + inline ldiv_t + div(long __i, long __j) noexcept { return ldiv(__i, __j); } + + + + +} +# 199 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + using ::lldiv_t; + + + + + + using ::_Exit; + + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wlong-long" + using ::llabs; + + inline lldiv_t + div(long long __n, long long __d) + { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; } + + using ::lldiv; +#pragma GCC diagnostic pop +# 234 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 + using ::atoll; + using ::strtoll; + using ::strtoull; + + using ::strtof; + using ::strtold; + + +} + +namespace std +{ + + using ::__gnu_cxx::lldiv_t; + + using ::__gnu_cxx::_Exit; + + using ::__gnu_cxx::llabs; + using ::__gnu_cxx::div; + using ::__gnu_cxx::lldiv; + + using ::__gnu_cxx::atoll; + using ::__gnu_cxx::strtof; + using ::__gnu_cxx::strtoll; + using ::__gnu_cxx::strtoull; + using ::__gnu_cxx::strtold; +} +# 278 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +} +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h" 2 3 + +using std::abort; +using std::atexit; +using std::exit; + + + using std::at_quick_exit; + + + using std::quick_exit; + + + using std::_Exit; + + + + +using std::div_t; +using std::ldiv_t; + +using std::abs; +using std::atof; +using std::atoi; +using std::atol; +using std::bsearch; +using std::calloc; +using std::div; +using std::free; +using std::getenv; +using std::labs; +using std::ldiv; +using std::malloc; + +using std::mblen; +using std::mbstowcs; +using std::mbtowc; + +using std::qsort; +using std::rand; +using std::realloc; +using std::srand; +using std::strtod; +using std::strtol; +using std::strtoul; +using std::system; + +using std::wcstombs; +using std::wctomb; +# 55 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" 2 +# 72 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" + +# 72 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern "C" { + + +struct cudaFuncAttributes; +# 112 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +inline __attribute__((device)) cudaError_t __cudaCDP2Malloc(void **p, size_t s) +{ + return cudaErrorUnknown; +} + +inline __attribute__((device)) cudaError_t __cudaCDP2FuncGetAttributes(struct cudaFuncAttributes *p, const void *c) +{ + return cudaErrorUnknown; +} + +inline __attribute__((device)) cudaError_t __cudaCDP2DeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device) +{ + return cudaErrorUnknown; +} + +inline __attribute__((device)) cudaError_t __cudaCDP2GetDevice(int *device) +{ + return cudaErrorUnknown; +} + +inline __attribute__((device)) cudaError_t __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func, int blockSize, size_t dynamicSmemSize) +{ + return cudaErrorUnknown; +} + +inline __attribute__((device)) cudaError_t __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *func, int blockSize, size_t dynamicSmemSize, unsigned int flags) +{ + return cudaErrorUnknown; +} + + + + + +} +# 173 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 174 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" 2 +# 184 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern "C" +{ + + + + + +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaDeviceSynchronizeDeprecationAvoidance(void); +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2DeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2DeviceGetLimit(size_t *pValue, enum cudaLimit limit); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2DeviceGetCacheConfig(enum cudaFuncCache *pCacheConfig); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2DeviceGetSharedMemConfig(enum cudaSharedMemConfig *pConfig); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2GetLastError(void); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2PeekAtLastError(void); +extern __attribute__((device)) __attribute__((cudart_builtin)) const char* __cudaCDP2GetErrorString(cudaError_t error); +extern __attribute__((device)) __attribute__((cudart_builtin)) const char* __cudaCDP2GetErrorName(cudaError_t error); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2GetDeviceCount(int *count); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2GetDevice(int *device); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2StreamCreateWithFlags(cudaStream_t *pStream, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2StreamDestroy(cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2StreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2StreamWaitEvent_ptsz(cudaStream_t stream, cudaEvent_t event, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventCreateWithFlags(cudaEvent_t *event, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventRecord(cudaEvent_t event, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventRecord_ptsz(cudaEvent_t event, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventRecordWithFlags_ptsz(cudaEvent_t event, cudaStream_t stream, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventDestroy(cudaEvent_t event); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2FuncGetAttributes(struct cudaFuncAttributes *attr, const void *func); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Free(void *devPtr); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Malloc(void **devPtr, size_t size); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2MemcpyAsync(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2MemcpyAsync_ptsz(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memcpy2DAsync(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memcpy2DAsync_ptsz(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memcpy3DAsync(const struct cudaMemcpy3DParms *p, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memcpy3DAsync_ptsz(const struct cudaMemcpy3DParms *p, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2MemsetAsync(void *devPtr, int value, size_t count, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2MemsetAsync_ptsz(void *devPtr, int value, size_t count, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memset2DAsync(void *devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memset2DAsync_ptsz(void *devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memset3DAsync(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memset3DAsync_ptsz(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2RuntimeGetVersion(int *runtimeVersion); +extern __attribute__((device)) __attribute__((cudart_builtin)) void * __cudaCDP2GetParameterBuffer(size_t alignment, size_t size); +extern __attribute__((device)) __attribute__((cudart_builtin)) void * __cudaCDP2GetParameterBufferV2(void *func, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2LaunchDevice_ptsz(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2LaunchDeviceV2_ptsz(void *parameterBuffer, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2LaunchDevice(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2LaunchDeviceV2(void *parameterBuffer, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func, int blockSize, size_t dynamicSmemSize); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *func, int blockSize, size_t dynamicSmemSize, unsigned int flags); + + +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream); +# 311 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static inline __attribute__((device)) __attribute__((cudart_builtin)) cudaGraphExec_t cudaGetCurrentGraphExec(void) +{ + unsigned long long current_graph_exec; + asm ("mov.u64 %0, %%current_graph_exec;" : "=l"(current_graph_exec)); + return (cudaGraphExec_t)current_graph_exec; +} +# 346 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetParam(cudaGraphDeviceNode_t node, size_t offset, const void *value , size_t size); +# 374 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetEnabled(cudaGraphDeviceNode_t node, bool enable); +# 401 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetGridDim(cudaGraphDeviceNode_t node, dim3 gridDim); +# 430 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeUpdatesApply(const cudaGraphKernelNodeUpdate *updates, size_t updateCount); +# 448 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static inline __attribute__((device)) __attribute__((cudart_builtin)) void cudaTriggerProgrammaticLaunchCompletion(void) +{ + asm volatile("griddepcontrol.launch_dependents;":::); +} +# 464 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static inline __attribute__((device)) __attribute__((cudart_builtin)) void cudaGridDependencySynchronize(void) +{ + asm volatile("griddepcontrol.wait;":::"memory"); +} +# 479 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) void cudaGraphSetConditional(cudaGraphConditionalHandle handle, unsigned int value); + + +extern __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long cudaCGGetIntrinsicHandle(enum cudaCGScope scope); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaCGSynchronize(unsigned long long handle, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaCGSynchronizeGrid(unsigned long long handle, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaCGGetSize(unsigned int *numThreads, unsigned int *numGrids, unsigned long long handle); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaCGGetRank(unsigned int *threadRank, unsigned int *gridRank, unsigned long long handle); +# 498 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device) +{ + return __cudaCDP2DeviceGetAttribute(value, attr, device); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetLimit(size_t *pValue, enum cudaLimit limit) +{ + return __cudaCDP2DeviceGetLimit(pValue, limit); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetCacheConfig(enum cudaFuncCache *pCacheConfig) +{ + return __cudaCDP2DeviceGetCacheConfig(pCacheConfig); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetSharedMemConfig(enum cudaSharedMemConfig *pConfig) +{ + return __cudaCDP2DeviceGetSharedMemConfig(pConfig); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGetLastError(void) +{ + return __cudaCDP2GetLastError(); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaPeekAtLastError(void) +{ + return __cudaCDP2PeekAtLastError(); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) const char* cudaGetErrorString(cudaError_t error) +{ + return __cudaCDP2GetErrorString(error); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) const char* cudaGetErrorName(cudaError_t error) +{ + return __cudaCDP2GetErrorName(error); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceCount(int *count) +{ + return __cudaCDP2GetDeviceCount(count); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGetDevice(int *device) +{ + return __cudaCDP2GetDevice(device); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithFlags(cudaStream_t *pStream, unsigned int flags) +{ + return __cudaCDP2StreamCreateWithFlags(pStream, flags); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaStreamDestroy(cudaStream_t stream) +{ + return __cudaCDP2StreamDestroy(stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) +{ + return __cudaCDP2StreamWaitEvent(stream, event, flags); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaStreamWaitEvent_ptsz(cudaStream_t stream, cudaEvent_t event, unsigned int flags) +{ + return __cudaCDP2StreamWaitEvent_ptsz(stream, event, flags); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaEventCreateWithFlags(cudaEvent_t *event, unsigned int flags) +{ + return __cudaCDP2EventCreateWithFlags(event, flags); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream) +{ + return __cudaCDP2EventRecord(event, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecord_ptsz(cudaEvent_t event, cudaStream_t stream) +{ + return __cudaCDP2EventRecord_ptsz(event, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) +{ + return __cudaCDP2EventRecordWithFlags(event, stream, flags); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecordWithFlags_ptsz(cudaEvent_t event, cudaStream_t stream, unsigned int flags) +{ + return __cudaCDP2EventRecordWithFlags_ptsz(event, stream, flags); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaEventDestroy(cudaEvent_t event) +{ + return __cudaCDP2EventDestroy(event); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetAttributes(struct cudaFuncAttributes *attr, const void *func) +{ + return __cudaCDP2FuncGetAttributes(attr, func); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaFree(void *devPtr) +{ + return __cudaCDP2Free(devPtr); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMalloc(void **devPtr, size_t size) +{ + return __cudaCDP2Malloc(devPtr, size); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpyAsync(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream) +{ + return __cudaCDP2MemcpyAsync(dst, src, count, kind, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpyAsync_ptsz(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream) +{ + return __cudaCDP2MemcpyAsync_ptsz(dst, src, count, kind, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy2DAsync(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream) +{ + return __cudaCDP2Memcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy2DAsync_ptsz(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream) +{ + return __cudaCDP2Memcpy2DAsync_ptsz(dst, dpitch, src, spitch, width, height, kind, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy3DAsync(const struct cudaMemcpy3DParms *p, cudaStream_t stream) +{ + return __cudaCDP2Memcpy3DAsync(p, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy3DAsync_ptsz(const struct cudaMemcpy3DParms *p, cudaStream_t stream) +{ + return __cudaCDP2Memcpy3DAsync_ptsz(p, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemsetAsync(void *devPtr, int value, size_t count, cudaStream_t stream) +{ + return __cudaCDP2MemsetAsync(devPtr, value, count, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemsetAsync_ptsz(void *devPtr, int value, size_t count, cudaStream_t stream) +{ + return __cudaCDP2MemsetAsync_ptsz(devPtr, value, count, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemset2DAsync(void *devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) +{ + return __cudaCDP2Memset2DAsync(devPtr, pitch, value, width, height, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemset2DAsync_ptsz(void *devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) +{ + return __cudaCDP2Memset2DAsync_ptsz(devPtr, pitch, value, width, height, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemset3DAsync(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream) +{ + return __cudaCDP2Memset3DAsync(pitchedDevPtr, value, extent, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemset3DAsync_ptsz(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream) +{ + return __cudaCDP2Memset3DAsync_ptsz(pitchedDevPtr, value, extent, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaRuntimeGetVersion(int *runtimeVersion) +{ + return __cudaCDP2RuntimeGetVersion(runtimeVersion); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func, int blockSize, size_t dynamicSmemSize) +{ + return __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSmemSize); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *func, int blockSize, size_t dynamicSmemSize, unsigned int flags) +{ + return __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSmemSize, flags); +} +# 714 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) void * cudaGetParameterBuffer(size_t alignment, size_t size) +{ + return __cudaCDP2GetParameterBuffer(alignment, size); +} + + + + + + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) void * cudaGetParameterBufferV2(void *func, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize) +{ + return __cudaCDP2GetParameterBufferV2(func, gridDimension, blockDimension, sharedMemSize); +} + + + + + + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDevice_ptsz(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream) +{ + return __cudaCDP2LaunchDevice_ptsz(func, parameterBuffer, gridDimension, blockDimension, sharedMemSize, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDeviceV2_ptsz(void *parameterBuffer, cudaStream_t stream) +{ + return __cudaCDP2LaunchDeviceV2_ptsz(parameterBuffer, stream); +} +# 800 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" + static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDevice(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream) + { + return __cudaCDP2LaunchDevice(func, parameterBuffer, gridDimension, blockDimension, sharedMemSize, stream); + } + + static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDeviceV2(void *parameterBuffer, cudaStream_t stream) + { + return __cudaCDP2LaunchDeviceV2(parameterBuffer, stream); + } +# 862 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +} + + + + + +template static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMalloc(T **devPtr, size_t size); +template static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetAttributes(struct cudaFuncAttributes *attr, T *entry); +template static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, T func, int blockSize, size_t dynamicSmemSize); +template static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, T func, int blockSize, size_t dynamicSmemSize, unsigned int flags); +# 901 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +template +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetParam(cudaGraphDeviceNode_t node, size_t offset, const T &value) +{ + return cudaGraphKernelNodeSetParam(node, offset, &value, sizeof(T)); +} +# 154 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 2 +# 287 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern "C" { +# 334 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceReset(void); +# 356 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceSynchronize(void); +# 442 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetLimit(enum cudaLimit limit, size_t value); +# 478 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetLimit(size_t *pValue, enum cudaLimit limit); +# 501 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t *maxWidthInElements, const struct cudaChannelFormatDesc *fmtDesc, int device); +# 535 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetCacheConfig(enum cudaFuncCache *pCacheConfig); +# 572 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority); +# 616 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetCacheConfig(enum cudaFuncCache cacheConfig); +# 643 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetByPCIBusId(int *device, const char *pciBusId); +# 673 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetPCIBusId(char *pciBusId, int len, int device); +# 724 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t *handle, cudaEvent_t event); +# 768 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcOpenEventHandle(cudaEvent_t *event, cudaIpcEventHandle_t handle); +# 813 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t *handle, void *devPtr); +# 880 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcOpenMemHandle(void **devPtr, cudaIpcMemHandle_t handle, unsigned int flags); +# 919 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcCloseMemHandle(void *devPtr); +# 951 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(enum cudaFlushGPUDirectRDMAWritesTarget target, enum cudaFlushGPUDirectRDMAWritesScope scope); +# 989 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback); +# 1012 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback); +# 1059 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetSharedMemConfig(enum cudaSharedMemConfig *pConfig); +# 1105 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaDeviceSetSharedMemConfig(enum cudaSharedMemConfig config); +# 1146 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadExit(void); +# 1172 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSynchronize(void); +# 1221 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSetLimit(enum cudaLimit limit, size_t value); +# 1254 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadGetLimit(size_t *pValue, enum cudaLimit limit); +# 1290 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadGetCacheConfig(enum cudaFuncCache *pCacheConfig); +# 1337 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSetCacheConfig(enum cudaFuncCache cacheConfig); +# 1402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetLastError(void); +# 1453 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaPeekAtLastError(void); +# 1469 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) const char* cudaGetErrorName(cudaError_t error); +# 1485 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) const char* cudaGetErrorString(cudaError_t error); +# 1514 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceCount(int *count); +# 1818 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceProperties_v2(struct cudaDeviceProp *prop, int device); +# 2024 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device); +# 2042 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t *memPool, int device); +# 2066 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool); +# 2086 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetMemPool(cudaMemPool_t *memPool, int device); +# 2148 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetNvSciSyncAttributes(void *nvSciSyncAttrList, int device, int flags); +# 2188 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetP2PAttribute(int *value, enum cudaDeviceP2PAttr attr, int srcDevice, int dstDevice); +# 2210 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaChooseDevice(int *device, const struct cudaDeviceProp *prop); +# 2239 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags); +# 2285 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetDevice(int device); +# 2307 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDevice(int *device); +# 2338 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetValidDevices(int *device_arr, int len); +# 2408 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetDeviceFlags( unsigned int flags ); +# 2453 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetDeviceFlags( unsigned int *flags ); +# 2497 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamCreate(cudaStream_t *pStream); +# 2533 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithFlags(cudaStream_t *pStream, unsigned int flags); +# 2585 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithPriority(cudaStream_t *pStream, unsigned int flags, int priority); +# 2613 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int *priority); +# 2639 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int *flags); +# 2676 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetId(cudaStream_t hStream, unsigned long long *streamId); +# 2702 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetDevice(cudaStream_t hStream, int *device); +# 2717 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaCtxResetPersistingL2Cache(void); +# 2737 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src); +# 2758 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetAttribute( + cudaStream_t hStream, cudaLaunchAttributeID attr, + cudaLaunchAttributeValue *value_out); +# 2782 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamSetAttribute( + cudaStream_t hStream, cudaLaunchAttributeID attr, + const cudaLaunchAttributeValue *value); +# 2816 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamDestroy(cudaStream_t stream); +# 2847 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags = 0); + + + + + + + +typedef void ( *cudaStreamCallback_t)(cudaStream_t stream, cudaError_t status, void *userData); +# 2922 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamAddCallback(cudaStream_t stream, + cudaStreamCallback_t callback, void *userData, unsigned int flags); +# 2946 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamSynchronize(cudaStream_t stream); +# 2971 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamQuery(cudaStream_t stream); +# 3055 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamAttachMemAsync(cudaStream_t stream, void *devPtr, size_t length = 0, unsigned int flags = 0x04); +# 3094 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamBeginCapture(cudaStream_t stream, enum cudaStreamCaptureMode mode); +# 3135 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t *dependencies, const cudaGraphEdgeData *dependencyData, size_t numDependencies, enum cudaStreamCaptureMode mode); +# 3186 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaThreadExchangeStreamCaptureMode(enum cudaStreamCaptureMode *mode); +# 3215 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t *pGraph); +# 3253 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamIsCapturing(cudaStream_t stream, enum cudaStreamCaptureStatus *pCaptureStatus); +# 3303 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamGetCaptureInfo_v2(cudaStream_t stream, enum cudaStreamCaptureStatus *captureStatus_out, unsigned long long *id_out = 0, cudaGraph_t *graph_out = 0, const cudaGraphNode_t **dependencies_out = 0, size_t *numDependencies_out = 0); +# 3362 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamGetCaptureInfo_v3(cudaStream_t stream, + enum cudaStreamCaptureStatus *captureStatus_out, unsigned long long *id_out = 0, + cudaGraph_t *graph_out = 0, const cudaGraphNode_t **dependencies_out = 0, + const cudaGraphEdgeData **edgeData_out = 0, size_t *numDependencies_out = 0); +# 3402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t *dependencies, size_t numDependencies, unsigned int flags = 0); +# 3437 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamUpdateCaptureDependencies_v2(cudaStream_t stream, cudaGraphNode_t *dependencies, const cudaGraphEdgeData *dependencyData, size_t numDependencies, unsigned int flags = 0); +# 3474 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventCreate(cudaEvent_t *event); +# 3511 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventCreateWithFlags(cudaEvent_t *event, unsigned int flags); +# 3552 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream = 0); +# 3600 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream = 0, unsigned int flags = 0); +# 3633 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventQuery(cudaEvent_t event); +# 3664 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventSynchronize(cudaEvent_t event); +# 3694 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventDestroy(cudaEvent_t event); +# 3739 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventElapsedTime(float *ms, cudaEvent_t start, cudaEvent_t end); +# 3787 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventElapsedTime_v2(float *ms, cudaEvent_t start, cudaEvent_t end); +# 3968 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaImportExternalMemory(cudaExternalMemory_t *extMem_out, const struct cudaExternalMemoryHandleDesc *memHandleDesc); +# 4023 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaExternalMemoryGetMappedBuffer(void **devPtr, cudaExternalMemory_t extMem, const struct cudaExternalMemoryBufferDesc *bufferDesc); +# 4083 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t *mipmap, cudaExternalMemory_t extMem, const struct cudaExternalMemoryMipmappedArrayDesc *mipmapDesc); +# 4107 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem); +# 4261 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t *extSem_out, const struct cudaExternalSemaphoreHandleDesc *semHandleDesc); +# 4344 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSignalExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t *extSemArray, const struct cudaExternalSemaphoreSignalParams *paramsArray, unsigned int numExtSems, cudaStream_t stream = 0); +# 4420 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaWaitExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t *extSemArray, const struct cudaExternalSemaphoreWaitParams *paramsArray, unsigned int numExtSems, cudaStream_t stream = 0); +# 4443 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem); +# 4511 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchKernel(const void *func, dim3 gridDim, dim3 blockDim, void **args, size_t sharedMem, cudaStream_t stream); +# 4574 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchKernelExC(const cudaLaunchConfig_t *config, const void *func, void **args); +# 4632 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchCooperativeKernel(const void *func, dim3 gridDim, dim3 blockDim, void **args, size_t sharedMem, cudaStream_t stream); +# 4733 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaLaunchCooperativeKernelMultiDevice(struct cudaLaunchParams *launchParamsList, unsigned int numDevices, unsigned int flags = 0); +# 4783 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFuncSetCacheConfig(const void *func, enum cudaFuncCache cacheConfig); +# 4818 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetAttributes(struct cudaFuncAttributes *attr, const void *func); +# 4877 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncSetAttribute(const void *func, enum cudaFuncAttribute attr, int value); +# 4903 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetName(const char **name, const void *func); +# 4926 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetParamInfo(const void *func, size_t paramIndex, size_t *paramOffset, size_t *paramSize); +# 4950 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaSetDoubleForDevice(double *d); +# 4974 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaSetDoubleForHost(double *d); +# 5040 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void *userData); +# 5114 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaFuncSetSharedMemConfig(const void *func, enum cudaSharedMemConfig config); +# 5171 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func, int blockSize, size_t dynamicSMemSize); +# 5201 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t *dynamicSmemSize, const void *func, int numBlocks, int blockSize); +# 5247 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *func, int blockSize, size_t dynamicSMemSize, unsigned int flags); +# 5283 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxPotentialClusterSize(int *clusterSize, const void *func, const cudaLaunchConfig_t *launchConfig); +# 5323 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveClusters(int *numClusters, const void *func, const cudaLaunchConfig_t *launchConfig); +# 5443 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMallocManaged(void **devPtr, size_t size, unsigned int flags = 0x01); +# 5476 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMalloc(void **devPtr, size_t size); +# 5513 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocHost(void **ptr, size_t size); +# 5556 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocPitch(void **devPtr, size_t *pitch, size_t width, size_t height); +# 5608 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocArray(cudaArray_t *array, const struct cudaChannelFormatDesc *desc, size_t width, size_t height = 0, unsigned int flags = 0); +# 5647 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFree(void *devPtr); +# 5670 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeHost(void *ptr); +# 5693 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeArray(cudaArray_t array); +# 5716 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray); +# 5782 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostAlloc(void **pHost, size_t size, unsigned int flags); +# 5879 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostRegister(void *ptr, size_t size, unsigned int flags); +# 5902 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostUnregister(void *ptr); +# 5947 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostGetDevicePointer(void **pDevice, void *pHost, unsigned int flags); +# 5969 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostGetFlags(unsigned int *pFlags, void *pHost); +# 6008 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMalloc3D(struct cudaPitchedPtr* pitchedDevPtr, struct cudaExtent extent); +# 6153 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMalloc3DArray(cudaArray_t *array, const struct cudaChannelFormatDesc* desc, struct cudaExtent extent, unsigned int flags = 0); +# 6298 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocMipmappedArray(cudaMipmappedArray_t *mipmappedArray, const struct cudaChannelFormatDesc* desc, struct cudaExtent extent, unsigned int numLevels, unsigned int flags = 0); +# 6331 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t *levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level); +# 6436 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3D(const struct cudaMemcpy3DParms *p); +# 6468 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3DPeer(const struct cudaMemcpy3DPeerParms *p); +# 6586 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy3DAsync(const struct cudaMemcpy3DParms *p, cudaStream_t stream = 0); +# 6613 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3DPeerAsync(const struct cudaMemcpy3DPeerParms *p, cudaStream_t stream = 0); +# 6647 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemGetInfo(size_t *free, size_t *total); +# 6673 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetInfo(struct cudaChannelFormatDesc *desc, struct cudaExtent *extent, unsigned int *flags, cudaArray_t array); +# 6702 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetPlane(cudaArray_t *pPlaneArray, cudaArray_t hArray, unsigned int planeIdx); +# 6725 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetMemoryRequirements(struct cudaArrayMemoryRequirements *memoryRequirements, cudaArray_t array, int device); +# 6749 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMipmappedArrayGetMemoryRequirements(struct cudaArrayMemoryRequirements *memoryRequirements, cudaMipmappedArray_t mipmap, int device); +# 6777 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaArrayGetSparseProperties(struct cudaArraySparseProperties *sparseProperties, cudaArray_t array); +# 6807 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaMipmappedArrayGetSparseProperties(struct cudaArraySparseProperties *sparseProperties, cudaMipmappedArray_t mipmap); +# 6852 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind); +# 6887 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyPeer(void *dst, int dstDevice, const void *src, int srcDevice, size_t count); +# 6936 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2D(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind); +# 6986 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind); +# 7036 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DFromArray(void *dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind); +# 7083 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, enum cudaMemcpyKind kind = cudaMemcpyDeviceToDevice); +# 7126 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyToSymbol(const void *symbol, const void *src, size_t count, size_t offset = 0, enum cudaMemcpyKind kind = cudaMemcpyHostToDevice); +# 7170 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyFromSymbol(void *dst, const void *symbol, size_t count, size_t offset = 0, enum cudaMemcpyKind kind = cudaMemcpyDeviceToHost); +# 7227 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpyAsync(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7262 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyPeerAsync(void *dst, int dstDevice, const void *src, int srcDevice, size_t count, cudaStream_t stream = 0); +# 7334 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyBatchAsync(void **dsts, void **srcs, size_t *sizes, size_t count, struct cudaMemcpyAttributes *attrs, size_t *attrsIdxs, size_t numAttrs, size_t *failIdx, cudaStream_t stream); +# 7402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3DBatchAsync(size_t numOps, struct cudaMemcpy3DBatchOp *opList, size_t *failIdx, unsigned long long flags, cudaStream_t stream); +# 7465 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy2DAsync(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7523 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7580 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DFromArrayAsync(void *dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7631 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyToSymbolAsync(const void *symbol, const void *src, size_t count, size_t offset, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7682 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyFromSymbolAsync(void *dst, const void *symbol, size_t count, size_t offset, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7711 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset(void *devPtr, int value, size_t count); +# 7745 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset2D(void *devPtr, size_t pitch, int value, size_t width, size_t height); +# 7791 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset3D(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent); +# 7827 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemsetAsync(void *devPtr, int value, size_t count, cudaStream_t stream = 0); +# 7868 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemset2DAsync(void *devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream = 0); +# 7921 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemset3DAsync(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream = 0); +# 7949 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSymbolAddress(void **devPtr, const void *symbol); +# 7976 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSymbolSize(size_t *size, const void *symbol); +# 8048 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPrefetchAsync(const void *devPtr, size_t count, int dstDevice, cudaStream_t stream = 0); +# 8129 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPrefetchAsync_v2(const void *devPtr, size_t count, struct cudaMemLocation location, unsigned int flags, cudaStream_t stream = 0); +# 8243 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemAdvise(const void *devPtr, size_t count, enum cudaMemoryAdvise advice, int device); +# 8366 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemAdvise_v2(const void *devPtr, size_t count, enum cudaMemoryAdvise advice, struct cudaMemLocation location); +# 8448 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemRangeGetAttribute(void *data, size_t dataSize, enum cudaMemRangeAttribute attribute, const void *devPtr, size_t count); +# 8491 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemRangeGetAttributes(void **data, size_t *dataSizes, enum cudaMemRangeAttribute *attributes, size_t numAttributes, const void *devPtr, size_t count); +# 8551 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t count, enum cudaMemcpyKind kind); +# 8593 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyFromArray(void *dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, enum cudaMemcpyKind kind); +# 8636 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, enum cudaMemcpyKind kind = cudaMemcpyDeviceToDevice); +# 8687 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 8737 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyFromArrayAsync(void *dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 8806 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocAsync(void **devPtr, size_t size, cudaStream_t hStream); +# 8832 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeAsync(void *devPtr, cudaStream_t hStream); +# 8857 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep); +# 8901 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, enum cudaMemPoolAttr attr, void *value ); +# 8949 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, enum cudaMemPoolAttr attr, void *value ); +# 8964 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const struct cudaMemAccessDesc *descList, size_t count); +# 8977 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolGetAccess(enum cudaMemAccessFlags *flags, cudaMemPool_t memPool, struct cudaMemLocation *location); +# 9021 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolCreate(cudaMemPool_t *memPool, const struct cudaMemPoolProps *poolProps); +# 9043 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool); +# 9079 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocFromPoolAsync(void **ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream); +# 9104 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolExportToShareableHandle( + void *shareableHandle, + cudaMemPool_t memPool, + enum cudaMemAllocationHandleType handleType, + unsigned int flags); +# 9131 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolImportFromShareableHandle( + cudaMemPool_t *memPool, + void *shareableHandle, + enum cudaMemAllocationHandleType handleType, + unsigned int flags); +# 9154 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolExportPointer(struct cudaMemPoolPtrExportData *exportData, void *ptr); +# 9183 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolImportPointer(void **ptr, cudaMemPool_t memPool, struct cudaMemPoolPtrExportData *exportData); +# 9336 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaPointerGetAttributes(struct cudaPointerAttributes *attributes, const void *ptr); +# 9377 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceCanAccessPeer(int *canAccessPeer, int device, int peerDevice); +# 9419 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags); +# 9441 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceDisablePeerAccess(int peerDevice); +# 9505 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource); +# 9540 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags); +# 9579 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t *resources, cudaStream_t stream = 0); +# 9614 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t *resources, cudaStream_t stream = 0); +# 9646 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceGetMappedPointer(void **devPtr, size_t *size, cudaGraphicsResource_t resource); +# 9684 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t *array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel); +# 9713 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t *mipmappedArray, cudaGraphicsResource_t resource); +# 9748 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetChannelDesc(struct cudaChannelFormatDesc *desc, cudaArray_const_t array); +# 9778 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) struct cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, enum cudaChannelFormatKind f); +# 10003 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaCreateTextureObject(cudaTextureObject_t *pTexObject, const struct cudaResourceDesc *pResDesc, const struct cudaTextureDesc *pTexDesc, const struct cudaResourceViewDesc *pResViewDesc); +# 10023 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject); +# 10043 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectResourceDesc(struct cudaResourceDesc *pResDesc, cudaTextureObject_t texObject); +# 10063 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectTextureDesc(struct cudaTextureDesc *pTexDesc, cudaTextureObject_t texObject); +# 10084 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectResourceViewDesc(struct cudaResourceViewDesc *pResViewDesc, cudaTextureObject_t texObject); +# 10129 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t *pSurfObject, const struct cudaResourceDesc *pResDesc); +# 10149 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject); +# 10168 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSurfaceObjectResourceDesc(struct cudaResourceDesc *pResDesc, cudaSurfaceObject_t surfObject); +# 10202 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDriverGetVersion(int *driverVersion); +# 10231 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaRuntimeGetVersion(int *runtimeVersion); +# 10278 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphCreate(cudaGraph_t *pGraph, unsigned int flags); +# 10377 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddKernelNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaKernelNodeParams *pNodeParams); +# 10410 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, struct cudaKernelNodeParams *pNodeParams); +# 10437 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const struct cudaKernelNodeParams *pNodeParams); +# 10457 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeCopyAttributes( + cudaGraphNode_t hSrc, + cudaGraphNode_t hDst); +# 10480 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeGetAttribute( + cudaGraphNode_t hNode, + cudaLaunchAttributeID attr, + cudaLaunchAttributeValue *value_out); +# 10504 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeSetAttribute( + cudaGraphNode_t hNode, + cudaLaunchAttributeID attr, + const cudaLaunchAttributeValue *value); +# 10555 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaMemcpy3DParms *pCopyParams); +# 10614 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNodeToSymbol( + cudaGraphNode_t *pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t *pDependencies, + size_t numDependencies, + const void* symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 10683 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNodeFromSymbol( + cudaGraphNode_t* pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t* pDependencies, + size_t numDependencies, + void* dst, + const void* symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 10751 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNode1D( + cudaGraphNode_t *pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t *pDependencies, + size_t numDependencies, + void* dst, + const void* src, + size_t count, + enum cudaMemcpyKind kind); +# 10783 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, struct cudaMemcpy3DParms *pNodeParams); +# 10810 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const struct cudaMemcpy3DParms *pNodeParams); +# 10849 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParamsToSymbol( + cudaGraphNode_t node, + const void* symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 10895 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParamsFromSymbol( + cudaGraphNode_t node, + void* dst, + const void* symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 10941 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParams1D( + cudaGraphNode_t node, + void* dst, + const void* src, + size_t count, + enum cudaMemcpyKind kind); +# 10989 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddMemsetNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaMemsetParams *pMemsetParams); +# 11012 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, struct cudaMemsetParams *pNodeParams); +# 11036 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const struct cudaMemsetParams *pNodeParams); +# 11078 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddHostNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaHostNodeParams *pNodeParams); +# 11101 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, struct cudaHostNodeParams *pNodeParams); +# 11125 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const struct cudaHostNodeParams *pNodeParams); +# 11166 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddChildGraphNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, cudaGraph_t childGraph); +# 11193 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t *pGraph); +# 11231 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies); +# 11275 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddEventRecordNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, cudaEvent_t event); +# 11302 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t *event_out); +# 11330 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event); +# 11377 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddEventWaitNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, cudaEvent_t event); +# 11404 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t *event_out); +# 11432 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event); +# 11482 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaExternalSemaphoreSignalNodeParams *nodeParams); +# 11515 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, struct cudaExternalSemaphoreSignalNodeParams *params_out); +# 11543 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const struct cudaExternalSemaphoreSignalNodeParams *nodeParams); +# 11593 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaExternalSemaphoreWaitNodeParams *nodeParams); +# 11626 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, struct cudaExternalSemaphoreWaitNodeParams *params_out); +# 11654 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const struct cudaExternalSemaphoreWaitNodeParams *nodeParams); +# 11732 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddMemAllocNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, struct cudaMemAllocNodeParams *nodeParams); +# 11759 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, struct cudaMemAllocNodeParams *params_out); +# 11820 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddMemFreeNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, void *dptr); +# 11844 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void *dptr_out); +# 11872 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGraphMemTrim(int device); +# 11909 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetGraphMemAttribute(int device, enum cudaGraphMemAttributeType attr, void* value); +# 11943 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetGraphMemAttribute(int device, enum cudaGraphMemAttributeType attr, void* value); +# 11971 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphClone(cudaGraph_t *pGraphClone, cudaGraph_t originalGraph); +# 11999 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t *pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph); +# 12030 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, enum cudaGraphNodeType *pType); +# 12061 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t *nodes, size_t *numNodes); +# 12092 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t *pRootNodes, size_t *pNumRootNodes); +# 12126 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t *from, cudaGraphNode_t *to, size_t *numEdges); +# 12166 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetEdges_v2(cudaGraph_t graph, cudaGraphNode_t *from, cudaGraphNode_t *to, cudaGraphEdgeData *edgeData, size_t *numEdges); +# 12197 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t *pDependencies, size_t *pNumDependencies); +# 12234 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependencies_v2(cudaGraphNode_t node, cudaGraphNode_t *pDependencies, cudaGraphEdgeData *edgeData, size_t *pNumDependencies); +# 12266 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t *pDependentNodes, size_t *pNumDependentNodes); +# 12304 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependentNodes_v2(cudaGraphNode_t node, cudaGraphNode_t *pDependentNodes, cudaGraphEdgeData *edgeData, size_t *pNumDependentNodes); +# 12335 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, size_t numDependencies); +# 12367 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, const cudaGraphEdgeData *edgeData, size_t numDependencies); +# 12398 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, size_t numDependencies); +# 12433 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphRemoveDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, const cudaGraphEdgeData *edgeData, size_t numDependencies); +# 12463 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node); +# 12534 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiate(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, unsigned long long flags = 0); +# 12607 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, unsigned long long flags = 0); +# 12714 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiateWithParams(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams *instantiateParams); +# 12739 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long *flags); +# 12799 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaKernelNodeParams *pNodeParams); +# 12850 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaMemcpy3DParms *pNodeParams); +# 12905 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParamsToSymbol( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + const void* symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 12968 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParamsFromSymbol( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + void* dst, + const void* symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 13029 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParams1D( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + void* dst, + const void* src, + size_t count, + enum cudaMemcpyKind kind); +# 13088 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaMemsetParams *pNodeParams); +# 13128 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaHostNodeParams *pNodeParams); +# 13175 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph); +# 13220 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event); +# 13265 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event); +# 13313 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const struct cudaExternalSemaphoreSignalNodeParams *nodeParams); +# 13361 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const struct cudaExternalSemaphoreWaitNodeParams *nodeParams); +# 13401 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled); +# 13435 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int *isEnabled); +# 13529 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo *resultInfo); +# 13554 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream); +# 13585 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream); +# 13608 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec); +# 13629 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDestroy(cudaGraph_t graph); +# 13648 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char *path, unsigned int flags); +# 13684 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaUserObjectCreate(cudaUserObject_t *object_out, void *ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags); +# 13708 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned int count = 1); +# 13736 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned int count = 1); +# 13764 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count = 1, unsigned int flags = 0); +# 13789 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count = 1); +# 13831 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, struct cudaGraphNodeParams *nodeParams); +# 13875 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddNode_v2(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, const cudaGraphEdgeData *dependencyData, size_t numDependencies, struct cudaGraphNodeParams *nodeParams); +# 13904 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeSetParams(cudaGraphNode_t node, struct cudaGraphNodeParams *nodeParams); +# 13953 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, struct cudaGraphNodeParams *nodeParams); +# 13980 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle *pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue = 0, unsigned int flags = 0); +# 14061 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetDriverEntryPoint(const char *symbol, void **funcPtr, unsigned long long flags, enum cudaDriverEntryPointQueryResult *driverStatus = +# 14061 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 3 4 + __null +# 14061 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + ); +# 14137 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetDriverEntryPointByVersion(const char *symbol, void **funcPtr, unsigned int cudaVersion, unsigned long long flags, enum cudaDriverEntryPointQueryResult *driverStatus = +# 14137 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 3 4 + __null +# 14137 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + ); +# 14212 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryLoadData(cudaLibrary_t *library, const void *code, + enum cudaJitOption *jitOptions, void **jitOptionsValues, unsigned int numJitOptions, + enum cudaLibraryOption *libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions); +# 14272 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryLoadFromFile(cudaLibrary_t *library, const char *fileName, + enum cudaJitOption *jitOptions, void **jitOptionsValues, unsigned int numJitOptions, + enum cudaLibraryOption *libraryOptions, void **libraryOptionValues, unsigned int numLibraryOptions); +# 14293 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryUnload(cudaLibrary_t library); +# 14318 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryGetKernel(cudaKernel_t *pKernel, cudaLibrary_t library, const char *name); +# 14352 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryGetGlobal(void **dptr, size_t *bytes, cudaLibrary_t library, const char *name); +# 14385 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryGetManaged(void **dptr, size_t *bytes, cudaLibrary_t library, const char *name); +# 14412 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryGetUnifiedFunction(void **fptr, cudaLibrary_t library, const char *symbol); +# 14434 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryGetKernelCount(unsigned int *count, cudaLibrary_t lib); +# 14456 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryEnumerateKernels(cudaKernel_t *kernels, unsigned int numKernels, cudaLibrary_t lib); +# 14525 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaKernelSetAttributeForDevice(cudaKernel_t kernel, enum cudaFuncAttribute attr, int value, int device); + + + + +extern __attribute__((host)) cudaError_t cudaGetExportTable(const void **ppExportTable, const cudaUUID_t *pExportTableId); +# 14716 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetFuncBySymbol(cudaFunction_t* functionPtr, const void* symbolPtr); +# 14740 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetKernel(cudaKernel_t *kernelPtr, const void *entryFuncAddr); +# 14918 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +} +# 62 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" 2 +# 120 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" +template __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(0, 0, 0, 0, cudaChannelFormatKindNone); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescHalf(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescHalf1(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescHalf2(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindFloat); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescHalf4(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindFloat); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(char) * 8; + + + + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); + +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(signed char) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned char) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(signed char) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned char) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(signed char) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned char) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(signed char) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned char) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(short) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(short) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(int) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned int) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(int) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned int) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(int) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned int) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(int) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned int) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +} +# 392 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(float) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(float) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(float) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindFloat); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(float) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindFloat); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescNV12(void) +{ + int e = (int)sizeof(char) * 8; + + return cudaCreateChannelDesc(e, e, e, 0, cudaChannelFormatKindNV12); +} + +template __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(0, 0, 0, 0, cudaChannelFormatKindNone); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindSignedNormalized8X1); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindSignedNormalized8X2); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindSignedNormalized8X4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindUnsignedNormalized8X1); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindUnsignedNormalized8X2); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedNormalized8X4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 0, 0, 0, cudaChannelFormatKindSignedNormalized16X1); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 0, 0, cudaChannelFormatKindSignedNormalized16X2); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 16, 16, cudaChannelFormatKindSignedNormalized16X4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 0, 0, 0, cudaChannelFormatKindUnsignedNormalized16X1); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 0, 0, cudaChannelFormatKindUnsignedNormalized16X2); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 16, 16, cudaChannelFormatKindUnsignedNormalized16X4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 0, cudaChannelFormatKindNV12); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(10, 10, 10, 2, cudaChannelFormatKindUnsignedNormalized1010102); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed1); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed1SRGB); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed2); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed2SRGB); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed3); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed3SRGB); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindUnsignedBlockCompressed4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindSignedBlockCompressed4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindUnsignedBlockCompressed5); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindSignedBlockCompressed5); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 16, 0, cudaChannelFormatKindUnsignedBlockCompressed6H); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 16, 0, cudaChannelFormatKindSignedBlockCompressed6H); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed7); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed7SRGB); +} +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" 1 +# 53 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 54 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 55 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" 2 +# 79 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static __inline__ __attribute__((host)) struct cudaPitchedPtr make_cudaPitchedPtr(void *d, size_t p, size_t xsz, size_t ysz) +{ + struct cudaPitchedPtr s; + + s.ptr = d; + s.pitch = p; + s.xsize = xsz; + s.ysize = ysz; + + return s; +} +# 106 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static __inline__ __attribute__((host)) struct cudaPos make_cudaPos(size_t x, size_t y, size_t z) +{ + struct cudaPos p; + + p.x = x; + p.y = y; + p.z = z; + + return p; +} +# 132 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static __inline__ __attribute__((host)) struct cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) +{ + struct cudaExtent e; + + e.width = w; + e.height = h; + e.depth = d; + + return e; +} +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 100 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + + + + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.h" 1 +# 77 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.h" +static __inline__ __attribute__((host)) __attribute__((device)) char1 make_char1(signed char x); + +static __inline__ __attribute__((host)) __attribute__((device)) uchar1 make_uchar1(unsigned char x); + +static __inline__ __attribute__((host)) __attribute__((device)) char2 make_char2(signed char x, signed char y); + +static __inline__ __attribute__((host)) __attribute__((device)) uchar2 make_uchar2(unsigned char x, unsigned char y); + +static __inline__ __attribute__((host)) __attribute__((device)) char3 make_char3(signed char x, signed char y, signed char z); + +static __inline__ __attribute__((host)) __attribute__((device)) uchar3 make_uchar3(unsigned char x, unsigned char y, unsigned char z); + +static __inline__ __attribute__((host)) __attribute__((device)) char4 make_char4(signed char x, signed char y, signed char z, signed char w); + +static __inline__ __attribute__((host)) __attribute__((device)) uchar4 make_uchar4(unsigned char x, unsigned char y, unsigned char z, unsigned char w); + +static __inline__ __attribute__((host)) __attribute__((device)) short1 make_short1(short x); + +static __inline__ __attribute__((host)) __attribute__((device)) ushort1 make_ushort1(unsigned short x); + +static __inline__ __attribute__((host)) __attribute__((device)) short2 make_short2(short x, short y); + +static __inline__ __attribute__((host)) __attribute__((device)) ushort2 make_ushort2(unsigned short x, unsigned short y); + +static __inline__ __attribute__((host)) __attribute__((device)) short3 make_short3(short x,short y, short z); + +static __inline__ __attribute__((host)) __attribute__((device)) ushort3 make_ushort3(unsigned short x, unsigned short y, unsigned short z); + +static __inline__ __attribute__((host)) __attribute__((device)) short4 make_short4(short x, short y, short z, short w); + +static __inline__ __attribute__((host)) __attribute__((device)) ushort4 make_ushort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w); + +static __inline__ __attribute__((host)) __attribute__((device)) int1 make_int1(int x); + +static __inline__ __attribute__((host)) __attribute__((device)) uint1 make_uint1(unsigned int x); + +static __inline__ __attribute__((host)) __attribute__((device)) int2 make_int2(int x, int y); + +static __inline__ __attribute__((host)) __attribute__((device)) uint2 make_uint2(unsigned int x, unsigned int y); + +static __inline__ __attribute__((host)) __attribute__((device)) int3 make_int3(int x, int y, int z); + +static __inline__ __attribute__((host)) __attribute__((device)) uint3 make_uint3(unsigned int x, unsigned int y, unsigned int z); + +static __inline__ __attribute__((host)) __attribute__((device)) int4 make_int4(int x, int y, int z, int w); + +static __inline__ __attribute__((host)) __attribute__((device)) uint4 make_uint4(unsigned int x, unsigned int y, unsigned int z, unsigned int w); + +static __inline__ __attribute__((host)) __attribute__((device)) long1 make_long1(long int x); + +static __inline__ __attribute__((host)) __attribute__((device)) ulong1 make_ulong1(unsigned long int x); + +static __inline__ __attribute__((host)) __attribute__((device)) long2 make_long2(long int x, long int y); + +static __inline__ __attribute__((host)) __attribute__((device)) ulong2 make_ulong2(unsigned long int x, unsigned long int y); + +static __inline__ __attribute__((host)) __attribute__((device)) long3 make_long3(long int x, long int y, long int z); + +static __inline__ __attribute__((host)) __attribute__((device)) ulong3 make_ulong3(unsigned long int x, unsigned long int y, unsigned long int z); + +static __inline__ __attribute__((host)) __attribute__((device)) long4 make_long4(long int x, long int y, long int z, long int w); + +static __inline__ __attribute__((host)) __attribute__((device)) ulong4 make_ulong4(unsigned long int x, unsigned long int y, unsigned long int z, unsigned long int w); + +static __inline__ __attribute__((host)) __attribute__((device)) float1 make_float1(float x); + +static __inline__ __attribute__((host)) __attribute__((device)) float2 make_float2(float x, float y); + +static __inline__ __attribute__((host)) __attribute__((device)) float3 make_float3(float x, float y, float z); + +static __inline__ __attribute__((host)) __attribute__((device)) float4 make_float4(float x, float y, float z, float w); + +static __inline__ __attribute__((host)) __attribute__((device)) longlong1 make_longlong1(long long int x); + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong1 make_ulonglong1(unsigned long long int x); + +static __inline__ __attribute__((host)) __attribute__((device)) longlong2 make_longlong2(long long int x, long long int y); + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong2 make_ulonglong2(unsigned long long int x, unsigned long long int y); + +static __inline__ __attribute__((host)) __attribute__((device)) longlong3 make_longlong3(long long int x, long long int y, long long int z); + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong3 make_ulonglong3(unsigned long long int x, unsigned long long int y, unsigned long long int z); + +static __inline__ __attribute__((host)) __attribute__((device)) longlong4 make_longlong4(long long int x, long long int y, long long int z, long long int w); + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong4 make_ulonglong4(unsigned long long int x, unsigned long long int y, unsigned long long int z, unsigned long long int w); + +static __inline__ __attribute__((host)) __attribute__((device)) double1 make_double1(double x); + +static __inline__ __attribute__((host)) __attribute__((device)) double2 make_double2(double x, double y); + +static __inline__ __attribute__((host)) __attribute__((device)) double3 make_double3(double x, double y, double z); + +static __inline__ __attribute__((host)) __attribute__((device)) double4 make_double4(double x, double y, double z, double w); + + + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.hpp" 1 +# 73 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.hpp" +static __inline__ __attribute__((host)) __attribute__((device)) char1 make_char1(signed char x) +{ + char1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uchar1 make_uchar1(unsigned char x) +{ + uchar1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) char2 make_char2(signed char x, signed char y) +{ + char2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uchar2 make_uchar2(unsigned char x, unsigned char y) +{ + uchar2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) char3 make_char3(signed char x, signed char y, signed char z) +{ + char3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uchar3 make_uchar3(unsigned char x, unsigned char y, unsigned char z) +{ + uchar3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) char4 make_char4(signed char x, signed char y, signed char z, signed char w) +{ + char4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uchar4 make_uchar4(unsigned char x, unsigned char y, unsigned char z, unsigned char w) +{ + uchar4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) short1 make_short1(short x) +{ + short1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ushort1 make_ushort1(unsigned short x) +{ + ushort1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) short2 make_short2(short x, short y) +{ + short2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ushort2 make_ushort2(unsigned short x, unsigned short y) +{ + ushort2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) short3 make_short3(short x,short y, short z) +{ + short3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ushort3 make_ushort3(unsigned short x, unsigned short y, unsigned short z) +{ + ushort3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) short4 make_short4(short x, short y, short z, short w) +{ + short4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ushort4 make_ushort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w) +{ + ushort4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) int1 make_int1(int x) +{ + int1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uint1 make_uint1(unsigned int x) +{ + uint1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) int2 make_int2(int x, int y) +{ + int2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uint2 make_uint2(unsigned int x, unsigned int y) +{ + uint2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) int3 make_int3(int x, int y, int z) +{ + int3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uint3 make_uint3(unsigned int x, unsigned int y, unsigned int z) +{ + uint3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) int4 make_int4(int x, int y, int z, int w) +{ + int4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uint4 make_uint4(unsigned int x, unsigned int y, unsigned int z, unsigned int w) +{ + uint4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) long1 make_long1(long int x) +{ + long1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulong1 make_ulong1(unsigned long int x) +{ + ulong1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) long2 make_long2(long int x, long int y) +{ + long2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulong2 make_ulong2(unsigned long int x, unsigned long int y) +{ + ulong2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) long3 make_long3(long int x, long int y, long int z) +{ + long3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulong3 make_ulong3(unsigned long int x, unsigned long int y, unsigned long int z) +{ + ulong3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) long4 make_long4(long int x, long int y, long int z, long int w) +{ + long4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulong4 make_ulong4(unsigned long int x, unsigned long int y, unsigned long int z, unsigned long int w) +{ + ulong4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) float1 make_float1(float x) +{ + float1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) float2 make_float2(float x, float y) +{ + float2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) float3 make_float3(float x, float y, float z) +{ + float3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) float4 make_float4(float x, float y, float z, float w) +{ + float4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) longlong1 make_longlong1(long long int x) +{ + longlong1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong1 make_ulonglong1(unsigned long long int x) +{ + ulonglong1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) longlong2 make_longlong2(long long int x, long long int y) +{ + longlong2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong2 make_ulonglong2(unsigned long long int x, unsigned long long int y) +{ + ulonglong2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) longlong3 make_longlong3(long long int x, long long int y, long long int z) +{ + longlong3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong3 make_ulonglong3(unsigned long long int x, unsigned long long int y, unsigned long long int z) +{ + ulonglong3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) longlong4 make_longlong4(long long int x, long long int y, long long int z, long long int w) +{ + longlong4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong4 make_ulonglong4(unsigned long long int x, unsigned long long int y, unsigned long long int z, unsigned long long int w) +{ + ulonglong4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) double1 make_double1(double x) +{ + double1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) double2 make_double2(double x, double y) +{ + double2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) double3 make_double3(double x, double y, double z) +{ + double3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) double4 make_double4(double x, double y, double z, double w) +{ + double4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} +# 177 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.h" 2 +# 106 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 117 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 1 +# 71 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 72 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 73 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 85 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +# 1 "/usr/include/string.h" 1 3 4 +# 26 "/usr/include/string.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/string.h" 2 3 4 + + +# 28 "/usr/include/string.h" 3 4 +extern "C" { + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 34 "/usr/include/string.h" 2 3 4 +# 43 "/usr/include/string.h" 3 4 +extern void *memcpy (void *__restrict __dest, const void *__restrict __src, + size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern void *memmove (void *__dest, const void *__src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern void *memccpy (void *__restrict __dest, const void *__restrict __src, + int __c, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__write_only__, 1, 4))); + + + + +extern void *memset (void *__s, int __c, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int memcmp (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 80 "/usr/include/string.h" 3 4 +extern int __memcmpeq (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + +extern "C++" +{ +extern void *memchr (void *__s, int __c, size_t __n) + noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const void *memchr (const void *__s, int __c, size_t __n) + noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 105 "/usr/include/string.h" 3 4 +} +# 115 "/usr/include/string.h" 3 4 +extern "C++" void *rawmemchr (void *__s, int __c) + noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const void *rawmemchr (const void *__s, int __c) + noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + + + +extern "C++" void *memrchr (void *__s, int __c, size_t __n) + noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__read_only__, 1, 3))); +extern "C++" const void *memrchr (const void *__s, int __c, size_t __n) + noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__read_only__, 1, 3))); +# 141 "/usr/include/string.h" 3 4 +extern char *strcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strcat (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncat (char *__restrict __dest, const char *__restrict __src, + size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern int strncmp (const char *__s1, const char *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcoll (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern size_t strxfrm (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 1, 3))); + + + + + + +extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + + +extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n, + locale_t __l) noexcept (true) __attribute__ ((__nonnull__ (2, 4))) + __attribute__ ((__access__ (__write_only__, 1, 3))); + + + + + +extern char *strdup (const char *__s) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); + + + + + + +extern char *strndup (const char *__string, size_t __n) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); +# 224 "/usr/include/string.h" 3 4 +extern "C++" +{ +extern char *strchr (char *__s, int __c) + noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *strchr (const char *__s, int __c) + noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 244 "/usr/include/string.h" 3 4 +} + + + + + + +extern "C++" +{ +extern char *strrchr (char *__s, int __c) + noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *strrchr (const char *__s, int __c) + noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 271 "/usr/include/string.h" 3 4 +} +# 281 "/usr/include/string.h" 3 4 +extern "C++" char *strchrnul (char *__s, int __c) + noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const char *strchrnul (const char *__s, int __c) + noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 293 "/usr/include/string.h" 3 4 +extern size_t strcspn (const char *__s, const char *__reject) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern size_t strspn (const char *__s, const char *__accept) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern "C++" +{ +extern char *strpbrk (char *__s, const char *__accept) + noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern const char *strpbrk (const char *__s, const char *__accept) + noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 321 "/usr/include/string.h" 3 4 +} + + + + + + +extern "C++" +{ +extern char *strstr (char *__haystack, const char *__needle) + noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern const char *strstr (const char *__haystack, const char *__needle) + noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 348 "/usr/include/string.h" 3 4 +} + + + + + + + +extern char *strtok (char *__restrict __s, const char *__restrict __delim) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern char *__strtok_r (char *__restrict __s, + const char *__restrict __delim, + char **__restrict __save_ptr) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + +extern char *strtok_r (char *__restrict __s, const char *__restrict __delim, + char **__restrict __save_ptr) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + + + + + +extern "C++" char *strcasestr (char *__haystack, const char *__needle) + noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern "C++" const char *strcasestr (const char *__haystack, + const char *__needle) + noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 389 "/usr/include/string.h" 3 4 +extern void *memmem (const void *__haystack, size_t __haystacklen, + const void *__needle, size_t __needlelen) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3))) + __attribute__ ((__access__ (__read_only__, 1, 2))) + __attribute__ ((__access__ (__read_only__, 3, 4))); + + + +extern void *__mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern void *mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern size_t strlen (const char *__s) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + +extern size_t strnlen (const char *__string, size_t __maxlen) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + +extern char *strerror (int __errnum) noexcept (true); +# 444 "/usr/include/string.h" 3 4 +extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3))); + + + + +extern const char *strerrordesc_np (int __err) noexcept (true); + +extern const char *strerrorname_np (int __err) noexcept (true); + + + + + +extern char *strerror_l (int __errnum, locale_t __l) noexcept (true); + + + +# 1 "/usr/include/strings.h" 1 3 4 +# 23 "/usr/include/strings.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 24 "/usr/include/strings.h" 2 3 4 + + + + + + +extern "C" { + + + +extern int bcmp (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern void bcopy (const void *__src, void *__dest, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern void bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern "C++" +{ +extern char *index (char *__s, int __c) + noexcept (true) __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *index (const char *__s, int __c) + noexcept (true) __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 66 "/usr/include/strings.h" 3 4 +} + + + + + + + +extern "C++" +{ +extern char *rindex (char *__s, int __c) + noexcept (true) __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *rindex (const char *__s, int __c) + noexcept (true) __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 94 "/usr/include/strings.h" 3 4 +} +# 104 "/usr/include/strings.h" 3 4 +extern int ffs (int __i) noexcept (true) __attribute__ ((__const__)); + + + + + +extern int ffsl (long int __l) noexcept (true) __attribute__ ((__const__)); +__extension__ extern int ffsll (long long int __ll) + noexcept (true) __attribute__ ((__const__)); + + + +extern int strcasecmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strncasecmp (const char *__s1, const char *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + + + + +extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + + + +extern int strncasecmp_l (const char *__s1, const char *__s2, + size_t __n, locale_t __loc) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4))); + + +} +# 463 "/usr/include/string.h" 2 3 4 + + + +extern void explicit_bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__write_only__, 1, 2))); + + + +extern char *strsep (char **__restrict __stringp, + const char *__restrict __delim) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern char *strsignal (int __sig) noexcept (true); + + + +extern const char *sigabbrev_np (int __sig) noexcept (true); + + +extern const char *sigdescr_np (int __sig) noexcept (true); + + + +extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern char *stpcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern char *__stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern char *stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern size_t strlcpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__write_only__, 1, 3))); + + + +extern size_t strlcat (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__read_write__, 1, 3))); + + + + +extern int strverscmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strfry (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void *memfrob (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__read_write__, 1, 2))); + + + + + + + +extern "C++" char *basename (char *__filename) + noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); +extern "C++" const char *basename (const char *__filename) + noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); +# 552 "/usr/include/string.h" 3 4 +} +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 1 "/usr/include/time.h" 1 3 4 +# 29 "/usr/include/time.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 30 "/usr/include/time.h" 2 3 4 + + + +# 1 "/usr/include/bits/time.h" 1 3 4 +# 73 "/usr/include/bits/time.h" 3 4 +# 1 "/usr/include/bits/timex.h" 1 3 4 +# 26 "/usr/include/bits/timex.h" 3 4 +struct timex +{ +# 58 "/usr/include/bits/timex.h" 3 4 + unsigned int modes; + __syscall_slong_t offset; + __syscall_slong_t freq; + __syscall_slong_t maxerror; + __syscall_slong_t esterror; + int status; + __syscall_slong_t constant; + __syscall_slong_t precision; + __syscall_slong_t tolerance; + struct timeval time; + __syscall_slong_t tick; + __syscall_slong_t ppsfreq; + __syscall_slong_t jitter; + int shift; + __syscall_slong_t stabil; + __syscall_slong_t jitcnt; + __syscall_slong_t calcnt; + __syscall_slong_t errcnt; + __syscall_slong_t stbcnt; + + int tai; + + + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; + +}; +# 74 "/usr/include/bits/time.h" 2 3 4 + +extern "C" { + + +extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) noexcept (true) __attribute__ ((__nonnull__ (2))); +# 90 "/usr/include/bits/time.h" 3 4 +} +# 34 "/usr/include/time.h" 2 3 4 + + + + + +# 1 "/usr/include/bits/types/struct_tm.h" 1 3 4 + + + + + + +struct tm +{ + int tm_sec; + int tm_min; + int tm_hour; + int tm_mday; + int tm_mon; + int tm_year; + int tm_wday; + int tm_yday; + int tm_isdst; + + + long int tm_gmtoff; + const char *tm_zone; + + + + +}; +# 40 "/usr/include/time.h" 2 3 4 +# 48 "/usr/include/time.h" 3 4 +# 1 "/usr/include/bits/types/struct_itimerspec.h" 1 3 4 + + + + + + + +struct itimerspec + { + struct timespec it_interval; + struct timespec it_value; + }; +# 49 "/usr/include/time.h" 2 3 4 +struct sigevent; +# 68 "/usr/include/time.h" 3 4 +extern "C" { + + + +extern clock_t clock (void) noexcept (true); + + + +extern time_t time (time_t *__timer) noexcept (true); + + +extern double difftime (time_t __time1, time_t __time0); + + +extern time_t mktime (struct tm *__tp) noexcept (true); +# 99 "/usr/include/time.h" 3 4 +extern size_t strftime (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp) + noexcept (true) __attribute__ ((__nonnull__ (1, 3, 4))); + + + + +extern char *strptime (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp) + noexcept (true); + + + + + + +extern size_t strftime_l (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp, + locale_t __loc) noexcept (true); + + + +extern char *strptime_l (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp, + locale_t __loc) noexcept (true); + + + + + + +extern struct tm *gmtime (const time_t *__timer) noexcept (true); + + + +extern struct tm *localtime (const time_t *__timer) noexcept (true); +# 154 "/usr/include/time.h" 3 4 +extern struct tm *gmtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) noexcept (true); + + + +extern struct tm *localtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) noexcept (true); +# 179 "/usr/include/time.h" 3 4 +extern char *asctime (const struct tm *__tp) noexcept (true); + + + +extern char *ctime (const time_t *__timer) noexcept (true); +# 197 "/usr/include/time.h" 3 4 +extern char *asctime_r (const struct tm *__restrict __tp, + char *__restrict __buf) noexcept (true); + + + +extern char *ctime_r (const time_t *__restrict __timer, + char *__restrict __buf) noexcept (true); +# 217 "/usr/include/time.h" 3 4 +extern char *__tzname[2]; +extern int __daylight; +extern long int __timezone; + + + + +extern char *tzname[2]; + + + +extern void tzset (void) noexcept (true); + + + +extern int daylight; +extern long int timezone; +# 246 "/usr/include/time.h" 3 4 +extern time_t timegm (struct tm *__tp) noexcept (true); +# 263 "/usr/include/time.h" 3 4 +extern time_t timelocal (struct tm *__tp) noexcept (true); + + + + + + + +extern int dysize (int __year) noexcept (true) __attribute__ ((__const__)); +# 281 "/usr/include/time.h" 3 4 +extern int nanosleep (const struct timespec *__requested_time, + struct timespec *__remaining); + + +extern int clock_getres (clockid_t __clock_id, struct timespec *__res) noexcept (true); + + +extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + +extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp) + noexcept (true) __attribute__ ((__nonnull__ (2))); +# 323 "/usr/include/time.h" 3 4 +extern int clock_nanosleep (clockid_t __clock_id, int __flags, + const struct timespec *__req, + struct timespec *__rem); +# 338 "/usr/include/time.h" 3 4 +extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) noexcept (true); + + + + +extern int timer_create (clockid_t __clock_id, + struct sigevent *__restrict __evp, + timer_t *__restrict __timerid) noexcept (true); + + +extern int timer_delete (timer_t __timerid) noexcept (true); + + + +extern int timer_settime (timer_t __timerid, int __flags, + const struct itimerspec *__restrict __value, + struct itimerspec *__restrict __ovalue) noexcept (true); + + +extern int timer_gettime (timer_t __timerid, struct itimerspec *__value) + noexcept (true); +# 376 "/usr/include/time.h" 3 4 +extern int timer_getoverrun (timer_t __timerid) noexcept (true); + + + + + + +extern int timespec_get (struct timespec *__ts, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 399 "/usr/include/time.h" 3 4 +extern int timespec_getres (struct timespec *__ts, int __base) + noexcept (true); +# 425 "/usr/include/time.h" 3 4 +extern int getdate_err; +# 434 "/usr/include/time.h" 3 4 +extern struct tm *getdate (const char *__string); +# 448 "/usr/include/time.h" 3 4 +extern int getdate_r (const char *__restrict __string, + struct tm *__restrict __resbufp); + + +} +# 87 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 + + +# 88 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern "C" +{ + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) clock_t clock(void) + + + + +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 +noexcept (true) +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void* memset(void*, int, size_t) +# 96 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 + noexcept (true) +# 96 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void* memcpy(void*, const void*, size_t) +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 + noexcept (true) +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; + +} +# 111 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/new" 1 3 +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/new" 3 + +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/new" 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/exception.h" 1 3 +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/exception.h" 3 + +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/exception.h" 3 + + + + +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/exception.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/exception.h" 3 + class exception + { + public: + exception() noexcept { } + virtual ~exception() noexcept; + + exception(const exception&) = default; + exception& operator=(const exception&) = default; + exception(exception&&) = default; + exception& operator=(exception&&) = default; + + + + + virtual const char* + what() const noexcept; + }; + + + +} + +} +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/new" 2 3 + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/new" 2 3 + +#pragma GCC visibility push(default) + +extern "C++" { + +namespace std +{ + + + + + + + class bad_alloc : public exception + { + public: + bad_alloc() throw() { } + + + bad_alloc(const bad_alloc&) = default; + bad_alloc& operator=(const bad_alloc&) = default; + + + + + virtual ~bad_alloc() throw(); + + + virtual const char* what() const throw(); + }; + + + class bad_array_new_length : public bad_alloc + { + public: + bad_array_new_length() throw() { } + + + + virtual ~bad_array_new_length() throw(); + + + virtual const char* what() const throw(); + }; + + + + enum class align_val_t: size_t {}; + + + struct nothrow_t + { + + explicit nothrow_t() = default; + + }; + + extern const nothrow_t nothrow; + + + + typedef void (*new_handler)(); + + + + new_handler set_new_handler(new_handler) throw(); + + + + new_handler get_new_handler() noexcept; + +} +# 131 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/new" 3 +[[__nodiscard__]] void* operator new(std::size_t) + __attribute__((__externally_visible__)); +[[__nodiscard__]] void* operator new[](std::size_t) + __attribute__((__externally_visible__)); +void operator delete(void*) noexcept + __attribute__((__externally_visible__)); +void operator delete[](void*) noexcept + __attribute__((__externally_visible__)); + +void operator delete(void*, std::size_t) noexcept + __attribute__((__externally_visible__)); +void operator delete[](void*, std::size_t) noexcept + __attribute__((__externally_visible__)); + +[[__nodiscard__]] void* operator new(std::size_t, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new[](std::size_t, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +void operator delete(void*, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__)); +void operator delete[](void*, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__)); + +[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t) + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +void operator delete(void*, std::align_val_t) + noexcept __attribute__((__externally_visible__)); +void operator delete(void*, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__)); +[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t) + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +void operator delete[](void*, std::align_val_t) + noexcept __attribute__((__externally_visible__)); +void operator delete[](void*, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__)); + +void operator delete(void*, std::size_t, std::align_val_t) + noexcept __attribute__((__externally_visible__)); +void operator delete[](void*, std::size_t, std::align_val_t) + noexcept __attribute__((__externally_visible__)); + + + + +[[__nodiscard__]] inline void* operator new(std::size_t, void* __p) noexcept +{ return __p; } +[[__nodiscard__]] inline void* operator new[](std::size_t, void* __p) noexcept +{ return __p; } + + +inline void operator delete (void*, void*) noexcept { } +inline void operator delete[](void*, void*) noexcept { } + +} + + +namespace std +{ + + + template + [[nodiscard]] constexpr _Tp* + launder(_Tp* __p) noexcept + { return __builtin_launder(__p); } + + + + + template + void launder(_Ret (*)(_Args...) noexcept (_NE)) = delete; + template + void launder(_Ret (*)(_Args......) noexcept (_NE)) = delete; + + void launder(void*) = delete; + void launder(const void*) = delete; + void launder(volatile void*) = delete; + void launder(const volatile void*) = delete; + + + + inline constexpr size_t hardware_destructive_interference_size = 64; + inline constexpr size_t hardware_constructive_interference_size = 64; + +} +# 236 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/new" 3 +#pragma GCC visibility pop +# 112 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 125 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + +# 125 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void* operator new(std:: size_t, void*) throw(); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void* operator new[](std:: size_t, void*) throw(); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete(void*, void*) throw(); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete[](void*, void*) throw(); + +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete(void*, std:: size_t) throw(); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete[](void*, std:: size_t) throw(); + + + + +# 1 "/usr/include/stdio.h" 1 3 4 +# 28 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 29 "/usr/include/stdio.h" 2 3 4 + + +# 30 "/usr/include/stdio.h" 3 4 +extern "C" { + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 35 "/usr/include/stdio.h" 2 3 4 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stdarg.h" 1 3 4 +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stdarg.h" 3 4 +typedef __builtin_va_list __gnuc_va_list; +# 38 "/usr/include/stdio.h" 2 3 4 + + +# 1 "/usr/include/bits/types/__fpos_t.h" 1 3 4 + + + + +# 1 "/usr/include/bits/types/__mbstate_t.h" 1 3 4 +# 13 "/usr/include/bits/types/__mbstate_t.h" 3 4 +typedef struct +{ + int __count; + union + { + unsigned int __wch; + char __wchb[4]; + } __value; +} __mbstate_t; +# 6 "/usr/include/bits/types/__fpos_t.h" 2 3 4 + + + + +typedef struct _G_fpos_t +{ + __off_t __pos; + __mbstate_t __state; +} __fpos_t; +# 41 "/usr/include/stdio.h" 2 3 4 +# 1 "/usr/include/bits/types/__fpos64_t.h" 1 3 4 +# 10 "/usr/include/bits/types/__fpos64_t.h" 3 4 +typedef struct _G_fpos64_t +{ + __off64_t __pos; + __mbstate_t __state; +} __fpos64_t; +# 42 "/usr/include/stdio.h" 2 3 4 +# 1 "/usr/include/bits/types/__FILE.h" 1 3 4 + + + +struct _IO_FILE; +typedef struct _IO_FILE __FILE; +# 43 "/usr/include/stdio.h" 2 3 4 +# 1 "/usr/include/bits/types/FILE.h" 1 3 4 + + + +struct _IO_FILE; + + +typedef struct _IO_FILE FILE; +# 44 "/usr/include/stdio.h" 2 3 4 +# 1 "/usr/include/bits/types/struct_FILE.h" 1 3 4 +# 36 "/usr/include/bits/types/struct_FILE.h" 3 4 +struct _IO_FILE; +struct _IO_marker; +struct _IO_codecvt; +struct _IO_wide_data; + + + + +typedef void _IO_lock_t; + + + + + +struct _IO_FILE +{ + int _flags; + + + char *_IO_read_ptr; + char *_IO_read_end; + char *_IO_read_base; + char *_IO_write_base; + char *_IO_write_ptr; + char *_IO_write_end; + char *_IO_buf_base; + char *_IO_buf_end; + + + char *_IO_save_base; + char *_IO_backup_base; + char *_IO_save_end; + + struct _IO_marker *_markers; + + struct _IO_FILE *_chain; + + int _fileno; + int _flags2:24; + + char _short_backupbuf[1]; + __off_t _old_offset; + + + unsigned short _cur_column; + signed char _vtable_offset; + char _shortbuf[1]; + + _IO_lock_t *_lock; + + + + + + + + __off64_t _offset; + + struct _IO_codecvt *_codecvt; + struct _IO_wide_data *_wide_data; + struct _IO_FILE *_freeres_list; + void *_freeres_buf; + struct _IO_FILE **_prevchain; + int _mode; + + char _unused2[15 * sizeof (int) - 5 * sizeof (void *)]; +}; +# 45 "/usr/include/stdio.h" 2 3 4 + + +# 1 "/usr/include/bits/types/cookie_io_functions_t.h" 1 3 4 +# 27 "/usr/include/bits/types/cookie_io_functions_t.h" 3 4 +typedef __ssize_t cookie_read_function_t (void *__cookie, char *__buf, + size_t __nbytes); + + + + + + + +typedef __ssize_t cookie_write_function_t (void *__cookie, const char *__buf, + size_t __nbytes); + + + + + + + +typedef int cookie_seek_function_t (void *__cookie, __off64_t *__pos, int __w); + + +typedef int cookie_close_function_t (void *__cookie); + + + + + + +typedef struct _IO_cookie_io_functions_t +{ + cookie_read_function_t *read; + cookie_write_function_t *write; + cookie_seek_function_t *seek; + cookie_close_function_t *close; +} cookie_io_functions_t; +# 48 "/usr/include/stdio.h" 2 3 4 + + + + + +typedef __gnuc_va_list va_list; +# 85 "/usr/include/stdio.h" 3 4 +typedef __fpos_t fpos_t; + + + + +typedef __fpos64_t fpos64_t; +# 129 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/bits/stdio_lim.h" 1 3 4 +# 130 "/usr/include/stdio.h" 2 3 4 +# 149 "/usr/include/stdio.h" 3 4 +extern FILE *stdin; +extern FILE *stdout; +extern FILE *stderr; + + + + + + +extern int remove (const char *__filename) noexcept (true); + +extern int rename (const char *__old, const char *__new) noexcept (true); + + + +extern int renameat (int __oldfd, const char *__old, int __newfd, + const char *__new) noexcept (true); +# 176 "/usr/include/stdio.h" 3 4 +extern int renameat2 (int __oldfd, const char *__old, int __newfd, + const char *__new, unsigned int __flags) noexcept (true); + + + + + + +extern int fclose (FILE *__stream) __attribute__ ((__nonnull__ (1))); +# 194 "/usr/include/stdio.h" 3 4 +extern FILE *tmpfile (void) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; +# 206 "/usr/include/stdio.h" 3 4 +extern FILE *tmpfile64 (void) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; + + + +extern char *tmpnam (char[20]) noexcept (true) ; + + + + +extern char *tmpnam_r (char __s[20]) noexcept (true) ; +# 228 "/usr/include/stdio.h" 3 4 +extern char *tempnam (const char *__dir, const char *__pfx) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (__builtin_free, 1))); + + + + + + +extern int fflush (FILE *__stream); +# 245 "/usr/include/stdio.h" 3 4 +extern int fflush_unlocked (FILE *__stream); +# 255 "/usr/include/stdio.h" 3 4 +extern int fcloseall (void); +# 264 "/usr/include/stdio.h" 3 4 +extern FILE *fopen (const char *__restrict __filename, + const char *__restrict __modes) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; + + + + +extern FILE *freopen (const char *__restrict __filename, + const char *__restrict __modes, + FILE *__restrict __stream) __attribute__ ((__nonnull__ (3))); +# 289 "/usr/include/stdio.h" 3 4 +extern FILE *fopen64 (const char *__restrict __filename, + const char *__restrict __modes) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; +extern FILE *freopen64 (const char *__restrict __filename, + const char *__restrict __modes, + FILE *__restrict __stream) __attribute__ ((__nonnull__ (3))); + + + + +extern FILE *fdopen (int __fd, const char *__modes) noexcept (true) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; + + + + + +extern FILE *fopencookie (void *__restrict __magic_cookie, + const char *__restrict __modes, + cookie_io_functions_t __io_funcs) noexcept (true) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; + + + + +extern FILE *fmemopen (void *__s, size_t __len, const char *__modes) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; + + + + +extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) noexcept (true) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; +# 334 "/usr/include/stdio.h" 3 4 +extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) noexcept (true) + __attribute__ ((__nonnull__ (1))); + + + +extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, + int __modes, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf, + size_t __size) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void setlinebuf (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + + +extern int fprintf (FILE *__restrict __stream, + const char *__restrict __format, ...) __attribute__ ((__nonnull__ (1))); + + + + +extern int printf (const char *__restrict __format, ...); + +extern int sprintf (char *__restrict __s, + const char *__restrict __format, ...) noexcept (true); + + + + + +extern int vfprintf (FILE *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg) __attribute__ ((__nonnull__ (1))); + + + + +extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg); + +extern int vsprintf (char *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg) noexcept (true); + + + +extern int snprintf (char *__restrict __s, size_t __maxlen, + const char *__restrict __format, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 3, 4))); + +extern int vsnprintf (char *__restrict __s, size_t __maxlen, + const char *__restrict __format, __gnuc_va_list __arg) + noexcept (true) __attribute__ ((__format__ (__printf__, 3, 0))); + + + + + +extern int vasprintf (char **__restrict __ptr, const char *__restrict __f, + __gnuc_va_list __arg) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))) ; +extern int __asprintf (char **__restrict __ptr, + const char *__restrict __fmt, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) ; +extern int asprintf (char **__restrict __ptr, + const char *__restrict __fmt, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) ; + + + + +extern int vdprintf (int __fd, const char *__restrict __fmt, + __gnuc_va_list __arg) + __attribute__ ((__format__ (__printf__, 2, 0))); +extern int dprintf (int __fd, const char *__restrict __fmt, ...) + __attribute__ ((__format__ (__printf__, 2, 3))); + + + + + + + +extern int fscanf (FILE *__restrict __stream, + const char *__restrict __format, ...) __attribute__ ((__nonnull__ (1))); + + + + +extern int scanf (const char *__restrict __format, ...) ; + +extern int sscanf (const char *__restrict __s, + const char *__restrict __format, ...) noexcept (true); +# 442 "/usr/include/stdio.h" 3 4 +extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc23_fscanf") + + __attribute__ ((__nonnull__ (1))); +extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc23_scanf") + ; +extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_sscanf") + + ; +# 490 "/usr/include/stdio.h" 3 4 +extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg) + __attribute__ ((__format__ (__scanf__, 2, 0))) __attribute__ ((__nonnull__ (1))); + + + + + +extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) + __attribute__ ((__format__ (__scanf__, 1, 0))) ; + + +extern int vsscanf (const char *__restrict __s, + const char *__restrict __format, __gnuc_va_list __arg) + noexcept (true) __attribute__ ((__format__ (__scanf__, 2, 0))); + + + + + + +extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfscanf") + + + + __attribute__ ((__format__ (__scanf__, 2, 0))) __attribute__ ((__nonnull__ (1))); +extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vscanf") + + __attribute__ ((__format__ (__scanf__, 1, 0))) ; +extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vsscanf") + + + + __attribute__ ((__format__ (__scanf__, 2, 0))); +# 575 "/usr/include/stdio.h" 3 4 +extern int fgetc (FILE *__stream) __attribute__ ((__nonnull__ (1))); +extern int getc (FILE *__stream) __attribute__ ((__nonnull__ (1))); + + + + + +extern int getchar (void); + + + + + + +extern int getc_unlocked (FILE *__stream) __attribute__ ((__nonnull__ (1))); +extern int getchar_unlocked (void); +# 600 "/usr/include/stdio.h" 3 4 +extern int fgetc_unlocked (FILE *__stream) __attribute__ ((__nonnull__ (1))); +# 611 "/usr/include/stdio.h" 3 4 +extern int fputc (int __c, FILE *__stream) __attribute__ ((__nonnull__ (2))); +extern int putc (int __c, FILE *__stream) __attribute__ ((__nonnull__ (2))); + + + + + +extern int putchar (int __c); +# 627 "/usr/include/stdio.h" 3 4 +extern int fputc_unlocked (int __c, FILE *__stream) __attribute__ ((__nonnull__ (2))); + + + + + + + +extern int putc_unlocked (int __c, FILE *__stream) __attribute__ ((__nonnull__ (2))); +extern int putchar_unlocked (int __c); + + + + + + +extern int getw (FILE *__stream) __attribute__ ((__nonnull__ (1))); + + +extern int putw (int __w, FILE *__stream) __attribute__ ((__nonnull__ (2))); + + + + + + + +extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream) + __attribute__ ((__access__ (__write_only__, 1, 2))) __attribute__ ((__nonnull__ (3))); +# 677 "/usr/include/stdio.h" 3 4 +extern char *fgets_unlocked (char *__restrict __s, int __n, + FILE *__restrict __stream) + __attribute__ ((__access__ (__write_only__, 1, 2))) __attribute__ ((__nonnull__ (3))); +# 689 "/usr/include/stdio.h" 3 4 +extern __ssize_t __getdelim (char **__restrict __lineptr, + size_t *__restrict __n, int __delimiter, + FILE *__restrict __stream) __attribute__ ((__nonnull__ (4))); +extern __ssize_t getdelim (char **__restrict __lineptr, + size_t *__restrict __n, int __delimiter, + FILE *__restrict __stream) __attribute__ ((__nonnull__ (4))); + + +extern __ssize_t getline (char **__restrict __lineptr, + size_t *__restrict __n, + FILE *__restrict __stream) __attribute__ ((__nonnull__ (3))); + + + + + + + +extern int fputs (const char *__restrict __s, FILE *__restrict __stream) + __attribute__ ((__nonnull__ (2))); + + + + + +extern int puts (const char *__s); + + + + + + +extern int ungetc (int __c, FILE *__stream) __attribute__ ((__nonnull__ (2))); + + + + + + +extern size_t fread (void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream) + __attribute__ ((__nonnull__ (4))); + + + + +extern size_t fwrite (const void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __s) __attribute__ ((__nonnull__ (4))); +# 745 "/usr/include/stdio.h" 3 4 +extern int fputs_unlocked (const char *__restrict __s, + FILE *__restrict __stream) __attribute__ ((__nonnull__ (2))); +# 756 "/usr/include/stdio.h" 3 4 +extern size_t fread_unlocked (void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream) + __attribute__ ((__nonnull__ (4))); +extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream) + __attribute__ ((__nonnull__ (4))); + + + + + + + +extern int fseek (FILE *__stream, long int __off, int __whence) + __attribute__ ((__nonnull__ (1))); + + + + +extern long int ftell (FILE *__stream) __attribute__ ((__nonnull__ (1))); + + + + +extern void rewind (FILE *__stream) __attribute__ ((__nonnull__ (1))); +# 793 "/usr/include/stdio.h" 3 4 +extern int fseeko (FILE *__stream, __off_t __off, int __whence) + __attribute__ ((__nonnull__ (1))); + + + + +extern __off_t ftello (FILE *__stream) __attribute__ ((__nonnull__ (1))); +# 819 "/usr/include/stdio.h" 3 4 +extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos) + __attribute__ ((__nonnull__ (1))); + + + + +extern int fsetpos (FILE *__stream, const fpos_t *__pos) __attribute__ ((__nonnull__ (1))); +# 841 "/usr/include/stdio.h" 3 4 +extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence) + __attribute__ ((__nonnull__ (1))); +extern __off64_t ftello64 (FILE *__stream) __attribute__ ((__nonnull__ (1))); +extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos) + __attribute__ ((__nonnull__ (1))); +extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos) __attribute__ ((__nonnull__ (1))); + + + +extern void clearerr (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern int feof (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern int ferror (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern void clearerr_unlocked (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); +extern int feof_unlocked (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); +extern int ferror_unlocked (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + + +extern void perror (const char *__s) __attribute__ ((__cold__)); + + + + +extern int fileno (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern int fileno_unlocked (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); +# 887 "/usr/include/stdio.h" 3 4 +extern int pclose (FILE *__stream) __attribute__ ((__nonnull__ (1))); + + + + + +extern FILE *popen (const char *__command, const char *__modes) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (pclose, 1))) ; + + + + + + +extern char *ctermid (char *__s) noexcept (true) + __attribute__ ((__access__ (__write_only__, 1))); + + + + + +extern char *cuserid (char *__s) + __attribute__ ((__access__ (__write_only__, 1))); + + + + +struct obstack; + + +extern int obstack_printf (struct obstack *__restrict __obstack, + const char *__restrict __format, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))); +extern int obstack_vprintf (struct obstack *__restrict __obstack, + const char *__restrict __format, + __gnuc_va_list __args) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))); + + + + + + + +extern void flockfile (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int ftrylockfile (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void funlockfile (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); +# 949 "/usr/include/stdio.h" 3 4 +extern int __uflow (FILE *); +extern int __overflow (FILE *, int); +# 973 "/usr/include/stdio.h" 3 4 +} +# 137 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h" 1 3 +# 138 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 + + + + + + +# 143 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern "C" +{ +extern + + + + + + + +__attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) int printf(const char*, ...); + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void* malloc(size_t) +# 157 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 + noexcept (true) +# 157 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void free(void*) +# 158 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 + noexcept (true) +# 158 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; +# 168 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +} + + + + + +# 1 "/usr/include/assert.h" 1 3 4 +# 64 "/usr/include/assert.h" 3 4 + +# 64 "/usr/include/assert.h" 3 4 +extern "C" { + + +extern void __assert_fail (const char *__assertion, const char *__file, + unsigned int __line, const char *__function) + noexcept (true) __attribute__ ((__noreturn__)) __attribute__ ((__cold__)); + + +extern void __assert_perror_fail (int __errnum, const char *__file, + unsigned int __line, const char *__function) + noexcept (true) __attribute__ ((__noreturn__)) __attribute__ ((__cold__)); + + + + +extern void __assert (const char *__assertion, const char *__file, int __line) + noexcept (true) __attribute__ ((__noreturn__)) __attribute__ ((__cold__)); + + +} +# 175 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 + + + +# 177 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern "C" +{ +# 205 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void __assert_fail( + const char *, const char *, unsigned int, const char *) + +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 + noexcept (true) +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; + + + + +} +# 267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void* operator new(std:: size_t) ; +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void* operator new[](std:: size_t) ; +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete(void*) throw(); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete[](void*) throw(); + +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete(void*, std:: size_t) throw(); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete[](void*, std:: size_t) throw(); + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void* operator new(std:: size_t, std::align_val_t); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void* operator new[](std:: size_t, std::align_val_t); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete(void*, std::align_val_t) noexcept; +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete[](void*, std::align_val_t) noexcept; +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete(void*, std:: size_t, std::align_val_t) noexcept; +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete[](void*, std:: size_t, std::align_val_t) noexcept; +# 303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 1 +# 114 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 115 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 116 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 126 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern "C" +{ +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) int abs(int a) +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) long int labs(long int a) +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 255 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) long long int llabs(long long int a) +# 255 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 255 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fabs(double x) +# 283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 306 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fabsf(float x) +# 306 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 306 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 317 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int min(const int a, const int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned int umin(const unsigned int a, const unsigned int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llmin(const long long int a, const long long int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned long long int ullmin(const unsigned long long int a, const unsigned long long int b); +# 359 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fminf(float x, float y) +# 359 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 359 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 379 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmin(double x, double y) +# 379 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 379 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 392 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int max(const int a, const int b); + + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned int umax(const unsigned int a, const unsigned int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llmax(const long long int a, const long long int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned long long int ullmax(const unsigned long long int a, const unsigned long long int b); +# 435 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmaxf(float x, float y) +# 435 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 435 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 455 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmax(double, double) +# 455 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 455 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sin(double x) +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 495 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cos(double x) +# 495 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 495 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 511 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincos(double x, double *sptr, double *cptr) +# 511 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 511 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 524 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincosf(float x, float *sptr, float *cptr) +# 524 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 524 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 547 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tan(double x) +# 547 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 547 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 571 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sqrt(double x) +# 571 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 571 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 597 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rsqrt(double x); +# 621 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rsqrtf(float x); +# 648 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log2(double x) +# 648 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 648 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 677 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp2(double x) +# 677 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 677 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 706 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float exp2f(float x) +# 706 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 706 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 737 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp10(double x) +# 737 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 737 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 764 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float exp10f(float x) +# 764 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 764 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 798 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double expm1(double x) +# 798 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 798 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 831 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float expm1f(float x) +# 831 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 831 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 858 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log2f(float x) +# 858 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 858 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 883 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log10(double x) +# 883 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 883 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 909 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log(double x) +# 909 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 909 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 936 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log1p(double x) +# 936 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 936 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 966 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log1pf(float x) +# 966 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 966 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 992 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double floor(double x) +# 992 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 992 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1021 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp(double x) +# 1021 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1021 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1040 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cosh(double x) +# 1040 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1040 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sinh(double x) +# 1060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1080 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tanh(double x) +# 1080 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1080 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double acosh(double x) +# 1104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1131 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float acoshf(float x) +# 1131 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1131 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1155 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double asinh(double x) +# 1155 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1155 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1179 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float asinhf(float x) +# 1179 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1179 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atanh(double x) +# 1204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1229 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atanhf(float x) +# 1229 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1229 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1247 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double ldexp(double x, int exp) +# 1247 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1247 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1262 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ldexpf(float x, int exp) +# 1262 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1262 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double logb(double x) +# 1283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1307 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float logbf(float x) +# 1307 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1307 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1331 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int ilogb(double x) +# 1331 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1331 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1355 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int ilogbf(float x) +# 1355 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1355 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1383 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double scalbn(double x, int n) +# 1383 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1383 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float scalbnf(float x, int n) +# 1411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1439 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double scalbln(double x, long int n) +# 1439 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1439 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1467 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float scalblnf(float x, long int n) +# 1467 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1467 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1499 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double frexp(double x, int *nptr) +# 1499 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1499 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1528 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float frexpf(float x, int *nptr) +# 1528 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1528 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1551 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double round(double x) +# 1551 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1551 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1577 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float roundf(float x) +# 1577 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1577 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1595 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lround(double x) +# 1595 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1595 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1613 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lroundf(float x) +# 1613 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1613 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1631 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llround(double x) +# 1631 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1631 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1649 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llroundf(float x) +# 1649 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1649 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1694 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rint(double x) +# 1694 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1694 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1719 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rintf(float x) +# 1719 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1719 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1736 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lrint(double x) +# 1736 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1736 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1753 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lrintf(float x) +# 1753 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1753 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1770 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llrint(double x) +# 1770 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1770 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1787 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llrintf(float x) +# 1787 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1787 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nearbyint(double x) +# 1811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1835 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nearbyintf(float x) +# 1835 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1835 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1859 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double ceil(double x) +# 1859 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1859 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1882 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double trunc(double x) +# 1882 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1882 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float truncf(float x) +# 1908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1930 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fdim(double x, double y) +# 1930 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1930 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1951 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fdimf(float x, float y) +# 1951 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1951 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atan2(double y, double x) +# 2034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atan(double x) +# 2060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double acos(double x) +# 2077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2099 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double asin(double x) +# 2099 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2099 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2130 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double hypot(double x, double y) +# 2130 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2130 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2156 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rhypot(double x, double y) +# 2156 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2156 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2187 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float hypotf(float x, float y) +# 2187 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2187 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2213 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rhypotf(float x, float y) +# 2213 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2213 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2231 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double norm3d(double a, double b, double c) +# 2231 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2231 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2249 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm3d(double a, double b, double c) +# 2249 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2249 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double norm4d(double a, double b, double c, double d) +# 2267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm4d(double a, double b, double c, double d) +# 2285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +__attribute__((device)) __attribute__((device_builtin)) double norm(int dim, double const * p) +# 2303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2321 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm(int dim, double const * p) +# 2321 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2321 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnormf(int dim, float const * p) +# 2340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2358 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +__attribute__((device)) __attribute__((device_builtin)) float normf(int dim, float const * p) +# 2358 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2358 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2377 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float norm3df(float a, float b, float c) +# 2377 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2377 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2395 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnorm3df(float a, float b, float c) +# 2395 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2395 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2413 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float norm4df(float a, float b, float c, float d) +# 2413 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2413 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2431 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnorm4df(float a, float b, float c, float d) +# 2431 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2431 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2459 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cbrt(double x) +# 2459 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2459 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2486 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cbrtf(float x) +# 2486 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2486 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2512 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rcbrt(double x); +# 2533 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rcbrtf(float x); +# 2556 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sinpi(double x) noexcept (true); +# 2579 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinpif(float x) noexcept (true); +# 2601 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cospi(double x) noexcept (true); +# 2623 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cospif(float x) noexcept (true); +# 2636 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincospi(double x, double *sptr, double *cptr); +# 2649 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincospif(float x, float *sptr, float *cptr); +# 2735 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double pow(double x, double y) +# 2735 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2735 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2759 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double modf(double x, double *iptr) +# 2759 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2759 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2786 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmod(double x, double y) +# 2786 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2786 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2816 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double remainder(double x, double y) +# 2816 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2816 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2849 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float remainderf(float x, float y) +# 2849 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2849 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2887 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double remquo(double x, double y, int *quo) +# 2887 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2887 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2925 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float remquof(float x, float y, int *quo) +# 2925 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2925 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2946 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double j0(double x) +# 2946 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2946 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2968 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float j0f(float x) +# 2968 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2968 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2995 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double j1(double x) +# 2995 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2995 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3022 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float j1f(float x) +# 3022 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3022 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3045 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double jn(int n, double x) +# 3045 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3045 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3068 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float jnf(int n, float x) +# 3068 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3068 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3095 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double y0(double x) +# 3095 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3095 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3122 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float y0f(float x) +# 3122 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3122 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3149 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double y1(double x) +# 3149 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3149 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3176 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float y1f(float x) +# 3176 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3176 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double yn(int n, double x) +# 3204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3232 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ynf(int n, float x) +# 3232 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3232 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3250 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double cyl_bessel_i0(double x) +# 3250 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3250 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float cyl_bessel_i0f(float x) +# 3267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double cyl_bessel_i1(double x) +# 3285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3302 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float cyl_bessel_i1f(float x) +# 3302 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3302 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erf(double x) +# 3328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erff(float x) +# 3353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3383 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfinv(double x); +# 3406 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfinvf(float x); +# 3430 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfc(double x) +# 3430 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3430 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3453 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcf(float x) +# 3453 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3453 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3485 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double lgamma(double x) +# 3485 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3485 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3513 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfcinv(double x); +# 3534 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcinvf(float x); +# 3556 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double normcdfinv(double x); +# 3578 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normcdfinvf(float x); +# 3597 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double normcdf(double x); +# 3616 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normcdff(float x); +# 3636 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfcx(double x); +# 3656 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcxf(float x); +# 3689 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float lgammaf(float x) +# 3689 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3689 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3718 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tgamma(double x) +# 3718 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3718 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3747 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tgammaf(float x) +# 3747 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3747 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3761 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double copysign(double x, double y) +# 3761 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3761 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3775 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float copysignf(float x, float y) +# 3775 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3775 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3794 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nextafter(double x, double y) +# 3794 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3794 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3813 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nextafterf(float x, float y) +# 3813 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3813 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3829 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nan(const char *tagp) +# 3829 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3829 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3845 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nanf(const char *tagp) +# 3845 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3845 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinff(float) +# 3852 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3852 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnanf(float) +# 3853 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3853 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3863 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finite(double) +# 3863 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3863 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finitef(float) +# 3864 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3864 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbit(double) +# 3865 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3865 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnan(double) +# 3866 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3866 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinf(double) +# 3867 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3867 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitf(float) +# 3870 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3870 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3921 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fma(double x, double y, double z) +# 3921 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3921 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmaf(float x, float y, float z) +# 3971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3982 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitl(long double) +# 3982 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3982 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finitel(long double) +# 3988 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3988 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinfl(long double) +# 3989 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3989 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnanl(long double) +# 3990 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3990 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float acosf(float x) +# 4034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4056 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float asinf(float x) +# 4056 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4056 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4083 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atanf(float x) +# 4083 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4083 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4163 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atan2f(float y, float x) +# 4163 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4163 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4182 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cosf(float x) +# 4182 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4182 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4202 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinf(float x) +# 4202 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4202 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4222 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tanf(float x) +# 4222 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4222 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4241 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float coshf(float x) +# 4241 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4241 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4261 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinhf(float x) +# 4261 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4261 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4281 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tanhf(float x) +# 4281 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4281 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4304 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float logf(float x) +# 4304 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4304 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4334 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float expf(float x) +# 4334 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4334 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4357 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log10f(float x) +# 4357 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4357 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4380 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float modff(float x, float *iptr) +# 4380 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4380 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4463 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float powf(float x, float y) +# 4463 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4463 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4487 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sqrtf(float x) +# 4487 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4487 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4510 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ceilf(float x) +# 4510 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4510 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4533 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float floorf(float x) +# 4533 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4533 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4559 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmodf(float x, float y) +# 4559 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4559 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4574 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +} + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/math.h" 1 3 +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/math.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/requires_hosted.h" 1 3 +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 1 3 +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 2 3 +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + struct __true_type { }; + struct __false_type { }; + + template + struct __truth_type + { typedef __false_type __type; }; + + template<> + struct __truth_type + { typedef __true_type __type; }; + + + + template + struct __traitor + { + enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; + typedef typename __truth_type<__value>::__type __type; + }; + + + template + struct __are_same + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __are_same<_Tp, _Tp> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_void + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_void + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_integer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 185 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 273 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +__extension__ template<> struct __is_integer<__int128> { enum { __value = 1 }; typedef __true_type __type; }; __extension__ template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; +# 290 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + template + struct __is_floating + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 367 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + template + struct __is_pointer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __is_pointer<_Tp*> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_arithmetic + : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > + { }; + + + + + template + struct __is_scalar + : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > + { }; + + + + + template + struct __is_char + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_byte + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + enum class byte : unsigned char; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 471 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + template struct iterator_traits; + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = __is_trivially_copyable(_Tp) }; + }; + + + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = 0 }; + }; + + + template + struct __memcpyable + { + enum { __value = 0 }; + }; + + template + struct __memcpyable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcpyable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + template + struct __memcmpable + { + enum { __value = 0 }; + }; + + + template + struct __memcmpable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + + template::__value + + > + struct __is_memcmp_ordered + { + static const bool __value = _Tp(-1) > _Tp(1); + }; + + template + struct __is_memcmp_ordered<_Tp, false> + { + static const bool __value = false; + }; + + + template + struct __is_memcmp_ordered_with + { + static const bool __value = __is_memcmp_ordered<_Tp>::__value + && __is_memcmp_ordered<_Up>::__value; + }; + + template + struct __is_memcmp_ordered_with<_Tp, _Up, false> + { + static const bool __value = false; + }; +# 580 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + template<> + struct __is_memcmp_ordered_with + { static constexpr bool __value = true; }; + + template + struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> + { static constexpr bool __value = false; }; + + template + struct __is_memcmp_ordered_with + { static constexpr bool __value = false; }; + + + + + + template + struct __is_move_iterator + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + template + + inline _Iterator + __miter_base(_Iterator __it) + { return __it; } + + +} +} +# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 + +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 + + + + +extern "C++" { + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct __enable_if + { }; + + template + struct __enable_if + { typedef _Tp __type; }; + + + + template + struct __conditional_type + { typedef _Iftrue __type; }; + + template + struct __conditional_type + { typedef _Iffalse __type; }; + + + + template + struct __add_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned short __type; }; + + template<> + struct __add_unsigned + { typedef unsigned int __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long long __type; }; + + + template<> + struct __add_unsigned; + + template<> + struct __add_unsigned; + + + + template + struct __remove_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef short __type; }; + + template<> + struct __remove_unsigned + { typedef int __type; }; + + template<> + struct __remove_unsigned + { typedef long __type; }; + + template<> + struct __remove_unsigned + { typedef long long __type; }; + + + template<> + struct __remove_unsigned; + + template<> + struct __remove_unsigned; + + + + template + constexpr + inline bool + __is_null_pointer(_Type* __ptr) + { return __ptr == 0; } + + template + constexpr + inline bool + __is_null_pointer(_Type) + { return false; } + + + constexpr bool + __is_null_pointer(std::nullptr_t) + { return true; } + + + + + template::__value> + struct __promote + { typedef double __type; }; + + + + + template + struct __promote<_Tp, false> + { }; + + template<> + struct __promote + { typedef long double __type; }; + + template<> + struct __promote + { typedef double __type; }; + + template<> + struct __promote + { typedef float __type; }; +# 225 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 + template + using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); + + + + template + using __promote_2 = __promote<__promoted_t<_Tp, _Up>>; + + template + using __promote_3 = __promote<__promoted_t<_Tp, _Up, _Vp>>; + + template + using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>; +# 269 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 + +} +} +# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 + +# 1 "/usr/include/math.h" 1 3 4 +# 27 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 28 "/usr/include/math.h" 2 3 4 + + + + + + +extern "C" { + + + + + +# 1 "/usr/include/bits/math-vector.h" 1 3 4 +# 25 "/usr/include/bits/math-vector.h" 3 4 +# 1 "/usr/include/bits/libm-simd-decl-stubs.h" 1 3 4 +# 26 "/usr/include/bits/math-vector.h" 2 3 4 +# 41 "/usr/include/math.h" 2 3 4 +# 156 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/flt-eval-method.h" 1 3 4 +# 157 "/usr/include/math.h" 2 3 4 +# 167 "/usr/include/math.h" 3 4 +typedef float float_t; +typedef double double_t; +# 208 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/fp-logb.h" 1 3 4 +# 209 "/usr/include/math.h" 2 3 4 +# 251 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/fp-fast.h" 1 3 4 +# 252 "/usr/include/math.h" 2 3 4 + + + +enum + { + FP_INT_UPWARD = + + 0, + FP_INT_DOWNWARD = + + 1, + FP_INT_TOWARDZERO = + + 2, + FP_INT_TONEARESTFROMZERO = + + 3, + FP_INT_TONEAREST = + + 4, + }; + + +# 1 "/usr/include/bits/mathcalls-macros.h" 1 3 4 +# 276 "/usr/include/math.h" 2 3 4 + + + + + +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassify (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbit (double __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinf (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finite (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnan (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsig (double __x, double __y) noexcept (true); + + +extern int __issignaling (double __value) noexcept (true) + __attribute__ ((__const__)); +# 282 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern double acos (double __x) noexcept (true); extern double __acos (double __x) noexcept (true); + + extern double asin (double __x) noexcept (true); extern double __asin (double __x) noexcept (true); + + extern double atan (double __x) noexcept (true); extern double __atan (double __x) noexcept (true); + + extern double atan2 (double __y, double __x) noexcept (true); extern double __atan2 (double __y, double __x) noexcept (true); + + + extern double cos (double __x) noexcept (true); extern double __cos (double __x) noexcept (true); + + extern double sin (double __x) noexcept (true); extern double __sin (double __x) noexcept (true); + + extern double tan (double __x) noexcept (true); extern double __tan (double __x) noexcept (true); + + + +extern double acospi (double __x) noexcept (true); extern double __acospi (double __x) noexcept (true); + +extern double asinpi (double __x) noexcept (true); extern double __asinpi (double __x) noexcept (true); + +extern double atanpi (double __x) noexcept (true); extern double __atanpi (double __x) noexcept (true); + +extern double atan2pi (double __y, double __x) noexcept (true); extern double __atan2pi (double __y, double __x) noexcept (true); + + + extern double cospi (double __x) noexcept (true); extern double __cospi (double __x) noexcept (true); + + extern double sinpi (double __x) noexcept (true); extern double __sinpi (double __x) noexcept (true); + + extern double tanpi (double __x) noexcept (true); extern double __tanpi (double __x) noexcept (true); + + + + + + extern double cosh (double __x) noexcept (true); extern double __cosh (double __x) noexcept (true); + + extern double sinh (double __x) noexcept (true); extern double __sinh (double __x) noexcept (true); + + extern double tanh (double __x) noexcept (true); extern double __tanh (double __x) noexcept (true); + + + + extern void sincos (double __x, double *__sinx, double *__cosx) noexcept (true); extern void __sincos (double __x, double *__sinx, double *__cosx) noexcept (true) + ; + + + + + extern double acosh (double __x) noexcept (true); extern double __acosh (double __x) noexcept (true); + + extern double asinh (double __x) noexcept (true); extern double __asinh (double __x) noexcept (true); + + extern double atanh (double __x) noexcept (true); extern double __atanh (double __x) noexcept (true); + + + + + + extern double exp (double __x) noexcept (true); extern double __exp (double __x) noexcept (true); + + +extern double frexp (double __x, int *__exponent) noexcept (true); extern double __frexp (double __x, int *__exponent) noexcept (true); + + +extern double ldexp (double __x, int __exponent) noexcept (true); extern double __ldexp (double __x, int __exponent) noexcept (true); + + + extern double log (double __x) noexcept (true); extern double __log (double __x) noexcept (true); + + + extern double log10 (double __x) noexcept (true); extern double __log10 (double __x) noexcept (true); + + +extern double modf (double __x, double *__iptr) noexcept (true); extern double __modf (double __x, double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern double exp10 (double __x) noexcept (true); extern double __exp10 (double __x) noexcept (true); + + +extern double exp2m1 (double __x) noexcept (true); extern double __exp2m1 (double __x) noexcept (true); + + +extern double exp10m1 (double __x) noexcept (true); extern double __exp10m1 (double __x) noexcept (true); + + +extern double log2p1 (double __x) noexcept (true); extern double __log2p1 (double __x) noexcept (true); + + +extern double log10p1 (double __x) noexcept (true); extern double __log10p1 (double __x) noexcept (true); + + + extern double logp1 (double __x) noexcept (true); extern double __logp1 (double __x) noexcept (true); + + + + + extern double expm1 (double __x) noexcept (true); extern double __expm1 (double __x) noexcept (true); + + + extern double log1p (double __x) noexcept (true); extern double __log1p (double __x) noexcept (true); + + +extern double logb (double __x) noexcept (true); extern double __logb (double __x) noexcept (true); + + + + + extern double exp2 (double __x) noexcept (true); extern double __exp2 (double __x) noexcept (true); + + + extern double log2 (double __x) noexcept (true); extern double __log2 (double __x) noexcept (true); + + + + + + + extern double pow (double __x, double __y) noexcept (true); extern double __pow (double __x, double __y) noexcept (true); + + +extern double sqrt (double __x) noexcept (true); extern double __sqrt (double __x) noexcept (true); + + + + extern double hypot (double __x, double __y) noexcept (true); extern double __hypot (double __x, double __y) noexcept (true); + + + + + extern double cbrt (double __x) noexcept (true); extern double __cbrt (double __x) noexcept (true); + + + + + + +extern double ceil (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double fabs (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double floor (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double fmod (double __x, double __y) noexcept (true); extern double __fmod (double __x, double __y) noexcept (true); +# 216 "/usr/include/bits/mathcalls.h" 3 4 +extern int finite (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern double drem (double __x, double __y) noexcept (true); extern double __drem (double __x, double __y) noexcept (true); + + + +extern double significand (double __x) noexcept (true); extern double __significand (double __x) noexcept (true); + + + + + + +extern double copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern double nan (const char *__tagb) noexcept (true); extern double __nan (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern double j0 (double) noexcept (true); extern double __j0 (double) noexcept (true); +extern double j1 (double) noexcept (true); extern double __j1 (double) noexcept (true); +extern double jn (int, double) noexcept (true); extern double __jn (int, double) noexcept (true); +extern double y0 (double) noexcept (true); extern double __y0 (double) noexcept (true); +extern double y1 (double) noexcept (true); extern double __y1 (double) noexcept (true); +extern double yn (int, double) noexcept (true); extern double __yn (int, double) noexcept (true); + + + + + + extern double erf (double) noexcept (true); extern double __erf (double) noexcept (true); + extern double erfc (double) noexcept (true); extern double __erfc (double) noexcept (true); +extern double lgamma (double) noexcept (true); extern double __lgamma (double) noexcept (true); + + + + +extern double tgamma (double) noexcept (true); extern double __tgamma (double) noexcept (true); + + + + + +extern double gamma (double) noexcept (true); extern double __gamma (double) noexcept (true); + + + + + + + +extern double lgamma_r (double, int *__signgamp) noexcept (true); extern double __lgamma_r (double, int *__signgamp) noexcept (true); + + + + + + +extern double rint (double __x) noexcept (true); extern double __rint (double __x) noexcept (true); + + +extern double nextafter (double __x, double __y) noexcept (true); extern double __nextafter (double __x, double __y) noexcept (true); + +extern double nexttoward (double __x, long double __y) noexcept (true); extern double __nexttoward (double __x, long double __y) noexcept (true); + + + + +extern double nextdown (double __x) noexcept (true); extern double __nextdown (double __x) noexcept (true); + +extern double nextup (double __x) noexcept (true); extern double __nextup (double __x) noexcept (true); + + + +extern double remainder (double __x, double __y) noexcept (true); extern double __remainder (double __x, double __y) noexcept (true); + + + +extern double scalbn (double __x, int __n) noexcept (true); extern double __scalbn (double __x, int __n) noexcept (true); + + + +extern int ilogb (double __x) noexcept (true); extern int __ilogb (double __x) noexcept (true); + + + + +extern long int llogb (double __x) noexcept (true); extern long int __llogb (double __x) noexcept (true); + + + + +extern double scalbln (double __x, long int __n) noexcept (true); extern double __scalbln (double __x, long int __n) noexcept (true); + + + +extern double nearbyint (double __x) noexcept (true); extern double __nearbyint (double __x) noexcept (true); + + + +extern double round (double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern double trunc (double __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern double remquo (double __x, double __y, int *__quo) noexcept (true); extern double __remquo (double __x, double __y, int *__quo) noexcept (true); + + + + + + +extern long int lrint (double __x) noexcept (true); extern long int __lrint (double __x) noexcept (true); +__extension__ +extern long long int llrint (double __x) noexcept (true); extern long long int __llrint (double __x) noexcept (true); + + + +extern long int lround (double __x) noexcept (true); extern long int __lround (double __x) noexcept (true); +__extension__ +extern long long int llround (double __x) noexcept (true); extern long long int __llround (double __x) noexcept (true); + + + +extern double fdim (double __x, double __y) noexcept (true); extern double __fdim (double __x, double __y) noexcept (true); + + + +extern double fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + +extern double fma (double __x, double __y, double __z) noexcept (true); extern double __fma (double __x, double __y, double __z) noexcept (true); + + + + +extern double roundeven (double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfp (double __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfp (double __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpx (double __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpx (double __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalize (double *__cx, const double *__x) noexcept (true); + + + + + + +extern double fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern double fmaximum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorder (const double *__x, const double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermag (const double *__x, const double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern double getpayload (const double *__x) noexcept (true); extern double __getpayload (const double *__x) noexcept (true); + + +extern int setpayload (double *__x, double __payload) noexcept (true); + + +extern int setpayloadsig (double *__x, double __payload) noexcept (true); + + + + + + + +extern double scalb (double __x, double __n) noexcept (true); extern double __scalb (double __x, double __n) noexcept (true); +# 283 "/usr/include/math.h" 2 3 4 +# 298 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyf (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitf (float __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinff (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitef (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanf (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigf (float __x, float __y) noexcept (true); + + +extern int __issignalingf (float __value) noexcept (true) + __attribute__ ((__const__)); +# 299 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern float acosf (float __x) noexcept (true); extern float __acosf (float __x) noexcept (true); + + extern float asinf (float __x) noexcept (true); extern float __asinf (float __x) noexcept (true); + + extern float atanf (float __x) noexcept (true); extern float __atanf (float __x) noexcept (true); + + extern float atan2f (float __y, float __x) noexcept (true); extern float __atan2f (float __y, float __x) noexcept (true); + + + extern float cosf (float __x) noexcept (true); extern float __cosf (float __x) noexcept (true); + + extern float sinf (float __x) noexcept (true); extern float __sinf (float __x) noexcept (true); + + extern float tanf (float __x) noexcept (true); extern float __tanf (float __x) noexcept (true); + + + +extern float acospif (float __x) noexcept (true); extern float __acospif (float __x) noexcept (true); + +extern float asinpif (float __x) noexcept (true); extern float __asinpif (float __x) noexcept (true); + +extern float atanpif (float __x) noexcept (true); extern float __atanpif (float __x) noexcept (true); + +extern float atan2pif (float __y, float __x) noexcept (true); extern float __atan2pif (float __y, float __x) noexcept (true); + + + extern float cospif (float __x) noexcept (true); extern float __cospif (float __x) noexcept (true); + + extern float sinpif (float __x) noexcept (true); extern float __sinpif (float __x) noexcept (true); + + extern float tanpif (float __x) noexcept (true); extern float __tanpif (float __x) noexcept (true); + + + + + + extern float coshf (float __x) noexcept (true); extern float __coshf (float __x) noexcept (true); + + extern float sinhf (float __x) noexcept (true); extern float __sinhf (float __x) noexcept (true); + + extern float tanhf (float __x) noexcept (true); extern float __tanhf (float __x) noexcept (true); + + + + extern void sincosf (float __x, float *__sinx, float *__cosx) noexcept (true); extern void __sincosf (float __x, float *__sinx, float *__cosx) noexcept (true) + ; + + + + + extern float acoshf (float __x) noexcept (true); extern float __acoshf (float __x) noexcept (true); + + extern float asinhf (float __x) noexcept (true); extern float __asinhf (float __x) noexcept (true); + + extern float atanhf (float __x) noexcept (true); extern float __atanhf (float __x) noexcept (true); + + + + + + extern float expf (float __x) noexcept (true); extern float __expf (float __x) noexcept (true); + + +extern float frexpf (float __x, int *__exponent) noexcept (true); extern float __frexpf (float __x, int *__exponent) noexcept (true); + + +extern float ldexpf (float __x, int __exponent) noexcept (true); extern float __ldexpf (float __x, int __exponent) noexcept (true); + + + extern float logf (float __x) noexcept (true); extern float __logf (float __x) noexcept (true); + + + extern float log10f (float __x) noexcept (true); extern float __log10f (float __x) noexcept (true); + + +extern float modff (float __x, float *__iptr) noexcept (true); extern float __modff (float __x, float *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern float exp10f (float __x) noexcept (true); extern float __exp10f (float __x) noexcept (true); + + +extern float exp2m1f (float __x) noexcept (true); extern float __exp2m1f (float __x) noexcept (true); + + +extern float exp10m1f (float __x) noexcept (true); extern float __exp10m1f (float __x) noexcept (true); + + +extern float log2p1f (float __x) noexcept (true); extern float __log2p1f (float __x) noexcept (true); + + +extern float log10p1f (float __x) noexcept (true); extern float __log10p1f (float __x) noexcept (true); + + + extern float logp1f (float __x) noexcept (true); extern float __logp1f (float __x) noexcept (true); + + + + + extern float expm1f (float __x) noexcept (true); extern float __expm1f (float __x) noexcept (true); + + + extern float log1pf (float __x) noexcept (true); extern float __log1pf (float __x) noexcept (true); + + +extern float logbf (float __x) noexcept (true); extern float __logbf (float __x) noexcept (true); + + + + + extern float exp2f (float __x) noexcept (true); extern float __exp2f (float __x) noexcept (true); + + + extern float log2f (float __x) noexcept (true); extern float __log2f (float __x) noexcept (true); + + + + + + + extern float powf (float __x, float __y) noexcept (true); extern float __powf (float __x, float __y) noexcept (true); + + +extern float sqrtf (float __x) noexcept (true); extern float __sqrtf (float __x) noexcept (true); + + + + extern float hypotf (float __x, float __y) noexcept (true); extern float __hypotf (float __x, float __y) noexcept (true); + + + + + extern float cbrtf (float __x) noexcept (true); extern float __cbrtf (float __x) noexcept (true); + + + + + + +extern float ceilf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float fabsf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float floorf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float fmodf (float __x, float __y) noexcept (true); extern float __fmodf (float __x, float __y) noexcept (true); +# 210 "/usr/include/bits/mathcalls.h" 3 4 +extern int isinff (float __value) noexcept (true) + __attribute__ ((__const__)); + + + + +extern int finitef (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern float dremf (float __x, float __y) noexcept (true); extern float __dremf (float __x, float __y) noexcept (true); + + + +extern float significandf (float __x) noexcept (true); extern float __significandf (float __x) noexcept (true); + + + + + + +extern float copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern float nanf (const char *__tagb) noexcept (true); extern float __nanf (const char *__tagb) noexcept (true); +# 246 "/usr/include/bits/mathcalls.h" 3 4 +extern int isnanf (float __value) noexcept (true) + __attribute__ ((__const__)); + + + + + +extern float j0f (float) noexcept (true); extern float __j0f (float) noexcept (true); +extern float j1f (float) noexcept (true); extern float __j1f (float) noexcept (true); +extern float jnf (int, float) noexcept (true); extern float __jnf (int, float) noexcept (true); +extern float y0f (float) noexcept (true); extern float __y0f (float) noexcept (true); +extern float y1f (float) noexcept (true); extern float __y1f (float) noexcept (true); +extern float ynf (int, float) noexcept (true); extern float __ynf (int, float) noexcept (true); + + + + + + extern float erff (float) noexcept (true); extern float __erff (float) noexcept (true); + extern float erfcf (float) noexcept (true); extern float __erfcf (float) noexcept (true); +extern float lgammaf (float) noexcept (true); extern float __lgammaf (float) noexcept (true); + + + + +extern float tgammaf (float) noexcept (true); extern float __tgammaf (float) noexcept (true); + + + + + +extern float gammaf (float) noexcept (true); extern float __gammaf (float) noexcept (true); + + + + + + + +extern float lgammaf_r (float, int *__signgamp) noexcept (true); extern float __lgammaf_r (float, int *__signgamp) noexcept (true); + + + + + + +extern float rintf (float __x) noexcept (true); extern float __rintf (float __x) noexcept (true); + + +extern float nextafterf (float __x, float __y) noexcept (true); extern float __nextafterf (float __x, float __y) noexcept (true); + +extern float nexttowardf (float __x, long double __y) noexcept (true); extern float __nexttowardf (float __x, long double __y) noexcept (true); + + + + +extern float nextdownf (float __x) noexcept (true); extern float __nextdownf (float __x) noexcept (true); + +extern float nextupf (float __x) noexcept (true); extern float __nextupf (float __x) noexcept (true); + + + +extern float remainderf (float __x, float __y) noexcept (true); extern float __remainderf (float __x, float __y) noexcept (true); + + + +extern float scalbnf (float __x, int __n) noexcept (true); extern float __scalbnf (float __x, int __n) noexcept (true); + + + +extern int ilogbf (float __x) noexcept (true); extern int __ilogbf (float __x) noexcept (true); + + + + +extern long int llogbf (float __x) noexcept (true); extern long int __llogbf (float __x) noexcept (true); + + + + +extern float scalblnf (float __x, long int __n) noexcept (true); extern float __scalblnf (float __x, long int __n) noexcept (true); + + + +extern float nearbyintf (float __x) noexcept (true); extern float __nearbyintf (float __x) noexcept (true); + + + +extern float roundf (float __x) noexcept (true) __attribute__ ((__const__)); + + + +extern float truncf (float __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern float remquof (float __x, float __y, int *__quo) noexcept (true); extern float __remquof (float __x, float __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf (float __x) noexcept (true); extern long int __lrintf (float __x) noexcept (true); +__extension__ +extern long long int llrintf (float __x) noexcept (true); extern long long int __llrintf (float __x) noexcept (true); + + + +extern long int lroundf (float __x) noexcept (true); extern long int __lroundf (float __x) noexcept (true); +__extension__ +extern long long int llroundf (float __x) noexcept (true); extern long long int __llroundf (float __x) noexcept (true); + + + +extern float fdimf (float __x, float __y) noexcept (true); extern float __fdimf (float __x, float __y) noexcept (true); + + + +extern float fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + +extern float fmaf (float __x, float __y, float __z) noexcept (true); extern float __fmaf (float __x, float __y, float __z) noexcept (true); + + + + +extern float roundevenf (float __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf (float __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf (float __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf (float __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef (float *__cx, const float *__x) noexcept (true); + + + + + + +extern float fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern float fmaximumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf (const float *__x, const float *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf (const float *__x, const float *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern float getpayloadf (const float *__x) noexcept (true); extern float __getpayloadf (const float *__x) noexcept (true); + + +extern int setpayloadf (float *__x, float __payload) noexcept (true); + + +extern int setpayloadsigf (float *__x, float __payload) noexcept (true); + + + + + + + +extern float scalbf (float __x, float __n) noexcept (true); extern float __scalbf (float __x, float __n) noexcept (true); +# 300 "/usr/include/math.h" 2 3 4 +# 367 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinfl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitel (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigl (long double __x, long double __y) noexcept (true); + + +extern int __issignalingl (long double __value) noexcept (true) + __attribute__ ((__const__)); +# 368 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern long double acosl (long double __x) noexcept (true); extern long double __acosl (long double __x) noexcept (true); + + extern long double asinl (long double __x) noexcept (true); extern long double __asinl (long double __x) noexcept (true); + + extern long double atanl (long double __x) noexcept (true); extern long double __atanl (long double __x) noexcept (true); + + extern long double atan2l (long double __y, long double __x) noexcept (true); extern long double __atan2l (long double __y, long double __x) noexcept (true); + + + extern long double cosl (long double __x) noexcept (true); extern long double __cosl (long double __x) noexcept (true); + + extern long double sinl (long double __x) noexcept (true); extern long double __sinl (long double __x) noexcept (true); + + extern long double tanl (long double __x) noexcept (true); extern long double __tanl (long double __x) noexcept (true); + + + +extern long double acospil (long double __x) noexcept (true); extern long double __acospil (long double __x) noexcept (true); + +extern long double asinpil (long double __x) noexcept (true); extern long double __asinpil (long double __x) noexcept (true); + +extern long double atanpil (long double __x) noexcept (true); extern long double __atanpil (long double __x) noexcept (true); + +extern long double atan2pil (long double __y, long double __x) noexcept (true); extern long double __atan2pil (long double __y, long double __x) noexcept (true); + + + extern long double cospil (long double __x) noexcept (true); extern long double __cospil (long double __x) noexcept (true); + + extern long double sinpil (long double __x) noexcept (true); extern long double __sinpil (long double __x) noexcept (true); + + extern long double tanpil (long double __x) noexcept (true); extern long double __tanpil (long double __x) noexcept (true); + + + + + + extern long double coshl (long double __x) noexcept (true); extern long double __coshl (long double __x) noexcept (true); + + extern long double sinhl (long double __x) noexcept (true); extern long double __sinhl (long double __x) noexcept (true); + + extern long double tanhl (long double __x) noexcept (true); extern long double __tanhl (long double __x) noexcept (true); + + + + extern void sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true) + ; + + + + + extern long double acoshl (long double __x) noexcept (true); extern long double __acoshl (long double __x) noexcept (true); + + extern long double asinhl (long double __x) noexcept (true); extern long double __asinhl (long double __x) noexcept (true); + + extern long double atanhl (long double __x) noexcept (true); extern long double __atanhl (long double __x) noexcept (true); + + + + + + extern long double expl (long double __x) noexcept (true); extern long double __expl (long double __x) noexcept (true); + + +extern long double frexpl (long double __x, int *__exponent) noexcept (true); extern long double __frexpl (long double __x, int *__exponent) noexcept (true); + + +extern long double ldexpl (long double __x, int __exponent) noexcept (true); extern long double __ldexpl (long double __x, int __exponent) noexcept (true); + + + extern long double logl (long double __x) noexcept (true); extern long double __logl (long double __x) noexcept (true); + + + extern long double log10l (long double __x) noexcept (true); extern long double __log10l (long double __x) noexcept (true); + + +extern long double modfl (long double __x, long double *__iptr) noexcept (true); extern long double __modfl (long double __x, long double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern long double exp10l (long double __x) noexcept (true); extern long double __exp10l (long double __x) noexcept (true); + + +extern long double exp2m1l (long double __x) noexcept (true); extern long double __exp2m1l (long double __x) noexcept (true); + + +extern long double exp10m1l (long double __x) noexcept (true); extern long double __exp10m1l (long double __x) noexcept (true); + + +extern long double log2p1l (long double __x) noexcept (true); extern long double __log2p1l (long double __x) noexcept (true); + + +extern long double log10p1l (long double __x) noexcept (true); extern long double __log10p1l (long double __x) noexcept (true); + + + extern long double logp1l (long double __x) noexcept (true); extern long double __logp1l (long double __x) noexcept (true); + + + + + extern long double expm1l (long double __x) noexcept (true); extern long double __expm1l (long double __x) noexcept (true); + + + extern long double log1pl (long double __x) noexcept (true); extern long double __log1pl (long double __x) noexcept (true); + + +extern long double logbl (long double __x) noexcept (true); extern long double __logbl (long double __x) noexcept (true); + + + + + extern long double exp2l (long double __x) noexcept (true); extern long double __exp2l (long double __x) noexcept (true); + + + extern long double log2l (long double __x) noexcept (true); extern long double __log2l (long double __x) noexcept (true); + + + + + + + extern long double powl (long double __x, long double __y) noexcept (true); extern long double __powl (long double __x, long double __y) noexcept (true); + + +extern long double sqrtl (long double __x) noexcept (true); extern long double __sqrtl (long double __x) noexcept (true); + + + + extern long double hypotl (long double __x, long double __y) noexcept (true); extern long double __hypotl (long double __x, long double __y) noexcept (true); + + + + + extern long double cbrtl (long double __x) noexcept (true); extern long double __cbrtl (long double __x) noexcept (true); + + + + + + +extern long double ceill (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double floorl (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmodl (long double __x, long double __y) noexcept (true); extern long double __fmodl (long double __x, long double __y) noexcept (true); +# 210 "/usr/include/bits/mathcalls.h" 3 4 +extern int isinfl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + + +extern int finitel (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern long double dreml (long double __x, long double __y) noexcept (true); extern long double __dreml (long double __x, long double __y) noexcept (true); + + + +extern long double significandl (long double __x) noexcept (true); extern long double __significandl (long double __x) noexcept (true); + + + + + + +extern long double copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double nanl (const char *__tagb) noexcept (true); extern long double __nanl (const char *__tagb) noexcept (true); +# 246 "/usr/include/bits/mathcalls.h" 3 4 +extern int isnanl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + + + +extern long double j0l (long double) noexcept (true); extern long double __j0l (long double) noexcept (true); +extern long double j1l (long double) noexcept (true); extern long double __j1l (long double) noexcept (true); +extern long double jnl (int, long double) noexcept (true); extern long double __jnl (int, long double) noexcept (true); +extern long double y0l (long double) noexcept (true); extern long double __y0l (long double) noexcept (true); +extern long double y1l (long double) noexcept (true); extern long double __y1l (long double) noexcept (true); +extern long double ynl (int, long double) noexcept (true); extern long double __ynl (int, long double) noexcept (true); + + + + + + extern long double erfl (long double) noexcept (true); extern long double __erfl (long double) noexcept (true); + extern long double erfcl (long double) noexcept (true); extern long double __erfcl (long double) noexcept (true); +extern long double lgammal (long double) noexcept (true); extern long double __lgammal (long double) noexcept (true); + + + + +extern long double tgammal (long double) noexcept (true); extern long double __tgammal (long double) noexcept (true); + + + + + +extern long double gammal (long double) noexcept (true); extern long double __gammal (long double) noexcept (true); + + + + + + + +extern long double lgammal_r (long double, int *__signgamp) noexcept (true); extern long double __lgammal_r (long double, int *__signgamp) noexcept (true); + + + + + + +extern long double rintl (long double __x) noexcept (true); extern long double __rintl (long double __x) noexcept (true); + + +extern long double nextafterl (long double __x, long double __y) noexcept (true); extern long double __nextafterl (long double __x, long double __y) noexcept (true); + +extern long double nexttowardl (long double __x, long double __y) noexcept (true); extern long double __nexttowardl (long double __x, long double __y) noexcept (true); + + + + +extern long double nextdownl (long double __x) noexcept (true); extern long double __nextdownl (long double __x) noexcept (true); + +extern long double nextupl (long double __x) noexcept (true); extern long double __nextupl (long double __x) noexcept (true); + + + +extern long double remainderl (long double __x, long double __y) noexcept (true); extern long double __remainderl (long double __x, long double __y) noexcept (true); + + + +extern long double scalbnl (long double __x, int __n) noexcept (true); extern long double __scalbnl (long double __x, int __n) noexcept (true); + + + +extern int ilogbl (long double __x) noexcept (true); extern int __ilogbl (long double __x) noexcept (true); + + + + +extern long int llogbl (long double __x) noexcept (true); extern long int __llogbl (long double __x) noexcept (true); + + + + +extern long double scalblnl (long double __x, long int __n) noexcept (true); extern long double __scalblnl (long double __x, long int __n) noexcept (true); + + + +extern long double nearbyintl (long double __x) noexcept (true); extern long double __nearbyintl (long double __x) noexcept (true); + + + +extern long double roundl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern long double truncl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double remquol (long double __x, long double __y, int *__quo) noexcept (true); extern long double __remquol (long double __x, long double __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintl (long double __x) noexcept (true); extern long int __lrintl (long double __x) noexcept (true); +__extension__ +extern long long int llrintl (long double __x) noexcept (true); extern long long int __llrintl (long double __x) noexcept (true); + + + +extern long int lroundl (long double __x) noexcept (true); extern long int __lroundl (long double __x) noexcept (true); +__extension__ +extern long long int llroundl (long double __x) noexcept (true); extern long long int __llroundl (long double __x) noexcept (true); + + + +extern long double fdiml (long double __x, long double __y) noexcept (true); extern long double __fdiml (long double __x, long double __y) noexcept (true); + + + +extern long double fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + +extern long double fmal (long double __x, long double __y, long double __z) noexcept (true); extern long double __fmal (long double __x, long double __y, long double __z) noexcept (true); + + + + +extern long double roundevenl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpl (long double __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizel (long double *__cx, const long double *__x) noexcept (true); + + + + + + +extern long double fmaxmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double fmaximuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderl (const long double *__x, const long double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagl (const long double *__x, const long double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern long double getpayloadl (const long double *__x) noexcept (true); extern long double __getpayloadl (const long double *__x) noexcept (true); + + +extern int setpayloadl (long double *__x, long double __payload) noexcept (true); + + +extern int setpayloadsigl (long double *__x, long double __payload) noexcept (true); + + + + + + + +extern long double scalbl (long double __x, long double __n) noexcept (true); extern long double __scalbl (long double __x, long double __n) noexcept (true); +# 369 "/usr/include/math.h" 2 3 4 +# 419 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float32 acosf32 (_Float32 __x) noexcept (true); extern _Float32 __acosf32 (_Float32 __x) noexcept (true); + + extern _Float32 asinf32 (_Float32 __x) noexcept (true); extern _Float32 __asinf32 (_Float32 __x) noexcept (true); + + extern _Float32 atanf32 (_Float32 __x) noexcept (true); extern _Float32 __atanf32 (_Float32 __x) noexcept (true); + + extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); + + + extern _Float32 cosf32 (_Float32 __x) noexcept (true); extern _Float32 __cosf32 (_Float32 __x) noexcept (true); + + extern _Float32 sinf32 (_Float32 __x) noexcept (true); extern _Float32 __sinf32 (_Float32 __x) noexcept (true); + + extern _Float32 tanf32 (_Float32 __x) noexcept (true); extern _Float32 __tanf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 acospif32 (_Float32 __x) noexcept (true); extern _Float32 __acospif32 (_Float32 __x) noexcept (true); + +extern _Float32 asinpif32 (_Float32 __x) noexcept (true); extern _Float32 __asinpif32 (_Float32 __x) noexcept (true); + +extern _Float32 atanpif32 (_Float32 __x) noexcept (true); extern _Float32 __atanpif32 (_Float32 __x) noexcept (true); + +extern _Float32 atan2pif32 (_Float32 __y, _Float32 __x) noexcept (true); extern _Float32 __atan2pif32 (_Float32 __y, _Float32 __x) noexcept (true); + + + extern _Float32 cospif32 (_Float32 __x) noexcept (true); extern _Float32 __cospif32 (_Float32 __x) noexcept (true); + + extern _Float32 sinpif32 (_Float32 __x) noexcept (true); extern _Float32 __sinpif32 (_Float32 __x) noexcept (true); + + extern _Float32 tanpif32 (_Float32 __x) noexcept (true); extern _Float32 __tanpif32 (_Float32 __x) noexcept (true); + + + + + + extern _Float32 coshf32 (_Float32 __x) noexcept (true); extern _Float32 __coshf32 (_Float32 __x) noexcept (true); + + extern _Float32 sinhf32 (_Float32 __x) noexcept (true); extern _Float32 __sinhf32 (_Float32 __x) noexcept (true); + + extern _Float32 tanhf32 (_Float32 __x) noexcept (true); extern _Float32 __tanhf32 (_Float32 __x) noexcept (true); + + + + extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true) + ; + + + + + extern _Float32 acoshf32 (_Float32 __x) noexcept (true); extern _Float32 __acoshf32 (_Float32 __x) noexcept (true); + + extern _Float32 asinhf32 (_Float32 __x) noexcept (true); extern _Float32 __asinhf32 (_Float32 __x) noexcept (true); + + extern _Float32 atanhf32 (_Float32 __x) noexcept (true); extern _Float32 __atanhf32 (_Float32 __x) noexcept (true); + + + + + + extern _Float32 expf32 (_Float32 __x) noexcept (true); extern _Float32 __expf32 (_Float32 __x) noexcept (true); + + +extern _Float32 frexpf32 (_Float32 __x, int *__exponent) noexcept (true); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) noexcept (true); + + +extern _Float32 ldexpf32 (_Float32 __x, int __exponent) noexcept (true); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) noexcept (true); + + + extern _Float32 logf32 (_Float32 __x) noexcept (true); extern _Float32 __logf32 (_Float32 __x) noexcept (true); + + + extern _Float32 log10f32 (_Float32 __x) noexcept (true); extern _Float32 __log10f32 (_Float32 __x) noexcept (true); + + +extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true); extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float32 exp10f32 (_Float32 __x) noexcept (true); extern _Float32 __exp10f32 (_Float32 __x) noexcept (true); + + +extern _Float32 exp2m1f32 (_Float32 __x) noexcept (true); extern _Float32 __exp2m1f32 (_Float32 __x) noexcept (true); + + +extern _Float32 exp10m1f32 (_Float32 __x) noexcept (true); extern _Float32 __exp10m1f32 (_Float32 __x) noexcept (true); + + +extern _Float32 log2p1f32 (_Float32 __x) noexcept (true); extern _Float32 __log2p1f32 (_Float32 __x) noexcept (true); + + +extern _Float32 log10p1f32 (_Float32 __x) noexcept (true); extern _Float32 __log10p1f32 (_Float32 __x) noexcept (true); + + + extern _Float32 logp1f32 (_Float32 __x) noexcept (true); extern _Float32 __logp1f32 (_Float32 __x) noexcept (true); + + + + + extern _Float32 expm1f32 (_Float32 __x) noexcept (true); extern _Float32 __expm1f32 (_Float32 __x) noexcept (true); + + + extern _Float32 log1pf32 (_Float32 __x) noexcept (true); extern _Float32 __log1pf32 (_Float32 __x) noexcept (true); + + +extern _Float32 logbf32 (_Float32 __x) noexcept (true); extern _Float32 __logbf32 (_Float32 __x) noexcept (true); + + + + + extern _Float32 exp2f32 (_Float32 __x) noexcept (true); extern _Float32 __exp2f32 (_Float32 __x) noexcept (true); + + + extern _Float32 log2f32 (_Float32 __x) noexcept (true); extern _Float32 __log2f32 (_Float32 __x) noexcept (true); + + + + + + + extern _Float32 powf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) noexcept (true); + + +extern _Float32 sqrtf32 (_Float32 __x) noexcept (true); extern _Float32 __sqrtf32 (_Float32 __x) noexcept (true); + + + + extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + + + extern _Float32 cbrtf32 (_Float32 __x) noexcept (true); extern _Float32 __cbrtf32 (_Float32 __x) noexcept (true); + + + + + + +extern _Float32 ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); +# 231 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 nanf32 (const char *__tagb) noexcept (true); extern _Float32 __nanf32 (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32 j0f32 (_Float32) noexcept (true); extern _Float32 __j0f32 (_Float32) noexcept (true); +extern _Float32 j1f32 (_Float32) noexcept (true); extern _Float32 __j1f32 (_Float32) noexcept (true); +extern _Float32 jnf32 (int, _Float32) noexcept (true); extern _Float32 __jnf32 (int, _Float32) noexcept (true); +extern _Float32 y0f32 (_Float32) noexcept (true); extern _Float32 __y0f32 (_Float32) noexcept (true); +extern _Float32 y1f32 (_Float32) noexcept (true); extern _Float32 __y1f32 (_Float32) noexcept (true); +extern _Float32 ynf32 (int, _Float32) noexcept (true); extern _Float32 __ynf32 (int, _Float32) noexcept (true); + + + + + + extern _Float32 erff32 (_Float32) noexcept (true); extern _Float32 __erff32 (_Float32) noexcept (true); + extern _Float32 erfcf32 (_Float32) noexcept (true); extern _Float32 __erfcf32 (_Float32) noexcept (true); +extern _Float32 lgammaf32 (_Float32) noexcept (true); extern _Float32 __lgammaf32 (_Float32) noexcept (true); + + + + +extern _Float32 tgammaf32 (_Float32) noexcept (true); extern _Float32 __tgammaf32 (_Float32) noexcept (true); +# 285 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32 lgammaf32_r (_Float32, int *__signgamp) noexcept (true); extern _Float32 __lgammaf32_r (_Float32, int *__signgamp) noexcept (true); + + + + + + +extern _Float32 rintf32 (_Float32 __x) noexcept (true); extern _Float32 __rintf32 (_Float32 __x) noexcept (true); + + +extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + + + + +extern _Float32 nextdownf32 (_Float32 __x) noexcept (true); extern _Float32 __nextdownf32 (_Float32 __x) noexcept (true); + +extern _Float32 nextupf32 (_Float32 __x) noexcept (true); extern _Float32 __nextupf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + +extern _Float32 scalbnf32 (_Float32 __x, int __n) noexcept (true); extern _Float32 __scalbnf32 (_Float32 __x, int __n) noexcept (true); + + + +extern int ilogbf32 (_Float32 __x) noexcept (true); extern int __ilogbf32 (_Float32 __x) noexcept (true); + + + + +extern long int llogbf32 (_Float32 __x) noexcept (true); extern long int __llogbf32 (_Float32 __x) noexcept (true); + + + + +extern _Float32 scalblnf32 (_Float32 __x, long int __n) noexcept (true); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) noexcept (true); + + + +extern _Float32 nearbyintf32 (_Float32 __x) noexcept (true); extern _Float32 __nearbyintf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32 truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf32 (_Float32 __x) noexcept (true); extern long int __lrintf32 (_Float32 __x) noexcept (true); +__extension__ +extern long long int llrintf32 (_Float32 __x) noexcept (true); extern long long int __llrintf32 (_Float32 __x) noexcept (true); + + + +extern long int lroundf32 (_Float32 __x) noexcept (true); extern long int __lroundf32 (_Float32 __x) noexcept (true); +__extension__ +extern long long int llroundf32 (_Float32 __x) noexcept (true); extern long long int __llroundf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + +extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); + + + + +extern _Float32 roundevenf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) noexcept (true); + + + + + + +extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 fmaximumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float32 getpayloadf32 (const _Float32 *__x) noexcept (true); extern _Float32 __getpayloadf32 (const _Float32 *__x) noexcept (true); + + +extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) noexcept (true); + + +extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) noexcept (true); +# 420 "/usr/include/math.h" 2 3 4 +# 436 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float64 acosf64 (_Float64 __x) noexcept (true); extern _Float64 __acosf64 (_Float64 __x) noexcept (true); + + extern _Float64 asinf64 (_Float64 __x) noexcept (true); extern _Float64 __asinf64 (_Float64 __x) noexcept (true); + + extern _Float64 atanf64 (_Float64 __x) noexcept (true); extern _Float64 __atanf64 (_Float64 __x) noexcept (true); + + extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); extern _Float64 __atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); + + + extern _Float64 cosf64 (_Float64 __x) noexcept (true); extern _Float64 __cosf64 (_Float64 __x) noexcept (true); + + extern _Float64 sinf64 (_Float64 __x) noexcept (true); extern _Float64 __sinf64 (_Float64 __x) noexcept (true); + + extern _Float64 tanf64 (_Float64 __x) noexcept (true); extern _Float64 __tanf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 acospif64 (_Float64 __x) noexcept (true); extern _Float64 __acospif64 (_Float64 __x) noexcept (true); + +extern _Float64 asinpif64 (_Float64 __x) noexcept (true); extern _Float64 __asinpif64 (_Float64 __x) noexcept (true); + +extern _Float64 atanpif64 (_Float64 __x) noexcept (true); extern _Float64 __atanpif64 (_Float64 __x) noexcept (true); + +extern _Float64 atan2pif64 (_Float64 __y, _Float64 __x) noexcept (true); extern _Float64 __atan2pif64 (_Float64 __y, _Float64 __x) noexcept (true); + + + extern _Float64 cospif64 (_Float64 __x) noexcept (true); extern _Float64 __cospif64 (_Float64 __x) noexcept (true); + + extern _Float64 sinpif64 (_Float64 __x) noexcept (true); extern _Float64 __sinpif64 (_Float64 __x) noexcept (true); + + extern _Float64 tanpif64 (_Float64 __x) noexcept (true); extern _Float64 __tanpif64 (_Float64 __x) noexcept (true); + + + + + + extern _Float64 coshf64 (_Float64 __x) noexcept (true); extern _Float64 __coshf64 (_Float64 __x) noexcept (true); + + extern _Float64 sinhf64 (_Float64 __x) noexcept (true); extern _Float64 __sinhf64 (_Float64 __x) noexcept (true); + + extern _Float64 tanhf64 (_Float64 __x) noexcept (true); extern _Float64 __tanhf64 (_Float64 __x) noexcept (true); + + + + extern void sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) noexcept (true); extern void __sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) noexcept (true) + ; + + + + + extern _Float64 acoshf64 (_Float64 __x) noexcept (true); extern _Float64 __acoshf64 (_Float64 __x) noexcept (true); + + extern _Float64 asinhf64 (_Float64 __x) noexcept (true); extern _Float64 __asinhf64 (_Float64 __x) noexcept (true); + + extern _Float64 atanhf64 (_Float64 __x) noexcept (true); extern _Float64 __atanhf64 (_Float64 __x) noexcept (true); + + + + + + extern _Float64 expf64 (_Float64 __x) noexcept (true); extern _Float64 __expf64 (_Float64 __x) noexcept (true); + + +extern _Float64 frexpf64 (_Float64 __x, int *__exponent) noexcept (true); extern _Float64 __frexpf64 (_Float64 __x, int *__exponent) noexcept (true); + + +extern _Float64 ldexpf64 (_Float64 __x, int __exponent) noexcept (true); extern _Float64 __ldexpf64 (_Float64 __x, int __exponent) noexcept (true); + + + extern _Float64 logf64 (_Float64 __x) noexcept (true); extern _Float64 __logf64 (_Float64 __x) noexcept (true); + + + extern _Float64 log10f64 (_Float64 __x) noexcept (true); extern _Float64 __log10f64 (_Float64 __x) noexcept (true); + + +extern _Float64 modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true); extern _Float64 __modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float64 exp10f64 (_Float64 __x) noexcept (true); extern _Float64 __exp10f64 (_Float64 __x) noexcept (true); + + +extern _Float64 exp2m1f64 (_Float64 __x) noexcept (true); extern _Float64 __exp2m1f64 (_Float64 __x) noexcept (true); + + +extern _Float64 exp10m1f64 (_Float64 __x) noexcept (true); extern _Float64 __exp10m1f64 (_Float64 __x) noexcept (true); + + +extern _Float64 log2p1f64 (_Float64 __x) noexcept (true); extern _Float64 __log2p1f64 (_Float64 __x) noexcept (true); + + +extern _Float64 log10p1f64 (_Float64 __x) noexcept (true); extern _Float64 __log10p1f64 (_Float64 __x) noexcept (true); + + + extern _Float64 logp1f64 (_Float64 __x) noexcept (true); extern _Float64 __logp1f64 (_Float64 __x) noexcept (true); + + + + + extern _Float64 expm1f64 (_Float64 __x) noexcept (true); extern _Float64 __expm1f64 (_Float64 __x) noexcept (true); + + + extern _Float64 log1pf64 (_Float64 __x) noexcept (true); extern _Float64 __log1pf64 (_Float64 __x) noexcept (true); + + +extern _Float64 logbf64 (_Float64 __x) noexcept (true); extern _Float64 __logbf64 (_Float64 __x) noexcept (true); + + + + + extern _Float64 exp2f64 (_Float64 __x) noexcept (true); extern _Float64 __exp2f64 (_Float64 __x) noexcept (true); + + + extern _Float64 log2f64 (_Float64 __x) noexcept (true); extern _Float64 __log2f64 (_Float64 __x) noexcept (true); + + + + + + + extern _Float64 powf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __powf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float64 sqrtf64 (_Float64 __x) noexcept (true); extern _Float64 __sqrtf64 (_Float64 __x) noexcept (true); + + + + extern _Float64 hypotf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __hypotf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + + + extern _Float64 cbrtf64 (_Float64 __x) noexcept (true); extern _Float64 __cbrtf64 (_Float64 __x) noexcept (true); + + + + + + +extern _Float64 ceilf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fabsf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 floorf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmodf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __fmodf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 231 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64 nanf64 (const char *__tagb) noexcept (true); extern _Float64 __nanf64 (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64 j0f64 (_Float64) noexcept (true); extern _Float64 __j0f64 (_Float64) noexcept (true); +extern _Float64 j1f64 (_Float64) noexcept (true); extern _Float64 __j1f64 (_Float64) noexcept (true); +extern _Float64 jnf64 (int, _Float64) noexcept (true); extern _Float64 __jnf64 (int, _Float64) noexcept (true); +extern _Float64 y0f64 (_Float64) noexcept (true); extern _Float64 __y0f64 (_Float64) noexcept (true); +extern _Float64 y1f64 (_Float64) noexcept (true); extern _Float64 __y1f64 (_Float64) noexcept (true); +extern _Float64 ynf64 (int, _Float64) noexcept (true); extern _Float64 __ynf64 (int, _Float64) noexcept (true); + + + + + + extern _Float64 erff64 (_Float64) noexcept (true); extern _Float64 __erff64 (_Float64) noexcept (true); + extern _Float64 erfcf64 (_Float64) noexcept (true); extern _Float64 __erfcf64 (_Float64) noexcept (true); +extern _Float64 lgammaf64 (_Float64) noexcept (true); extern _Float64 __lgammaf64 (_Float64) noexcept (true); + + + + +extern _Float64 tgammaf64 (_Float64) noexcept (true); extern _Float64 __tgammaf64 (_Float64) noexcept (true); +# 285 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64 lgammaf64_r (_Float64, int *__signgamp) noexcept (true); extern _Float64 __lgammaf64_r (_Float64, int *__signgamp) noexcept (true); + + + + + + +extern _Float64 rintf64 (_Float64 __x) noexcept (true); extern _Float64 __rintf64 (_Float64 __x) noexcept (true); + + +extern _Float64 nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + + + + +extern _Float64 nextdownf64 (_Float64 __x) noexcept (true); extern _Float64 __nextdownf64 (_Float64 __x) noexcept (true); + +extern _Float64 nextupf64 (_Float64 __x) noexcept (true); extern _Float64 __nextupf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 remainderf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __remainderf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + +extern _Float64 scalbnf64 (_Float64 __x, int __n) noexcept (true); extern _Float64 __scalbnf64 (_Float64 __x, int __n) noexcept (true); + + + +extern int ilogbf64 (_Float64 __x) noexcept (true); extern int __ilogbf64 (_Float64 __x) noexcept (true); + + + + +extern long int llogbf64 (_Float64 __x) noexcept (true); extern long int __llogbf64 (_Float64 __x) noexcept (true); + + + + +extern _Float64 scalblnf64 (_Float64 __x, long int __n) noexcept (true); extern _Float64 __scalblnf64 (_Float64 __x, long int __n) noexcept (true); + + + +extern _Float64 nearbyintf64 (_Float64 __x) noexcept (true); extern _Float64 __nearbyintf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 roundf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64 truncf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64 remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcept (true); extern _Float64 __remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf64 (_Float64 __x) noexcept (true); extern long int __lrintf64 (_Float64 __x) noexcept (true); +__extension__ +extern long long int llrintf64 (_Float64 __x) noexcept (true); extern long long int __llrintf64 (_Float64 __x) noexcept (true); + + + +extern long int lroundf64 (_Float64 __x) noexcept (true); extern long int __lroundf64 (_Float64 __x) noexcept (true); +__extension__ +extern long long int llroundf64 (_Float64 __x) noexcept (true); extern long long int __llroundf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 fdimf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __fdimf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + +extern _Float64 fmaxf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64 fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); extern _Float64 __fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); + + + + +extern _Float64 roundevenf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef64 (_Float64 *__cx, const _Float64 *__x) noexcept (true); + + + + + + +extern _Float64 fmaxmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64 fmaximumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf64 (const _Float64 *__x, const _Float64 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf64 (const _Float64 *__x, const _Float64 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float64 getpayloadf64 (const _Float64 *__x) noexcept (true); extern _Float64 __getpayloadf64 (const _Float64 *__x) noexcept (true); + + +extern int setpayloadf64 (_Float64 *__x, _Float64 __payload) noexcept (true); + + +extern int setpayloadsigf64 (_Float64 *__x, _Float64 __payload) noexcept (true); +# 437 "/usr/include/math.h" 2 3 4 +# 450 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyf128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitf128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinff128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitef128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanf128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern int __issignalingf128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); +# 451 "/usr/include/math.h" 2 3 4 + + +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float128 acosf128 (_Float128 __x) noexcept (true); extern _Float128 __acosf128 (_Float128 __x) noexcept (true); + + extern _Float128 asinf128 (_Float128 __x) noexcept (true); extern _Float128 __asinf128 (_Float128 __x) noexcept (true); + + extern _Float128 atanf128 (_Float128 __x) noexcept (true); extern _Float128 __atanf128 (_Float128 __x) noexcept (true); + + extern _Float128 atan2f128 (_Float128 __y, _Float128 __x) noexcept (true); extern _Float128 __atan2f128 (_Float128 __y, _Float128 __x) noexcept (true); + + + extern _Float128 cosf128 (_Float128 __x) noexcept (true); extern _Float128 __cosf128 (_Float128 __x) noexcept (true); + + extern _Float128 sinf128 (_Float128 __x) noexcept (true); extern _Float128 __sinf128 (_Float128 __x) noexcept (true); + + extern _Float128 tanf128 (_Float128 __x) noexcept (true); extern _Float128 __tanf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 acospif128 (_Float128 __x) noexcept (true); extern _Float128 __acospif128 (_Float128 __x) noexcept (true); + +extern _Float128 asinpif128 (_Float128 __x) noexcept (true); extern _Float128 __asinpif128 (_Float128 __x) noexcept (true); + +extern _Float128 atanpif128 (_Float128 __x) noexcept (true); extern _Float128 __atanpif128 (_Float128 __x) noexcept (true); + +extern _Float128 atan2pif128 (_Float128 __y, _Float128 __x) noexcept (true); extern _Float128 __atan2pif128 (_Float128 __y, _Float128 __x) noexcept (true); + + + extern _Float128 cospif128 (_Float128 __x) noexcept (true); extern _Float128 __cospif128 (_Float128 __x) noexcept (true); + + extern _Float128 sinpif128 (_Float128 __x) noexcept (true); extern _Float128 __sinpif128 (_Float128 __x) noexcept (true); + + extern _Float128 tanpif128 (_Float128 __x) noexcept (true); extern _Float128 __tanpif128 (_Float128 __x) noexcept (true); + + + + + + extern _Float128 coshf128 (_Float128 __x) noexcept (true); extern _Float128 __coshf128 (_Float128 __x) noexcept (true); + + extern _Float128 sinhf128 (_Float128 __x) noexcept (true); extern _Float128 __sinhf128 (_Float128 __x) noexcept (true); + + extern _Float128 tanhf128 (_Float128 __x) noexcept (true); extern _Float128 __tanhf128 (_Float128 __x) noexcept (true); + + + + extern void sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) noexcept (true); extern void __sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) noexcept (true) + ; + + + + + extern _Float128 acoshf128 (_Float128 __x) noexcept (true); extern _Float128 __acoshf128 (_Float128 __x) noexcept (true); + + extern _Float128 asinhf128 (_Float128 __x) noexcept (true); extern _Float128 __asinhf128 (_Float128 __x) noexcept (true); + + extern _Float128 atanhf128 (_Float128 __x) noexcept (true); extern _Float128 __atanhf128 (_Float128 __x) noexcept (true); + + + + + + extern _Float128 expf128 (_Float128 __x) noexcept (true); extern _Float128 __expf128 (_Float128 __x) noexcept (true); + + +extern _Float128 frexpf128 (_Float128 __x, int *__exponent) noexcept (true); extern _Float128 __frexpf128 (_Float128 __x, int *__exponent) noexcept (true); + + +extern _Float128 ldexpf128 (_Float128 __x, int __exponent) noexcept (true); extern _Float128 __ldexpf128 (_Float128 __x, int __exponent) noexcept (true); + + + extern _Float128 logf128 (_Float128 __x) noexcept (true); extern _Float128 __logf128 (_Float128 __x) noexcept (true); + + + extern _Float128 log10f128 (_Float128 __x) noexcept (true); extern _Float128 __log10f128 (_Float128 __x) noexcept (true); + + +extern _Float128 modff128 (_Float128 __x, _Float128 *__iptr) noexcept (true); extern _Float128 __modff128 (_Float128 __x, _Float128 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float128 exp10f128 (_Float128 __x) noexcept (true); extern _Float128 __exp10f128 (_Float128 __x) noexcept (true); + + +extern _Float128 exp2m1f128 (_Float128 __x) noexcept (true); extern _Float128 __exp2m1f128 (_Float128 __x) noexcept (true); + + +extern _Float128 exp10m1f128 (_Float128 __x) noexcept (true); extern _Float128 __exp10m1f128 (_Float128 __x) noexcept (true); + + +extern _Float128 log2p1f128 (_Float128 __x) noexcept (true); extern _Float128 __log2p1f128 (_Float128 __x) noexcept (true); + + +extern _Float128 log10p1f128 (_Float128 __x) noexcept (true); extern _Float128 __log10p1f128 (_Float128 __x) noexcept (true); + + + extern _Float128 logp1f128 (_Float128 __x) noexcept (true); extern _Float128 __logp1f128 (_Float128 __x) noexcept (true); + + + + + extern _Float128 expm1f128 (_Float128 __x) noexcept (true); extern _Float128 __expm1f128 (_Float128 __x) noexcept (true); + + + extern _Float128 log1pf128 (_Float128 __x) noexcept (true); extern _Float128 __log1pf128 (_Float128 __x) noexcept (true); + + +extern _Float128 logbf128 (_Float128 __x) noexcept (true); extern _Float128 __logbf128 (_Float128 __x) noexcept (true); + + + + + extern _Float128 exp2f128 (_Float128 __x) noexcept (true); extern _Float128 __exp2f128 (_Float128 __x) noexcept (true); + + + extern _Float128 log2f128 (_Float128 __x) noexcept (true); extern _Float128 __log2f128 (_Float128 __x) noexcept (true); + + + + + + + extern _Float128 powf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __powf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float128 sqrtf128 (_Float128 __x) noexcept (true); extern _Float128 __sqrtf128 (_Float128 __x) noexcept (true); + + + + extern _Float128 hypotf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __hypotf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + + + extern _Float128 cbrtf128 (_Float128 __x) noexcept (true); extern _Float128 __cbrtf128 (_Float128 __x) noexcept (true); + + + + + + +extern _Float128 ceilf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fabsf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 floorf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmodf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __fmodf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 231 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float128 copysignf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 nanf128 (const char *__tagb) noexcept (true); extern _Float128 __nanf128 (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float128 j0f128 (_Float128) noexcept (true); extern _Float128 __j0f128 (_Float128) noexcept (true); +extern _Float128 j1f128 (_Float128) noexcept (true); extern _Float128 __j1f128 (_Float128) noexcept (true); +extern _Float128 jnf128 (int, _Float128) noexcept (true); extern _Float128 __jnf128 (int, _Float128) noexcept (true); +extern _Float128 y0f128 (_Float128) noexcept (true); extern _Float128 __y0f128 (_Float128) noexcept (true); +extern _Float128 y1f128 (_Float128) noexcept (true); extern _Float128 __y1f128 (_Float128) noexcept (true); +extern _Float128 ynf128 (int, _Float128) noexcept (true); extern _Float128 __ynf128 (int, _Float128) noexcept (true); + + + + + + extern _Float128 erff128 (_Float128) noexcept (true); extern _Float128 __erff128 (_Float128) noexcept (true); + extern _Float128 erfcf128 (_Float128) noexcept (true); extern _Float128 __erfcf128 (_Float128) noexcept (true); +extern _Float128 lgammaf128 (_Float128) noexcept (true); extern _Float128 __lgammaf128 (_Float128) noexcept (true); + + + + +extern _Float128 tgammaf128 (_Float128) noexcept (true); extern _Float128 __tgammaf128 (_Float128) noexcept (true); +# 285 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float128 lgammaf128_r (_Float128, int *__signgamp) noexcept (true); extern _Float128 __lgammaf128_r (_Float128, int *__signgamp) noexcept (true); + + + + + + +extern _Float128 rintf128 (_Float128 __x) noexcept (true); extern _Float128 __rintf128 (_Float128 __x) noexcept (true); + + +extern _Float128 nextafterf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __nextafterf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + + + + +extern _Float128 nextdownf128 (_Float128 __x) noexcept (true); extern _Float128 __nextdownf128 (_Float128 __x) noexcept (true); + +extern _Float128 nextupf128 (_Float128 __x) noexcept (true); extern _Float128 __nextupf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 remainderf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __remainderf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + +extern _Float128 scalbnf128 (_Float128 __x, int __n) noexcept (true); extern _Float128 __scalbnf128 (_Float128 __x, int __n) noexcept (true); + + + +extern int ilogbf128 (_Float128 __x) noexcept (true); extern int __ilogbf128 (_Float128 __x) noexcept (true); + + + + +extern long int llogbf128 (_Float128 __x) noexcept (true); extern long int __llogbf128 (_Float128 __x) noexcept (true); + + + + +extern _Float128 scalblnf128 (_Float128 __x, long int __n) noexcept (true); extern _Float128 __scalblnf128 (_Float128 __x, long int __n) noexcept (true); + + + +extern _Float128 nearbyintf128 (_Float128 __x) noexcept (true); extern _Float128 __nearbyintf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 roundf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float128 truncf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 remquof128 (_Float128 __x, _Float128 __y, int *__quo) noexcept (true); extern _Float128 __remquof128 (_Float128 __x, _Float128 __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf128 (_Float128 __x) noexcept (true); extern long int __lrintf128 (_Float128 __x) noexcept (true); +__extension__ +extern long long int llrintf128 (_Float128 __x) noexcept (true); extern long long int __llrintf128 (_Float128 __x) noexcept (true); + + + +extern long int lroundf128 (_Float128 __x) noexcept (true); extern long int __lroundf128 (_Float128 __x) noexcept (true); +__extension__ +extern long long int llroundf128 (_Float128 __x) noexcept (true); extern long long int __llroundf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 fdimf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __fdimf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + +extern _Float128 fmaxf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float128 fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); extern _Float128 __fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + + + +extern _Float128 roundevenf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef128 (_Float128 *__cx, const _Float128 *__x) noexcept (true); + + + + + + +extern _Float128 fmaxmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 fmaximumf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimumf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmaximum_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmaximum_magf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_magf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmaximum_mag_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_mag_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf128 (const _Float128 *__x, const _Float128 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf128 (const _Float128 *__x, const _Float128 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float128 getpayloadf128 (const _Float128 *__x) noexcept (true); extern _Float128 __getpayloadf128 (const _Float128 *__x) noexcept (true); + + +extern int setpayloadf128 (_Float128 *__x, _Float128 __payload) noexcept (true); + + +extern int setpayloadsigf128 (_Float128 *__x, _Float128 __payload) noexcept (true); +# 454 "/usr/include/math.h" 2 3 4 +# 470 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float32x acosf32x (_Float32x __x) noexcept (true); extern _Float32x __acosf32x (_Float32x __x) noexcept (true); + + extern _Float32x asinf32x (_Float32x __x) noexcept (true); extern _Float32x __asinf32x (_Float32x __x) noexcept (true); + + extern _Float32x atanf32x (_Float32x __x) noexcept (true); extern _Float32x __atanf32x (_Float32x __x) noexcept (true); + + extern _Float32x atan2f32x (_Float32x __y, _Float32x __x) noexcept (true); extern _Float32x __atan2f32x (_Float32x __y, _Float32x __x) noexcept (true); + + + extern _Float32x cosf32x (_Float32x __x) noexcept (true); extern _Float32x __cosf32x (_Float32x __x) noexcept (true); + + extern _Float32x sinf32x (_Float32x __x) noexcept (true); extern _Float32x __sinf32x (_Float32x __x) noexcept (true); + + extern _Float32x tanf32x (_Float32x __x) noexcept (true); extern _Float32x __tanf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x acospif32x (_Float32x __x) noexcept (true); extern _Float32x __acospif32x (_Float32x __x) noexcept (true); + +extern _Float32x asinpif32x (_Float32x __x) noexcept (true); extern _Float32x __asinpif32x (_Float32x __x) noexcept (true); + +extern _Float32x atanpif32x (_Float32x __x) noexcept (true); extern _Float32x __atanpif32x (_Float32x __x) noexcept (true); + +extern _Float32x atan2pif32x (_Float32x __y, _Float32x __x) noexcept (true); extern _Float32x __atan2pif32x (_Float32x __y, _Float32x __x) noexcept (true); + + + extern _Float32x cospif32x (_Float32x __x) noexcept (true); extern _Float32x __cospif32x (_Float32x __x) noexcept (true); + + extern _Float32x sinpif32x (_Float32x __x) noexcept (true); extern _Float32x __sinpif32x (_Float32x __x) noexcept (true); + + extern _Float32x tanpif32x (_Float32x __x) noexcept (true); extern _Float32x __tanpif32x (_Float32x __x) noexcept (true); + + + + + + extern _Float32x coshf32x (_Float32x __x) noexcept (true); extern _Float32x __coshf32x (_Float32x __x) noexcept (true); + + extern _Float32x sinhf32x (_Float32x __x) noexcept (true); extern _Float32x __sinhf32x (_Float32x __x) noexcept (true); + + extern _Float32x tanhf32x (_Float32x __x) noexcept (true); extern _Float32x __tanhf32x (_Float32x __x) noexcept (true); + + + + extern void sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) noexcept (true); extern void __sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) noexcept (true) + ; + + + + + extern _Float32x acoshf32x (_Float32x __x) noexcept (true); extern _Float32x __acoshf32x (_Float32x __x) noexcept (true); + + extern _Float32x asinhf32x (_Float32x __x) noexcept (true); extern _Float32x __asinhf32x (_Float32x __x) noexcept (true); + + extern _Float32x atanhf32x (_Float32x __x) noexcept (true); extern _Float32x __atanhf32x (_Float32x __x) noexcept (true); + + + + + + extern _Float32x expf32x (_Float32x __x) noexcept (true); extern _Float32x __expf32x (_Float32x __x) noexcept (true); + + +extern _Float32x frexpf32x (_Float32x __x, int *__exponent) noexcept (true); extern _Float32x __frexpf32x (_Float32x __x, int *__exponent) noexcept (true); + + +extern _Float32x ldexpf32x (_Float32x __x, int __exponent) noexcept (true); extern _Float32x __ldexpf32x (_Float32x __x, int __exponent) noexcept (true); + + + extern _Float32x logf32x (_Float32x __x) noexcept (true); extern _Float32x __logf32x (_Float32x __x) noexcept (true); + + + extern _Float32x log10f32x (_Float32x __x) noexcept (true); extern _Float32x __log10f32x (_Float32x __x) noexcept (true); + + +extern _Float32x modff32x (_Float32x __x, _Float32x *__iptr) noexcept (true); extern _Float32x __modff32x (_Float32x __x, _Float32x *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float32x exp10f32x (_Float32x __x) noexcept (true); extern _Float32x __exp10f32x (_Float32x __x) noexcept (true); + + +extern _Float32x exp2m1f32x (_Float32x __x) noexcept (true); extern _Float32x __exp2m1f32x (_Float32x __x) noexcept (true); + + +extern _Float32x exp10m1f32x (_Float32x __x) noexcept (true); extern _Float32x __exp10m1f32x (_Float32x __x) noexcept (true); + + +extern _Float32x log2p1f32x (_Float32x __x) noexcept (true); extern _Float32x __log2p1f32x (_Float32x __x) noexcept (true); + + +extern _Float32x log10p1f32x (_Float32x __x) noexcept (true); extern _Float32x __log10p1f32x (_Float32x __x) noexcept (true); + + + extern _Float32x logp1f32x (_Float32x __x) noexcept (true); extern _Float32x __logp1f32x (_Float32x __x) noexcept (true); + + + + + extern _Float32x expm1f32x (_Float32x __x) noexcept (true); extern _Float32x __expm1f32x (_Float32x __x) noexcept (true); + + + extern _Float32x log1pf32x (_Float32x __x) noexcept (true); extern _Float32x __log1pf32x (_Float32x __x) noexcept (true); + + +extern _Float32x logbf32x (_Float32x __x) noexcept (true); extern _Float32x __logbf32x (_Float32x __x) noexcept (true); + + + + + extern _Float32x exp2f32x (_Float32x __x) noexcept (true); extern _Float32x __exp2f32x (_Float32x __x) noexcept (true); + + + extern _Float32x log2f32x (_Float32x __x) noexcept (true); extern _Float32x __log2f32x (_Float32x __x) noexcept (true); + + + + + + + extern _Float32x powf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __powf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32x sqrtf32x (_Float32x __x) noexcept (true); extern _Float32x __sqrtf32x (_Float32x __x) noexcept (true); + + + + extern _Float32x hypotf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __hypotf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + + + extern _Float32x cbrtf32x (_Float32x __x) noexcept (true); extern _Float32x __cbrtf32x (_Float32x __x) noexcept (true); + + + + + + +extern _Float32x ceilf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x floorf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); +# 231 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x nanf32x (const char *__tagb) noexcept (true); extern _Float32x __nanf32x (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32x j0f32x (_Float32x) noexcept (true); extern _Float32x __j0f32x (_Float32x) noexcept (true); +extern _Float32x j1f32x (_Float32x) noexcept (true); extern _Float32x __j1f32x (_Float32x) noexcept (true); +extern _Float32x jnf32x (int, _Float32x) noexcept (true); extern _Float32x __jnf32x (int, _Float32x) noexcept (true); +extern _Float32x y0f32x (_Float32x) noexcept (true); extern _Float32x __y0f32x (_Float32x) noexcept (true); +extern _Float32x y1f32x (_Float32x) noexcept (true); extern _Float32x __y1f32x (_Float32x) noexcept (true); +extern _Float32x ynf32x (int, _Float32x) noexcept (true); extern _Float32x __ynf32x (int, _Float32x) noexcept (true); + + + + + + extern _Float32x erff32x (_Float32x) noexcept (true); extern _Float32x __erff32x (_Float32x) noexcept (true); + extern _Float32x erfcf32x (_Float32x) noexcept (true); extern _Float32x __erfcf32x (_Float32x) noexcept (true); +extern _Float32x lgammaf32x (_Float32x) noexcept (true); extern _Float32x __lgammaf32x (_Float32x) noexcept (true); + + + + +extern _Float32x tgammaf32x (_Float32x) noexcept (true); extern _Float32x __tgammaf32x (_Float32x) noexcept (true); +# 285 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32x lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true); extern _Float32x __lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true); + + + + + + +extern _Float32x rintf32x (_Float32x __x) noexcept (true); extern _Float32x __rintf32x (_Float32x __x) noexcept (true); + + +extern _Float32x nextafterf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __nextafterf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + + + + +extern _Float32x nextdownf32x (_Float32x __x) noexcept (true); extern _Float32x __nextdownf32x (_Float32x __x) noexcept (true); + +extern _Float32x nextupf32x (_Float32x __x) noexcept (true); extern _Float32x __nextupf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x remainderf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __remainderf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + +extern _Float32x scalbnf32x (_Float32x __x, int __n) noexcept (true); extern _Float32x __scalbnf32x (_Float32x __x, int __n) noexcept (true); + + + +extern int ilogbf32x (_Float32x __x) noexcept (true); extern int __ilogbf32x (_Float32x __x) noexcept (true); + + + + +extern long int llogbf32x (_Float32x __x) noexcept (true); extern long int __llogbf32x (_Float32x __x) noexcept (true); + + + + +extern _Float32x scalblnf32x (_Float32x __x, long int __n) noexcept (true); extern _Float32x __scalblnf32x (_Float32x __x, long int __n) noexcept (true); + + + +extern _Float32x nearbyintf32x (_Float32x __x) noexcept (true); extern _Float32x __nearbyintf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x roundf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32x truncf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) noexcept (true); extern _Float32x __remquof32x (_Float32x __x, _Float32x __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf32x (_Float32x __x) noexcept (true); extern long int __lrintf32x (_Float32x __x) noexcept (true); +__extension__ +extern long long int llrintf32x (_Float32x __x) noexcept (true); extern long long int __llrintf32x (_Float32x __x) noexcept (true); + + + +extern long int lroundf32x (_Float32x __x) noexcept (true); extern long int __lroundf32x (_Float32x __x) noexcept (true); +__extension__ +extern long long int llroundf32x (_Float32x __x) noexcept (true); extern long long int __llroundf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x fdimf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fdimf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + +extern _Float32x fmaxf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32x fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); extern _Float32x __fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); + + + + +extern _Float32x roundevenf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef32x (_Float32x *__cx, const _Float32x *__x) noexcept (true); + + + + + + +extern _Float32x fmaxmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x fmaximumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf32x (const _Float32x *__x, const _Float32x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf32x (const _Float32x *__x, const _Float32x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float32x getpayloadf32x (const _Float32x *__x) noexcept (true); extern _Float32x __getpayloadf32x (const _Float32x *__x) noexcept (true); + + +extern int setpayloadf32x (_Float32x *__x, _Float32x __payload) noexcept (true); + + +extern int setpayloadsigf32x (_Float32x *__x, _Float32x __payload) noexcept (true); +# 471 "/usr/include/math.h" 2 3 4 +# 487 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float64x acosf64x (_Float64x __x) noexcept (true); extern _Float64x __acosf64x (_Float64x __x) noexcept (true); + + extern _Float64x asinf64x (_Float64x __x) noexcept (true); extern _Float64x __asinf64x (_Float64x __x) noexcept (true); + + extern _Float64x atanf64x (_Float64x __x) noexcept (true); extern _Float64x __atanf64x (_Float64x __x) noexcept (true); + + extern _Float64x atan2f64x (_Float64x __y, _Float64x __x) noexcept (true); extern _Float64x __atan2f64x (_Float64x __y, _Float64x __x) noexcept (true); + + + extern _Float64x cosf64x (_Float64x __x) noexcept (true); extern _Float64x __cosf64x (_Float64x __x) noexcept (true); + + extern _Float64x sinf64x (_Float64x __x) noexcept (true); extern _Float64x __sinf64x (_Float64x __x) noexcept (true); + + extern _Float64x tanf64x (_Float64x __x) noexcept (true); extern _Float64x __tanf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x acospif64x (_Float64x __x) noexcept (true); extern _Float64x __acospif64x (_Float64x __x) noexcept (true); + +extern _Float64x asinpif64x (_Float64x __x) noexcept (true); extern _Float64x __asinpif64x (_Float64x __x) noexcept (true); + +extern _Float64x atanpif64x (_Float64x __x) noexcept (true); extern _Float64x __atanpif64x (_Float64x __x) noexcept (true); + +extern _Float64x atan2pif64x (_Float64x __y, _Float64x __x) noexcept (true); extern _Float64x __atan2pif64x (_Float64x __y, _Float64x __x) noexcept (true); + + + extern _Float64x cospif64x (_Float64x __x) noexcept (true); extern _Float64x __cospif64x (_Float64x __x) noexcept (true); + + extern _Float64x sinpif64x (_Float64x __x) noexcept (true); extern _Float64x __sinpif64x (_Float64x __x) noexcept (true); + + extern _Float64x tanpif64x (_Float64x __x) noexcept (true); extern _Float64x __tanpif64x (_Float64x __x) noexcept (true); + + + + + + extern _Float64x coshf64x (_Float64x __x) noexcept (true); extern _Float64x __coshf64x (_Float64x __x) noexcept (true); + + extern _Float64x sinhf64x (_Float64x __x) noexcept (true); extern _Float64x __sinhf64x (_Float64x __x) noexcept (true); + + extern _Float64x tanhf64x (_Float64x __x) noexcept (true); extern _Float64x __tanhf64x (_Float64x __x) noexcept (true); + + + + extern void sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) noexcept (true); extern void __sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) noexcept (true) + ; + + + + + extern _Float64x acoshf64x (_Float64x __x) noexcept (true); extern _Float64x __acoshf64x (_Float64x __x) noexcept (true); + + extern _Float64x asinhf64x (_Float64x __x) noexcept (true); extern _Float64x __asinhf64x (_Float64x __x) noexcept (true); + + extern _Float64x atanhf64x (_Float64x __x) noexcept (true); extern _Float64x __atanhf64x (_Float64x __x) noexcept (true); + + + + + + extern _Float64x expf64x (_Float64x __x) noexcept (true); extern _Float64x __expf64x (_Float64x __x) noexcept (true); + + +extern _Float64x frexpf64x (_Float64x __x, int *__exponent) noexcept (true); extern _Float64x __frexpf64x (_Float64x __x, int *__exponent) noexcept (true); + + +extern _Float64x ldexpf64x (_Float64x __x, int __exponent) noexcept (true); extern _Float64x __ldexpf64x (_Float64x __x, int __exponent) noexcept (true); + + + extern _Float64x logf64x (_Float64x __x) noexcept (true); extern _Float64x __logf64x (_Float64x __x) noexcept (true); + + + extern _Float64x log10f64x (_Float64x __x) noexcept (true); extern _Float64x __log10f64x (_Float64x __x) noexcept (true); + + +extern _Float64x modff64x (_Float64x __x, _Float64x *__iptr) noexcept (true); extern _Float64x __modff64x (_Float64x __x, _Float64x *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float64x exp10f64x (_Float64x __x) noexcept (true); extern _Float64x __exp10f64x (_Float64x __x) noexcept (true); + + +extern _Float64x exp2m1f64x (_Float64x __x) noexcept (true); extern _Float64x __exp2m1f64x (_Float64x __x) noexcept (true); + + +extern _Float64x exp10m1f64x (_Float64x __x) noexcept (true); extern _Float64x __exp10m1f64x (_Float64x __x) noexcept (true); + + +extern _Float64x log2p1f64x (_Float64x __x) noexcept (true); extern _Float64x __log2p1f64x (_Float64x __x) noexcept (true); + + +extern _Float64x log10p1f64x (_Float64x __x) noexcept (true); extern _Float64x __log10p1f64x (_Float64x __x) noexcept (true); + + + extern _Float64x logp1f64x (_Float64x __x) noexcept (true); extern _Float64x __logp1f64x (_Float64x __x) noexcept (true); + + + + + extern _Float64x expm1f64x (_Float64x __x) noexcept (true); extern _Float64x __expm1f64x (_Float64x __x) noexcept (true); + + + extern _Float64x log1pf64x (_Float64x __x) noexcept (true); extern _Float64x __log1pf64x (_Float64x __x) noexcept (true); + + +extern _Float64x logbf64x (_Float64x __x) noexcept (true); extern _Float64x __logbf64x (_Float64x __x) noexcept (true); + + + + + extern _Float64x exp2f64x (_Float64x __x) noexcept (true); extern _Float64x __exp2f64x (_Float64x __x) noexcept (true); + + + extern _Float64x log2f64x (_Float64x __x) noexcept (true); extern _Float64x __log2f64x (_Float64x __x) noexcept (true); + + + + + + + extern _Float64x powf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __powf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64x sqrtf64x (_Float64x __x) noexcept (true); extern _Float64x __sqrtf64x (_Float64x __x) noexcept (true); + + + + extern _Float64x hypotf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __hypotf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + + + extern _Float64x cbrtf64x (_Float64x __x) noexcept (true); extern _Float64x __cbrtf64x (_Float64x __x) noexcept (true); + + + + + + +extern _Float64x ceilf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x floorf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 231 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x nanf64x (const char *__tagb) noexcept (true); extern _Float64x __nanf64x (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64x j0f64x (_Float64x) noexcept (true); extern _Float64x __j0f64x (_Float64x) noexcept (true); +extern _Float64x j1f64x (_Float64x) noexcept (true); extern _Float64x __j1f64x (_Float64x) noexcept (true); +extern _Float64x jnf64x (int, _Float64x) noexcept (true); extern _Float64x __jnf64x (int, _Float64x) noexcept (true); +extern _Float64x y0f64x (_Float64x) noexcept (true); extern _Float64x __y0f64x (_Float64x) noexcept (true); +extern _Float64x y1f64x (_Float64x) noexcept (true); extern _Float64x __y1f64x (_Float64x) noexcept (true); +extern _Float64x ynf64x (int, _Float64x) noexcept (true); extern _Float64x __ynf64x (int, _Float64x) noexcept (true); + + + + + + extern _Float64x erff64x (_Float64x) noexcept (true); extern _Float64x __erff64x (_Float64x) noexcept (true); + extern _Float64x erfcf64x (_Float64x) noexcept (true); extern _Float64x __erfcf64x (_Float64x) noexcept (true); +extern _Float64x lgammaf64x (_Float64x) noexcept (true); extern _Float64x __lgammaf64x (_Float64x) noexcept (true); + + + + +extern _Float64x tgammaf64x (_Float64x) noexcept (true); extern _Float64x __tgammaf64x (_Float64x) noexcept (true); +# 285 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64x lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true); extern _Float64x __lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true); + + + + + + +extern _Float64x rintf64x (_Float64x __x) noexcept (true); extern _Float64x __rintf64x (_Float64x __x) noexcept (true); + + +extern _Float64x nextafterf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __nextafterf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + + + + +extern _Float64x nextdownf64x (_Float64x __x) noexcept (true); extern _Float64x __nextdownf64x (_Float64x __x) noexcept (true); + +extern _Float64x nextupf64x (_Float64x __x) noexcept (true); extern _Float64x __nextupf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x remainderf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __remainderf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + +extern _Float64x scalbnf64x (_Float64x __x, int __n) noexcept (true); extern _Float64x __scalbnf64x (_Float64x __x, int __n) noexcept (true); + + + +extern int ilogbf64x (_Float64x __x) noexcept (true); extern int __ilogbf64x (_Float64x __x) noexcept (true); + + + + +extern long int llogbf64x (_Float64x __x) noexcept (true); extern long int __llogbf64x (_Float64x __x) noexcept (true); + + + + +extern _Float64x scalblnf64x (_Float64x __x, long int __n) noexcept (true); extern _Float64x __scalblnf64x (_Float64x __x, long int __n) noexcept (true); + + + +extern _Float64x nearbyintf64x (_Float64x __x) noexcept (true); extern _Float64x __nearbyintf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x roundf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64x truncf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) noexcept (true); extern _Float64x __remquof64x (_Float64x __x, _Float64x __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf64x (_Float64x __x) noexcept (true); extern long int __lrintf64x (_Float64x __x) noexcept (true); +__extension__ +extern long long int llrintf64x (_Float64x __x) noexcept (true); extern long long int __llrintf64x (_Float64x __x) noexcept (true); + + + +extern long int lroundf64x (_Float64x __x) noexcept (true); extern long int __lroundf64x (_Float64x __x) noexcept (true); +__extension__ +extern long long int llroundf64x (_Float64x __x) noexcept (true); extern long long int __llroundf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x fdimf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fdimf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + +extern _Float64x fmaxf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64x fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); extern _Float64x __fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + + + +extern _Float64x roundevenf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef64x (_Float64x *__cx, const _Float64x *__x) noexcept (true); + + + + + + +extern _Float64x fmaxmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x fmaximumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf64x (const _Float64x *__x, const _Float64x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf64x (const _Float64x *__x, const _Float64x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float64x getpayloadf64x (const _Float64x *__x) noexcept (true); extern _Float64x __getpayloadf64x (const _Float64x *__x) noexcept (true); + + +extern int setpayloadf64x (_Float64x *__x, _Float64x __payload) noexcept (true); + + +extern int setpayloadsigf64x (_Float64x *__x, _Float64x __payload) noexcept (true); +# 488 "/usr/include/math.h" 2 3 4 +# 535 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern float fadd (double __x, double __y) noexcept (true); + + +extern float fdiv (double __x, double __y) noexcept (true); + + +extern float ffma (double __x, double __y, double __z) noexcept (true); + + +extern float fmul (double __x, double __y) noexcept (true); + + +extern float fsqrt (double __x) noexcept (true); + + +extern float fsub (double __x, double __y) noexcept (true); +# 536 "/usr/include/math.h" 2 3 4 +# 556 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern float faddl (long double __x, long double __y) noexcept (true); + + +extern float fdivl (long double __x, long double __y) noexcept (true); + + +extern float ffmal (long double __x, long double __y, long double __z) noexcept (true); + + +extern float fmull (long double __x, long double __y) noexcept (true); + + +extern float fsqrtl (long double __x) noexcept (true); + + +extern float fsubl (long double __x, long double __y) noexcept (true); +# 557 "/usr/include/math.h" 2 3 4 +# 585 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern double daddl (long double __x, long double __y) noexcept (true); + + +extern double ddivl (long double __x, long double __y) noexcept (true); + + +extern double dfmal (long double __x, long double __y, long double __z) noexcept (true); + + +extern double dmull (long double __x, long double __y) noexcept (true); + + +extern double dsqrtl (long double __x) noexcept (true); + + +extern double dsubl (long double __x, long double __y) noexcept (true); +# 586 "/usr/include/math.h" 2 3 4 +# 666 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32divf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); + + +extern _Float32 f32mulf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32sqrtf32x (_Float32x __x) noexcept (true); + + +extern _Float32 f32subf32x (_Float32x __x, _Float32x __y) noexcept (true); +# 667 "/usr/include/math.h" 2 3 4 +# 676 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32divf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); + + +extern _Float32 f32mulf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32sqrtf64 (_Float64 __x) noexcept (true); + + +extern _Float32 f32subf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 677 "/usr/include/math.h" 2 3 4 +# 686 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32divf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + +extern _Float32 f32mulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32sqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float32 f32subf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 687 "/usr/include/math.h" 2 3 4 +# 696 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32divf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float32 f32mulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32sqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float32 f32subf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 697 "/usr/include/math.h" 2 3 4 +# 716 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xdivf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xfmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); + + +extern _Float32x f32xmulf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xsqrtf64 (_Float64 __x) noexcept (true); + + +extern _Float32x f32xsubf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 717 "/usr/include/math.h" 2 3 4 +# 726 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xdivf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xfmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + +extern _Float32x f32xmulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xsqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float32x f32xsubf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 727 "/usr/include/math.h" 2 3 4 +# 736 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xdivf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xfmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float32x f32xmulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xsqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float32x f32xsubf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 737 "/usr/include/math.h" 2 3 4 +# 756 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float64 f64addf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64divf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + +extern _Float64 f64mulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64sqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float64 f64subf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 757 "/usr/include/math.h" 2 3 4 +# 766 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float64 f64addf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64divf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float64 f64mulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64sqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float64 f64subf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 767 "/usr/include/math.h" 2 3 4 +# 786 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float64x f64xaddf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xdivf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xfmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float64x f64xmulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xsqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float64x f64xsubf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 787 "/usr/include/math.h" 2 3 4 +# 823 "/usr/include/math.h" 3 4 +extern int signgam; +# 903 "/usr/include/math.h" 3 4 +enum + { + FP_NAN = + + 0, + FP_INFINITE = + + 1, + FP_ZERO = + + 2, + FP_SUBNORMAL = + + 3, + FP_NORMAL = + + 4 + }; +# 1024 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/iscanonical.h" 1 3 4 +# 23 "/usr/include/bits/iscanonical.h" 3 4 +extern int __iscanonicall (long double __x) + noexcept (true) __attribute__ ((__const__)); +# 46 "/usr/include/bits/iscanonical.h" 3 4 +extern "C++" { +inline int iscanonical (float __val) { return ((void) (__typeof (__val)) (__val), 1); } +inline int iscanonical (double __val) { return ((void) (__typeof (__val)) (__val), 1); } +inline int iscanonical (long double __val) { return __iscanonicall (__val); } + +inline int iscanonical (_Float128 __val) { return ((void) (__typeof (__val)) (__val), 1); } + +} +# 1025 "/usr/include/math.h" 2 3 4 +# 1036 "/usr/include/math.h" 3 4 +extern "C++" { +inline int issignaling (float __val) { return __issignalingf (__val); } +inline int issignaling (double __val) { return __issignaling (__val); } +inline int +issignaling (long double __val) +{ + + + + return __issignalingl (__val); + +} + + + +inline int issignaling (_Float128 __val) { return __issignalingf128 (__val); } + +} +# 1067 "/usr/include/math.h" 3 4 +extern "C++" { +# 1098 "/usr/include/math.h" 3 4 +template inline bool +iszero (__T __val) +{ + return __val == 0; +} + +} +# 1333 "/usr/include/math.h" 3 4 +extern "C++" { +template struct __iseqsig_type; + +template<> struct __iseqsig_type +{ + static int __call (float __x, float __y) throw () + { + return __iseqsigf (__x, __y); + } +}; + +template<> struct __iseqsig_type +{ + static int __call (double __x, double __y) throw () + { + return __iseqsig (__x, __y); + } +}; + +template<> struct __iseqsig_type +{ + static int __call (long double __x, long double __y) throw () + { + + return __iseqsigl (__x, __y); + + + + } +}; + + +template<> struct __iseqsig_type<_Float32> +{ + static int __call (_Float32 __x, _Float32 __y) throw () + { + return __iseqsigf (__x, __y); + } +}; + + + +template<> struct __iseqsig_type<_Float64> +{ + static int __call (_Float64 __x, _Float64 __y) throw () + { + return __iseqsig (__x, __y); + } +}; + + + + + +template<> struct __iseqsig_type<_Float128> +{ + static int __call (_Float128 __x, _Float128 __y) throw () + { + + return __iseqsigf128 (__x, __y); + + + + } +}; + + + +template<> struct __iseqsig_type<_Float32x> +{ + static int __call (_Float32x __x, _Float32x __y) throw () + { + return __iseqsig (__x, __y); + } +}; + + + +template<> struct __iseqsig_type<_Float64x> +{ + static int __call (_Float64x __x, _Float64x __y) throw () + { + + return __iseqsigl (__x, __y); + + + + } +}; + + +template +inline int +iseqsig (_T1 __x, _T2 __y) throw () +{ + + typedef decltype (((__x) + (__y) + 0.0f)) _T3; + + + + return __iseqsig_type<_T3>::__call (__x, __y); +} + +} + + + + +} +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 +# 56 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 +# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::acos; + + + inline constexpr float + acos(float __x) + { return __builtin_acosf(__x); } + + inline constexpr long double + acos(long double __x) + { return __builtin_acosl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acos(_Tp __x) + { return __builtin_acos(__x); } + + using ::asin; + + + inline constexpr float + asin(float __x) + { return __builtin_asinf(__x); } + + inline constexpr long double + asin(long double __x) + { return __builtin_asinl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asin(_Tp __x) + { return __builtin_asin(__x); } + + using ::atan; + + + inline constexpr float + atan(float __x) + { return __builtin_atanf(__x); } + + inline constexpr long double + atan(long double __x) + { return __builtin_atanl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atan(_Tp __x) + { return __builtin_atan(__x); } + + using ::atan2; + + + inline constexpr float + atan2(float __y, float __x) + { return __builtin_atan2f(__y, __x); } + + inline constexpr long double + atan2(long double __y, long double __x) + { return __builtin_atan2l(__y, __x); } + + + using ::ceil; + + + inline constexpr float + ceil(float __x) + { return __builtin_ceilf(__x); } + + inline constexpr long double + ceil(long double __x) + { return __builtin_ceill(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ceil(_Tp __x) + { return __builtin_ceil(__x); } + + using ::cos; + + + inline constexpr float + cos(float __x) + { return __builtin_cosf(__x); } + + inline constexpr long double + cos(long double __x) + { return __builtin_cosl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cos(_Tp __x) + { return __builtin_cos(__x); } + + using ::cosh; + + + inline constexpr float + cosh(float __x) + { return __builtin_coshf(__x); } + + inline constexpr long double + cosh(long double __x) + { return __builtin_coshl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cosh(_Tp __x) + { return __builtin_cosh(__x); } + + using ::exp; + + + inline constexpr float + exp(float __x) + { return __builtin_expf(__x); } + + inline constexpr long double + exp(long double __x) + { return __builtin_expl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp(_Tp __x) + { return __builtin_exp(__x); } + + using ::fabs; + + + inline constexpr float + fabs(float __x) + { return __builtin_fabsf(__x); } + + inline constexpr long double + fabs(long double __x) + { return __builtin_fabsl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + fabs(_Tp __x) + { return __builtin_fabs(__x); } + + using ::floor; + + + inline constexpr float + floor(float __x) + { return __builtin_floorf(__x); } + + inline constexpr long double + floor(long double __x) + { return __builtin_floorl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + floor(_Tp __x) + { return __builtin_floor(__x); } + + using ::fmod; + + + inline constexpr float + fmod(float __x, float __y) + { return __builtin_fmodf(__x, __y); } + + inline constexpr long double + fmod(long double __x, long double __y) + { return __builtin_fmodl(__x, __y); } + + + using ::frexp; + + + inline float + frexp(float __x, int* __exp) + { return __builtin_frexpf(__x, __exp); } + + inline long double + frexp(long double __x, int* __exp) + { return __builtin_frexpl(__x, __exp); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + frexp(_Tp __x, int* __exp) + { return __builtin_frexp(__x, __exp); } + + using ::ldexp; + + + inline constexpr float + ldexp(float __x, int __exp) + { return __builtin_ldexpf(__x, __exp); } + + inline constexpr long double + ldexp(long double __x, int __exp) + { return __builtin_ldexpl(__x, __exp); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ldexp(_Tp __x, int __exp) + { return __builtin_ldexp(__x, __exp); } + + using ::log; + + + inline constexpr float + log(float __x) + { return __builtin_logf(__x); } + + inline constexpr long double + log(long double __x) + { return __builtin_logl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log(_Tp __x) + { return __builtin_log(__x); } + + using ::log10; + + + inline constexpr float + log10(float __x) + { return __builtin_log10f(__x); } + + inline constexpr long double + log10(long double __x) + { return __builtin_log10l(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log10(_Tp __x) + { return __builtin_log10(__x); } + + using ::modf; + + + inline float + modf(float __x, float* __iptr) + { return __builtin_modff(__x, __iptr); } + + inline long double + modf(long double __x, long double* __iptr) + { return __builtin_modfl(__x, __iptr); } + + + using ::pow; + + + inline constexpr float + pow(float __x, float __y) + { return __builtin_powf(__x, __y); } + + inline constexpr long double + pow(long double __x, long double __y) + { return __builtin_powl(__x, __y); } +# 400 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + using ::sin; + + + inline constexpr float + sin(float __x) + { return __builtin_sinf(__x); } + + inline constexpr long double + sin(long double __x) + { return __builtin_sinl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sin(_Tp __x) + { return __builtin_sin(__x); } + + using ::sinh; + + + inline constexpr float + sinh(float __x) + { return __builtin_sinhf(__x); } + + inline constexpr long double + sinh(long double __x) + { return __builtin_sinhl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sinh(_Tp __x) + { return __builtin_sinh(__x); } + + using ::sqrt; + + + inline constexpr float + sqrt(float __x) + { return __builtin_sqrtf(__x); } + + inline constexpr long double + sqrt(long double __x) + { return __builtin_sqrtl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sqrt(_Tp __x) + { return __builtin_sqrt(__x); } + + using ::tan; + + + inline constexpr float + tan(float __x) + { return __builtin_tanf(__x); } + + inline constexpr long double + tan(long double __x) + { return __builtin_tanl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tan(_Tp __x) + { return __builtin_tan(__x); } + + using ::tanh; + + + inline constexpr float + tanh(float __x) + { return __builtin_tanhf(__x); } + + inline constexpr long double + tanh(long double __x) + { return __builtin_tanhl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tanh(_Tp __x) + { return __builtin_tanh(__x); } +# 1053 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + atan2(_Tp __y, _Up __x) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return atan2(__type(__y), __type(__x)); + } + + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmod(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmod(__type(__x), __type(__y)); + } + + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + pow(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return pow(__type(__x), __type(__y)); + } +# 1100 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + constexpr int + fpclassify(float __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + constexpr int + fpclassify(double __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + constexpr int + fpclassify(long double __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + int>::__type + fpclassify(_Tp __x) + { return __x != 0 ? 4 : 2; } + + + + constexpr bool + isfinite(float __x) + { return __builtin_isfinite(__x); } + + constexpr bool + isfinite(double __x) + { return __builtin_isfinite(__x); } + + constexpr bool + isfinite(long double __x) + { return __builtin_isfinite(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isfinite(_Tp) + { return true; } + + + + constexpr bool + isinf(float __x) + { return __builtin_isinf(__x); } + + + + + + constexpr bool + isinf(double __x) + { return __builtin_isinf(__x); } + + + constexpr bool + isinf(long double __x) + { return __builtin_isinf(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isinf(_Tp) + { return false; } + + + + constexpr bool + isnan(float __x) + { return __builtin_isnan(__x); } + + + + + + constexpr bool + isnan(double __x) + { return __builtin_isnan(__x); } + + + constexpr bool + isnan(long double __x) + { return __builtin_isnan(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isnan(_Tp) + { return false; } + + + + constexpr bool + isnormal(float __x) + { return __builtin_isnormal(__x); } + + constexpr bool + isnormal(double __x) + { return __builtin_isnormal(__x); } + + constexpr bool + isnormal(long double __x) + { return __builtin_isnormal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isnormal(_Tp __x) + { return __x != 0 ? true : false; } + + + + + constexpr bool + signbit(float __x) + { return __builtin_signbit(__x); } + + constexpr bool + signbit(double __x) + { return __builtin_signbit(__x); } + + constexpr bool + signbit(long double __x) + { return __builtin_signbit(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + signbit(_Tp __x) + { return __x < 0 ? true : false; } + + + + constexpr bool + isgreater(float __x, float __y) + { return __builtin_isgreater(__x, __y); } + + constexpr bool + isgreater(double __x, double __y) + { return __builtin_isgreater(__x, __y); } + + constexpr bool + isgreater(long double __x, long double __y) + { return __builtin_isgreater(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isgreater(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isgreater(__type(__x), __type(__y)); + } + + + + constexpr bool + isgreaterequal(float __x, float __y) + { return __builtin_isgreaterequal(__x, __y); } + + constexpr bool + isgreaterequal(double __x, double __y) + { return __builtin_isgreaterequal(__x, __y); } + + constexpr bool + isgreaterequal(long double __x, long double __y) + { return __builtin_isgreaterequal(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isgreaterequal(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isgreaterequal(__type(__x), __type(__y)); + } + + + + constexpr bool + isless(float __x, float __y) + { return __builtin_isless(__x, __y); } + + constexpr bool + isless(double __x, double __y) + { return __builtin_isless(__x, __y); } + + constexpr bool + isless(long double __x, long double __y) + { return __builtin_isless(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isless(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isless(__type(__x), __type(__y)); + } + + + + constexpr bool + islessequal(float __x, float __y) + { return __builtin_islessequal(__x, __y); } + + constexpr bool + islessequal(double __x, double __y) + { return __builtin_islessequal(__x, __y); } + + constexpr bool + islessequal(long double __x, long double __y) + { return __builtin_islessequal(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + islessequal(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_islessequal(__type(__x), __type(__y)); + } + + + + constexpr bool + islessgreater(float __x, float __y) + { return __builtin_islessgreater(__x, __y); } + + constexpr bool + islessgreater(double __x, double __y) + { return __builtin_islessgreater(__x, __y); } + + constexpr bool + islessgreater(long double __x, long double __y) + { return __builtin_islessgreater(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + islessgreater(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_islessgreater(__type(__x), __type(__y)); + } + + + + constexpr bool + isunordered(float __x, float __y) + { return __builtin_isunordered(__x, __y); } + + constexpr bool + isunordered(double __x, double __y) + { return __builtin_isunordered(__x, __y); } + + constexpr bool + isunordered(long double __x, long double __y) + { return __builtin_isunordered(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isunordered(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isunordered(__type(__x), __type(__y)); + } +# 1820 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + using ::acosf; + + + using ::acosl; + + + + using ::asinf; + + + using ::asinl; + + + + using ::atanf; + + + using ::atanl; + + + + using ::atan2f; + + + using ::atan2l; + + + + using ::ceilf; + + + using ::ceill; + + + + using ::cosf; + + + using ::cosl; + + + + using ::coshf; + + + using ::coshl; + + + + using ::expf; + + + using ::expl; + + + + using ::fabsf; + + + using ::fabsl; + + + + using ::floorf; + + + using ::floorl; + + + + using ::fmodf; + + + using ::fmodl; + + + + using ::frexpf; + + + using ::frexpl; + + + + using ::ldexpf; + + + using ::ldexpl; + + + + using ::logf; + + + using ::logl; + + + + using ::log10f; + + + using ::log10l; + + + + using ::modff; + + + using ::modfl; + + + + using ::powf; + + + using ::powl; + + + + using ::sinf; + + + using ::sinl; + + + + using ::sinhf; + + + using ::sinhl; + + + + using ::sqrtf; + + + using ::sqrtl; + + + + using ::tanf; + + + using ::tanl; + + + + using ::tanhf; + + + using ::tanhl; +# 2085 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + using ::double_t; + using ::float_t; + + + + using ::acosh; + using ::acoshf; + using ::acoshl; + + using ::asinh; + using ::asinhf; + using ::asinhl; + + using ::atanh; + using ::atanhf; + using ::atanhl; + + using ::cbrt; + using ::cbrtf; + using ::cbrtl; + + using ::copysign; + using ::copysignf; + using ::copysignl; + + using ::erf; + using ::erff; + using ::erfl; + + using ::erfc; + using ::erfcf; + using ::erfcl; + + using ::exp2; + using ::exp2f; + using ::exp2l; + + using ::expm1; + using ::expm1f; + using ::expm1l; + + using ::fdim; + using ::fdimf; + using ::fdiml; + + using ::fma; + using ::fmaf; + using ::fmal; + + using ::fmax; + using ::fmaxf; + using ::fmaxl; + + using ::fmin; + using ::fminf; + using ::fminl; + + using ::hypot; + using ::hypotf; + using ::hypotl; + + using ::ilogb; + using ::ilogbf; + using ::ilogbl; + + using ::lgamma; + using ::lgammaf; + using ::lgammal; + + + using ::llrint; + using ::llrintf; + using ::llrintl; + + using ::llround; + using ::llroundf; + using ::llroundl; + + + using ::log1p; + using ::log1pf; + using ::log1pl; + + using ::log2; + using ::log2f; + using ::log2l; + + using ::logb; + using ::logbf; + using ::logbl; + + using ::lrint; + using ::lrintf; + using ::lrintl; + + using ::lround; + using ::lroundf; + using ::lroundl; + + using ::nan; + using ::nanf; + using ::nanl; + + using ::nearbyint; + using ::nearbyintf; + using ::nearbyintl; + + using ::nextafter; + using ::nextafterf; + using ::nextafterl; + + using ::nexttoward; + using ::nexttowardf; + using ::nexttowardl; + + using ::remainder; + using ::remainderf; + using ::remainderl; + + using ::remquo; + using ::remquof; + using ::remquol; + + using ::rint; + using ::rintf; + using ::rintl; + + using ::round; + using ::roundf; + using ::roundl; + + using ::scalbln; + using ::scalblnf; + using ::scalblnl; + + using ::scalbn; + using ::scalbnf; + using ::scalbnl; + + using ::tgamma; + using ::tgammaf; + using ::tgammal; + + using ::trunc; + using ::truncf; + using ::truncl; + + + + constexpr float + acosh(float __x) + { return __builtin_acoshf(__x); } + + constexpr long double + acosh(long double __x) + { return __builtin_acoshl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acosh(_Tp __x) + { return __builtin_acosh(__x); } + + + + constexpr float + asinh(float __x) + { return __builtin_asinhf(__x); } + + constexpr long double + asinh(long double __x) + { return __builtin_asinhl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asinh(_Tp __x) + { return __builtin_asinh(__x); } + + + + constexpr float + atanh(float __x) + { return __builtin_atanhf(__x); } + + constexpr long double + atanh(long double __x) + { return __builtin_atanhl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atanh(_Tp __x) + { return __builtin_atanh(__x); } + + + + constexpr float + cbrt(float __x) + { return __builtin_cbrtf(__x); } + + constexpr long double + cbrt(long double __x) + { return __builtin_cbrtl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cbrt(_Tp __x) + { return __builtin_cbrt(__x); } + + + + constexpr float + copysign(float __x, float __y) + { return __builtin_copysignf(__x, __y); } + + constexpr long double + copysign(long double __x, long double __y) + { return __builtin_copysignl(__x, __y); } + + + + constexpr float + erf(float __x) + { return __builtin_erff(__x); } + + constexpr long double + erf(long double __x) + { return __builtin_erfl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erf(_Tp __x) + { return __builtin_erf(__x); } + + + + constexpr float + erfc(float __x) + { return __builtin_erfcf(__x); } + + constexpr long double + erfc(long double __x) + { return __builtin_erfcl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erfc(_Tp __x) + { return __builtin_erfc(__x); } + + + + constexpr float + exp2(float __x) + { return __builtin_exp2f(__x); } + + constexpr long double + exp2(long double __x) + { return __builtin_exp2l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp2(_Tp __x) + { return __builtin_exp2(__x); } + + + + constexpr float + expm1(float __x) + { return __builtin_expm1f(__x); } + + constexpr long double + expm1(long double __x) + { return __builtin_expm1l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + expm1(_Tp __x) + { return __builtin_expm1(__x); } + + + + constexpr float + fdim(float __x, float __y) + { return __builtin_fdimf(__x, __y); } + + constexpr long double + fdim(long double __x, long double __y) + { return __builtin_fdiml(__x, __y); } + + + + constexpr float + fma(float __x, float __y, float __z) + { return __builtin_fmaf(__x, __y, __z); } + + constexpr long double + fma(long double __x, long double __y, long double __z) + { return __builtin_fmal(__x, __y, __z); } + + + + constexpr float + fmax(float __x, float __y) + { return __builtin_fmaxf(__x, __y); } + + constexpr long double + fmax(long double __x, long double __y) + { return __builtin_fmaxl(__x, __y); } + + + + constexpr float + fmin(float __x, float __y) + { return __builtin_fminf(__x, __y); } + + constexpr long double + fmin(long double __x, long double __y) + { return __builtin_fminl(__x, __y); } + + + + constexpr float + hypot(float __x, float __y) + { return __builtin_hypotf(__x, __y); } + + constexpr long double + hypot(long double __x, long double __y) + { return __builtin_hypotl(__x, __y); } + + + + constexpr int + ilogb(float __x) + { return __builtin_ilogbf(__x); } + + constexpr int + ilogb(long double __x) + { return __builtin_ilogbl(__x); } + + + + template + constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + int>::__type + ilogb(_Tp __x) + { return __builtin_ilogb(__x); } + + + + constexpr float + lgamma(float __x) + { return __builtin_lgammaf(__x); } + + constexpr long double + lgamma(long double __x) + { return __builtin_lgammal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + lgamma(_Tp __x) + { return __builtin_lgamma(__x); } + + + + constexpr long long + llrint(float __x) + { return __builtin_llrintf(__x); } + + constexpr long long + llrint(long double __x) + { return __builtin_llrintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llrint(_Tp __x) + { return __builtin_llrint(__x); } + + + + constexpr long long + llround(float __x) + { return __builtin_llroundf(__x); } + + constexpr long long + llround(long double __x) + { return __builtin_llroundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llround(_Tp __x) + { return __builtin_llround(__x); } + + + + constexpr float + log1p(float __x) + { return __builtin_log1pf(__x); } + + constexpr long double + log1p(long double __x) + { return __builtin_log1pl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log1p(_Tp __x) + { return __builtin_log1p(__x); } + + + + + constexpr float + log2(float __x) + { return __builtin_log2f(__x); } + + constexpr long double + log2(long double __x) + { return __builtin_log2l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log2(_Tp __x) + { return __builtin_log2(__x); } + + + + constexpr float + logb(float __x) + { return __builtin_logbf(__x); } + + constexpr long double + logb(long double __x) + { return __builtin_logbl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + logb(_Tp __x) + { return __builtin_logb(__x); } + + + + constexpr long + lrint(float __x) + { return __builtin_lrintf(__x); } + + constexpr long + lrint(long double __x) + { return __builtin_lrintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lrint(_Tp __x) + { return __builtin_lrint(__x); } + + + + constexpr long + lround(float __x) + { return __builtin_lroundf(__x); } + + constexpr long + lround(long double __x) + { return __builtin_lroundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lround(_Tp __x) + { return __builtin_lround(__x); } + + + + constexpr float + nearbyint(float __x) + { return __builtin_nearbyintf(__x); } + + constexpr long double + nearbyint(long double __x) + { return __builtin_nearbyintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nearbyint(_Tp __x) + { return __builtin_nearbyint(__x); } + + + + constexpr float + nextafter(float __x, float __y) + { return __builtin_nextafterf(__x, __y); } + + constexpr long double + nextafter(long double __x, long double __y) + { return __builtin_nextafterl(__x, __y); } + + + + constexpr float + nexttoward(float __x, long double __y) + { return __builtin_nexttowardf(__x, __y); } + + constexpr long double + nexttoward(long double __x, long double __y) + { return __builtin_nexttowardl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nexttoward(_Tp __x, long double __y) + { return __builtin_nexttoward(__x, __y); } + + + + constexpr float + remainder(float __x, float __y) + { return __builtin_remainderf(__x, __y); } + + constexpr long double + remainder(long double __x, long double __y) + { return __builtin_remainderl(__x, __y); } + + + + inline float + remquo(float __x, float __y, int* __pquo) + { return __builtin_remquof(__x, __y, __pquo); } + + inline long double + remquo(long double __x, long double __y, int* __pquo) + { return __builtin_remquol(__x, __y, __pquo); } + + + + constexpr float + rint(float __x) + { return __builtin_rintf(__x); } + + constexpr long double + rint(long double __x) + { return __builtin_rintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + rint(_Tp __x) + { return __builtin_rint(__x); } + + + + constexpr float + round(float __x) + { return __builtin_roundf(__x); } + + constexpr long double + round(long double __x) + { return __builtin_roundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + round(_Tp __x) + { return __builtin_round(__x); } + + + + constexpr float + scalbln(float __x, long __ex) + { return __builtin_scalblnf(__x, __ex); } + + constexpr long double + scalbln(long double __x, long __ex) + { return __builtin_scalblnl(__x, __ex); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbln(_Tp __x, long __ex) + { return __builtin_scalbln(__x, __ex); } + + + + constexpr float + scalbn(float __x, int __ex) + { return __builtin_scalbnf(__x, __ex); } + + constexpr long double + scalbn(long double __x, int __ex) + { return __builtin_scalbnl(__x, __ex); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbn(_Tp __x, int __ex) + { return __builtin_scalbn(__x, __ex); } + + + + constexpr float + tgamma(float __x) + { return __builtin_tgammaf(__x); } + + constexpr long double + tgamma(long double __x) + { return __builtin_tgammal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tgamma(_Tp __x) + { return __builtin_tgamma(__x); } + + + + constexpr float + trunc(float __x) + { return __builtin_truncf(__x); } + + constexpr long double + trunc(long double __x) + { return __builtin_truncl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + trunc(_Tp __x) + { return __builtin_trunc(__x); } +# 3682 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + copysign(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return copysign(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fdim(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fdim(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmax(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmax(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmin(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmin(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + hypot(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return hypot(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + nextafter(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return nextafter(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remainder(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remainder(__type(__x), __type(__y)); + } + + template + inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remquo(_Tp __x, _Up __y, int* __pquo) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remquo(__type(__x), __type(__y), __pquo); + } + + template + constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type + fma(_Tp __x, _Up __y, _Vp __z) + { + typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; + return fma(__type(__x), __type(__y), __type(__z)); + } + + + + + + + + template + inline _Tp + __hypot3(_Tp __x, _Tp __y, _Tp __z) + { + __x = std::abs(__x); + __y = std::abs(__y); + __z = std::abs(__z); + if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x) + return __a * std::sqrt((__x / __a) * (__x / __a) + + (__y / __a) * (__y / __a) + + (__z / __a) * (__z / __a)); + else + return {}; + } + + inline float + hypot(float __x, float __y, float __z) + { return std::__hypot3(__x, __y, __z); } + + inline double + hypot(double __x, double __y, double __z) + { return std::__hypot3(__x, __y, __z); } + + inline long double + hypot(long double __x, long double __y, long double __z) + { return std::__hypot3(__x, __y, __z); } + + template + __gnu_cxx::__promoted_t<_Tp, _Up, _Vp> + hypot(_Tp __x, _Up __y, _Vp __z) + { + using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>; + return std::__hypot3<__type>(__x, __y, __z); + } +# 3902 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + +} + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 1 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 1 3 +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h" 1 3 +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/exception_defines.h" 1 3 +# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + void + __throw_bad_exception(void) __attribute__((__noreturn__)); + + + void + __throw_bad_alloc(void) __attribute__((__noreturn__)); + + void + __throw_bad_array_new_length(void) __attribute__((__noreturn__)); + + + void + __throw_bad_cast(void) __attribute__((__noreturn__,__cold__)); + + void + __throw_bad_typeid(void) __attribute__((__noreturn__,__cold__)); + + + void + __throw_logic_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_domain_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_invalid_argument(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_length_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_out_of_range(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__,__cold__)) + __attribute__((__format__(__gnu_printf__, 1, 2))); + + void + __throw_runtime_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_range_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_overflow_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_underflow_error(const char*) __attribute__((__noreturn__,__cold__)); + + + void + __throw_ios_failure(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_ios_failure(const char*, int) __attribute__((__noreturn__,__cold__)); + + + void + __throw_system_error(int) __attribute__((__noreturn__,__cold__)); + + + void + __throw_future_error(int) __attribute__((__noreturn__,__cold__)); + + + void + __throw_bad_function_call() __attribute__((__noreturn__,__cold__)); +# 140 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h" 3 + +} +# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + template + struct __is_integer_nonstrict + : public std::__is_integer<_Tp> + { + using std::__is_integer<_Tp>::__value; + + + enum { __width = __value ? sizeof(_Tp) * 8 : 0 }; + }; + + template + struct __numeric_traits_integer + { + + static_assert(__is_integer_nonstrict<_Value>::__value, + "invalid specialization"); + + + + + static const bool __is_signed = (_Value)(-1) < 0; + static const int __digits + = __is_integer_nonstrict<_Value>::__width - __is_signed; + + + static const _Value __max = __is_signed + ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1) + : ~(_Value)0; + static const _Value __min = __is_signed ? -__max - 1 : (_Value)0; + }; + + template + const _Value __numeric_traits_integer<_Value>::__min; + + template + const _Value __numeric_traits_integer<_Value>::__max; + + template + const bool __numeric_traits_integer<_Value>::__is_signed; + + template + const int __numeric_traits_integer<_Value>::__digits; +# 137 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + template + using __int_traits = __numeric_traits_integer<_Tp>; +# 157 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + template + struct __numeric_traits_floating + { + + static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136); + + + static const bool __is_signed = true; + static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18); + static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932); + }; + + template + const int __numeric_traits_floating<_Value>::__max_digits10; + + template + const bool __numeric_traits_floating<_Value>::__is_signed; + + template + const int __numeric_traits_floating<_Value>::__digits10; + + template + const int __numeric_traits_floating<_Value>::__max_exponent10; + + + + + + + template + struct __numeric_traits + : public __numeric_traits_integer<_Value> + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; +# 238 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + +} +# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 1 3 +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + class reference_wrapper; +# 86 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct integral_constant + { + static constexpr _Tp value = __v; + using value_type = _Tp; + using type = integral_constant<_Tp, __v>; + constexpr operator value_type() const noexcept { return value; } + + + constexpr value_type operator()() const noexcept { return value; } + + }; +# 106 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + using __bool_constant = integral_constant; + + + + using true_type = __bool_constant; + + + using false_type = __bool_constant; + + + + + template + using bool_constant = __bool_constant<__v>; + + + + + + + template + struct enable_if + { }; + + + template + struct enable_if + { using type = _Tp; }; + + + template + using __enable_if_t = typename enable_if<_Cond, _Tp>::type; + + template + struct __conditional + { + template + using type = _Tp; + }; + + template<> + struct __conditional + { + template + using type = _Up; + }; + + + template + using __conditional_t + = typename __conditional<_Cond>::template type<_If, _Else>; + + + template + struct __type_identity + { using type = _Type; }; + + template + using __type_identity_t = typename __type_identity<_Tp>::type; + + namespace __detail + { + + template + using __first_t = _Tp; + + + template + auto __or_fn(int) -> __first_t...>; + + template + auto __or_fn(...) -> true_type; + + template + auto __and_fn(int) -> __first_t...>; + + template + auto __and_fn(...) -> false_type; + } + + + + + template + struct __or_ + : decltype(__detail::__or_fn<_Bn...>(0)) + { }; + + template + struct __and_ + : decltype(__detail::__and_fn<_Bn...>(0)) + { }; + + template + struct __not_ + : __bool_constant + { }; + + + + + + template + inline constexpr bool __or_v = __or_<_Bn...>::value; + template + inline constexpr bool __and_v = __and_<_Bn...>::value; + + namespace __detail + { + template + struct __disjunction_impl + { using type = _B1; }; + + template + struct __disjunction_impl<__enable_if_t, _B1, _B2, _Bn...> + { using type = typename __disjunction_impl::type; }; + + template + struct __conjunction_impl + { using type = _B1; }; + + template + struct __conjunction_impl<__enable_if_t, _B1, _B2, _Bn...> + { using type = typename __conjunction_impl::type; }; + } + + + template + struct conjunction + : __detail::__conjunction_impl::type + { }; + + template<> + struct conjunction<> + : true_type + { }; + + template + struct disjunction + : __detail::__disjunction_impl::type + { }; + + template<> + struct disjunction<> + : false_type + { }; + + template + struct negation + : __not_<_Pp>::type + { }; + + + + + template + inline constexpr bool conjunction_v = conjunction<_Bn...>::value; + + template + inline constexpr bool disjunction_v = disjunction<_Bn...>::value; + + template + inline constexpr bool negation_v = negation<_Pp>::value; + + + + + + template + struct is_reference; + template + struct is_function; + template + struct is_void; + template + struct remove_cv; + template + struct is_const; + + + template + struct __is_array_unknown_bounds; + + + + + template + constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>) + { return {}; } + + template + constexpr typename __or_< + is_reference<_NestedType>, + is_function<_NestedType>, + is_void<_NestedType>, + __is_array_unknown_bounds<_NestedType> + >::type __is_complete_or_unbounded(_TypeIdentity) + { return {}; } + + + template + using __remove_cv_t = typename remove_cv<_Tp>::type; + + + + + + template + struct is_void + : public false_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + + template + struct __is_integral_helper + : public false_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + + + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + __extension__ + template<> + struct __is_integral_helper<__int128> + : public true_type { }; + + __extension__ + template<> + struct __is_integral_helper + : public true_type { }; +# 460 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_integral + : public __is_integral_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct __is_floating_point_helper + : public false_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; +# 513 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template<> + struct __is_floating_point_helper<__float128> + : public true_type { }; + + + + + template + struct is_floating_point + : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type + { }; + + + + template + struct is_array + : public __bool_constant<__is_array(_Tp)> + { }; +# 545 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct __is_pointer_helper + : public false_type { }; + + template + struct __is_pointer_helper<_Tp*> + : public true_type { }; + + + template + struct is_pointer + : public __is_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_lvalue_reference + : public false_type { }; + + template + struct is_lvalue_reference<_Tp&> + : public true_type { }; + + + template + struct is_rvalue_reference + : public false_type { }; + + template + struct is_rvalue_reference<_Tp&&> + : public true_type { }; + + + + template + struct is_member_object_pointer + : public __bool_constant<__is_member_object_pointer(_Tp)> + { }; +# 601 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_member_function_pointer + : public __bool_constant<__is_member_function_pointer(_Tp)> + { }; +# 622 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_enum + : public __bool_constant<__is_enum(_Tp)> + { }; + + + template + struct is_union + : public __bool_constant<__is_union(_Tp)> + { }; + + + template + struct is_class + : public __bool_constant<__is_class(_Tp)> + { }; + + + + template + struct is_function + : public __bool_constant<__is_function(_Tp)> + { }; +# 661 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_null_pointer + : public false_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + + + template + struct __is_nullptr_t + : public is_null_pointer<_Tp> + { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead"))); + + + + + + + template + struct is_reference + : public __bool_constant<__is_reference(_Tp)> + { }; +# 715 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_arithmetic + : public __or_, is_floating_point<_Tp>>::type + { }; + + + template + struct is_fundamental + : public __or_, is_void<_Tp>, + is_null_pointer<_Tp>>::type + { }; + + + + template + struct is_object + : public __bool_constant<__is_object(_Tp)> + { }; +# 741 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_member_pointer; + + + template + struct is_scalar + : public __or_, is_enum<_Tp>, is_pointer<_Tp>, + is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type + { }; + + + template + struct is_compound + : public __bool_constant::value> { }; + + + + template + struct is_member_pointer + : public __bool_constant<__is_member_pointer(_Tp)> + { }; +# 779 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_same; + + + template + using __is_one_of = __or_...>; + + + __extension__ + template + using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, + signed char, signed short, signed int, signed long, + signed long long + + , signed __int128 +# 804 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + >; + + + __extension__ + template + using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>, + unsigned char, unsigned short, unsigned int, unsigned long, + unsigned long long + + , unsigned __int128 +# 824 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + >; + + + template + using __is_standard_integer + = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>; + + + template using __void_t = void; + + + + + + template + struct is_const + : public false_type { }; + + template + struct is_const<_Tp const> + : public true_type { }; + + + template + struct is_volatile + : public false_type { }; + + template + struct is_volatile<_Tp volatile> + : public true_type { }; + + + template + struct is_trivial + : public __bool_constant<__is_trivial(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copyable + : public __bool_constant<__is_trivially_copyable(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_standard_layout + : public __bool_constant<__is_standard_layout(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + template + struct + + is_pod + : public __bool_constant<__is_pod(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct + [[__deprecated__]] + is_literal_type + : public __bool_constant<__is_literal_type(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_empty + : public __bool_constant<__is_empty(_Tp)> + { }; + + + template + struct is_polymorphic + : public __bool_constant<__is_polymorphic(_Tp)> + { }; + + + + + template + struct is_final + : public __bool_constant<__is_final(_Tp)> + { }; + + + + template + struct is_abstract + : public __bool_constant<__is_abstract(_Tp)> + { }; + + + template::value> + struct __is_signed_helper + : public false_type { }; + + template + struct __is_signed_helper<_Tp, true> + : public __bool_constant<_Tp(-1) < _Tp(0)> + { }; + + + + template + struct is_signed + : public __is_signed_helper<_Tp>::type + { }; + + + template + struct is_unsigned + : public __and_, __not_>>::type + { }; + + + template + _Up + __declval(int); + + template + _Tp + __declval(long); + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)); + + template + struct remove_all_extents; + + + template + struct __is_array_known_bounds + : public false_type + { }; + + template + struct __is_array_known_bounds<_Tp[_Size]> + : public true_type + { }; + + template + struct __is_array_unknown_bounds + : public false_type + { }; + + template + struct __is_array_unknown_bounds<_Tp[]> + : public true_type + { }; +# 1006 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + struct __do_is_destructible_impl + { + template().~_Tp())> + static true_type __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_destructible_impl + : public __do_is_destructible_impl + { + using type = decltype(__test<_Tp>(0)); + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_destructible_safe; + + template + struct __is_destructible_safe<_Tp, false, false> + : public __is_destructible_impl::type>::type + { }; + + template + struct __is_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_destructible + : public __is_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + + struct __do_is_nt_destructible_impl + { + template + static __bool_constant().~_Tp())> + __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_nt_destructible_impl + : public __do_is_nt_destructible_impl + { + using type = decltype(__test<_Tp>(0)); + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_nt_destructible_safe; + + template + struct __is_nt_destructible_safe<_Tp, false, false> + : public __is_nt_destructible_impl::type>::type + { }; + + template + struct __is_nt_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_nt_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_nothrow_destructible + : public __is_nt_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_constructible_impl + = __bool_constant<__is_constructible(_Tp, _Args...)>; + + + + template + struct is_constructible + : public __is_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_default_constructible + : public __is_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct __add_lvalue_reference_helper + { using type = _Tp; }; + + template + struct __add_lvalue_reference_helper<_Tp, __void_t<_Tp&>> + { using type = _Tp&; }; + + template + using __add_lval_ref_t = typename __add_lvalue_reference_helper<_Tp>::type; + + + + template + struct is_copy_constructible + : public __is_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct __add_rvalue_reference_helper + { using type = _Tp; }; + + template + struct __add_rvalue_reference_helper<_Tp, __void_t<_Tp&&>> + { using type = _Tp&&; }; + + template + using __add_rval_ref_t = typename __add_rvalue_reference_helper<_Tp>::type; + + + + template + struct is_move_constructible + : public __is_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_constructible_impl + = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>; + + + + template + struct is_nothrow_constructible + : public __is_nothrow_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_default_constructible + : public __is_nothrow_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_copy_constructible + : public __is_nothrow_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_move_constructible + : public __is_nothrow_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_assignable_impl = __bool_constant<__is_assignable(_Tp, _Up)>; + + + + template + struct is_assignable + : public __is_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_copy_assignable + : public __is_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_move_assignable + : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_assignable_impl + = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>; + + + + template + struct is_nothrow_assignable + : public __is_nothrow_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_copy_assignable + : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_move_assignable + : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_trivially_constructible_impl + = __bool_constant<__is_trivially_constructible(_Tp, _Args...)>; + + + + template + struct is_trivially_constructible + : public __is_trivially_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_default_constructible + : public __is_trivially_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; +# 1319 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + struct __do_is_implicitly_default_constructible_impl + { + template + static void __helper(const _Tp&); + + template + static true_type __test(const _Tp&, + decltype(__helper({}))* = 0); + + static false_type __test(...); + }; + + template + struct __is_implicitly_default_constructible_impl + : public __do_is_implicitly_default_constructible_impl + { + using type = decltype(__test(declval<_Tp>())); + }; + + template + struct __is_implicitly_default_constructible_safe + : public __is_implicitly_default_constructible_impl<_Tp>::type + { }; + + template + struct __is_implicitly_default_constructible + : public __and_<__is_constructible_impl<_Tp>, + __is_implicitly_default_constructible_safe<_Tp>>::type + { }; + + + + template + struct is_trivially_copy_constructible + : public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_move_constructible + : public __is_trivially_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_trivially_assignable_impl + = __bool_constant<__is_trivially_assignable(_Tp, _Up)>; + + + + template + struct is_trivially_assignable + : public __is_trivially_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copy_assignable + : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_move_assignable + : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_destructible + : public __and_<__is_destructible_safe<_Tp>, + __bool_constant<__has_trivial_destructor(_Tp)>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + struct has_virtual_destructor + : public __bool_constant<__has_virtual_destructor(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct alignment_of + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct rank + : public integral_constant { }; + + template + struct rank<_Tp[_Size]> + : public integral_constant::value> { }; + + template + struct rank<_Tp[]> + : public integral_constant::value> { }; + + + template + struct extent + : public integral_constant { }; + + template + struct extent<_Tp[_Size], 0> + : public integral_constant { }; + + template + struct extent<_Tp[_Size], _Uint> + : public extent<_Tp, _Uint - 1>::type { }; + + template + struct extent<_Tp[], 0> + : public integral_constant { }; + + template + struct extent<_Tp[], _Uint> + : public extent<_Tp, _Uint - 1>::type { }; + + + + + + + template + struct is_same + : public __bool_constant<__is_same(_Tp, _Up)> + { }; +# 1491 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_base_of + : public __bool_constant<__is_base_of(_Base, _Derived)> + { }; + + + template + struct is_convertible + : public __bool_constant<__is_convertible(_From, _To)> + { }; +# 1540 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + using __is_array_convertible + = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; +# 1600 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++14-extensions" + template + struct __is_nothrow_new_constructible_impl + : __bool_constant< + noexcept(::new(std::declval()) _Tp(std::declval<_Args>()...)) + > + { }; + + template + inline constexpr bool __is_nothrow_new_constructible + = __and_, + __is_nothrow_new_constructible_impl<_Tp, _Args...>>::value; +#pragma GCC diagnostic pop + + + + + template + struct remove_const + { using type = _Tp; }; + + template + struct remove_const<_Tp const> + { using type = _Tp; }; + + + template + struct remove_volatile + { using type = _Tp; }; + + template + struct remove_volatile<_Tp volatile> + { using type = _Tp; }; + + + + template + struct remove_cv + { using type = __remove_cv(_Tp); }; +# 1659 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct add_const + { using type = _Tp const; }; + + + template + struct add_volatile + { using type = _Tp volatile; }; + + + template + struct add_cv + { using type = _Tp const volatile; }; + + + + template + using remove_const_t = typename remove_const<_Tp>::type; + + + template + using remove_volatile_t = typename remove_volatile<_Tp>::type; + + + template + using remove_cv_t = typename remove_cv<_Tp>::type; + + + template + using add_const_t = typename add_const<_Tp>::type; + + + template + using add_volatile_t = typename add_volatile<_Tp>::type; + + + template + using add_cv_t = typename add_cv<_Tp>::type; + + + + + + + template + struct remove_reference + { using type = __remove_reference(_Tp); }; +# 1721 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct add_lvalue_reference + { using type = __add_lval_ref_t<_Tp>; }; + + + template + struct add_rvalue_reference + { using type = __add_rval_ref_t<_Tp>; }; + + + + template + using remove_reference_t = typename remove_reference<_Tp>::type; + + + template + using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; + + + template + using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; + + + + + + + + template + struct __cv_selector; + + template + struct __cv_selector<_Unqualified, false, false> + { using __type = _Unqualified; }; + + template + struct __cv_selector<_Unqualified, false, true> + { using __type = volatile _Unqualified; }; + + template + struct __cv_selector<_Unqualified, true, false> + { using __type = const _Unqualified; }; + + template + struct __cv_selector<_Unqualified, true, true> + { using __type = const volatile _Unqualified; }; + + template::value, + bool _IsVol = is_volatile<_Qualified>::value> + class __match_cv_qualifiers + { + using __match = __cv_selector<_Unqualified, _IsConst, _IsVol>; + + public: + using __type = typename __match::__type; + }; + + + template + struct __make_unsigned + { using __type = _Tp; }; + + template<> + struct __make_unsigned + { using __type = unsigned char; }; + + template<> + struct __make_unsigned + { using __type = unsigned char; }; + + template<> + struct __make_unsigned + { using __type = unsigned short; }; + + template<> + struct __make_unsigned + { using __type = unsigned int; }; + + template<> + struct __make_unsigned + { using __type = unsigned long; }; + + template<> + struct __make_unsigned + { using __type = unsigned long long; }; + + + __extension__ + template<> + struct __make_unsigned<__int128> + { using __type = unsigned __int128; }; +# 1834 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template::value, + bool _IsEnum = __is_enum(_Tp)> + class __make_unsigned_selector; + + template + class __make_unsigned_selector<_Tp, true, false> + { + using __unsigned_type + = typename __make_unsigned<__remove_cv_t<_Tp>>::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + class __make_unsigned_selector_base + { + protected: + template struct _List { }; + + template + struct _List<_Tp, _Up...> : _List<_Up...> + { static constexpr size_t __size = sizeof(_Tp); }; + + template + struct __select; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, true> + { using __type = _Uint; }; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, false> + : __select<_Sz, _List<_UInts...>> + { }; + }; + + + template + class __make_unsigned_selector<_Tp, false, true> + : __make_unsigned_selector_base + { + + using _UInts = _List; + + using __unsigned_type = typename __select::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + + + + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; +# 1908 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + + + + + + template + struct make_unsigned + { using type = typename __make_unsigned_selector<_Tp>::__type; }; + + + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + + + + + template + struct __make_signed + { using __type = _Tp; }; + + template<> + struct __make_signed + { using __type = signed char; }; + + template<> + struct __make_signed + { using __type = signed char; }; + + template<> + struct __make_signed + { using __type = signed short; }; + + template<> + struct __make_signed + { using __type = signed int; }; + + template<> + struct __make_signed + { using __type = signed long; }; + + template<> + struct __make_signed + { using __type = signed long long; }; + + + __extension__ + template<> + struct __make_signed + { using __type = __int128; }; +# 1994 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template::value, + bool _IsEnum = __is_enum(_Tp)> + class __make_signed_selector; + + template + class __make_signed_selector<_Tp, true, false> + { + using __signed_type + = typename __make_signed<__remove_cv_t<_Tp>>::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __signed_type>::__type; + }; + + + template + class __make_signed_selector<_Tp, false, true> + { + using __unsigned_type = typename __make_unsigned_selector<_Tp>::__type; + + public: + using __type = typename __make_signed_selector<__unsigned_type>::__type; + }; + + + + + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; +# 2040 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + + + + + + template + struct make_signed + { using type = typename __make_signed_selector<_Tp>::__type; }; + + + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + + + + template + using make_signed_t = typename make_signed<_Tp>::type; + + + template + using make_unsigned_t = typename make_unsigned<_Tp>::type; + + + + + + template + struct remove_extent + { using type = _Tp; }; + + template + struct remove_extent<_Tp[_Size]> + { using type = _Tp; }; + + template + struct remove_extent<_Tp[]> + { using type = _Tp; }; + + + template + struct remove_all_extents + { using type = _Tp; }; + + template + struct remove_all_extents<_Tp[_Size]> + { using type = typename remove_all_extents<_Tp>::type; }; + + template + struct remove_all_extents<_Tp[]> + { using type = typename remove_all_extents<_Tp>::type; }; + + + + template + using remove_extent_t = typename remove_extent<_Tp>::type; + + + template + using remove_all_extents_t = typename remove_all_extents<_Tp>::type; + + + + + + + template + struct remove_pointer + { using type = __remove_pointer(_Tp); }; +# 2139 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct __add_pointer_helper + { using type = _Tp; }; + + template + struct __add_pointer_helper<_Tp, __void_t<_Tp*>> + { using type = _Tp*; }; + + + template + struct add_pointer + : public __add_pointer_helper<_Tp> + { }; + + template + struct add_pointer<_Tp&> + { using type = _Tp*; }; + + template + struct add_pointer<_Tp&&> + { using type = _Tp*; }; + + + + template + using remove_pointer_t = typename remove_pointer<_Tp>::type; + + + template + using add_pointer_t = typename add_pointer<_Tp>::type; + + + template + struct __aligned_storage_msa + { + union __type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__)) { } __align; + }; + }; +# 2194 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template::__type)> + struct + + aligned_storage + { + union type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__((_Align)))) { } __align; + }; + }; + + template + struct __strictest_alignment + { + static const size_t _S_alignment = 0; + static const size_t _S_size = 0; + }; + + template + struct __strictest_alignment<_Tp, _Types...> + { + static const size_t _S_alignment = + alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment + ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; + static const size_t _S_size = + sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size + ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 2240 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct + + aligned_union + { + private: + static_assert(sizeof...(_Types) != 0, "At least one type is required"); + + using __strictest = __strictest_alignment<_Types...>; + static const size_t _S_len = _Len > __strictest::_S_size + ? _Len : __strictest::_S_size; + public: + + static const size_t alignment_value = __strictest::_S_alignment; + + using type = typename aligned_storage<_S_len, alignment_value>::type; + }; + + template + const size_t aligned_union<_Len, _Types...>::alignment_value; +#pragma GCC diagnostic pop + + + + + + template + struct __decay_selector + : __conditional_t::value, + remove_cv<_Up>, + add_pointer<_Up>> + { }; + + template + struct __decay_selector<_Up[_Nm]> + { using type = _Up*; }; + + template + struct __decay_selector<_Up[]> + { using type = _Up*; }; + + + + + template + struct decay + { using type = typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&> + { using type = typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&&> + { using type = typename __decay_selector<_Tp>::type; }; + + + + + template + struct __strip_reference_wrapper + { + using __type = _Tp; + }; + + template + struct __strip_reference_wrapper > + { + using __type = _Tp&; + }; + + + template + using __decay_t = typename decay<_Tp>::type; + + template + using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; + + + + + + template + using _Require = __enable_if_t<__and_<_Cond...>::value>; + + + template + using __remove_cvref_t + = typename remove_cv::type>::type; + + + + + template + struct conditional + { using type = _Iftrue; }; + + + template + struct conditional + { using type = _Iffalse; }; + + + template + struct common_type; +# 2355 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct __success_type + { using type = _Tp; }; + + struct __failure_type + { }; + + struct __do_common_type_impl + { + template + using __cond_t + = decltype(true ? std::declval<_Tp>() : std::declval<_Up>()); + + + + template + static __success_type<__decay_t<__cond_t<_Tp, _Up>>> + _S_test(int); +# 2382 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + static __failure_type + _S_test_2(...); + + template + static decltype(_S_test_2<_Tp, _Up>(0)) + _S_test(...); + }; + + + template<> + struct common_type<> + { }; + + + template + struct common_type<_Tp0> + : public common_type<_Tp0, _Tp0> + { }; + + + template, typename _Dp2 = __decay_t<_Tp2>> + struct __common_type_impl + { + + + using type = common_type<_Dp1, _Dp2>; + }; + + template + struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> + : private __do_common_type_impl + { + + + using type = decltype(_S_test<_Tp1, _Tp2>(0)); + }; + + + template + struct common_type<_Tp1, _Tp2> + : public __common_type_impl<_Tp1, _Tp2>::type + { }; + + template + struct __common_type_pack + { }; + + template + struct __common_type_fold; + + + template + struct common_type<_Tp1, _Tp2, _Rp...> + : public __common_type_fold, + __common_type_pack<_Rp...>> + { }; + + + + + template + struct __common_type_fold<_CTp, __common_type_pack<_Rp...>, + __void_t> + : public common_type + { }; + + + template + struct __common_type_fold<_CTp, _Rp, void> + { }; + + template + struct __underlying_type_impl + { + using type = __underlying_type(_Tp); + }; + + template + struct __underlying_type_impl<_Tp, false> + { }; + + + + template + struct underlying_type + : public __underlying_type_impl<_Tp> + { }; + + + template + struct __declval_protector + { + static const bool __stop = false; + }; + + + + + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)) + { + static_assert(__declval_protector<_Tp>::__stop, + "declval() must not be used!"); + return __declval<_Tp>(0); + } + + + template + struct result_of; + + + + + struct __invoke_memfun_ref { }; + struct __invoke_memfun_deref { }; + struct __invoke_memobj_ref { }; + struct __invoke_memobj_deref { }; + struct __invoke_other { }; + + + template + struct __result_of_success : __success_type<_Tp> + { using __invoke_type = _Tag; }; + + + struct __result_of_memfun_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_ref + : private __result_of_memfun_ref_impl + { + using type = decltype(_S_test<_MemPtr, _Arg, _Args...>(0)); + }; + + + struct __result_of_memfun_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_deref + : private __result_of_memfun_deref_impl + { + using type = decltype(_S_test<_MemPtr, _Arg, _Args...>(0)); + }; + + + struct __result_of_memobj_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>() + ), __invoke_memobj_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_ref + : private __result_of_memobj_ref_impl + { + using type = decltype(_S_test<_MemPtr, _Arg>(0)); + }; + + + struct __result_of_memobj_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>() + ), __invoke_memobj_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_deref + : private __result_of_memobj_deref_impl + { + using type = decltype(_S_test<_MemPtr, _Arg>(0)); + }; + + template + struct __result_of_memobj; + + template + struct __result_of_memobj<_Res _Class::*, _Arg> + { + using _Argval = __remove_cvref_t<_Arg>; + using _MemPtr = _Res _Class::*; + using type = typename __conditional_t<__or_, + is_base_of<_Class, _Argval>>::value, + __result_of_memobj_ref<_MemPtr, _Arg>, + __result_of_memobj_deref<_MemPtr, _Arg> + >::type; + }; + + template + struct __result_of_memfun; + + template + struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> + { + using _Argval = typename remove_reference<_Arg>::type; + using _MemPtr = _Res _Class::*; + using type = typename __conditional_t::value, + __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, + __result_of_memfun_deref<_MemPtr, _Arg, _Args...> + >::type; + }; + + + + + + + template> + struct __inv_unwrap + { + using type = _Tp; + }; + + template + struct __inv_unwrap<_Tp, reference_wrapper<_Up>> + { + using type = _Up&; + }; + + template + struct __result_of_impl + { + using type = __failure_type; + }; + + template + struct __result_of_impl + : public __result_of_memobj<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type> + { }; + + template + struct __result_of_impl + : public __result_of_memfun<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type, _Args...> + { }; + + + struct __result_of_other_impl + { + template + static __result_of_success()(std::declval<_Args>()...) + ), __invoke_other> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_impl + : private __result_of_other_impl + { + using type = decltype(_S_test<_Functor, _ArgTypes...>(0)); + }; + + + template + struct __invoke_result + : public __result_of_impl< + is_member_object_pointer< + typename remove_reference<_Functor>::type + >::value, + is_member_function_pointer< + typename remove_reference<_Functor>::type + >::value, + _Functor, _ArgTypes... + >::type + { }; + + + template + using __invoke_result_t = typename __invoke_result<_Fn, _Args...>::type; + + + template + struct result_of<_Functor(_ArgTypes...)> + : public __invoke_result<_Functor, _ArgTypes...> + { } __attribute__ ((__deprecated__ ("use '" "std::invoke_result" "' instead"))); + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + template::__type)> + using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; + + template + using aligned_union_t = typename aligned_union<_Len, _Types...>::type; +#pragma GCC diagnostic pop + + + template + using decay_t = typename decay<_Tp>::type; + + + template + using enable_if_t = typename enable_if<_Cond, _Tp>::type; + + + template + using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; + + + template + using common_type_t = typename common_type<_Tp...>::type; + + + template + using underlying_type_t = typename underlying_type<_Tp>::type; + + + template + using result_of_t = typename result_of<_Tp>::type; + + + + + template using void_t = void; +# 2759 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template class _Op, typename... _Args> + struct __detector + { + using type = _Default; + using __is_detected = false_type; + }; + + + template class _Op, + typename... _Args> + struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> + { + using type = _Op<_Args...>; + using __is_detected = true_type; + }; + + template class _Op, + typename... _Args> + using __detected_or = __detector<_Default, void, _Op, _Args...>; + + + + template class _Op, + typename... _Args> + using __detected_or_t + = typename __detected_or<_Default, _Op, _Args...>::type; +# 2801 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct __is_swappable; + + template + struct __is_nothrow_swappable; + + template + struct __is_tuple_like_impl : false_type + { }; + + + template + struct __is_tuple_like + : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type + { }; + + + template + + inline + _Require<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>> + swap(_Tp&, _Tp&) + noexcept(__and_, + is_nothrow_move_assignable<_Tp>>::value); + + template + + inline + __enable_if_t<__is_swappable<_Tp>::value> + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value); + + + namespace __swappable_details { + using std::swap; + + struct __do_is_swappable_impl + { + template(), std::declval<_Tp&>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_impl + : public __swappable_details::__do_is_swappable_impl + { + using type = decltype(__test<_Tp>(0)); + }; + + template + struct __is_nothrow_swappable_impl + : public __swappable_details::__do_is_nothrow_swappable_impl + { + using type = decltype(__test<_Tp>(0)); + }; + + template + struct __is_swappable + : public __is_swappable_impl<_Tp>::type + { }; + + template + struct __is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { }; + + + + + + + template + struct is_swappable + : public __is_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_v = + is_swappable<_Tp>::value; + + + template + inline constexpr bool is_nothrow_swappable_v = + is_nothrow_swappable<_Tp>::value; + + + + namespace __swappable_with_details { + using std::swap; + + struct __do_is_swappable_with_impl + { + template(), std::declval<_Up>())), + typename + = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_with_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) + && + noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_with_impl + : public __swappable_with_details::__do_is_swappable_with_impl + { + using type = decltype(__test<_Tp, _Up>(0)); + }; + + + template + struct __is_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_swappable_impl + { + using type = decltype(__test<_Tp&>(0)); + }; + + template + struct __is_nothrow_swappable_with_impl + : public __swappable_with_details::__do_is_nothrow_swappable_with_impl + { + using type = decltype(__test<_Tp, _Up>(0)); + }; + + + template + struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_nothrow_swappable_impl + { + using type = decltype(__test<_Tp&>(0)); + }; + + + + template + struct is_swappable_with + : public __is_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable_with + : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_with_v = + is_swappable_with<_Tp, _Up>::value; + + + template + inline constexpr bool is_nothrow_swappable_with_v = + is_nothrow_swappable_with<_Tp, _Up>::value; +# 3023 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template::value, typename = void> + struct __is_invocable_impl + : false_type + { + using __nothrow_conv = false_type; + }; + + + template + struct __is_invocable_impl<_Result, _Ret, + true, + __void_t> + : true_type + { + using __nothrow_conv = true_type; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + + template + struct __is_invocable_impl<_Result, _Ret, + false, + __void_t> + { + private: + + using _Res_t = typename _Result::type; + + + + static _Res_t _S_get() noexcept; + + + template + static void _S_conv(__type_identity_t<_Tp>) noexcept; + + + template(_S_get())), + typename = decltype(_S_conv<_Tp>(_S_get())), + + bool _Dangle = __reference_converts_from_temporary(_Tp, _Res_t) + + + + > + static __bool_constant<_Nothrow && !_Dangle> + _S_test(int); + + template + static false_type + _S_test(...); + + public: + + using type = decltype(_S_test<_Ret, true>(1)); + + + using __nothrow_conv = decltype(_S_test<_Ret>(1)); + }; +#pragma GCC diagnostic pop + + template + struct __is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { }; + + template + constexpr bool __call_is_nt(__invoke_memfun_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept((std::declval<_Up>().*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memfun_deref) + { + return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept(std::declval<_Up>().*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_deref) + { + return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_other) + { + return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); + } + + template + struct __call_is_nothrow + : __bool_constant< + std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) + > + { }; + + template + using __call_is_nothrow_ + = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; + + + template + struct __is_nothrow_invocable + : __and_<__is_invocable<_Fn, _Args...>, + __call_is_nothrow_<_Fn, _Args...>>::type + { }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + struct __nonesuchbase {}; + struct __nonesuch : private __nonesuchbase { + ~__nonesuch() = delete; + __nonesuch(__nonesuch const&) = delete; + void operator=(__nonesuch const&) = delete; + }; +#pragma GCC diagnostic pop + + + + + template + struct invoke_result + : public __invoke_result<_Functor, _ArgTypes...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}), + "_Functor must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; + + + template + struct is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + struct is_invocable_r + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_invocable + : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + + + + template + using __is_nt_invocable_impl + = typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv; + + + + template + struct is_nothrow_invocable_r + : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; +# 3251 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template + inline constexpr bool is_void_v = is_void<_Tp>::value; +template + inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; +template + inline constexpr bool is_integral_v = is_integral<_Tp>::value; +template + inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; + + +template + inline constexpr bool is_array_v = __is_array(_Tp); +# 3272 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template + inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; +template + inline constexpr bool is_lvalue_reference_v = false; +template + inline constexpr bool is_lvalue_reference_v<_Tp&> = true; +template + inline constexpr bool is_rvalue_reference_v = false; +template + inline constexpr bool is_rvalue_reference_v<_Tp&&> = true; + + +template + inline constexpr bool is_member_object_pointer_v = + __is_member_object_pointer(_Tp); + + + + + + + +template + inline constexpr bool is_member_function_pointer_v = + __is_member_function_pointer(_Tp); + + + + + + +template + inline constexpr bool is_enum_v = __is_enum(_Tp); +template + inline constexpr bool is_union_v = __is_union(_Tp); +template + inline constexpr bool is_class_v = __is_class(_Tp); + + + +template + inline constexpr bool is_reference_v = __is_reference(_Tp); +# 3323 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template + inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; +template + inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; + + +template + inline constexpr bool is_object_v = __is_object(_Tp); + + + + + +template + inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; +template + inline constexpr bool is_compound_v = !is_fundamental_v<_Tp>; + + +template + inline constexpr bool is_member_pointer_v = __is_member_pointer(_Tp); + + + + + +template + inline constexpr bool is_const_v = false; +template + inline constexpr bool is_const_v = true; + + +template + inline constexpr bool is_function_v = __is_function(_Tp); +# 3366 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template + inline constexpr bool is_volatile_v = false; +template + inline constexpr bool is_volatile_v = true; + +template + inline constexpr bool is_trivial_v = __is_trivial(_Tp); +template + inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp); +template + inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp); +template + + inline constexpr bool is_pod_v = __is_pod(_Tp); +template + [[__deprecated__]] + inline constexpr bool is_literal_type_v = __is_literal_type(_Tp); +template + inline constexpr bool is_empty_v = __is_empty(_Tp); +template + inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp); +template + inline constexpr bool is_abstract_v = __is_abstract(_Tp); +template + inline constexpr bool is_final_v = __is_final(_Tp); + +template + inline constexpr bool is_signed_v = is_signed<_Tp>::value; +template + inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; + +template + inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...); +template + inline constexpr bool is_default_constructible_v = __is_constructible(_Tp); +template + inline constexpr bool is_copy_constructible_v + = __is_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_move_constructible_v + = __is_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Up); +template + inline constexpr bool is_copy_assignable_v + = __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t); +template + inline constexpr bool is_move_assignable_v + = __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; + +template + inline constexpr bool is_trivially_constructible_v + = __is_trivially_constructible(_Tp, _Args...); +template + inline constexpr bool is_trivially_default_constructible_v + = __is_trivially_constructible(_Tp); +template + inline constexpr bool is_trivially_copy_constructible_v + = __is_trivially_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_constructible_v + = __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_trivially_assignable_v + = __is_trivially_assignable(_Tp, _Up); +template + inline constexpr bool is_trivially_copy_assignable_v + = __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_assignable_v + = __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>); +# 3461 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template + inline constexpr bool is_trivially_destructible_v = + is_trivially_destructible<_Tp>::value; + + +template + inline constexpr bool is_nothrow_constructible_v + = __is_nothrow_constructible(_Tp, _Args...); +template + inline constexpr bool is_nothrow_default_constructible_v + = __is_nothrow_constructible(_Tp); +template + inline constexpr bool is_nothrow_copy_constructible_v + = __is_nothrow_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_constructible_v + = __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_assignable_v + = __is_nothrow_assignable(_Tp, _Up); +template + inline constexpr bool is_nothrow_copy_assignable_v + = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_assignable_v + = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_destructible_v = + is_nothrow_destructible<_Tp>::value; + +template + inline constexpr bool has_virtual_destructor_v + = __has_virtual_destructor(_Tp); + +template + inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; + +template + inline constexpr size_t rank_v = 0; +template + inline constexpr size_t rank_v<_Tp[_Size]> = 1 + rank_v<_Tp>; +template + inline constexpr size_t rank_v<_Tp[]> = 1 + rank_v<_Tp>; + +template + inline constexpr size_t extent_v = 0; +template + inline constexpr size_t extent_v<_Tp[_Size], 0> = _Size; +template + inline constexpr size_t extent_v<_Tp[_Size], _Idx> = extent_v<_Tp, _Idx - 1>; +template + inline constexpr size_t extent_v<_Tp[], 0> = 0; +template + inline constexpr size_t extent_v<_Tp[], _Idx> = extent_v<_Tp, _Idx - 1>; + + +template + inline constexpr bool is_same_v = __is_same(_Tp, _Up); + + + + + + +template + inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived); + +template + inline constexpr bool is_convertible_v = __is_convertible(_From, _To); + + + + +template + inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_v + = is_nothrow_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_invocable_r_v + = is_invocable_r<_Ret, _Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_r_v + = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; + + + + + + + template + struct has_unique_object_representations + : bool_constant<__has_unique_object_representations( + remove_cv_t> + )> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool has_unique_object_representations_v + = has_unique_object_representations<_Tp>::value; + + + + + + + template + struct is_aggregate + : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> + { }; + + + + + + + template + inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>); +# 4017 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + +} +# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 1 3 +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + inline constexpr _Tp* + __addressof(_Tp& __r) noexcept + { return __builtin_addressof(__r); } +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Tp&&>(__t); } +# 81 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type&& __t) noexcept + { + static_assert(!std::is_lvalue_reference<_Tp>::value, + "std::forward must not be used to convert an rvalue to an lvalue"); + return static_cast<_Tp&&>(__t); + } +# 134 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr typename std::remove_reference<_Tp>::type&& + move(_Tp&& __t) noexcept + { return static_cast::type&&>(__t); } + + + template + struct __move_if_noexcept_cond + : public __and_<__not_>, + is_copy_constructible<_Tp>>::type { }; +# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr + __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&> + move_if_noexcept(_Tp& __x) noexcept + { return std::move(__x); } +# 172 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + [[__nodiscard__]] + inline constexpr _Tp* + addressof(_Tp& __r) noexcept + { return std::__addressof(__r); } + + + + template + const _Tp* addressof(const _Tp&&) = delete; + + + template + + inline _Tp + __exchange(_Tp& __obj, _Up&& __new_val) + { + _Tp __old_val = std::move(__obj); + __obj = std::forward<_Up>(__new_val); + return __old_val; + } +# 216 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + + inline + + typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>>::value>::type + + + + swap(_Tp& __a, _Tp& __b) + noexcept(__and_, is_nothrow_move_assignable<_Tp>>::value) + + { + + + + + _Tp __tmp = std::move(__a); + __a = std::move(__b); + __b = std::move(__tmp); + } + + + + + template + + inline + + typename enable_if<__is_swappable<_Tp>::value>::type + + + + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value) + { + for (size_t __n = 0; __n < _Nm; ++__n) + swap(__a[__n], __b[__n]); + } + + + +} +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 1 3 +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 + +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct tuple_size; + + + + + + template::type, + typename = typename enable_if::value>::type, + size_t = tuple_size<_Tp>::value> + using __enable_if_has_tuple_size = _Tp; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + + template + inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value; + + + + template + struct tuple_element; + + + template + using __tuple_element_t = typename tuple_element<__i, _Tp>::type; + + template + struct tuple_element<__i, const _Tp> + { + using type = const __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, volatile _Tp> + { + using type = volatile __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, const volatile _Tp> + { + using type = const volatile __tuple_element_t<__i, _Tp>; + }; + + + + + + template + constexpr size_t + __find_uniq_type_in_pack() + { + constexpr size_t __sz = sizeof...(_Types); + constexpr bool __found[__sz] = { __is_same(_Tp, _Types) ... }; + size_t __n = __sz; + for (size_t __i = 0; __i < __sz; ++__i) + { + if (__found[__i]) + { + if (__n < __sz) + return __sz; + __n = __i; + } + } + return __n; + } +# 134 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 + template + using tuple_element_t = typename tuple_element<__i, _Tp>::type; + + + + + template struct _Index_tuple { }; + + + template + struct _Build_index_tuple + { +# 154 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 + using __type = _Index_tuple<__integer_pack(_Num)...>; + + }; + + + + + template + struct integer_sequence + { + + + + typedef _Tp value_type; + static constexpr size_t size() noexcept { return sizeof...(_Idx); } + }; + + + template + using make_integer_sequence + + + + = integer_sequence<_Tp, __integer_pack(_Num)...>; + + + + template + using index_sequence = integer_sequence; + + + template + using make_index_sequence = make_integer_sequence; + + + template + using index_sequence_for = make_index_sequence; + + + + + struct in_place_t { + explicit in_place_t() = default; + }; + + inline constexpr in_place_t in_place{}; + + template struct in_place_type_t + { + explicit in_place_type_t() = default; + }; + + template + inline constexpr in_place_type_t<_Tp> in_place_type{}; + + template struct in_place_index_t + { + explicit in_place_index_t() = default; + }; + + template + inline constexpr in_place_index_t<_Idx> in_place_index{}; + + template + inline constexpr bool __is_in_place_type_v = false; + + template + inline constexpr bool __is_in_place_type_v> = true; + + template + using __is_in_place_type = bool_constant<__is_in_place_type_v<_Tp>>; + + template + inline constexpr bool __is_in_place_index_v = false; + + template + inline constexpr bool __is_in_place_index_v> = true; + + + + + template + struct _Nth_type + { using type = __type_pack_element<_Np, _Types...>; }; +# 283 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 + +} +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + struct piecewise_construct_t { explicit piecewise_construct_t() = default; }; + + + inline constexpr piecewise_construct_t piecewise_construct = + piecewise_construct_t(); + + + + + template + struct pair; + + template + class tuple; + + + + + + template + struct array; + + template + struct _Index_tuple; + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(pair<_Tp1, _Tp2>& __in) noexcept; + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(pair<_Tp1, _Tp2>&& __in) noexcept; + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(const pair<_Tp1, _Tp2>& __in) noexcept; + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(const pair<_Tp1, _Tp2>&& __in) noexcept; + + template + constexpr __tuple_element_t<__i, tuple<_Elements...>>& + get(tuple<_Elements...>& __t) noexcept; + + template + constexpr const __tuple_element_t<__i, tuple<_Elements...>>& + get(const tuple<_Elements...>& __t) noexcept; + + template + constexpr __tuple_element_t<__i, tuple<_Elements...>>&& + get(tuple<_Elements...>&& __t) noexcept; + + template + constexpr const __tuple_element_t<__i, tuple<_Elements...>>&& + get(const tuple<_Elements...>&& __t) noexcept; + + template + constexpr _Tp& + get(array<_Tp, _Nm>&) noexcept; + + template + constexpr _Tp&& + get(array<_Tp, _Nm>&&) noexcept; + + template + constexpr const _Tp& + get(const array<_Tp, _Nm>&) noexcept; + + template + constexpr const _Tp&& + get(const array<_Tp, _Nm>&&) noexcept; + + + + + + + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return __and_, + is_constructible<_T2, const _U2&>>::value; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return __and_, + is_convertible>::value; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return __and_, + is_constructible<_T2, _U2&&>>::value; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return __and_, + is_convertible<_U2&&, _T2>>::value; + } + }; + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return false; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return false; + } + }; +# 260 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template class __pair_base + { + + template friend struct pair; + __pair_base() = default; + ~__pair_base() = default; + __pair_base(const __pair_base&) = default; + __pair_base& operator=(const __pair_base&) = delete; + + }; +# 283 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + struct pair + : public __pair_base<_T1, _T2> + { + typedef _T1 first_type; + typedef _T2 second_type; + + _T1 first; + _T2 second; + + + constexpr pair(const pair&) = default; + constexpr pair(pair&&) = default; + + template + + pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); + + + void + swap(pair& __p) + noexcept(__and_<__is_nothrow_swappable<_T1>, + __is_nothrow_swappable<_T2>>::value) + { + using std::swap; + swap(first, __p.first); + swap(second, __p.second); + } +# 331 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + private: + template + + pair(tuple<_Args1...>&, tuple<_Args2...>&, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); + public: +# 719 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template , + __is_implicitly_default_constructible<_U2>> + ::value, bool>::type = true> + constexpr pair() + : first(), second() { } + + template , + is_default_constructible<_U2>, + __not_< + __and_<__is_implicitly_default_constructible<_U1>, + __is_implicitly_default_constructible<_U2>>>> + ::value, bool>::type = false> + explicit constexpr pair() + : first(), second() { } + + + + using _PCCP = _PCC; + + + + template() + && _PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + template() + && !_PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + + template + using _PCCFP = _PCC::value + || !is_same<_T2, _U2>::value, + _T1, _T2>; + + + template::template + _ConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) + { ; } + + template::template + _ConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) + { ; } +# 803 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + private: + + + + struct __zero_as_null_pointer_constant + { + __zero_as_null_pointer_constant(int __zero_as_null_pointer_constant::*) + { } + template::value>> + __zero_as_null_pointer_constant(_Tp) = delete; + }; + + public: + + + + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + is_convertible<_U1, _T1>>::value, + bool> = true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + constexpr + pair(_U1&& __x, __zero_as_null_pointer_constant, ...) + : first(std::forward<_U1>(__x)), second(nullptr) + { ; } + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + __not_>>::value, + bool> = false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + explicit constexpr + pair(_U1&& __x, __zero_as_null_pointer_constant, ...) + : first(std::forward<_U1>(__x)), second(nullptr) + { ; } + + template, + __not_>, + is_constructible<_T2, _U2>, + __not_>, + is_convertible<_U2, _T2>>::value, + bool> = true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + constexpr + pair(__zero_as_null_pointer_constant, _U2&& __y, ...) + : first(nullptr), second(std::forward<_U2>(__y)) + { ; } + + template, + __not_>, + is_constructible<_T2, _U2>, + __not_>, + __not_>>::value, + bool> = false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + explicit constexpr + pair(__zero_as_null_pointer_constant, _U2&& __y, ...) + : first(nullptr), second(std::forward<_U2>(__y)) + { ; } + + + + template() + && _PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) + { ; } + + template() + && !_PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) + { ; } + + + template::template + _MoveConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) + { ; } + + template::template + _MoveConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) + { ; } + + + + pair& + operator=(__conditional_t<__and_, + is_copy_assignable<_T2>>::value, + const pair&, const __nonesuch&> __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + pair& + operator=(__conditional_t<__and_, + is_move_assignable<_T2>>::value, + pair&&, __nonesuch&&> __p) + noexcept(__and_, + is_nothrow_move_assignable<_T2>>::value) + { + first = std::forward(__p.first); + second = std::forward(__p.second); + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, const _U2&>>::value, + pair&>::type + operator=(const pair<_U1, _U2>& __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, _U2&&>>::value, + pair&>::type + operator=(pair<_U1, _U2>&& __p) + { + first = std::forward<_U1>(__p.first); + second = std::forward<_U2>(__p.second); + return *this; + } +# 995 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + }; + + + + + template pair(_T1, _T2) -> pair<_T1, _T2>; +# 1031 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + inline constexpr bool + operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first == __y.first && __x.second == __y.second; } +# 1043 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + inline constexpr bool + operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first < __y.first + || (!(__y.first < __x.first) && __x.second < __y.second); } + + + template + inline constexpr bool + operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x == __y); } + + + template + inline constexpr bool + operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __y < __x; } + + + template + inline constexpr bool + operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__y < __x); } + + + template + inline constexpr bool + operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x < __y); } +# 1080 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + inline + + + typename enable_if<__and_<__is_swappable<_T1>, + __is_swappable<_T2>>::value>::type + + + + swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } +# 1103 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + typename enable_if, + __is_swappable<_T2>>::value>::type + swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete; +# 1129 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + constexpr pair::__type, + typename __decay_and_strip<_T2>::__type> + make_pair(_T1&& __x, _T2&& __y) + { + typedef typename __decay_and_strip<_T1>::__type __ds_type1; + typedef typename __decay_and_strip<_T2>::__type __ds_type2; + typedef pair<__ds_type1, __ds_type2> __pair_type; + return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y)); + } +# 1152 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + struct __is_tuple_like_impl> : true_type + { }; + + + + template + struct tuple_size> + : public integral_constant { }; + + + template + struct tuple_element<0, pair<_Tp1, _Tp2>> + { typedef _Tp1 type; }; + + + template + struct tuple_element<1, pair<_Tp1, _Tp2>> + { typedef _Tp2 type; }; + + + + template + struct tuple_element<__i, tuple<_Types...>>; + + + template + inline constexpr size_t tuple_size_v> = 2; + + template + inline constexpr size_t tuple_size_v> = 2; + + template + inline constexpr bool __is_pair = false; + + template + inline constexpr bool __is_pair> = true; + + + + template + struct __pair_get; + + template<> + struct __pair_get<0> + { + template + static constexpr _Tp1& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr _Tp1&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp1>(__pair.first); } + + template + static constexpr const _Tp1& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr const _Tp1&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.first); } + }; + + template<> + struct __pair_get<1> + { + template + static constexpr _Tp2& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr _Tp2&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp2>(__pair.second); } + + template + static constexpr const _Tp2& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr const _Tp2&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.second); } + }; + + + + + + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__get(__in); } + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__move_get(std::move(__in)); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(const pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__const_get(__in); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(const pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__const_move_get(std::move(__in)); } + + + + template + constexpr _Tp& + get(pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr const _Tp& + get(const pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr _Tp&& + get(pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr const _Tp&& + get(const pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr _Tp& + get(pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr const _Tp& + get(const pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr _Tp&& + get(pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } + + template + constexpr const _Tp&& + get(const pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } +# 1332 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + +} +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 1 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 + +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 +# 74 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 93 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 + struct input_iterator_tag { }; + + + struct output_iterator_tag { }; + + + struct forward_iterator_tag : public input_iterator_tag { }; + + + + struct bidirectional_iterator_tag : public forward_iterator_tag { }; + + + + struct random_access_iterator_tag : public bidirectional_iterator_tag { }; +# 125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 + template + struct [[__deprecated__]] iterator + { + + typedef _Category iterator_category; + + typedef _Tp value_type; + + typedef _Distance difference_type; + + typedef _Pointer pointer; + + typedef _Reference reference; + }; +# 149 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits; + + + + + template> + struct __iterator_traits { }; + + + + template + struct __iterator_traits<_Iterator, + __void_t> + { + typedef typename _Iterator::iterator_category iterator_category; + typedef typename _Iterator::value_type value_type; + typedef typename _Iterator::difference_type difference_type; + typedef typename _Iterator::pointer pointer; + typedef typename _Iterator::reference reference; + }; + + + template + struct iterator_traits + : public __iterator_traits<_Iterator> { }; +# 209 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits<_Tp*> + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef _Tp* pointer; + typedef _Tp& reference; + }; + + + template + struct iterator_traits + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef const _Tp* pointer; + typedef const _Tp& reference; + }; + + + + + + + template + __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_Iter>::iterator_category + __iterator_category(const _Iter&) + { return typename iterator_traits<_Iter>::iterator_category(); } + + + + + template + using __iter_category_t + = typename iterator_traits<_Iter>::iterator_category; + + template + using _RequireInputIter = + __enable_if_t, + input_iterator_tag>::value>; + + template> + struct __is_random_access_iter + : is_base_of + { + typedef is_base_of _Base; + enum { __value = _Base::value }; + }; + + + + + + + + +} +# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 1 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 + +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/concept_check.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/concept_check.h" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/concept_check.h" 3 +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/debug/assertions.h" 1 3 +# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template struct _List_iterator; + template struct _List_const_iterator; + + + template + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + __distance(_InputIterator __first, _InputIterator __last, + input_iterator_tag) + { + + + + typename iterator_traits<_InputIterator>::difference_type __n = 0; + while (__first != __last) + { + ++__first; + ++__n; + } + return __n; + } + + template + __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_RandomAccessIterator>::difference_type + __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, + random_access_iterator_tag) + { + + + + return __last - __first; + } + + + + template + ptrdiff_t + __distance(std::_List_iterator<_Tp>, + std::_List_iterator<_Tp>, + input_iterator_tag); + + template + ptrdiff_t + __distance(std::_List_const_iterator<_Tp>, + std::_List_const_iterator<_Tp>, + input_iterator_tag); + + + + + template + void + __distance(_OutputIterator, _OutputIterator, output_iterator_tag) = delete; +# 144 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 + template + [[__nodiscard__]] __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + distance(_InputIterator __first, _InputIterator __last) + { + + return std::__distance(__first, __last, + std::__iterator_category(__first)); + } + + template + inline constexpr void + __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) + { + + + do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) std::__glibcxx_assert_fail(); } while (false); + while (__n--) + ++__i; + } + + template + inline constexpr void + __advance(_BidirectionalIterator& __i, _Distance __n, + bidirectional_iterator_tag) + { + + + + if (__n > 0) + while (__n--) + ++__i; + else + while (__n++) + --__i; + } + + template + inline constexpr void + __advance(_RandomAccessIterator& __i, _Distance __n, + random_access_iterator_tag) + { + + + + if (__builtin_constant_p(__n) && __n == 1) + ++__i; + else if (__builtin_constant_p(__n) && __n == -1) + --__i; + else + __i += __n; + } + + + + template + void + __advance(_OutputIterator&, _Distance, output_iterator_tag) = delete; +# 217 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 + template + __attribute__((__always_inline__)) + inline constexpr void + advance(_InputIterator& __i, _Distance __n) + { + + typename iterator_traits<_InputIterator>::difference_type __d = __n; + std::__advance(__i, __d, std::__iterator_category(__i)); + } + + + + template + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _InputIterator + next(_InputIterator __x, typename + iterator_traits<_InputIterator>::difference_type __n = 1) + { + + + std::advance(__x, __n); + return __x; + } + + template + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _BidirectionalIterator + prev(_BidirectionalIterator __x, typename + iterator_traits<_BidirectionalIterator>::difference_type __n = 1) + { + + + + std::advance(__x, -__n); + return __x; + } + + + + +} +# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 1 3 +# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/ptr_traits.h" 1 3 +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/ptr_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + class __undefined; + + + + template + struct __get_first_arg + { using type = __undefined; }; + + template class _SomeTemplate, typename _Tp, + typename... _Types> + struct __get_first_arg<_SomeTemplate<_Tp, _Types...>> + { using type = _Tp; }; + + + + template + struct __replace_first_arg + { }; + + template class _SomeTemplate, typename _Up, + typename _Tp, typename... _Types> + struct __replace_first_arg<_SomeTemplate<_Tp, _Types...>, _Up> + { using type = _SomeTemplate<_Up, _Types...>; }; + + + template + struct __ptr_traits_elem : __get_first_arg<_Ptr> + { }; + + + + + + + + template + struct __ptr_traits_elem<_Ptr, __void_t> + { using type = typename _Ptr::element_type; }; + + + template + using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type; + + + + + template::value> + struct __ptr_traits_ptr_to + { + using pointer = _Ptr; + using element_type = _Elt; + + + + + + + + static pointer + pointer_to(element_type& __r) + + + + + + { return pointer::pointer_to(__r); } + }; + + + template + struct __ptr_traits_ptr_to<_Ptr, _Elt, true> + { }; + + + template + struct __ptr_traits_ptr_to<_Tp*, _Tp, false> + { + using pointer = _Tp*; + using element_type = _Tp; + + + + + + + static pointer + pointer_to(element_type& __r) noexcept + { return std::addressof(__r); } + }; + + template + struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt> + { + private: + template + using __diff_t = typename _Tp::difference_type; + + template + using __rebind = __type_identity>; + + public: + + using pointer = _Ptr; + + + using element_type = _Elt; + + + using difference_type = __detected_or_t; + + + template + using rebind = typename __detected_or_t<__replace_first_arg<_Ptr, _Up>, + __rebind, _Ptr, _Up>::type; + }; + + + + template + struct __ptr_traits_impl<_Ptr, __undefined> + { }; + + + + + + + + template + struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>> + { }; + + + + + + + + template + struct pointer_traits<_Tp*> : __ptr_traits_ptr_to<_Tp*, _Tp> + { + + typedef _Tp* pointer; + + typedef _Tp element_type; + + typedef ptrdiff_t difference_type; + + template using rebind = _Up*; + }; + + + template + using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>; + + template + constexpr _Tp* + __to_address(_Tp* __ptr) noexcept + { + static_assert(!std::is_function<_Tp>::value, "not a function pointer"); + return __ptr; + } + + + template + constexpr typename std::pointer_traits<_Ptr>::element_type* + __to_address(const _Ptr& __ptr) + { return std::__to_address(__ptr.operator->()); } +# 257 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/ptr_traits.h" 3 + +} +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 2 3 +# 85 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 106 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + +# 106 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 128 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class reverse_iterator + : public iterator::iterator_category, + typename iterator_traits<_Iterator>::value_type, + typename iterator_traits<_Iterator>::difference_type, + typename iterator_traits<_Iterator>::pointer, + typename iterator_traits<_Iterator>::reference> + { + template + friend class reverse_iterator; +# 147 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + protected: + _Iterator current; + + typedef iterator_traits<_Iterator> __traits_type; + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::pointer pointer; + + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; +# 178 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + constexpr + reverse_iterator() + noexcept(noexcept(_Iterator())) + : current() + { } + + + + + explicit constexpr + reverse_iterator(iterator_type __x) + noexcept(noexcept(_Iterator(__x))) + : current(__x) + { } + + + + + constexpr + reverse_iterator(const reverse_iterator& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + reverse_iterator& operator=(const reverse_iterator&) = default; + + + + + + + template + + + + constexpr + reverse_iterator(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + template + + + + + constexpr + reverse_iterator& + operator=(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(current = __x.current)) + { + current = __x.current; + return *this; + } + + + + + + [[__nodiscard__]] + constexpr iterator_type + base() const + noexcept(noexcept(_Iterator(current))) + { return current; } +# 255 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + { + _Iterator __tmp = current; + return *--__tmp; + } + + + + + + + [[__nodiscard__]] + constexpr pointer + operator->() const + + + + + { + + + _Iterator __tmp = current; + --__tmp; + return _S_to_pointer(__tmp); + } + + + + + + + constexpr reverse_iterator& + operator++() + { + --current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator++(int) + { + reverse_iterator __tmp = *this; + --current; + return __tmp; + } + + + + + + + constexpr reverse_iterator& + operator--() + { + ++current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator--(int) + { + reverse_iterator __tmp = *this; + ++current; + return __tmp; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator+(difference_type __n) const + { return reverse_iterator(current - __n); } + + + + + + + + constexpr reverse_iterator& + operator+=(difference_type __n) + { + current -= __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator-(difference_type __n) const + { return reverse_iterator(current + __n); } + + + + + + + + constexpr reverse_iterator& + operator-=(difference_type __n) + { + current += __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + { return *(*this + __n); } +# 415 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + private: + template + static constexpr _Tp* + _S_to_pointer(_Tp* __p) + { return __p; } + + template + static constexpr pointer + _S_to_pointer(_Tp __t) + { return __t.operator->(); } + }; +# 438 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator==(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y.base() < __x.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() == __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() > __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() != __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() < __y.base(); } + + template + inline constexpr bool + operator<=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() >= __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() <= __y.base(); } +# 615 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr auto + operator-(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + -> decltype(__y.base() - __x.base()) + { return __y.base() - __x.base(); } + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Iterator> + operator+(typename reverse_iterator<_Iterator>::difference_type __n, + const reverse_iterator<_Iterator>& __x) + { return reverse_iterator<_Iterator>(__x.base() - __n); } + + + + template + inline constexpr reverse_iterator<_Iterator> + __make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Iterator> + make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } +# 657 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + + auto + __niter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__niter_base(__it.base()))) + { return __make_reverse_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + : __is_move_iterator<_Iterator> + { }; + + template + + auto + __miter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__miter_base(__it.base()))) + { return __make_reverse_iterator(__miter_base(__it.base())); } +# 688 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class back_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + explicit + back_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 726 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + + back_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_back(__value); + return *this; + } + + + back_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_back(std::move(__value)); + return *this; + } + + + + [[__nodiscard__]] + back_insert_iterator& + operator*() + { return *this; } + + + + back_insert_iterator& + operator++() + { return *this; } + + + + back_insert_iterator + operator++(int) + { return *this; } + }; +# 773 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline back_insert_iterator<_Container> + back_inserter(_Container& __x) + { return back_insert_iterator<_Container>(__x); } +# 789 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class front_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + explicit + front_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 827 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + + front_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_front(__value); + return *this; + } + + + front_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_front(std::move(__value)); + return *this; + } + + + + [[__nodiscard__]] + front_insert_iterator& + operator*() + { return *this; } + + + + front_insert_iterator& + operator++() + { return *this; } + + + + front_insert_iterator + operator++(int) + { return *this; } + }; +# 874 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline front_insert_iterator<_Container> + front_inserter(_Container& __x) + { return front_insert_iterator<_Container>(__x); } +# 894 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class insert_iterator + : public iterator + { + + + + typedef typename _Container::iterator _Iter; + + protected: + _Container* container; + _Iter iter; + + public: + + typedef _Container container_type; +# 919 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + + insert_iterator(_Container& __x, _Iter __i) + : container(std::__addressof(__x)), iter(__i) {} +# 955 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + + insert_iterator& + operator=(const typename _Container::value_type& __value) + { + iter = container->insert(iter, __value); + ++iter; + return *this; + } + + + insert_iterator& + operator=(typename _Container::value_type&& __value) + { + iter = container->insert(iter, std::move(__value)); + ++iter; + return *this; + } + + + + [[__nodiscard__]] + insert_iterator& + operator*() + { return *this; } + + + + insert_iterator& + operator++() + { return *this; } + + + + insert_iterator& + operator++(int) + { return *this; } + }; + +#pragma GCC diagnostic pop +# 1014 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline insert_iterator<_Container> + inserter(_Container& __x, typename _Container::iterator __i) + { return insert_iterator<_Container>(__x, __i); } + + + + + +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 1037 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class __normal_iterator + { + protected: + _Iterator _M_current; + + typedef std::iterator_traits<_Iterator> __traits_type; + + + template + using __convertible_from + = std::__enable_if_t::value>; + + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; + typedef typename __traits_type::pointer pointer; + + + + + + constexpr __normal_iterator() noexcept + : _M_current(_Iterator()) { } + + explicit + __normal_iterator(const _Iterator& __i) noexcept + : _M_current(__i) { } + + + + template> + + __normal_iterator(const __normal_iterator<_Iter, _Container>& __i) + noexcept +# 1085 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + : _M_current(__i.base()) { } + + + + reference + operator*() const noexcept + { return *_M_current; } + + + pointer + operator->() const noexcept + { return _M_current; } + + + __normal_iterator& + operator++() noexcept + { + ++_M_current; + return *this; + } + + + __normal_iterator + operator++(int) noexcept + { return __normal_iterator(_M_current++); } + + + + __normal_iterator& + operator--() noexcept + { + --_M_current; + return *this; + } + + + __normal_iterator + operator--(int) noexcept + { return __normal_iterator(_M_current--); } + + + + reference + operator[](difference_type __n) const noexcept + { return _M_current[__n]; } + + + __normal_iterator& + operator+=(difference_type __n) noexcept + { _M_current += __n; return *this; } + + + __normal_iterator + operator+(difference_type __n) const noexcept + { return __normal_iterator(_M_current + __n); } + + + __normal_iterator& + operator-=(difference_type __n) noexcept + { _M_current -= __n; return *this; } + + + __normal_iterator + operator-(difference_type __n) const noexcept + { return __normal_iterator(_M_current - __n); } + + + const _Iterator& + base() const noexcept + { return _M_current; } + }; +# 1205 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline bool + operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator==(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + + + + + + template + + + [[__nodiscard__]] + inline auto + operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept + -> decltype(__lhs.base() - __rhs.base()) + + + + + + { return __lhs.base() - __rhs.base(); } + + template + [[__nodiscard__]] + inline typename __normal_iterator<_Iterator, _Container>::difference_type + operator-(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() - __rhs.base(); } + + template + [[__nodiscard__]] + inline __normal_iterator<_Iterator, _Container> + operator+(typename __normal_iterator<_Iterator, _Container>::difference_type + __n, const __normal_iterator<_Iterator, _Container>& __i) + noexcept + { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } + + +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + + _Iterator + __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it.base(); } + + + + + + + template + constexpr auto + __to_address(const __gnu_cxx::__normal_iterator<_Iterator, + _Container>& __it) noexcept + -> decltype(std::__to_address(__it.base())) + { return std::__to_address(__it.base()); } +# 1412 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + namespace __detail + { +# 1428 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + } +# 1439 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class move_iterator + + + + { + _Iterator _M_current; + + using __traits_type = iterator_traits<_Iterator>; + + using __base_ref = typename __traits_type::reference; + + + template + friend class move_iterator; +# 1478 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + public: + using iterator_type = _Iterator; +# 1490 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + + typedef _Iterator pointer; + + + using reference + = __conditional_t::value, + typename remove_reference<__base_ref>::type&&, + __base_ref>; + + + constexpr + move_iterator() + : _M_current() { } + + explicit constexpr + move_iterator(iterator_type __i) + : _M_current(std::move(__i)) { } + + template + + + + constexpr + move_iterator(const move_iterator<_Iter>& __i) + : _M_current(__i._M_current) { } + + template + + + + + constexpr + move_iterator& operator=(const move_iterator<_Iter>& __i) + { + _M_current = __i._M_current; + return *this; + } + + + [[__nodiscard__]] + constexpr iterator_type + base() const + { return _M_current; } +# 1548 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + + + + { return static_cast(*_M_current); } + + + [[__nodiscard__]] + constexpr pointer + operator->() const + { return _M_current; } + + constexpr move_iterator& + operator++() + { + ++_M_current; + return *this; + } + + constexpr move_iterator + operator++(int) + { + move_iterator __tmp = *this; + ++_M_current; + return __tmp; + } + + + + + + + + constexpr move_iterator& + operator--() + { + --_M_current; + return *this; + } + + constexpr move_iterator + operator--(int) + { + move_iterator __tmp = *this; + --_M_current; + return __tmp; + } + + [[__nodiscard__]] + constexpr move_iterator + operator+(difference_type __n) const + { return move_iterator(_M_current + __n); } + + constexpr move_iterator& + operator+=(difference_type __n) + { + _M_current += __n; + return *this; + } + + [[__nodiscard__]] + constexpr move_iterator + operator-(difference_type __n) const + { return move_iterator(_M_current - __n); } + + constexpr move_iterator& + operator-=(difference_type __n) + { + _M_current -= __n; + return *this; + } + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + + + + { return std::move(_M_current[__n]); } +# 1662 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + }; + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() == __y.base(); } +# 1683 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return !(__x == __y); } + + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() < __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + + { return __x.base() == __y.base(); } +# 1750 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() < __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + template + [[__nodiscard__]] + inline constexpr auto + operator-(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + -> decltype(__x.base() - __y.base()) + { return __x.base() - __y.base(); } + + template + [[__nodiscard__]] + inline constexpr move_iterator<_Iterator> + operator+(typename move_iterator<_Iterator>::difference_type __n, + const move_iterator<_Iterator>& __x) + + + + { return __x + __n; } + + template + [[__nodiscard__]] + inline constexpr move_iterator<_Iterator> + make_move_iterator(_Iterator __i) + { return move_iterator<_Iterator>(std::move(__i)); } + + template::value_type>::value, + _Iterator, move_iterator<_Iterator>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Iterator __i) + { return _ReturnType(__i); } + + + + template::value, + const _Tp*, move_iterator<_Tp*>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Tp* __i) + { return _ReturnType(__i); } +# 2964 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + + auto + __niter_base(move_iterator<_Iterator> __it) + -> decltype(make_move_iterator(__niter_base(__it.base()))) + { return make_move_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template + + auto + __miter_base(move_iterator<_Iterator> __it) + -> decltype(__miter_base(__it.base())) + { return __miter_base(__it.base()); } +# 2996 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + using __iter_key_t = remove_const_t< + + + + typename iterator_traits<_InputIterator>::value_type::first_type>; + + + template + using __iter_val_t + + + + = typename iterator_traits<_InputIterator>::value_type::second_type; + + + template + struct pair; + + template + using __iter_to_alloc_t + = pair, __iter_val_t<_InputIterator>>; + + + +} +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/debug/debug.h" 1 3 +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/debug/debug.h" 3 +namespace std +{ + namespace __debug { } +} + + + + +namespace __gnu_debug +{ + using namespace std::__debug; + + template + struct _Safe_iterator; +} +# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/predefined_ops.h" 1 3 +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/predefined_ops.h" 3 +namespace __gnu_cxx +{ +namespace __ops +{ + struct _Iter_less_iter + { + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 < *__it2; } + }; + + constexpr + inline _Iter_less_iter + __iter_less_iter() + { return _Iter_less_iter(); } + + struct _Iter_less_val + { + + constexpr _Iter_less_val() = default; + + + + + + explicit + _Iter_less_val(_Iter_less_iter) { } + + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it < __val; } + }; + + + inline _Iter_less_val + __iter_less_val() + { return _Iter_less_val(); } + + + inline _Iter_less_val + __iter_comp_val(_Iter_less_iter) + { return _Iter_less_val(); } + + struct _Val_less_iter + { + + constexpr _Val_less_iter() = default; + + + + + + explicit + _Val_less_iter(_Iter_less_iter) { } + + template + + bool + operator()(_Value& __val, _Iterator __it) const + { return __val < *__it; } + }; + + + inline _Val_less_iter + __val_less_iter() + { return _Val_less_iter(); } + + + inline _Val_less_iter + __val_comp_iter(_Iter_less_iter) + { return _Val_less_iter(); } + + struct _Iter_equal_to_iter + { + template + + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 == *__it2; } + }; + + + inline _Iter_equal_to_iter + __iter_equal_to_iter() + { return _Iter_equal_to_iter(); } + + struct _Iter_equal_to_val + { + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it == __val; } + }; + + + inline _Iter_equal_to_val + __iter_equal_to_val() + { return _Iter_equal_to_val(); } + + + inline _Iter_equal_to_val + __iter_comp_val(_Iter_equal_to_iter) + { return _Iter_equal_to_val(); } + + template + struct _Iter_comp_iter + { + _Compare _M_comp; + + explicit constexpr + _Iter_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) + { return bool(_M_comp(*__it1, *__it2)); } + }; + + template + constexpr + inline _Iter_comp_iter<_Compare> + __iter_comp_iter(_Compare __comp) + { return _Iter_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_comp_val + { + _Compare _M_comp; + + + explicit + _Iter_comp_val(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Iterator __it, _Value& __val) + { return bool(_M_comp(*__it, __val)); } + }; + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Compare __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Iter_comp_iter<_Compare> __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + struct _Val_comp_iter + { + _Compare _M_comp; + + + explicit + _Val_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Value& __val, _Iterator __it) + { return bool(_M_comp(__val, *__it)); } + }; + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Compare __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Iter_comp_iter<_Compare> __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_equals_val + { + _Value& _M_value; + + + explicit + _Iter_equals_val(_Value& __value) + : _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return *__it == _M_value; } + }; + + template + + inline _Iter_equals_val<_Value> + __iter_equals_val(_Value& __val) + { return _Iter_equals_val<_Value>(__val); } + + template + struct _Iter_equals_iter + { + _Iterator1 _M_it1; + + + explicit + _Iter_equals_iter(_Iterator1 __it1) + : _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return *__it2 == *_M_it1; } + }; + + template + + inline _Iter_equals_iter<_Iterator> + __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) + { return _Iter_equals_iter<_Iterator>(__it); } + + template + struct _Iter_pred + { + _Predicate _M_pred; + + + explicit + _Iter_pred(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_pred<_Predicate> + __pred_iter(_Predicate __pred) + { return _Iter_pred<_Predicate>(std::move(__pred)); } + + template + struct _Iter_comp_to_val + { + _Compare _M_comp; + _Value& _M_value; + + + _Iter_comp_to_val(_Compare __comp, _Value& __value) + : _M_comp(std::move(__comp)), _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_comp(*__it, _M_value)); } + }; + + template + _Iter_comp_to_val<_Compare, _Value> + + __iter_comp_val(_Compare __comp, _Value &__val) + { + return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val); + } + + template + struct _Iter_comp_to_iter + { + _Compare _M_comp; + _Iterator1 _M_it1; + + + _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) + : _M_comp(std::move(__comp)), _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return bool(_M_comp(*__it2, *_M_it1)); } + }; + + template + + inline _Iter_comp_to_iter<_Compare, _Iterator> + __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) + { + return _Iter_comp_to_iter<_Compare, _Iterator>( + std::move(__comp._M_comp), __it); + } + + template + struct _Iter_negate + { + _Predicate _M_pred; + + + explicit + _Iter_negate(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return !bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_negate<_Predicate> + __negate(_Iter_pred<_Predicate> __pred) + { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } + +} +} +# 72 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 + +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/concepts" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/concepts" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/concepts" 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/concepts" 2 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 2 3 +# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 + template + constexpr _Tp + __rotl(_Tp __x, int __s) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) == 0) + { + + + constexpr unsigned __uNd = _Nd; + const unsigned __r = __s; + return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd)); + } + const int __r = __s % _Nd; + if (__r == 0) + return __x; + else if (__r > 0) + return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); + else + return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); + } + + template + constexpr _Tp + __rotr(_Tp __x, int __s) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) == 0) + { + + + constexpr unsigned __uNd = _Nd; + const unsigned __r = __s; + return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd)); + } + const int __r = __s % _Nd; + if (__r == 0) + return __x; + else if (__r > 0) + return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); + else + return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); + } + + template + constexpr int + __countl_zero(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + if (__x == 0) + return _Nd; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + { + constexpr int __diff = _Nd_u - _Nd; + return __builtin_clz(__x) - __diff; + } + else if constexpr (_Nd <= _Nd_ul) + { + constexpr int __diff = _Nd_ul - _Nd; + return __builtin_clzl(__x) - __diff; + } + else if constexpr (_Nd <= _Nd_ull) + { + constexpr int __diff = _Nd_ull - _Nd; + return __builtin_clzll(__x) - __diff; + } + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + unsigned long long __high = __x >> _Nd_ull; + if (__high != 0) + { + constexpr int __diff = (2 * _Nd_ull) - _Nd; + return __builtin_clzll(__high) - __diff; + } + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + return (_Nd - _Nd_ull) + __builtin_clzll(__low); + } + } + + template + constexpr int + __countl_one(_Tp __x) noexcept + { + return std::__countl_zero<_Tp>((_Tp)~__x); + } + + template + constexpr int + __countr_zero(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + if (__x == 0) + return _Nd; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + return __builtin_ctz(__x); + else if constexpr (_Nd <= _Nd_ul) + return __builtin_ctzl(__x); + else if constexpr (_Nd <= _Nd_ull) + return __builtin_ctzll(__x); + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + if (__low != 0) + return __builtin_ctzll(__low); + unsigned long long __high = __x >> _Nd_ull; + return __builtin_ctzll(__high) + _Nd_ull; + } + } + + template + constexpr int + __countr_one(_Tp __x) noexcept + { + return std::__countr_zero((_Tp)~__x); + } + + template + constexpr int + __popcount(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + return __builtin_popcount(__x); + else if constexpr (_Nd <= _Nd_ul) + return __builtin_popcountl(__x); + else if constexpr (_Nd <= _Nd_ull) + return __builtin_popcountll(__x); + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + unsigned long long __high = __x >> _Nd_ull; + return __builtin_popcountll(__low) + __builtin_popcountll(__high); + } + } + + template + constexpr bool + __has_single_bit(_Tp __x) noexcept + { return std::__popcount(__x) == 1; } + + template + constexpr _Tp + __bit_ceil(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + if (__x == 0 || __x == 1) + return 1; + auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u)); + + + + + if (!std::__is_constant_evaluated()) + { + do { if (std::__is_constant_evaluated() && !bool(__shift_exponent != __int_traits<_Tp>::__digits)) std::__glibcxx_assert_fail(); } while (false); + } + + using __promoted_type = decltype(__x << 1); + if constexpr (!is_same<__promoted_type, _Tp>::value) + { + + + + + + const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; + __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; + } + return (_Tp)1u << __shift_exponent; + } + + template + constexpr _Tp + __bit_floor(_Tp __x) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if (__x == 0) + return 0; + return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1))); + } + + template + constexpr int + __bit_width(_Tp __x) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + return _Nd - std::__countl_zero(__x); + } +# 482 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 + +} +# 77 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + template + constexpr + inline int + __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num) + { + + static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp"); +# 108 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); + } +# 152 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline void + iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) + { + + + + +# 185 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + swap(*__a, *__b); + + } +# 201 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + _ForwardIterator2 + swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + std::iter_swap(__first1, __first2); + return __first2; + } +# 230 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b) + { + + + + if (__b < __a) + return __b; + return __a; + } +# 254 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b) + { + + + + if (__a < __b) + return __b; + return __a; + } +# 278 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__b, __a)) + return __b; + return __a; + } +# 300 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__a, __b)) + return __b; + return __a; + } + + + + template + + inline _Iterator + __niter_base(_Iterator __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it; } +# 332 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + decltype(std::__niter_base(std::declval<_Ite>())) + __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, + std::random_access_iterator_tag>&) + noexcept(std::is_nothrow_copy_constructible<_Ite>::value); + + + + + + template + + inline _From + __niter_wrap(_From __from, _To __res) + { return __from + (std::__niter_base(__res) - std::__niter_base(__from)); } + + + template + + inline _Iterator + __niter_wrap(const _Iterator&, _Iterator __res) + { return __res; } + + + + + + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = *__first; + return __result; + } + }; + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = std::move(*__first); + return __result; + } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = *__first; + ++__first; + ++__result; + } + return __result; + } + + template + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to = *__from; } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = std::move(*__first); + ++__first; + ++__result; + } + return __result; + } + + template + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to = std::move(*__from); } + }; + + + template + struct __copy_move<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_m(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num = __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); + else if (_Num == 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result, __first); + return __result + _Num; + } + }; + + + + template + struct _Deque_iterator; + + struct _Bit_iterator; + + + + + + + template + struct char_traits; + + template + class istreambuf_iterator; + + template + class ostreambuf_iterator; + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(_CharT*, _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(const _CharT*, const _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + _CharT*>::__type + __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_move_a2( + istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>); + + + template + + inline _OI + __copy_move_a2(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::iterator_category _Category; + + + + + + return std::__copy_move<_IsMove, __memcpyable<_OI, _II>::__value, + _Category>::__copy_m(__first, __last, __result); + } + + template + _OI + __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + std::_Deque_iterator<_OTp, _OTp&, _OTp*> + __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_OTp, _OTp&, _OTp*>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, + std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + + inline _OI + __copy_move_a1(_II __first, _II __last, _OI __result) + { return std::__copy_move_a2<_IsMove>(__first, __last, __result); } + + template + + inline _OI + __copy_move_a(_II __first, _II __last, _OI __result) + { + return std::__niter_wrap(__result, + std::__copy_move_a1<_IsMove>(std::__niter_base(__first), + std::__niter_base(__last), + std::__niter_base(__result))); + } + + template + + _OI + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + + ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); + + template + + _OutputIterator + __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, + bool) + { + if (__n > 0) + { + while (true) + { + *__result = *__first; + ++__result; + if (--__n > 0) + ++__first; + else + break; + } + } + return __result; + } + + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, _CharT*>::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, + _Size, _CharT*, bool); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, _Size, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>, + bool); +# 639 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _OI + copy(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a<__is_move_iterator<_II>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 672 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _OI + move(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a(std::__miter_base(__first), + std::__miter_base(__last), __result); + } + + + + + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = *--__last; + return __result; + } + }; + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n = __last - __first; + for (; __n > 0; --__n) + *--__result = *--__last; + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n = __last - __first; + for (; __n > 0; --__n) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template + struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_move_b(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num = __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); + else if (_Num == 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result - 1, __first); + return __result - _Num; + } + }; + + template + + inline _BI2 + __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) + { + typedef typename iterator_traits<_BI1>::iterator_category _Category; + + + + + + return std::__copy_move_backward<_IsMove, + __memcpyable<_BI2, _BI1>::__value, + _Category>::__copy_move_b(__first, + __last, + __result); + } + + template + + inline _BI2 + __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) + { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); } + + template + _OI + __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + std::_Deque_iterator<_OTp, _OTp&, _OTp*> + __copy_move_backward_a1( + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_OTp, _OTp&, _OTp*>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, + std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __copy_move_backward_a1(_II, _II, + std::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + + inline _OI + __copy_move_backward_a(_II __first, _II __last, _OI __result) + { + return std::__niter_wrap(__result, + std::__copy_move_backward_a1<_IsMove> + (std::__niter_base(__first), std::__niter_base(__last), + std::__niter_base(__result))); + } + + template + + _OI + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_backward_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + + ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); +# 875 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _BI2 + copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + ; + + return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 910 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _BI2 + move_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + ; + + return std::__copy_move_backward_a(std::__miter_base(__first), + std::__miter_base(__last), + __result); + } + + + + + + + template + + inline typename + __gnu_cxx::__enable_if::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + for (; __first != __last; ++__first) + *__first = __value; + } + + template + + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __first != __last; ++__first) + *__first = __tmp; + } + + + template + + inline typename + __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type + __fill_a1(_Tp* __first, _Tp* __last, const _Tp& __c) + { + const _Tp __tmp = __c; +# 971 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + if (const size_t __len = __last - __first) + __builtin_memset(__first, static_cast(__tmp), __len); + } + + template + + inline void + __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first, + ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last, + const _Tp& __value) + { std::__fill_a1(__first.base(), __last.base(), __value); } + + template + void + __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const _VTp&); + + + void + __fill_a1(std::_Bit_iterator, std::_Bit_iterator, + const bool&); + + template + + inline void + __fill_a(_FIte __first, _FIte __last, const _Tp& __value) + { std::__fill_a1(__first, __last, __value); } + + template + + void + __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const _Tp&); +# 1019 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline void + fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) + { + + + + ; + + std::__fill_a(__first, __last, __value); + } + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wlong-long" + + inline constexpr int + __size_to_integer(int __n) { return __n; } + inline constexpr unsigned + __size_to_integer(unsigned __n) { return __n; } + inline constexpr long + __size_to_integer(long __n) { return __n; } + inline constexpr unsigned long + __size_to_integer(unsigned long __n) { return __n; } + inline constexpr long long + __size_to_integer(long long __n) { return __n; } + inline constexpr unsigned long long + __size_to_integer(unsigned long long __n) { return __n; } + + + __extension__ inline constexpr __int128 + __size_to_integer(__int128 __n) { return __n; } + __extension__ inline constexpr unsigned __int128 + __size_to_integer(unsigned __int128 __n) { return __n; } +# 1073 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + inline constexpr long long + __size_to_integer(float __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(double __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(long double __n) { return (long long)__n; } + + __extension__ inline constexpr long long + __size_to_integer(__float128 __n) { return (long long)__n; } + +#pragma GCC diagnostic pop + + template + + inline typename + __gnu_cxx::__enable_if::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + for (; __n > 0; --__n, (void) ++__first) + *__first = __value; + return __first; + } + + template + + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __n > 0; --__n, (void) ++__first) + *__first = __tmp; + return __first; + } + + template + + ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first, + _Size __n, const _Tp& __value, + std::input_iterator_tag); + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::output_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + return __fill_n_a1(__first, __n, __value); + } + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::input_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + return __fill_n_a1(__first, __n, __value); + } + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::random_access_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + if (__n <= 0) + return __first; + + ; + + std::__fill_a(__first, __first + __n, __value); + return __first + __n; + } +# 1175 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _OI + fill_n(_OI __first, _Size __n, const _Tp& __value) + { + + + + return std::__fill_n_a(__first, std::__size_to_integer(__n), __value, + std::__iterator_category(__first)); + } + + template + struct __equal + { + template + + static bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + for (; __first1 != __last1; ++__first1, (void) ++__first2) + if (!(*__first1 == *__first2)) + return false; + return true; + } + }; + + template<> + struct __equal + { + template + + static bool + equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) + { + if (const size_t __len = (__last1 - __first1)) + return !std::__memcmp(__first1, __first2, __len); + return true; + } + }; + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _II); + + template + bool + __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(_II, _II, + std::_Deque_iterator<_Tp, _Ref, _Ptr>); + + template + + inline bool + __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + const bool __simple = ((__is_integer<_ValueType1>::__value + || __is_pointer<_ValueType1>::__value) + && __memcmpable<_II1, _II2>::__value); + return std::__equal<__simple>::equal(__first1, __last1, __first2); + } + + template + + inline bool + __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) + { + return std::__equal_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2)); + } + + template + + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + _II2); + + template + + bool + __equal_aux(_II1, _II1, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + struct __lc_rai + { + template + + static _II1 + __newlast1(_II1, _II1 __last1, _II2, _II2) + { return __last1; } + + template + + static bool + __cnd2(_II __first, _II __last) + { return __first != __last; } + }; + + template<> + struct __lc_rai + { + template + + static _RAI1 + __newlast1(_RAI1 __first1, _RAI1 __last1, + _RAI2 __first2, _RAI2 __last2) + { + const typename iterator_traits<_RAI1>::difference_type + __diff1 = __last1 - __first1; + const typename iterator_traits<_RAI2>::difference_type + __diff2 = __last2 - __first2; + return __diff2 < __diff1 ? __first1 + __diff2 : __last1; + } + + template + static bool + __cnd2(_RAI, _RAI) + { return true; } + }; + + template + + bool + __lexicographical_compare_impl(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, + _Compare __comp) + { + typedef typename iterator_traits<_II1>::iterator_category _Category1; + typedef typename iterator_traits<_II2>::iterator_category _Category2; + typedef std::__lc_rai<_Category1, _Category2> __rai_type; + + __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); + for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); + ++__first1, (void)++__first2) + { + if (__comp(__first1, __first2)) + return true; + if (__comp(__first2, __first1)) + return false; + } + return __first1 == __last1 && __first2 != __last2; + } + + template + struct __lexicographical_compare + { + template + + static bool + __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using __gnu_cxx::__ops::__iter_less_iter; + return std::__lexicographical_compare_impl(__first1, __last1, + __first2, __last2, + __iter_less_iter()); + } + + template + + static int + __3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + while (__first1 != __last1) + { + if (__first2 == __last2) + return +1; + if (*__first1 < *__first2) + return -1; + if (*__first2 < *__first1) + return +1; + ++__first1; + ++__first2; + } + return int(__first2 == __last2) - 1; + } + }; + + template<> + struct __lexicographical_compare + { + template + + static bool + __lc(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { return __3way(__first1, __last1, __first2, __last2) < 0; } + + template + + static ptrdiff_t + __3way(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { + const size_t __len1 = __last1 - __first1; + const size_t __len2 = __last2 - __first2; + if (const size_t __len = std::min(__len1, __len2)) + if (int __result = std::__memcmp(__first1, __first2, __len)) + return __result; + return ptrdiff_t(__len1 - __len2); + } + }; + + template + + inline bool + __lexicographical_compare_aux1(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + typedef typename iterator_traits<_II2>::value_type _ValueType2; + const bool __simple = + (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value + && __is_pointer<_II1>::__value + && __is_pointer<_II2>::__value + + + + + + + + ); + + return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, + __first2, __last2); + } + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + _Tp2*, _Tp2*); + + template + bool + __lexicographical_compare_aux1(_Tp1*, _Tp1*, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + + inline bool + __lexicographical_compare_aux(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + return std::__lexicographical_compare_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2), + std::__niter_base(__last2)); + } + + template + + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + _II2, _II2); + + template + + bool + __lexicographical_compare_aux( + _II1, _II1, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + + _ForwardIterator + __lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len = std::distance(__first, __last); + + while (__len > 0) + { + _DistanceType __half = __len >> 1; + _ForwardIterator __middle = __first; + std::advance(__middle, __half); + if (__comp(__middle, __val)) + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + else + __len = __half; + } + return __first; + } +# 1527 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline _ForwardIterator + lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + + + + + ; + + return std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val()); + } + + + + template + inline constexpr _Tp + __lg(_Tp __n) + { + + return std::__bit_width(make_unsigned_t<_Tp>(__n)) - 1; +# 1563 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + } + + +# 1579 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + + + + + + + ; + + return std::__equal_aux(__first1, __last1, __first2); + } +# 1610 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return true; + } + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++17-extensions" + + + template + + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if constexpr (_RAIters::value) + { + if ((__last1 - __first1) != (__last2 - __first2)) + return false; + return std::equal(__first1, __last1, __first2); + } + else + { + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!(*__first1 == *__first2)) + return false; + return __first1 == __last1 && __first2 == __last2; + } + } + + + template + + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, + _BinaryPredicate __binary_pred) + { + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if constexpr (_RAIters::value) + { + if ((__last1 - __first1) != (__last2 - __first2)) + return false; + return std::equal(__first1, __last1, __first2, + __binary_pred); + } + else + { + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return __first1 == __last1 && __first2 == __last2; + } + } +#pragma GCC diagnostic pop +# 1701 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + + + + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2); + } +# 1734 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2, + __binary_pred); + } +# 1766 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + + + + + + + + + + ; + ; + + return std::__lexicographical_compare_aux(__first1, __last1, + __first2, __last2); + } +# 1801 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, _Compare __comp) + { + + + + ; + ; + + return std::__lexicographical_compare_impl + (__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 1916 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 1944 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2) + { + + + + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 1978 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + template + + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __first2 != __last2 + && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 2026 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2) + { + + + + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 2062 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + + + template + + inline _InputIterator + __find_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred, input_iterator_tag) + { + while (__first != __last && !__pred(__first)) + ++__first; + return __first; + } + + + template + + _RandomAccessIterator + __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Predicate __pred, random_access_iterator_tag) + { + typename iterator_traits<_RandomAccessIterator>::difference_type + __trip_count = (__last - __first) >> 2; + + for (; __trip_count > 0; --__trip_count) + { + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + } + + switch (__last - __first) + { + case 3: + if (__pred(__first)) + return __first; + ++__first; + + case 2: + if (__pred(__first)) + return __first; + ++__first; + + case 1: + if (__pred(__first)) + return __first; + ++__first; + + case 0: + default: + return __last; + } + } + + template + + inline _Iterator + __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) + { + return __find_if(__first, __last, __pred, + std::__iterator_category(__first)); + } + + template + + typename iterator_traits<_InputIterator>::difference_type + __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { + typename iterator_traits<_InputIterator>::difference_type __n = 0; + for (; __first != __last; ++__first) + if (__pred(__first)) + ++__n; + return __n; + } + + template + + _ForwardIterator + __remove_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + __first = std::__find_if(__first, __last, __pred); + if (__first == __last) + return __first; + _ForwardIterator __result = __first; + ++__first; + for (; __first != __last; ++__first) + if (!__pred(__first)) + { + *__result = std::move(*__first); + ++__result; + } + return __result; + } + + template + + _ForwardIterator1 + __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __predicate) + { + + if (__first1 == __last1 || __first2 == __last2) + return __first1; + + + _ForwardIterator2 __p1(__first2); + if (++__p1 == __last2) + return std::__find_if(__first1, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); + + + _ForwardIterator1 __current = __first1; + + for (;;) + { + __first1 = + std::__find_if(__first1, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); + + if (__first1 == __last1) + return __last1; + + _ForwardIterator2 __p = __p1; + __current = __first1; + if (++__current == __last1) + return __last1; + + while (__predicate(__current, __p)) + { + if (++__p == __last2) + return __first1; + if (++__current == __last1) + return __last1; + } + ++__first1; + } + return __first1; + } + + + template + + bool + __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _BinaryPredicate __pred) + { + + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!__pred(__first1, __first2)) + break; + + if (__first1 == __last1) + return true; + + + + _ForwardIterator2 __last2 = __first2; + std::advance(__last2, std::distance(__first1, __last1)); + for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) + { + if (__scan != std::__find_if(__first1, __scan, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) + continue; + + auto __matches + = std::__count_if(__first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); + if (0 == __matches || + std::__count_if(__scan, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) + != __matches) + return false; + } + return true; + } +# 2286 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + + ; + + return std::__is_permutation(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } + + + +# 2328 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _ForwardIterator1 + search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __predicate) + { + + + + + + + ; + ; + + return std::__search(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__predicate)); + } + + + +} +# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 1 3 +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + +# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +# 158 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + enum float_round_style + { + round_indeterminate = -1, + round_toward_zero = 0, + round_to_nearest = 1, + round_toward_infinity = 2, + round_toward_neg_infinity = 3 + }; + + + + + + + + enum float_denorm_style + { + + denorm_indeterminate = -1, + + denorm_absent = 0, + + denorm_present = 1 + }; +# 202 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + struct __numeric_limits_base + { + + + static constexpr bool is_specialized = false; + + + + + static constexpr int digits = 0; + + + static constexpr int digits10 = 0; + + + + + static constexpr int max_digits10 = 0; + + + + static constexpr bool is_signed = false; + + + static constexpr bool is_integer = false; + + + + + static constexpr bool is_exact = false; + + + + static constexpr int radix = 0; + + + + static constexpr int min_exponent = 0; + + + + static constexpr int min_exponent10 = 0; + + + + + static constexpr int max_exponent = 0; + + + + static constexpr int max_exponent10 = 0; + + + static constexpr bool has_infinity = false; + + + + static constexpr bool has_quiet_NaN = false; + + + + static constexpr bool has_signaling_NaN = false; + + + static constexpr float_denorm_style has_denorm = denorm_absent; + + + + static constexpr bool has_denorm_loss = false; + + + + static constexpr bool is_iec559 = false; + + + + + static constexpr bool is_bounded = false; +# 288 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + static constexpr bool is_modulo = false; + + + static constexpr bool traps = false; + + + static constexpr bool tinyness_before = false; + + + + + static constexpr float_round_style round_style = + round_toward_zero; + }; +# 311 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + template + struct numeric_limits : public __numeric_limits_base + { + + + static constexpr _Tp + min() noexcept { return _Tp(); } + + + static constexpr _Tp + max() noexcept { return _Tp(); } + + + + + static constexpr _Tp + lowest() noexcept { return _Tp(); } + + + + + static constexpr _Tp + epsilon() noexcept { return _Tp(); } + + + static constexpr _Tp + round_error() noexcept { return _Tp(); } + + + static constexpr _Tp + infinity() noexcept { return _Tp(); } + + + + static constexpr _Tp + quiet_NaN() noexcept { return _Tp(); } + + + + static constexpr _Tp + signaling_NaN() noexcept { return _Tp(); } + + + + + static constexpr _Tp + denorm_min() noexcept { return _Tp(); } + }; + + + + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; +# 383 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr bool + min() noexcept { return false; } + + static constexpr bool + max() noexcept { return true; } + + + static constexpr bool + lowest() noexcept { return min(); } + + static constexpr int digits = 1; + static constexpr int digits10 = 0; + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr bool + epsilon() noexcept { return false; } + + static constexpr bool + round_error() noexcept { return false; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr bool + infinity() noexcept { return false; } + + static constexpr bool + quiet_NaN() noexcept { return false; } + + static constexpr bool + signaling_NaN() noexcept { return false; } + + static constexpr bool + denorm_min() noexcept { return false; } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + + + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char + min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); } + + static constexpr char + max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); } + + + static constexpr char + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = ((char)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char + epsilon() noexcept { return 0; } + + static constexpr char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr + char infinity() noexcept { return char(); } + + static constexpr char + quiet_NaN() noexcept { return char(); } + + static constexpr char + signaling_NaN() noexcept { return char(); } + + static constexpr char + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr signed char + min() noexcept { return -0x7f - 1; } + + static constexpr signed char + max() noexcept { return 0x7f; } + + + static constexpr signed char + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr signed char + epsilon() noexcept { return 0; } + + static constexpr signed char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr signed char + infinity() noexcept { return static_cast(0); } + + static constexpr signed char + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr signed char + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr signed char + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned char + min() noexcept { return 0; } + + static constexpr unsigned char + max() noexcept { return 0x7f * 2U + 1; } + + + static constexpr unsigned char + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned char + epsilon() noexcept { return 0; } + + static constexpr unsigned char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned char + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned char + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned char + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned char + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr wchar_t + min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); } + + static constexpr wchar_t + max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); } + + + static constexpr wchar_t + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = ((wchar_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr wchar_t + epsilon() noexcept { return 0; } + + static constexpr wchar_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr wchar_t + infinity() noexcept { return wchar_t(); } + + static constexpr wchar_t + quiet_NaN() noexcept { return wchar_t(); } + + static constexpr wchar_t + signaling_NaN() noexcept { return wchar_t(); } + + static constexpr wchar_t + denorm_min() noexcept { return wchar_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; +# 796 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char16_t + min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); } + + static constexpr char16_t + max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); } + + static constexpr char16_t + lowest() noexcept { return min(); } + + static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136); + static constexpr int max_digits10 = 0; + static constexpr bool is_signed = ((char16_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char16_t + epsilon() noexcept { return 0; } + + static constexpr char16_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr char16_t + infinity() noexcept { return char16_t(); } + + static constexpr char16_t + quiet_NaN() noexcept { return char16_t(); } + + static constexpr char16_t + signaling_NaN() noexcept { return char16_t(); } + + static constexpr char16_t + denorm_min() noexcept { return char16_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char32_t + min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); } + + static constexpr char32_t + max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); } + + static constexpr char32_t + lowest() noexcept { return min(); } + + static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136); + static constexpr int max_digits10 = 0; + static constexpr bool is_signed = ((char32_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char32_t + epsilon() noexcept { return 0; } + + static constexpr char32_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr char32_t + infinity() noexcept { return char32_t(); } + + static constexpr char32_t + quiet_NaN() noexcept { return char32_t(); } + + static constexpr char32_t + signaling_NaN() noexcept { return char32_t(); } + + static constexpr char32_t + denorm_min() noexcept { return char32_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style = round_toward_zero; + }; + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr short + min() noexcept { return -0x7fff - 1; } + + static constexpr short + max() noexcept { return 0x7fff; } + + + static constexpr short + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0)); + static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr short + epsilon() noexcept { return 0; } + + static constexpr short + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr short + infinity() noexcept { return short(); } + + static constexpr short + quiet_NaN() noexcept { return short(); } + + static constexpr short + signaling_NaN() noexcept { return short(); } + + static constexpr short + denorm_min() noexcept { return short(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned short + min() noexcept { return 0; } + + static constexpr unsigned short + max() noexcept { return 0x7fff * 2U + 1; } + + + static constexpr unsigned short + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned short + epsilon() noexcept { return 0; } + + static constexpr unsigned short + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned short + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned short + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned short + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned short + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr int + min() noexcept { return -0x7fffffff - 1; } + + static constexpr int + max() noexcept { return 0x7fffffff; } + + + static constexpr int + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0)); + static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr int + epsilon() noexcept { return 0; } + + static constexpr int + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr int + infinity() noexcept { return static_cast(0); } + + static constexpr int + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr int + signaling_NaN() noexcept { return static_cast(0); } + + static constexpr int + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned int + min() noexcept { return 0; } + + static constexpr unsigned int + max() noexcept { return 0x7fffffff * 2U + 1; } + + + static constexpr unsigned int + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned int + epsilon() noexcept { return 0; } + + static constexpr unsigned int + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned int + infinity() noexcept { return static_cast(0); } + + static constexpr unsigned int + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned int + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned int + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr long + min() noexcept { return -0x7fffffffffffffffL - 1; } + + static constexpr long + max() noexcept { return 0x7fffffffffffffffL; } + + + static constexpr long + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0)); + static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr long + epsilon() noexcept { return 0; } + + static constexpr long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr long + infinity() noexcept { return static_cast(0); } + + static constexpr long + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr long + signaling_NaN() noexcept { return static_cast(0); } + + static constexpr long + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned long + min() noexcept { return 0; } + + static constexpr unsigned long + max() noexcept { return 0x7fffffffffffffffL * 2UL + 1; } + + + static constexpr unsigned long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned long + epsilon() noexcept { return 0; } + + static constexpr unsigned long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned long + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned long + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr long long + min() noexcept { return -0x7fffffffffffffffLL - 1; } + + static constexpr long long + max() noexcept { return 0x7fffffffffffffffLL; } + + + static constexpr long long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(long long) * 8 - ((long long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr long long + epsilon() noexcept { return 0; } + + static constexpr long long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr long long + infinity() noexcept { return static_cast(0); } + + static constexpr long long + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr long long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr long long + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned long long + min() noexcept { return 0; } + + static constexpr unsigned long long + max() noexcept { return 0x7fffffffffffffffLL * 2ULL + 1; } + + + static constexpr unsigned long long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned long long + epsilon() noexcept { return 0; } + + static constexpr unsigned long long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned long long + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; +# 1637 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + __extension__ template<> struct numeric_limits<__int128> { static constexpr bool is_specialized = true; static constexpr __int128 min() noexcept { return (((__int128)(-1) < 0) ? -(((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0) - 1 : (__int128)0); } static constexpr __int128 max() noexcept { return (((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0); } static constexpr int digits = 128 - 1; static constexpr int digits10 = (128 - 1) * 643L / 2136; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr __int128 epsilon() noexcept { return 0; } static constexpr __int128 round_error() noexcept { return 0; } static constexpr __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 0; static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr __int128 infinity() noexcept { return static_cast<__int128>(0); } static constexpr __int128 quiet_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 signaling_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 denorm_min() noexcept { return static_cast<__int128>(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; __extension__ template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr unsigned __int128 min() noexcept { return 0; } static constexpr unsigned __int128 max() noexcept { return (((unsigned __int128)(-1) < 0) ? (((((unsigned __int128)1 << ((128 - ((unsigned __int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(unsigned __int128)0); } static constexpr unsigned __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 0; static constexpr int digits = 128; static constexpr int digits10 = 128 * 643L / 2136; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr unsigned __int128 epsilon() noexcept { return 0; } static constexpr unsigned __int128 round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr unsigned __int128 infinity() noexcept { return static_cast(0); } static constexpr unsigned __int128 quiet_NaN() noexcept { return static_cast(0); } static constexpr unsigned __int128 signaling_NaN() noexcept { return static_cast(0); } static constexpr unsigned __int128 denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = true; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; +# 1669 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr float + min() noexcept { return 1.17549435082228750796873653722224568e-38F; } + + static constexpr float + max() noexcept { return 3.40282346638528859811704183484516925e+38F; } + + + static constexpr float + lowest() noexcept { return -3.40282346638528859811704183484516925e+38F; } + + + static constexpr int digits = 24; + static constexpr int digits10 = 6; + + static constexpr int max_digits10 + = (2 + (24) * 643L / 2136); + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr float + epsilon() noexcept { return 1.19209289550781250000000000000000000e-7F; } + + static constexpr float + round_error() noexcept { return 0.5F; } + + static constexpr int min_exponent = (-125); + static constexpr int min_exponent10 = (-37); + static constexpr int max_exponent = 128; + static constexpr int max_exponent10 = 38; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + static constexpr bool has_signaling_NaN = has_quiet_NaN; + static constexpr float_denorm_style has_denorm + = bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + = false; + + static constexpr float + infinity() noexcept { return __builtin_huge_valf(); } + + static constexpr float + quiet_NaN() noexcept { return __builtin_nanf(""); } + + static constexpr float + signaling_NaN() noexcept { return __builtin_nansf(""); } + + static constexpr float + denorm_min() noexcept { return 1.40129846432481707092372958328991613e-45F; } + + static constexpr bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before + = false; + static constexpr float_round_style round_style + = round_to_nearest; + }; + + + + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr double + min() noexcept { return double(2.22507385850720138309023271733240406e-308L); } + + static constexpr double + max() noexcept { return double(1.79769313486231570814527423731704357e+308L); } + + + static constexpr double + lowest() noexcept { return -double(1.79769313486231570814527423731704357e+308L); } + + + static constexpr int digits = 53; + static constexpr int digits10 = 15; + + static constexpr int max_digits10 + = (2 + (53) * 643L / 2136); + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr double + epsilon() noexcept { return double(2.22044604925031308084726333618164062e-16L); } + + static constexpr double + round_error() noexcept { return 0.5; } + + static constexpr int min_exponent = (-1021); + static constexpr int min_exponent10 = (-307); + static constexpr int max_exponent = 1024; + static constexpr int max_exponent10 = 308; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + static constexpr bool has_signaling_NaN = has_quiet_NaN; + static constexpr float_denorm_style has_denorm + = bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + = false; + + static constexpr double + infinity() noexcept { return __builtin_huge_val(); } + + static constexpr double + quiet_NaN() noexcept { return __builtin_nan(""); } + + static constexpr double + signaling_NaN() noexcept { return __builtin_nans(""); } + + static constexpr double + denorm_min() noexcept { return double(4.94065645841246544176568792868221372e-324L); } + + static constexpr bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before + = false; + static constexpr float_round_style round_style + = round_to_nearest; + }; + + + + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr long double + min() noexcept { return 3.36210314311209350626267781732175260e-4932L; } + + static constexpr long double + max() noexcept { return 1.18973149535723176502126385303097021e+4932L; } + + + static constexpr long double + lowest() noexcept { return -1.18973149535723176502126385303097021e+4932L; } + + + static constexpr int digits = 64; + static constexpr int digits10 = 18; + + static constexpr int max_digits10 + = (2 + (64) * 643L / 2136); + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr long double + epsilon() noexcept { return 1.08420217248550443400745280086994171e-19L; } + + static constexpr long double + round_error() noexcept { return 0.5L; } + + static constexpr int min_exponent = (-16381); + static constexpr int min_exponent10 = (-4931); + static constexpr int max_exponent = 16384; + static constexpr int max_exponent10 = 4932; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + static constexpr bool has_signaling_NaN = has_quiet_NaN; + static constexpr float_denorm_style has_denorm + = bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + = false; + + static constexpr long double + infinity() noexcept { return __builtin_huge_vall(); } + + static constexpr long double + quiet_NaN() noexcept { return __builtin_nanl(""); } + + static constexpr long double + signaling_NaN() noexcept { return __builtin_nansl(""); } + + static constexpr long double + denorm_min() noexcept { return 3.64519953188247460252840593361941982e-4951L; } + + static constexpr bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before = + false; + static constexpr float_round_style round_style = + round_to_nearest; + }; +# 1989 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +__extension__ template<> struct numeric_limits<_Float32> { static constexpr bool is_specialized = true; static constexpr _Float32 min() noexcept { return 1.17549435082228750796873653722224568e-38F32; } static constexpr _Float32 max() noexcept { return 3.40282346638528859811704183484516925e+38F32; } static constexpr _Float32 lowest() noexcept { return -3.40282346638528859811704183484516925e+38F32; } static constexpr int digits = 24; static constexpr int digits10 = 6; static constexpr int max_digits10 = (2 + (24) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr _Float32 epsilon() noexcept { return 1.19209289550781250000000000000000000e-7F32; } static constexpr _Float32 round_error() noexcept { return 0.5F32; } static constexpr int min_exponent = (-125); static constexpr int min_exponent10 = (-37); static constexpr int max_exponent = 128; static constexpr int max_exponent10 = 38; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr _Float32 infinity() noexcept { return __builtin_huge_valf32(); } static constexpr _Float32 quiet_NaN() noexcept { return __builtin_nanf32(""); } static constexpr _Float32 signaling_NaN() noexcept { return __builtin_nansf32(""); } static constexpr _Float32 denorm_min() noexcept { return 1.40129846432481707092372958328991613e-45F32; } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; + + +__extension__ template<> struct numeric_limits<_Float64> { static constexpr bool is_specialized = true; static constexpr _Float64 min() noexcept { return 2.22507385850720138309023271733240406e-308F64; } static constexpr _Float64 max() noexcept { return 1.79769313486231570814527423731704357e+308F64; } static constexpr _Float64 lowest() noexcept { return -1.79769313486231570814527423731704357e+308F64; } static constexpr int digits = 53; static constexpr int digits10 = 15; static constexpr int max_digits10 = (2 + (53) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr _Float64 epsilon() noexcept { return 2.22044604925031308084726333618164062e-16F64; } static constexpr _Float64 round_error() noexcept { return 0.5F64; } static constexpr int min_exponent = (-1021); static constexpr int min_exponent10 = (-307); static constexpr int max_exponent = 1024; static constexpr int max_exponent10 = 308; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr _Float64 infinity() noexcept { return __builtin_huge_valf64(); } static constexpr _Float64 quiet_NaN() noexcept { return __builtin_nanf64(""); } static constexpr _Float64 signaling_NaN() noexcept { return __builtin_nansf64(""); } static constexpr _Float64 denorm_min() noexcept { return 4.94065645841246544176568792868221372e-324F64; } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; + + +__extension__ template<> struct numeric_limits<_Float128> { static constexpr bool is_specialized = true; static constexpr _Float128 min() noexcept { return 3.36210314311209350626267781732175260e-4932F128; } static constexpr _Float128 max() noexcept { return 1.18973149535723176508575932662800702e+4932F128; } static constexpr _Float128 lowest() noexcept { return -1.18973149535723176508575932662800702e+4932F128; } static constexpr int digits = 113; static constexpr int digits10 = 33; static constexpr int max_digits10 = (2 + (113) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr _Float128 epsilon() noexcept { return 1.92592994438723585305597794258492732e-34F128; } static constexpr _Float128 round_error() noexcept { return 0.5F128; } static constexpr int min_exponent = (-16381); static constexpr int min_exponent10 = (-4931); static constexpr int max_exponent = 16384; static constexpr int max_exponent10 = 4932; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr _Float128 infinity() noexcept { return __builtin_huge_valf128(); } static constexpr _Float128 quiet_NaN() noexcept { return __builtin_nanf128(""); } static constexpr _Float128 signaling_NaN() noexcept { return __builtin_nansf128(""); } static constexpr _Float128 denorm_min() noexcept { return 6.47517511943802511092443895822764655e-4966F128; } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; +# 2087 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + __extension__ + template<> + struct numeric_limits<__float128> + { + static constexpr bool is_specialized = true; + + static constexpr __float128 + min() noexcept + { + + + + + return __extension__ 0x1.0p-16382Q; + + } + + static constexpr __float128 + max() noexcept + { + + + + + + + + return __extension__ 0x1.ffffffffffffffffffffffffffffp+16383Q; + + } + + static constexpr __float128 + lowest() noexcept + { return -max(); } + + static constexpr int digits = 113; + static constexpr int digits10 = 33; + + static constexpr int max_digits10 = 35; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr __float128 + epsilon() noexcept + { return double(1.9259299443872359e-34); } + + static constexpr __float128 + round_error() noexcept { return 0.5; } + + static constexpr int min_exponent = -16381; + static constexpr int min_exponent10 = -4931; + static constexpr int max_exponent = 16384; + static constexpr int max_exponent10 = 4932; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + + + static constexpr bool has_signaling_NaN = true; + + + + static constexpr float_denorm_style has_denorm + = denorm_present; + static constexpr bool has_denorm_loss = false; + + static constexpr __float128 + infinity() noexcept + { return __builtin_huge_val(); } + + static constexpr __float128 + quiet_NaN() noexcept + { return __builtin_nan(""); } + + static constexpr __float128 + signaling_NaN() noexcept + { + + return __builtin_nansq(""); + + + + + + } + + static constexpr __float128 + denorm_min() noexcept + { + + + + + return __extension__ 0x1.0p-16494Q; + + } + + static constexpr bool is_iec559 = has_signaling_NaN; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_to_nearest; +# 2218 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + }; + + + + +} +# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 1 3 +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 + namespace __detail + { + + + + template + struct __floating_point_constant + { + static const _Tp __value; + }; + + + + template + struct __numeric_constants + { + + static _Tp __pi() throw() + { return static_cast<_Tp>(3.1415926535897932384626433832795029L); } + + static _Tp __pi_2() throw() + { return static_cast<_Tp>(1.5707963267948966192313216916397514L); } + + static _Tp __pi_3() throw() + { return static_cast<_Tp>(1.0471975511965977461542144610931676L); } + + static _Tp __pi_4() throw() + { return static_cast<_Tp>(0.7853981633974483096156608458198757L); } + + static _Tp __1_pi() throw() + { return static_cast<_Tp>(0.3183098861837906715377675267450287L); } + + static _Tp __2_sqrtpi() throw() + { return static_cast<_Tp>(1.1283791670955125738961589031215452L); } + + static _Tp __sqrt2() throw() + { return static_cast<_Tp>(1.4142135623730950488016887242096981L); } + + static _Tp __sqrt3() throw() + { return static_cast<_Tp>(1.7320508075688772935274463415058723L); } + + static _Tp __sqrtpio2() throw() + { return static_cast<_Tp>(1.2533141373155002512078826424055226L); } + + static _Tp __sqrt1_2() throw() + { return static_cast<_Tp>(0.7071067811865475244008443621048490L); } + + static _Tp __lnpi() throw() + { return static_cast<_Tp>(1.1447298858494001741434273513530587L); } + + static _Tp __gamma_e() throw() + { return static_cast<_Tp>(0.5772156649015328606065120900824024L); } + + static _Tp __euler() throw() + { return static_cast<_Tp>(2.7182818284590452353602874713526625L); } + }; +# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 + template + inline bool __isnan(_Tp __x) + { return std::isnan(__x); } +# 133 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 + } + + + + + +} +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + namespace __detail + { +# 76 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __bernoulli_series(unsigned int __n) + { + + static const _Tp __num[28] = { + _Tp(1UL), -_Tp(1UL) / _Tp(2UL), + _Tp(1UL) / _Tp(6UL), _Tp(0UL), + -_Tp(1UL) / _Tp(30UL), _Tp(0UL), + _Tp(1UL) / _Tp(42UL), _Tp(0UL), + -_Tp(1UL) / _Tp(30UL), _Tp(0UL), + _Tp(5UL) / _Tp(66UL), _Tp(0UL), + -_Tp(691UL) / _Tp(2730UL), _Tp(0UL), + _Tp(7UL) / _Tp(6UL), _Tp(0UL), + -_Tp(3617UL) / _Tp(510UL), _Tp(0UL), + _Tp(43867UL) / _Tp(798UL), _Tp(0UL), + -_Tp(174611) / _Tp(330UL), _Tp(0UL), + _Tp(854513UL) / _Tp(138UL), _Tp(0UL), + -_Tp(236364091UL) / _Tp(2730UL), _Tp(0UL), + _Tp(8553103UL) / _Tp(6UL), _Tp(0UL) + }; + + if (__n == 0) + return _Tp(1); + + if (__n == 1) + return -_Tp(1) / _Tp(2); + + + if (__n % 2 == 1) + return _Tp(0); + + + if (__n < 28) + return __num[__n]; + + + _Tp __fact = _Tp(1); + if ((__n / 2) % 2 == 0) + __fact *= _Tp(-1); + for (unsigned int __k = 1; __k <= __n; ++__k) + __fact *= __k / (_Tp(2) * __numeric_constants<_Tp>::__pi()); + __fact *= _Tp(2); + + _Tp __sum = _Tp(0); + for (unsigned int __i = 1; __i < 1000; ++__i) + { + _Tp __term = std::pow(_Tp(__i), -_Tp(__n)); + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + __sum += __term; + } + + return __fact * __sum; + } +# 139 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + inline _Tp + __bernoulli(int __n) + { return __bernoulli_series<_Tp>(__n); } +# 153 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma_bernoulli(_Tp __x) + { + _Tp __lg = (__x - _Tp(0.5L)) * std::log(__x) - __x + + _Tp(0.5L) * std::log(_Tp(2) + * __numeric_constants<_Tp>::__pi()); + + const _Tp __xx = __x * __x; + _Tp __help = _Tp(1) / __x; + for ( unsigned int __i = 1; __i < 20; ++__i ) + { + const _Tp __2i = _Tp(2 * __i); + __help /= __2i * (__2i - _Tp(1)) * __xx; + __lg += __bernoulli<_Tp>(2 * __i) * __help; + } + + return __lg; + } +# 181 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma_lanczos(_Tp __x) + { + const _Tp __xm1 = __x - _Tp(1); + + static const _Tp __lanczos_cheb_7[9] = { + _Tp( 0.99999999999980993227684700473478L), + _Tp( 676.520368121885098567009190444019L), + _Tp(-1259.13921672240287047156078755283L), + _Tp( 771.3234287776530788486528258894L), + _Tp(-176.61502916214059906584551354L), + _Tp( 12.507343278686904814458936853L), + _Tp(-0.13857109526572011689554707L), + _Tp( 9.984369578019570859563e-6L), + _Tp( 1.50563273514931155834e-7L) + }; + + static const _Tp __LOGROOT2PI + = _Tp(0.9189385332046727417803297364056176L); + + _Tp __sum = __lanczos_cheb_7[0]; + for(unsigned int __k = 1; __k < 9; ++__k) + __sum += __lanczos_cheb_7[__k] / (__xm1 + __k); + + const _Tp __term1 = (__xm1 + _Tp(0.5L)) + * std::log((__xm1 + _Tp(7.5L)) + / __numeric_constants<_Tp>::__euler()); + const _Tp __term2 = __LOGROOT2PI + std::log(__sum); + const _Tp __result = __term1 + (__term2 - _Tp(7)); + + return __result; + } +# 225 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma(_Tp __x) + { + if (__x > _Tp(0.5L)) + return __log_gamma_lanczos(__x); + else + { + const _Tp __sin_fact + = std::abs(std::sin(__numeric_constants<_Tp>::__pi() * __x)); + if (__sin_fact == _Tp(0)) + std::__throw_domain_error(("Argument is nonpositive integer " "in __log_gamma") + ); + return __numeric_constants<_Tp>::__lnpi() + - std::log(__sin_fact) + - __log_gamma_lanczos(_Tp(1) - __x); + } + } +# 252 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma_sign(_Tp __x) + { + if (__x > _Tp(0)) + return _Tp(1); + else + { + const _Tp __sin_fact + = std::sin(__numeric_constants<_Tp>::__pi() * __x); + if (__sin_fact > _Tp(0)) + return (1); + else if (__sin_fact < _Tp(0)) + return -_Tp(1); + else + return _Tp(0); + } + } +# 283 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __log_bincoef(unsigned int __n, unsigned int __k) + { + + static const _Tp __max_bincoeff + = std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + _Tp __coeff = ::std::lgamma(_Tp(1 + __n)) + - ::std::lgamma(_Tp(1 + __k)) + - ::std::lgamma(_Tp(1 + __n - __k)); + + + + + + } +# 314 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __bincoef(unsigned int __n, unsigned int __k) + { + + static const _Tp __max_bincoeff + = std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + const _Tp __log_coeff = __log_bincoef<_Tp>(__n, __k); + if (__log_coeff > __max_bincoeff) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return std::exp(__log_coeff); + } +# 337 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + inline _Tp + __gamma(_Tp __x) + { return std::exp(__log_gamma(__x)); } +# 356 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __psi_series(_Tp __x) + { + _Tp __sum = -__numeric_constants<_Tp>::__gamma_e() - _Tp(1) / __x; + const unsigned int __max_iter = 100000; + for (unsigned int __k = 1; __k < __max_iter; ++__k) + { + const _Tp __term = __x / (__k * (__k + __x)); + __sum += __term; + if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon()) + break; + } + return __sum; + } +# 386 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __psi_asymp(_Tp __x) + { + _Tp __sum = std::log(__x) - _Tp(0.5L) / __x; + const _Tp __xx = __x * __x; + _Tp __xp = __xx; + const unsigned int __max_iter = 100; + for (unsigned int __k = 1; __k < __max_iter; ++__k) + { + const _Tp __term = __bernoulli<_Tp>(2 * __k) / (2 * __k * __xp); + __sum -= __term; + if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon()) + break; + __xp *= __xx; + } + return __sum; + } +# 417 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __psi(_Tp __x) + { + const int __n = static_cast(__x + 0.5L); + const _Tp __eps = _Tp(4) * std::numeric_limits<_Tp>::epsilon(); + if (__n <= 0 && std::abs(__x - _Tp(__n)) < __eps) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x < _Tp(0)) + { + const _Tp __pi = __numeric_constants<_Tp>::__pi(); + return __psi(_Tp(1) - __x) + - __pi * std::cos(__pi * __x) / std::sin(__pi * __x); + } + else if (__x > _Tp(100)) + return __psi_asymp(__x); + else + return __psi_series(__x); + } +# 446 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __psi(unsigned int __n, _Tp __x) + { + if (__x <= _Tp(0)) + std::__throw_domain_error(("Argument out of range " "in __psi") + ); + else if (__n == 0) + return __psi(__x); + else + { + const _Tp __hzeta = __hurwitz_zeta(_Tp(__n + 1), __x); + + const _Tp __ln_nfact = ::std::lgamma(_Tp(__n + 1)); + + + + _Tp __result = std::exp(__ln_nfact) * __hzeta; + if (__n % 2 == 1) + __result = -__result; + return __result; + } + } + } + + + + + + +} +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 1 3 +# 55 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 71 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + namespace __detail + { +# 98 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + void + __gamma_temme(_Tp __mu, + _Tp & __gam1, _Tp & __gam2, _Tp & __gampl, _Tp & __gammi) + { + + __gampl = _Tp(1) / ::std::tgamma(_Tp(1) + __mu); + __gammi = _Tp(1) / ::std::tgamma(_Tp(1) - __mu); + + + + + + if (std::abs(__mu) < std::numeric_limits<_Tp>::epsilon()) + __gam1 = -_Tp(__numeric_constants<_Tp>::__gamma_e()); + else + __gam1 = (__gammi - __gampl) / (_Tp(2) * __mu); + + __gam2 = (__gammi + __gampl) / (_Tp(2)); + + return; + } +# 136 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + void + __bessel_jn(_Tp __nu, _Tp __x, + _Tp & __Jnu, _Tp & __Nnu, _Tp & __Jpnu, _Tp & __Npnu) + { + if (__x == _Tp(0)) + { + if (__nu == _Tp(0)) + { + __Jnu = _Tp(1); + __Jpnu = _Tp(0); + } + else if (__nu == _Tp(1)) + { + __Jnu = _Tp(0); + __Jpnu = _Tp(0.5L); + } + else + { + __Jnu = _Tp(0); + __Jpnu = _Tp(0); + } + __Nnu = -std::numeric_limits<_Tp>::infinity(); + __Npnu = std::numeric_limits<_Tp>::infinity(); + return; + } + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + + + + const _Tp __fp_min = std::sqrt(std::numeric_limits<_Tp>::min()); + const int __max_iter = 15000; + const _Tp __x_min = _Tp(2); + + const int __nl = (__x < __x_min + ? static_cast(__nu + _Tp(0.5L)) + : std::max(0, static_cast(__nu - __x + _Tp(1.5L)))); + + const _Tp __mu = __nu - __nl; + const _Tp __mu2 = __mu * __mu; + const _Tp __xi = _Tp(1) / __x; + const _Tp __xi2 = _Tp(2) * __xi; + _Tp __w = __xi2 / __numeric_constants<_Tp>::__pi(); + int __isign = 1; + _Tp __h = __nu * __xi; + if (__h < __fp_min) + __h = __fp_min; + _Tp __b = __xi2 * __nu; + _Tp __d = _Tp(0); + _Tp __c = __h; + int __i; + for (__i = 1; __i <= __max_iter; ++__i) + { + __b += __xi2; + __d = __b - __d; + if (std::abs(__d) < __fp_min) + __d = __fp_min; + __c = __b - _Tp(1) / __c; + if (std::abs(__c) < __fp_min) + __c = __fp_min; + __d = _Tp(1) / __d; + const _Tp __del = __c * __d; + __h *= __del; + if (__d < _Tp(0)) + __isign = -__isign; + if (std::abs(__del - _Tp(1)) < __eps) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Argument x too large in __bessel_jn; " "try asymptotic expansion.") + ); + _Tp __Jnul = __isign * __fp_min; + _Tp __Jpnul = __h * __Jnul; + _Tp __Jnul1 = __Jnul; + _Tp __Jpnu1 = __Jpnul; + _Tp __fact = __nu * __xi; + for ( int __l = __nl; __l >= 1; --__l ) + { + const _Tp __Jnutemp = __fact * __Jnul + __Jpnul; + __fact -= __xi; + __Jpnul = __fact * __Jnutemp - __Jnul; + __Jnul = __Jnutemp; + } + if (__Jnul == _Tp(0)) + __Jnul = __eps; + _Tp __f= __Jpnul / __Jnul; + _Tp __Nmu, __Nnu1, __Npmu, __Jmu; + if (__x < __x_min) + { + const _Tp __x2 = __x / _Tp(2); + const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu; + _Tp __fact = (std::abs(__pimu) < __eps + ? _Tp(1) : __pimu / std::sin(__pimu)); + _Tp __d = -std::log(__x2); + _Tp __e = __mu * __d; + _Tp __fact2 = (std::abs(__e) < __eps + ? _Tp(1) : std::sinh(__e) / __e); + _Tp __gam1, __gam2, __gampl, __gammi; + __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi); + _Tp __ff = (_Tp(2) / __numeric_constants<_Tp>::__pi()) + * __fact * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d); + __e = std::exp(__e); + _Tp __p = __e / (__numeric_constants<_Tp>::__pi() * __gampl); + _Tp __q = _Tp(1) / (__e * __numeric_constants<_Tp>::__pi() * __gammi); + const _Tp __pimu2 = __pimu / _Tp(2); + _Tp __fact3 = (std::abs(__pimu2) < __eps + ? _Tp(1) : std::sin(__pimu2) / __pimu2 ); + _Tp __r = __numeric_constants<_Tp>::__pi() * __pimu2 * __fact3 * __fact3; + _Tp __c = _Tp(1); + __d = -__x2 * __x2; + _Tp __sum = __ff + __r * __q; + _Tp __sum1 = __p; + for (__i = 1; __i <= __max_iter; ++__i) + { + __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2); + __c *= __d / _Tp(__i); + __p /= _Tp(__i) - __mu; + __q /= _Tp(__i) + __mu; + const _Tp __del = __c * (__ff + __r * __q); + __sum += __del; + const _Tp __del1 = __c * __p - __i * __del; + __sum1 += __del1; + if ( std::abs(__del) < __eps * (_Tp(1) + std::abs(__sum)) ) + break; + } + if ( __i > __max_iter ) + std::__throw_runtime_error(("Bessel y series failed to converge " "in __bessel_jn.") + ); + __Nmu = -__sum; + __Nnu1 = -__sum1 * __xi2; + __Npmu = __mu * __xi * __Nmu - __Nnu1; + __Jmu = __w / (__Npmu - __f * __Nmu); + } + else + { + _Tp __a = _Tp(0.25L) - __mu2; + _Tp __q = _Tp(1); + _Tp __p = -__xi / _Tp(2); + _Tp __br = _Tp(2) * __x; + _Tp __bi = _Tp(2); + _Tp __fact = __a * __xi / (__p * __p + __q * __q); + _Tp __cr = __br + __q * __fact; + _Tp __ci = __bi + __p * __fact; + _Tp __den = __br * __br + __bi * __bi; + _Tp __dr = __br / __den; + _Tp __di = -__bi / __den; + _Tp __dlr = __cr * __dr - __ci * __di; + _Tp __dli = __cr * __di + __ci * __dr; + _Tp __temp = __p * __dlr - __q * __dli; + __q = __p * __dli + __q * __dlr; + __p = __temp; + int __i; + for (__i = 2; __i <= __max_iter; ++__i) + { + __a += _Tp(2 * (__i - 1)); + __bi += _Tp(2); + __dr = __a * __dr + __br; + __di = __a * __di + __bi; + if (std::abs(__dr) + std::abs(__di) < __fp_min) + __dr = __fp_min; + __fact = __a / (__cr * __cr + __ci * __ci); + __cr = __br + __cr * __fact; + __ci = __bi - __ci * __fact; + if (std::abs(__cr) + std::abs(__ci) < __fp_min) + __cr = __fp_min; + __den = __dr * __dr + __di * __di; + __dr /= __den; + __di /= -__den; + __dlr = __cr * __dr - __ci * __di; + __dli = __cr * __di + __ci * __dr; + __temp = __p * __dlr - __q * __dli; + __q = __p * __dli + __q * __dlr; + __p = __temp; + if (std::abs(__dlr - _Tp(1)) + std::abs(__dli) < __eps) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Lentz's method failed " "in __bessel_jn.") + ); + const _Tp __gam = (__p - __f) / __q; + __Jmu = std::sqrt(__w / ((__p - __f) * __gam + __q)); + + __Jmu = ::std::copysign(__Jmu, __Jnul); + + + + + __Nmu = __gam * __Jmu; + __Npmu = (__p + __q / __gam) * __Nmu; + __Nnu1 = __mu * __xi * __Nmu - __Npmu; + } + __fact = __Jmu / __Jnul; + __Jnu = __fact * __Jnul1; + __Jpnu = __fact * __Jpnu1; + for (__i = 1; __i <= __nl; ++__i) + { + const _Tp __Nnutemp = (__mu + __i) * __xi2 * __Nnu1 - __Nmu; + __Nmu = __Nnu1; + __Nnu1 = __Nnutemp; + } + __Nnu = __Nmu; + __Npnu = __nu * __xi * __Nmu - __Nnu1; + + return; + } +# 361 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + void + __cyl_bessel_jn_asymp(_Tp __nu, _Tp __x, _Tp & __Jnu, _Tp & __Nnu) + { + const _Tp __mu = _Tp(4) * __nu * __nu; + const _Tp __8x = _Tp(8) * __x; + + _Tp __P = _Tp(0); + _Tp __Q = _Tp(0); + + _Tp __k = _Tp(0); + _Tp __term = _Tp(1); + + int __epsP = 0; + int __epsQ = 0; + + _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + do + { + __term *= (__k == 0 + ? _Tp(1) + : -(__mu - (2 * __k - 1) * (2 * __k - 1)) / (__k * __8x)); + + __epsP = std::abs(__term) < __eps * std::abs(__P); + __P += __term; + + __k++; + + __term *= (__mu - (2 * __k - 1) * (2 * __k - 1)) / (__k * __8x); + __epsQ = std::abs(__term) < __eps * std::abs(__Q); + __Q += __term; + + if (__epsP && __epsQ && __k > (__nu / 2.)) + break; + + __k++; + } + while (__k < 1000); + + const _Tp __chi = __x - (__nu + _Tp(0.5L)) + * __numeric_constants<_Tp>::__pi_2(); + + const _Tp __c = std::cos(__chi); + const _Tp __s = std::sin(__chi); + + const _Tp __coef = std::sqrt(_Tp(2) + / (__numeric_constants<_Tp>::__pi() * __x)); + + __Jnu = __coef * (__c * __P - __s * __Q); + __Nnu = __coef * (__s * __P + __c * __Q); + + return; + } +# 444 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_bessel_ij_series(_Tp __nu, _Tp __x, _Tp __sgn, + unsigned int __max_iter) + { + if (__x == _Tp(0)) + return __nu == _Tp(0) ? _Tp(1) : _Tp(0); + + const _Tp __x2 = __x / _Tp(2); + _Tp __fact = __nu * std::log(__x2); + + __fact -= ::std::lgamma(__nu + _Tp(1)); + + + + __fact = std::exp(__fact); + const _Tp __xx4 = __sgn * __x2 * __x2; + _Tp __Jn = _Tp(1); + _Tp __term = _Tp(1); + + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + __term *= __xx4 / (_Tp(__i) * (__nu + _Tp(__i))); + __Jn += __term; + if (std::abs(__term / __Jn) < std::numeric_limits<_Tp>::epsilon()) + break; + } + + return __fact * __Jn; + } +# 490 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_bessel_j(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_j.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x * __x < _Tp(10) * (__nu + _Tp(1))) + return __cyl_bessel_ij_series(__nu, __x, -_Tp(1), 200); + else if (__x > _Tp(1000)) + { + _Tp __J_nu, __N_nu; + __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); + return __J_nu; + } + else + { + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + return __J_nu; + } + } +# 532 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_neumann_n(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_neumann_n.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x > _Tp(1000)) + { + _Tp __J_nu, __N_nu; + __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); + return __N_nu; + } + else + { + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + return __N_nu; + } + } +# 569 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + void + __sph_bessel_jn(unsigned int __n, _Tp __x, + _Tp & __j_n, _Tp & __n_n, _Tp & __jp_n, _Tp & __np_n) + { + const _Tp __nu = _Tp(__n) + _Tp(0.5L); + + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + + const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2() + / std::sqrt(__x); + + __j_n = __factor * __J_nu; + __n_n = __factor * __N_nu; + __jp_n = __factor * __Jp_nu - __j_n / (_Tp(2) * __x); + __np_n = __factor * __Np_nu - __n_n / (_Tp(2) * __x); + + return; + } +# 604 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + _Tp + __sph_bessel(unsigned int __n, _Tp __x) + { + if (__x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __sph_bessel.") + ); + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x == _Tp(0)) + { + if (__n == 0) + return _Tp(1); + else + return _Tp(0); + } + else + { + _Tp __j_n, __n_n, __jp_n, __np_n; + __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n); + return __j_n; + } + } +# 642 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + _Tp + __sph_neumann(unsigned int __n, _Tp __x) + { + if (__x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __sph_neumann.") + ); + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x == _Tp(0)) + return -std::numeric_limits<_Tp>::infinity(); + else + { + _Tp __j_n, __n_n, __jp_n, __np_n; + __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n); + return __n_n; + } + } + } + + + + + + +} +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 1 3 +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + namespace __detail + { +# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + template + _Tp + __beta_gamma(_Tp __x, _Tp __y) + { + + _Tp __bet; + + if (__x > __y) + { + __bet = ::std::tgamma(__x) + / ::std::tgamma(__x + __y); + __bet *= ::std::tgamma(__y); + } + else + { + __bet = ::std::tgamma(__y) + / ::std::tgamma(__x + __y); + __bet *= ::std::tgamma(__x); + } +# 111 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + return __bet; + } +# 127 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + template + _Tp + __beta_lgamma(_Tp __x, _Tp __y) + { + + _Tp __bet = ::std::lgamma(__x) + + ::std::lgamma(__y) + - ::std::lgamma(__x + __y); + + + + + + __bet = std::exp(__bet); + return __bet; + } +# 158 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + template + _Tp + __beta_product(_Tp __x, _Tp __y) + { + + _Tp __bet = (__x + __y) / (__x * __y); + + unsigned int __max_iter = 1000000; + for (unsigned int __k = 1; __k < __max_iter; ++__k) + { + _Tp __term = (_Tp(1) + (__x + __y) / __k) + / ((_Tp(1) + __x / __k) * (_Tp(1) + __y / __k)); + __bet *= __term; + } + + return __bet; + } +# 189 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + template + inline _Tp + __beta(_Tp __x, _Tp __y) + { + if (__isnan(__x) || __isnan(__y)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __beta_lgamma(__x, __y); + } + } + + + + + + +} +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 1 3 +# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + namespace __detail + { +# 76 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rf(_Tp __x, _Tp __y, _Tp __z) + { + const _Tp __min = std::numeric_limits<_Tp>::min(); + const _Tp __lolim = _Tp(5) * __min; + + if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0)) + std::__throw_domain_error(("Argument less than zero " "in __ellint_rf.") + ); + else if (__x + __y < __lolim || __x + __z < __lolim + || __y + __z < __lolim) + std::__throw_domain_error(("Argument too small in __ellint_rf")); + else + { + const _Tp __c0 = _Tp(1) / _Tp(4); + const _Tp __c1 = _Tp(1) / _Tp(24); + const _Tp __c2 = _Tp(1) / _Tp(10); + const _Tp __c3 = _Tp(3) / _Tp(44); + const _Tp __c4 = _Tp(1) / _Tp(14); + + _Tp __xn = __x; + _Tp __yn = __y; + _Tp __zn = __z; + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol = std::pow(__eps, _Tp(1) / _Tp(6)); + _Tp __mu; + _Tp __xndev, __yndev, __zndev; + + const unsigned int __max_iter = 100; + for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) + { + __mu = (__xn + __yn + __zn) / _Tp(3); + __xndev = 2 - (__mu + __xn) / __mu; + __yndev = 2 - (__mu + __yn) / __mu; + __zndev = 2 - (__mu + __zn) / __mu; + _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); + __epsilon = std::max(__epsilon, std::abs(__zndev)); + if (__epsilon < __errtol) + break; + const _Tp __xnroot = std::sqrt(__xn); + const _Tp __ynroot = std::sqrt(__yn); + const _Tp __znroot = std::sqrt(__zn); + const _Tp __lambda = __xnroot * (__ynroot + __znroot) + + __ynroot * __znroot; + __xn = __c0 * (__xn + __lambda); + __yn = __c0 * (__yn + __lambda); + __zn = __c0 * (__zn + __lambda); + } + + const _Tp __e2 = __xndev * __yndev - __zndev * __zndev; + const _Tp __e3 = __xndev * __yndev * __zndev; + const _Tp __s = _Tp(1) + (__c1 * __e2 - __c2 - __c3 * __e3) * __e2 + + __c4 * __e3; + + return __s / std::sqrt(__mu); + } + } +# 153 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_1_series(_Tp __k) + { + + const _Tp __kk = __k * __k; + + _Tp __term = __kk / _Tp(4); + _Tp __sum = _Tp(1) + __term; + + const unsigned int __max_iter = 1000; + for (unsigned int __i = 2; __i < __max_iter; ++__i) + { + __term *= (2 * __i - 1) * __kk / (2 * __i); + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + __sum += __term; + } + + return __numeric_constants<_Tp>::__pi_2() * __sum; + } +# 191 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_1(_Tp __k) + { + + if (__isnan(__k)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) >= _Tp(1)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __ellint_rf(_Tp(0), _Tp(1) - __k * __k, _Tp(1)); + } +# 219 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_1(_Tp __k, _Tp __phi) + { + + if (__isnan(__k) || __isnan(__phi)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __ellint_1.")); + else + { + + const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + + _Tp(0.5L)); + const _Tp __phi_red = __phi + - __n * __numeric_constants<_Tp>::__pi(); + + const _Tp __s = std::sin(__phi_red); + const _Tp __c = std::cos(__phi_red); + + const _Tp __F = __s + * __ellint_rf(__c * __c, + _Tp(1) - __k * __k * __s * __s, _Tp(1)); + + if (__n == 0) + return __F; + else + return __F + _Tp(2) * __n * __comp_ellint_1(__k); + } + } +# 266 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_2_series(_Tp __k) + { + + const _Tp __kk = __k * __k; + + _Tp __term = __kk; + _Tp __sum = __term; + + const unsigned int __max_iter = 1000; + for (unsigned int __i = 2; __i < __max_iter; ++__i) + { + const _Tp __i2m = 2 * __i - 1; + const _Tp __i2 = 2 * __i; + __term *= __i2m * __i2m * __kk / (__i2 * __i2); + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + __sum += __term / __i2m; + } + + return __numeric_constants<_Tp>::__pi_2() * (_Tp(1) - __sum); + } +# 314 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rd(_Tp __x, _Tp __y, _Tp __z) + { + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6)); + const _Tp __max = std::numeric_limits<_Tp>::max(); + const _Tp __lolim = _Tp(2) / std::pow(__max, _Tp(2) / _Tp(3)); + + if (__x < _Tp(0) || __y < _Tp(0)) + std::__throw_domain_error(("Argument less than zero " "in __ellint_rd.") + ); + else if (__x + __y < __lolim || __z < __lolim) + std::__throw_domain_error(("Argument too small " "in __ellint_rd.") + ); + else + { + const _Tp __c0 = _Tp(1) / _Tp(4); + const _Tp __c1 = _Tp(3) / _Tp(14); + const _Tp __c2 = _Tp(1) / _Tp(6); + const _Tp __c3 = _Tp(9) / _Tp(22); + const _Tp __c4 = _Tp(3) / _Tp(26); + + _Tp __xn = __x; + _Tp __yn = __y; + _Tp __zn = __z; + _Tp __sigma = _Tp(0); + _Tp __power4 = _Tp(1); + + _Tp __mu; + _Tp __xndev, __yndev, __zndev; + + const unsigned int __max_iter = 100; + for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) + { + __mu = (__xn + __yn + _Tp(3) * __zn) / _Tp(5); + __xndev = (__mu - __xn) / __mu; + __yndev = (__mu - __yn) / __mu; + __zndev = (__mu - __zn) / __mu; + _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); + __epsilon = std::max(__epsilon, std::abs(__zndev)); + if (__epsilon < __errtol) + break; + _Tp __xnroot = std::sqrt(__xn); + _Tp __ynroot = std::sqrt(__yn); + _Tp __znroot = std::sqrt(__zn); + _Tp __lambda = __xnroot * (__ynroot + __znroot) + + __ynroot * __znroot; + __sigma += __power4 / (__znroot * (__zn + __lambda)); + __power4 *= __c0; + __xn = __c0 * (__xn + __lambda); + __yn = __c0 * (__yn + __lambda); + __zn = __c0 * (__zn + __lambda); + } + + _Tp __ea = __xndev * __yndev; + _Tp __eb = __zndev * __zndev; + _Tp __ec = __ea - __eb; + _Tp __ed = __ea - _Tp(6) * __eb; + _Tp __ef = __ed + __ec + __ec; + _Tp __s1 = __ed * (-__c1 + __c3 * __ed + / _Tp(3) - _Tp(3) * __c4 * __zndev * __ef + / _Tp(2)); + _Tp __s2 = __zndev + * (__c2 * __ef + + __zndev * (-__c3 * __ec - __zndev * __c4 - __ea)); + + return _Tp(3) * __sigma + __power4 * (_Tp(1) + __s1 + __s2) + / (__mu * std::sqrt(__mu)); + } + } +# 399 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_2(_Tp __k) + { + + if (__isnan(__k)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) == 1) + return _Tp(1); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __comp_ellint_2.")); + else + { + const _Tp __kk = __k * __k; + + return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1)) + - __kk * __ellint_rd(_Tp(0), _Tp(1) - __kk, _Tp(1)) / _Tp(3); + } + } +# 433 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_2(_Tp __k, _Tp __phi) + { + + if (__isnan(__k) || __isnan(__phi)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __ellint_2.")); + else + { + + const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + + _Tp(0.5L)); + const _Tp __phi_red = __phi + - __n * __numeric_constants<_Tp>::__pi(); + + const _Tp __kk = __k * __k; + const _Tp __s = std::sin(__phi_red); + const _Tp __ss = __s * __s; + const _Tp __sss = __ss * __s; + const _Tp __c = std::cos(__phi_red); + const _Tp __cc = __c * __c; + + const _Tp __E = __s + * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1)) + - __kk * __sss + * __ellint_rd(__cc, _Tp(1) - __kk * __ss, _Tp(1)) + / _Tp(3); + + if (__n == 0) + return __E; + else + return __E + _Tp(2) * __n * __comp_ellint_2(__k); + } + } +# 492 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rc(_Tp __x, _Tp __y) + { + const _Tp __min = std::numeric_limits<_Tp>::min(); + const _Tp __lolim = _Tp(5) * __min; + + if (__x < _Tp(0) || __y < _Tp(0) || __x + __y < __lolim) + std::__throw_domain_error(("Argument less than zero " "in __ellint_rc.") + ); + else + { + const _Tp __c0 = _Tp(1) / _Tp(4); + const _Tp __c1 = _Tp(1) / _Tp(7); + const _Tp __c2 = _Tp(9) / _Tp(22); + const _Tp __c3 = _Tp(3) / _Tp(10); + const _Tp __c4 = _Tp(3) / _Tp(8); + + _Tp __xn = __x; + _Tp __yn = __y; + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol = std::pow(__eps / _Tp(30), _Tp(1) / _Tp(6)); + _Tp __mu; + _Tp __sn; + + const unsigned int __max_iter = 100; + for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) + { + __mu = (__xn + _Tp(2) * __yn) / _Tp(3); + __sn = (__yn + __mu) / __mu - _Tp(2); + if (std::abs(__sn) < __errtol) + break; + const _Tp __lambda = _Tp(2) * std::sqrt(__xn) * std::sqrt(__yn) + + __yn; + __xn = __c0 * (__xn + __lambda); + __yn = __c0 * (__yn + __lambda); + } + + _Tp __s = __sn * __sn + * (__c3 + __sn*(__c1 + __sn * (__c4 + __sn * __c2))); + + return (_Tp(1) + __s) / std::sqrt(__mu); + } + } +# 561 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rj(_Tp __x, _Tp __y, _Tp __z, _Tp __p) + { + const _Tp __min = std::numeric_limits<_Tp>::min(); + const _Tp __lolim = std::pow(_Tp(5) * __min, _Tp(1)/_Tp(3)); + + if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0)) + std::__throw_domain_error(("Argument less than zero " "in __ellint_rj.") + ); + else if (__x + __y < __lolim || __x + __z < __lolim + || __y + __z < __lolim || __p < __lolim) + std::__throw_domain_error(("Argument too small " "in __ellint_rj") + ); + else + { + const _Tp __c0 = _Tp(1) / _Tp(4); + const _Tp __c1 = _Tp(3) / _Tp(14); + const _Tp __c2 = _Tp(1) / _Tp(3); + const _Tp __c3 = _Tp(3) / _Tp(22); + const _Tp __c4 = _Tp(3) / _Tp(26); + + _Tp __xn = __x; + _Tp __yn = __y; + _Tp __zn = __z; + _Tp __pn = __p; + _Tp __sigma = _Tp(0); + _Tp __power4 = _Tp(1); + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6)); + + _Tp __mu; + _Tp __xndev, __yndev, __zndev, __pndev; + + const unsigned int __max_iter = 100; + for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) + { + __mu = (__xn + __yn + __zn + _Tp(2) * __pn) / _Tp(5); + __xndev = (__mu - __xn) / __mu; + __yndev = (__mu - __yn) / __mu; + __zndev = (__mu - __zn) / __mu; + __pndev = (__mu - __pn) / __mu; + _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); + __epsilon = std::max(__epsilon, std::abs(__zndev)); + __epsilon = std::max(__epsilon, std::abs(__pndev)); + if (__epsilon < __errtol) + break; + const _Tp __xnroot = std::sqrt(__xn); + const _Tp __ynroot = std::sqrt(__yn); + const _Tp __znroot = std::sqrt(__zn); + const _Tp __lambda = __xnroot * (__ynroot + __znroot) + + __ynroot * __znroot; + const _Tp __alpha1 = __pn * (__xnroot + __ynroot + __znroot) + + __xnroot * __ynroot * __znroot; + const _Tp __alpha2 = __alpha1 * __alpha1; + const _Tp __beta = __pn * (__pn + __lambda) + * (__pn + __lambda); + __sigma += __power4 * __ellint_rc(__alpha2, __beta); + __power4 *= __c0; + __xn = __c0 * (__xn + __lambda); + __yn = __c0 * (__yn + __lambda); + __zn = __c0 * (__zn + __lambda); + __pn = __c0 * (__pn + __lambda); + } + + _Tp __ea = __xndev * (__yndev + __zndev) + __yndev * __zndev; + _Tp __eb = __xndev * __yndev * __zndev; + _Tp __ec = __pndev * __pndev; + _Tp __e2 = __ea - _Tp(3) * __ec; + _Tp __e3 = __eb + _Tp(2) * __pndev * (__ea - __ec); + _Tp __s1 = _Tp(1) + __e2 * (-__c1 + _Tp(3) * __c3 * __e2 / _Tp(4) + - _Tp(3) * __c4 * __e3 / _Tp(2)); + _Tp __s2 = __eb * (__c2 / _Tp(2) + + __pndev * (-__c3 - __c3 + __pndev * __c4)); + _Tp __s3 = __pndev * __ea * (__c2 - __pndev * __c3) + - __c2 * __pndev * __ec; + + return _Tp(3) * __sigma + __power4 * (__s1 + __s2 + __s3) + / (__mu * std::sqrt(__mu)); + } + } +# 661 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_3(_Tp __k, _Tp __nu) + { + + if (__isnan(__k) || __isnan(__nu)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__nu == _Tp(1)) + return std::numeric_limits<_Tp>::infinity(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __comp_ellint_3.")); + else + { + const _Tp __kk = __k * __k; + + return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1)) + + __nu + * __ellint_rj(_Tp(0), _Tp(1) - __kk, _Tp(1), _Tp(1) - __nu) + / _Tp(3); + } + } +# 701 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_3(_Tp __k, _Tp __nu, _Tp __phi) + { + + if (__isnan(__k) || __isnan(__nu) || __isnan(__phi)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __ellint_3.")); + else + { + + const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + + _Tp(0.5L)); + const _Tp __phi_red = __phi + - __n * __numeric_constants<_Tp>::__pi(); + + const _Tp __kk = __k * __k; + const _Tp __s = std::sin(__phi_red); + const _Tp __ss = __s * __s; + const _Tp __sss = __ss * __s; + const _Tp __c = std::cos(__phi_red); + const _Tp __cc = __c * __c; + + const _Tp __Pi = __s + * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1)) + + __nu * __sss + * __ellint_rj(__cc, _Tp(1) - __kk * __ss, _Tp(1), + _Tp(1) - __nu * __ss) / _Tp(3); + + if (__n == 0) + return __Pi; + else + return __Pi + _Tp(2) * __n * __comp_ellint_3(__k, __nu); + } + } + } + + + + + +} +# 51 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 1 3 +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + namespace __detail + { + template _Tp __expint_E1(_Tp); +# 81 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_E1_series(_Tp __x) + { + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + _Tp __term = _Tp(1); + _Tp __esum = _Tp(0); + _Tp __osum = _Tp(0); + const unsigned int __max_iter = 1000; + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + __term *= - __x / __i; + if (std::abs(__term) < __eps) + break; + if (__term >= _Tp(0)) + __esum += __term / __i; + else + __osum += __term / __i; + } + + return - __esum - __osum + - __numeric_constants<_Tp>::__gamma_e() - std::log(__x); + } +# 118 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_E1_asymp(_Tp __x) + { + _Tp __term = _Tp(1); + _Tp __esum = _Tp(1); + _Tp __osum = _Tp(0); + const unsigned int __max_iter = 1000; + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + _Tp __prev = __term; + __term *= - __i / __x; + if (std::abs(__term) > std::abs(__prev)) + break; + if (__term >= _Tp(0)) + __esum += __term; + else + __osum += __term; + } + + return std::exp(- __x) * (__esum + __osum) / __x; + } +# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_En_series(unsigned int __n, _Tp __x) + { + const unsigned int __max_iter = 1000; + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const int __nm1 = __n - 1; + _Tp __ans = (__nm1 != 0 + ? _Tp(1) / __nm1 : -std::log(__x) + - __numeric_constants<_Tp>::__gamma_e()); + _Tp __fact = _Tp(1); + for (int __i = 1; __i <= __max_iter; ++__i) + { + __fact *= -__x / _Tp(__i); + _Tp __del; + if ( __i != __nm1 ) + __del = -__fact / _Tp(__i - __nm1); + else + { + _Tp __psi = -__numeric_constants<_Tp>::gamma_e(); + for (int __ii = 1; __ii <= __nm1; ++__ii) + __psi += _Tp(1) / _Tp(__ii); + __del = __fact * (__psi - std::log(__x)); + } + __ans += __del; + if (std::abs(__del) < __eps * std::abs(__ans)) + return __ans; + } + std::__throw_runtime_error(("Series summation failed " "in __expint_En_series.") + ); + } +# 201 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_En_cont_frac(unsigned int __n, _Tp __x) + { + const unsigned int __max_iter = 1000; + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __fp_min = std::numeric_limits<_Tp>::min(); + const int __nm1 = __n - 1; + _Tp __b = __x + _Tp(__n); + _Tp __c = _Tp(1) / __fp_min; + _Tp __d = _Tp(1) / __b; + _Tp __h = __d; + for ( unsigned int __i = 1; __i <= __max_iter; ++__i ) + { + _Tp __a = -_Tp(__i * (__nm1 + __i)); + __b += _Tp(2); + __d = _Tp(1) / (__a * __d + __b); + __c = __b + __a / __c; + const _Tp __del = __c * __d; + __h *= __del; + if (std::abs(__del - _Tp(1)) < __eps) + { + const _Tp __ans = __h * std::exp(-__x); + return __ans; + } + } + std::__throw_runtime_error(("Continued fraction failed " "in __expint_En_cont_frac.") + ); + } +# 246 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_En_recursion(unsigned int __n, _Tp __x) + { + _Tp __En; + _Tp __E1 = __expint_E1(__x); + if (__x < _Tp(__n)) + { + + __En = __E1; + for (unsigned int __j = 2; __j < __n; ++__j) + __En = (std::exp(-__x) - __x * __En) / _Tp(__j - 1); + } + else + { + + __En = _Tp(1); + const int __N = __n + 20; + _Tp __save = _Tp(0); + for (int __j = __N; __j > 0; --__j) + { + __En = (std::exp(-__x) - __j * __En) / __x; + if (__j == __n) + __save = __En; + } + _Tp __norm = __En / __E1; + __En /= __norm; + } + + return __En; + } +# 290 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_Ei_series(_Tp __x) + { + _Tp __term = _Tp(1); + _Tp __sum = _Tp(0); + const unsigned int __max_iter = 1000; + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + __term *= __x / __i; + __sum += __term / __i; + if (__term < std::numeric_limits<_Tp>::epsilon() * __sum) + break; + } + + return __numeric_constants<_Tp>::__gamma_e() + __sum + std::log(__x); + } +# 321 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_Ei_asymp(_Tp __x) + { + _Tp __term = _Tp(1); + _Tp __sum = _Tp(1); + const unsigned int __max_iter = 1000; + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + _Tp __prev = __term; + __term *= __i / __x; + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + if (__term >= __prev) + break; + __sum += __term; + } + + return std::exp(__x) * __sum / __x; + } +# 354 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_Ei(_Tp __x) + { + if (__x < _Tp(0)) + return -__expint_E1(-__x); + else if (__x < -std::log(std::numeric_limits<_Tp>::epsilon())) + return __expint_Ei_series(__x); + else + return __expint_Ei_asymp(__x); + } +# 378 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_E1(_Tp __x) + { + if (__x < _Tp(0)) + return -__expint_Ei(-__x); + else if (__x < _Tp(1)) + return __expint_E1_series(__x); + else if (__x < _Tp(100)) + return __expint_En_cont_frac(1, __x); + else + return __expint_E1_asymp(__x); + } +# 408 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_asymp(unsigned int __n, _Tp __x) + { + _Tp __term = _Tp(1); + _Tp __sum = _Tp(1); + for (unsigned int __i = 1; __i <= __n; ++__i) + { + _Tp __prev = __term; + __term *= -(__n - __i + 1) / __x; + if (std::abs(__term) > std::abs(__prev)) + break; + __sum += __term; + } + + return std::exp(-__x) * __sum / __x; + } +# 442 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_large_n(unsigned int __n, _Tp __x) + { + const _Tp __xpn = __x + __n; + const _Tp __xpn2 = __xpn * __xpn; + _Tp __term = _Tp(1); + _Tp __sum = _Tp(1); + for (unsigned int __i = 1; __i <= __n; ++__i) + { + _Tp __prev = __term; + __term *= (__n - 2 * (__i - 1) * __x) / __xpn2; + if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon()) + break; + __sum += __term; + } + + return std::exp(-__x) * __sum / __xpn; + } +# 476 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint(unsigned int __n, _Tp __x) + { + + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__n <= 1 && __x == _Tp(0)) + return std::numeric_limits<_Tp>::infinity(); + else + { + _Tp __E0 = std::exp(__x) / __x; + if (__n == 0) + return __E0; + + _Tp __E1 = __expint_E1(__x); + if (__n == 1) + return __E1; + + if (__x == _Tp(0)) + return _Tp(1) / static_cast<_Tp>(__n - 1); + + _Tp __En = __expint_En_recursion(__n, __x); + + return __En; + } + } +# 516 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + inline _Tp + __expint(_Tp __x) + { + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __expint_Ei(__x); + } + } + + + + + +} +# 52 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 1 3 +# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + namespace __detail + { +# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __conf_hyperg_series(_Tp __a, _Tp __c, _Tp __x) + { + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + _Tp __term = _Tp(1); + _Tp __Fac = _Tp(1); + const unsigned int __max_iter = 100000; + unsigned int __i; + for (__i = 0; __i < __max_iter; ++__i) + { + __term *= (__a + _Tp(__i)) * __x + / ((__c + _Tp(__i)) * _Tp(1 + __i)); + if (std::abs(__term) < __eps) + { + break; + } + __Fac += __term; + } + if (__i == __max_iter) + std::__throw_runtime_error(("Series failed to converge " "in __conf_hyperg_series.") + ); + + return __Fac; + } +# 120 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __conf_hyperg_luke(_Tp __a, _Tp __c, _Tp __xin) + { + const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L)); + const int __nmax = 20000; + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __x = -__xin; + const _Tp __x3 = __x * __x * __x; + const _Tp __t0 = __a / __c; + const _Tp __t1 = (__a + _Tp(1)) / (_Tp(2) * __c); + const _Tp __t2 = (__a + _Tp(2)) / (_Tp(2) * (__c + _Tp(1))); + _Tp __F = _Tp(1); + _Tp __prec; + + _Tp __Bnm3 = _Tp(1); + _Tp __Bnm2 = _Tp(1) + __t1 * __x; + _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x); + + _Tp __Anm3 = _Tp(1); + _Tp __Anm2 = __Bnm2 - __t0 * __x; + _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x + + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x; + + int __n = 3; + while(1) + { + _Tp __npam1 = _Tp(__n - 1) + __a; + _Tp __npcm1 = _Tp(__n - 1) + __c; + _Tp __npam2 = _Tp(__n - 2) + __a; + _Tp __npcm2 = _Tp(__n - 2) + __c; + _Tp __tnm1 = _Tp(2 * __n - 1); + _Tp __tnm3 = _Tp(2 * __n - 3); + _Tp __tnm5 = _Tp(2 * __n - 5); + _Tp __F1 = (_Tp(__n - 2) - __a) / (_Tp(2) * __tnm3 * __npcm1); + _Tp __F2 = (_Tp(__n) + __a) * __npam1 + / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1); + _Tp __F3 = -__npam2 * __npam1 * (_Tp(__n - 2) - __a) + / (_Tp(8) * __tnm3 * __tnm3 * __tnm5 + * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1); + _Tp __E = -__npam1 * (_Tp(__n - 1) - __c) + / (_Tp(2) * __tnm3 * __npcm2 * __npcm1); + + _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1 + + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3; + _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1 + + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3; + _Tp __r = __An / __Bn; + + __prec = std::abs((__F - __r) / __F); + __F = __r; + + if (__prec < __eps || __n > __nmax) + break; + + if (std::abs(__An) > __big || std::abs(__Bn) > __big) + { + __An /= __big; + __Bn /= __big; + __Anm1 /= __big; + __Bnm1 /= __big; + __Anm2 /= __big; + __Bnm2 /= __big; + __Anm3 /= __big; + __Bnm3 /= __big; + } + else if (std::abs(__An) < _Tp(1) / __big + || std::abs(__Bn) < _Tp(1) / __big) + { + __An *= __big; + __Bn *= __big; + __Anm1 *= __big; + __Bnm1 *= __big; + __Anm2 *= __big; + __Bnm2 *= __big; + __Anm3 *= __big; + __Bnm3 *= __big; + } + + ++__n; + __Bnm3 = __Bnm2; + __Bnm2 = __Bnm1; + __Bnm1 = __Bn; + __Anm3 = __Anm2; + __Anm2 = __Anm1; + __Anm1 = __An; + } + + if (__n >= __nmax) + std::__throw_runtime_error(("Iteration failed to converge " "in __conf_hyperg_luke.") + ); + + return __F; + } +# 227 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __conf_hyperg(_Tp __a, _Tp __c, _Tp __x) + { + + const _Tp __c_nint = ::std::nearbyint(__c); + + + + if (__isnan(__a) || __isnan(__c) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__c_nint == __c && __c_nint <= 0) + return std::numeric_limits<_Tp>::infinity(); + else if (__a == _Tp(0)) + return _Tp(1); + else if (__c == __a) + return std::exp(__x); + else if (__x < _Tp(0)) + return __conf_hyperg_luke(__a, __c, __x); + else + return __conf_hyperg_series(__a, __c, __x); + } +# 271 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __hyperg_series(_Tp __a, _Tp __b, _Tp __c, _Tp __x) + { + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + _Tp __term = _Tp(1); + _Tp __Fabc = _Tp(1); + const unsigned int __max_iter = 100000; + unsigned int __i; + for (__i = 0; __i < __max_iter; ++__i) + { + __term *= (__a + _Tp(__i)) * (__b + _Tp(__i)) * __x + / ((__c + _Tp(__i)) * _Tp(1 + __i)); + if (std::abs(__term) < __eps) + { + break; + } + __Fabc += __term; + } + if (__i == __max_iter) + std::__throw_runtime_error(("Series failed to converge " "in __hyperg_series.") + ); + + return __Fabc; + } + + + + + + + + template + _Tp + __hyperg_luke(_Tp __a, _Tp __b, _Tp __c, _Tp __xin) + { + const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L)); + const int __nmax = 20000; + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __x = -__xin; + const _Tp __x3 = __x * __x * __x; + const _Tp __t0 = __a * __b / __c; + const _Tp __t1 = (__a + _Tp(1)) * (__b + _Tp(1)) / (_Tp(2) * __c); + const _Tp __t2 = (__a + _Tp(2)) * (__b + _Tp(2)) + / (_Tp(2) * (__c + _Tp(1))); + + _Tp __F = _Tp(1); + + _Tp __Bnm3 = _Tp(1); + _Tp __Bnm2 = _Tp(1) + __t1 * __x; + _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x); + + _Tp __Anm3 = _Tp(1); + _Tp __Anm2 = __Bnm2 - __t0 * __x; + _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x + + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x; + + int __n = 3; + while (1) + { + const _Tp __npam1 = _Tp(__n - 1) + __a; + const _Tp __npbm1 = _Tp(__n - 1) + __b; + const _Tp __npcm1 = _Tp(__n - 1) + __c; + const _Tp __npam2 = _Tp(__n - 2) + __a; + const _Tp __npbm2 = _Tp(__n - 2) + __b; + const _Tp __npcm2 = _Tp(__n - 2) + __c; + const _Tp __tnm1 = _Tp(2 * __n - 1); + const _Tp __tnm3 = _Tp(2 * __n - 3); + const _Tp __tnm5 = _Tp(2 * __n - 5); + const _Tp __n2 = __n * __n; + const _Tp __F1 = (_Tp(3) * __n2 + (__a + __b - _Tp(6)) * __n + + _Tp(2) - __a * __b - _Tp(2) * (__a + __b)) + / (_Tp(2) * __tnm3 * __npcm1); + const _Tp __F2 = -(_Tp(3) * __n2 - (__a + __b + _Tp(6)) * __n + + _Tp(2) - __a * __b) * __npam1 * __npbm1 + / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1); + const _Tp __F3 = (__npam2 * __npam1 * __npbm2 * __npbm1 + * (_Tp(__n - 2) - __a) * (_Tp(__n - 2) - __b)) + / (_Tp(8) * __tnm3 * __tnm3 * __tnm5 + * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1); + const _Tp __E = -__npam1 * __npbm1 * (_Tp(__n - 1) - __c) + / (_Tp(2) * __tnm3 * __npcm2 * __npcm1); + + _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1 + + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3; + _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1 + + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3; + const _Tp __r = __An / __Bn; + + const _Tp __prec = std::abs((__F - __r) / __F); + __F = __r; + + if (__prec < __eps || __n > __nmax) + break; + + if (std::abs(__An) > __big || std::abs(__Bn) > __big) + { + __An /= __big; + __Bn /= __big; + __Anm1 /= __big; + __Bnm1 /= __big; + __Anm2 /= __big; + __Bnm2 /= __big; + __Anm3 /= __big; + __Bnm3 /= __big; + } + else if (std::abs(__An) < _Tp(1) / __big + || std::abs(__Bn) < _Tp(1) / __big) + { + __An *= __big; + __Bn *= __big; + __Anm1 *= __big; + __Bnm1 *= __big; + __Anm2 *= __big; + __Bnm2 *= __big; + __Anm3 *= __big; + __Bnm3 *= __big; + } + + ++__n; + __Bnm3 = __Bnm2; + __Bnm2 = __Bnm1; + __Bnm1 = __Bn; + __Anm3 = __Anm2; + __Anm2 = __Anm1; + __Anm1 = __An; + } + + if (__n >= __nmax) + std::__throw_runtime_error(("Iteration failed to converge " "in __hyperg_luke.") + ); + + return __F; + } +# 438 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __hyperg_reflect(_Tp __a, _Tp __b, _Tp __c, _Tp __x) + { + const _Tp __d = __c - __a - __b; + const int __intd = std::floor(__d + _Tp(0.5L)); + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __toler = _Tp(1000) * __eps; + const _Tp __log_max = std::log(std::numeric_limits<_Tp>::max()); + const bool __d_integer = (std::abs(__d - __intd) < __toler); + + if (__d_integer) + { + const _Tp __ln_omx = std::log(_Tp(1) - __x); + const _Tp __ad = std::abs(__d); + _Tp __F1, __F2; + + _Tp __d1, __d2; + if (__d >= _Tp(0)) + { + __d1 = __d; + __d2 = _Tp(0); + } + else + { + __d1 = _Tp(0); + __d2 = __d; + } + + const _Tp __lng_c = __log_gamma(__c); + + + if (__ad < __eps) + { + + __F1 = _Tp(0); + } + else + { + + bool __ok_d1 = true; + _Tp __lng_ad, __lng_ad1, __lng_bd1; + try + { + __lng_ad = __log_gamma(__ad); + __lng_ad1 = __log_gamma(__a + __d1); + __lng_bd1 = __log_gamma(__b + __d1); + } + catch(...) + { + __ok_d1 = false; + } + + if (__ok_d1) + { + + + + _Tp __sum1 = _Tp(1); + _Tp __term = _Tp(1); + _Tp __ln_pre1 = __lng_ad + __lng_c + __d2 * __ln_omx + - __lng_ad1 - __lng_bd1; + + + + for (int __i = 1; __i < __ad; ++__i) + { + const int __j = __i - 1; + __term *= (__a + __d2 + __j) * (__b + __d2 + __j) + / (_Tp(1) + __d2 + __j) / __i * (_Tp(1) - __x); + __sum1 += __term; + } + + if (__ln_pre1 > __log_max) + std::__throw_runtime_error(("Overflow of gamma functions" " in __hyperg_luke.") + ); + else + __F1 = std::exp(__ln_pre1) * __sum1; + } + else + { + + + __F1 = _Tp(0); + } + } + + + bool __ok_d2 = true; + _Tp __lng_ad2, __lng_bd2; + try + { + __lng_ad2 = __log_gamma(__a + __d2); + __lng_bd2 = __log_gamma(__b + __d2); + } + catch(...) + { + __ok_d2 = false; + } + + if (__ok_d2) + { + + + const int __maxiter = 2000; + const _Tp __psi_1 = -__numeric_constants<_Tp>::__gamma_e(); + const _Tp __psi_1pd = __psi(_Tp(1) + __ad); + const _Tp __psi_apd1 = __psi(__a + __d1); + const _Tp __psi_bpd1 = __psi(__b + __d1); + + _Tp __psi_term = __psi_1 + __psi_1pd - __psi_apd1 + - __psi_bpd1 - __ln_omx; + _Tp __fact = _Tp(1); + _Tp __sum2 = __psi_term; + _Tp __ln_pre2 = __lng_c + __d1 * __ln_omx + - __lng_ad2 - __lng_bd2; + + + int __j; + for (__j = 1; __j < __maxiter; ++__j) + { + + + const _Tp __term1 = _Tp(1) / _Tp(__j) + + _Tp(1) / (__ad + __j); + const _Tp __term2 = _Tp(1) / (__a + __d1 + _Tp(__j - 1)) + + _Tp(1) / (__b + __d1 + _Tp(__j - 1)); + __psi_term += __term1 - __term2; + __fact *= (__a + __d1 + _Tp(__j - 1)) + * (__b + __d1 + _Tp(__j - 1)) + / ((__ad + __j) * __j) * (_Tp(1) - __x); + const _Tp __delta = __fact * __psi_term; + __sum2 += __delta; + if (std::abs(__delta) < __eps * std::abs(__sum2)) + break; + } + if (__j == __maxiter) + std::__throw_runtime_error(("Sum F2 failed to converge " "in __hyperg_reflect") + ); + + if (__sum2 == _Tp(0)) + __F2 = _Tp(0); + else + __F2 = std::exp(__ln_pre2) * __sum2; + } + else + { + + + __F2 = _Tp(0); + } + + const _Tp __sgn_2 = (__intd % 2 == 1 ? -_Tp(1) : _Tp(1)); + const _Tp __F = __F1 + __sgn_2 * __F2; + + return __F; + } + else + { + + + + + bool __ok1 = true; + _Tp __sgn_g1ca = _Tp(0), __ln_g1ca = _Tp(0); + _Tp __sgn_g1cb = _Tp(0), __ln_g1cb = _Tp(0); + try + { + __sgn_g1ca = __log_gamma_sign(__c - __a); + __ln_g1ca = __log_gamma(__c - __a); + __sgn_g1cb = __log_gamma_sign(__c - __b); + __ln_g1cb = __log_gamma(__c - __b); + } + catch(...) + { + __ok1 = false; + } + + bool __ok2 = true; + _Tp __sgn_g2a = _Tp(0), __ln_g2a = _Tp(0); + _Tp __sgn_g2b = _Tp(0), __ln_g2b = _Tp(0); + try + { + __sgn_g2a = __log_gamma_sign(__a); + __ln_g2a = __log_gamma(__a); + __sgn_g2b = __log_gamma_sign(__b); + __ln_g2b = __log_gamma(__b); + } + catch(...) + { + __ok2 = false; + } + + const _Tp __sgn_gc = __log_gamma_sign(__c); + const _Tp __ln_gc = __log_gamma(__c); + const _Tp __sgn_gd = __log_gamma_sign(__d); + const _Tp __ln_gd = __log_gamma(__d); + const _Tp __sgn_gmd = __log_gamma_sign(-__d); + const _Tp __ln_gmd = __log_gamma(-__d); + + const _Tp __sgn1 = __sgn_gc * __sgn_gd * __sgn_g1ca * __sgn_g1cb; + const _Tp __sgn2 = __sgn_gc * __sgn_gmd * __sgn_g2a * __sgn_g2b; + + _Tp __pre1, __pre2; + if (__ok1 && __ok2) + { + _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb; + _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b + + __d * std::log(_Tp(1) - __x); + if (__ln_pre1 < __log_max && __ln_pre2 < __log_max) + { + __pre1 = std::exp(__ln_pre1); + __pre2 = std::exp(__ln_pre2); + __pre1 *= __sgn1; + __pre2 *= __sgn2; + } + else + { + std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect") + ); + } + } + else if (__ok1 && !__ok2) + { + _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb; + if (__ln_pre1 < __log_max) + { + __pre1 = std::exp(__ln_pre1); + __pre1 *= __sgn1; + __pre2 = _Tp(0); + } + else + { + std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect") + ); + } + } + else if (!__ok1 && __ok2) + { + _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b + + __d * std::log(_Tp(1) - __x); + if (__ln_pre2 < __log_max) + { + __pre1 = _Tp(0); + __pre2 = std::exp(__ln_pre2); + __pre2 *= __sgn2; + } + else + { + std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect") + ); + } + } + else + { + __pre1 = _Tp(0); + __pre2 = _Tp(0); + std::__throw_runtime_error(("Underflow of gamma functions " "in __hyperg_reflect") + ); + } + + const _Tp __F1 = __hyperg_series(__a, __b, _Tp(1) - __d, + _Tp(1) - __x); + const _Tp __F2 = __hyperg_series(__c - __a, __c - __b, _Tp(1) + __d, + _Tp(1) - __x); + + const _Tp __F = __pre1 * __F1 + __pre2 * __F2; + + return __F; + } + } +# 728 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __hyperg(_Tp __a, _Tp __b, _Tp __c, _Tp __x) + { + + const _Tp __a_nint = ::std::nearbyint(__a); + const _Tp __b_nint = ::std::nearbyint(__b); + const _Tp __c_nint = ::std::nearbyint(__c); + + + + + + const _Tp __toler = _Tp(1000) * std::numeric_limits<_Tp>::epsilon(); + if (std::abs(__x) >= _Tp(1)) + std::__throw_domain_error(("Argument outside unit circle " "in __hyperg.") + ); + else if (__isnan(__a) || __isnan(__b) + || __isnan(__c) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__c_nint == __c && __c_nint <= _Tp(0)) + return std::numeric_limits<_Tp>::infinity(); + else if (std::abs(__c - __b) < __toler || std::abs(__c - __a) < __toler) + return std::pow(_Tp(1) - __x, __c - __a - __b); + else if (__a >= _Tp(0) && __b >= _Tp(0) && __c >= _Tp(0) + && __x >= _Tp(0) && __x < _Tp(0.995L)) + return __hyperg_series(__a, __b, __c, __x); + else if (std::abs(__a) < _Tp(10) && std::abs(__b) < _Tp(10)) + { + + + if (__a < _Tp(0) && std::abs(__a - __a_nint) < __toler) + return __hyperg_series(__a_nint, __b, __c, __x); + else if (__b < _Tp(0) && std::abs(__b - __b_nint) < __toler) + return __hyperg_series(__a, __b_nint, __c, __x); + else if (__x < -_Tp(0.25L)) + return __hyperg_luke(__a, __b, __c, __x); + else if (__x < _Tp(0.5L)) + return __hyperg_series(__a, __b, __c, __x); + else + if (std::abs(__c) > _Tp(10)) + return __hyperg_series(__a, __b, __c, __x); + else + return __hyperg_reflect(__a, __b, __c, __x); + } + else + return __hyperg_luke(__a, __b, __c, __x); + } + } + + + + + + +} +# 53 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 1 3 +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 + namespace __detail + { +# 80 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 + template + _Tp + __poly_legendre_p(unsigned int __l, _Tp __x) + { + + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x == +_Tp(1)) + return +_Tp(1); + else if (__x == -_Tp(1)) + return (__l % 2 == 1 ? -_Tp(1) : +_Tp(1)); + else + { + _Tp __p_lm2 = _Tp(1); + if (__l == 0) + return __p_lm2; + + _Tp __p_lm1 = __x; + if (__l == 1) + return __p_lm1; + + _Tp __p_l = 0; + for (unsigned int __ll = 2; __ll <= __l; ++__ll) + { + + + __p_l = _Tp(2) * __x * __p_lm1 - __p_lm2 + - (__x * __p_lm1 - __p_lm2) / _Tp(__ll); + __p_lm2 = __p_lm1; + __p_lm1 = __p_l; + } + + return __p_l; + } + } +# 136 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 + template + _Tp + __assoc_legendre_p(unsigned int __l, unsigned int __m, _Tp __x, + _Tp __phase = _Tp(+1)) + { + + if (__m > __l) + return _Tp(0); + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__m == 0) + return __poly_legendre_p(__l, __x); + else + { + _Tp __p_mm = _Tp(1); + if (__m > 0) + { + + + _Tp __root = std::sqrt(_Tp(1) - __x) * std::sqrt(_Tp(1) + __x); + _Tp __fact = _Tp(1); + for (unsigned int __i = 1; __i <= __m; ++__i) + { + __p_mm *= __phase * __fact * __root; + __fact += _Tp(2); + } + } + if (__l == __m) + return __p_mm; + + _Tp __p_mp1m = _Tp(2 * __m + 1) * __x * __p_mm; + if (__l == __m + 1) + return __p_mp1m; + + _Tp __p_lm2m = __p_mm; + _Tp __P_lm1m = __p_mp1m; + _Tp __p_lm = _Tp(0); + for (unsigned int __j = __m + 2; __j <= __l; ++__j) + { + __p_lm = (_Tp(2 * __j - 1) * __x * __P_lm1m + - _Tp(__j + __m - 1) * __p_lm2m) / _Tp(__j - __m); + __p_lm2m = __P_lm1m; + __P_lm1m = __p_lm; + } + + return __p_lm; + } + } +# 214 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 + template + _Tp + __sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta) + { + if (__isnan(__theta)) + return std::numeric_limits<_Tp>::quiet_NaN(); + + const _Tp __x = std::cos(__theta); + + if (__m > __l) + return _Tp(0); + else if (__m == 0) + { + _Tp __P = __poly_legendre_p(__l, __x); + _Tp __fact = std::sqrt(_Tp(2 * __l + 1) + / (_Tp(4) * __numeric_constants<_Tp>::__pi())); + __P *= __fact; + return __P; + } + else if (__x == _Tp(1) || __x == -_Tp(1)) + { + + return _Tp(0); + } + else + { + + + + + + const _Tp __sgn = ( __m % 2 == 1 ? -_Tp(1) : _Tp(1)); + const _Tp __y_mp1m_factor = __x * std::sqrt(_Tp(2 * __m + 3)); + + const _Tp __lncirc = ::std::log1p(-__x * __x); + + + + + + const _Tp __lnpoch = ::std::lgamma(_Tp(__m + _Tp(0.5L))) + - ::std::lgamma(_Tp(__m)); + + + + + const _Tp __lnpre_val = + -_Tp(0.25L) * __numeric_constants<_Tp>::__lnpi() + + _Tp(0.5L) * (__lnpoch + __m * __lncirc); + const _Tp __sr = std::sqrt((_Tp(2) + _Tp(1) / __m) + / (_Tp(4) * __numeric_constants<_Tp>::__pi())); + _Tp __y_mm = __sgn * __sr * std::exp(__lnpre_val); + _Tp __y_mp1m = __y_mp1m_factor * __y_mm; + + if (__l == __m) + return __y_mm; + else if (__l == __m + 1) + return __y_mp1m; + else + { + _Tp __y_lm = _Tp(0); + + + for (unsigned int __ll = __m + 2; __ll <= __l; ++__ll) + { + const _Tp __rat1 = _Tp(__ll - __m) / _Tp(__ll + __m); + const _Tp __rat2 = _Tp(__ll - __m - 1) / _Tp(__ll + __m - 1); + const _Tp __fact1 = std::sqrt(__rat1 * _Tp(2 * __ll + 1) + * _Tp(2 * __ll - 1)); + const _Tp __fact2 = std::sqrt(__rat1 * __rat2 * _Tp(2 * __ll + 1) + / _Tp(2 * __ll - 3)); + __y_lm = (__x * __y_mp1m * __fact1 + - (__ll + __m - 1) * __y_mm * __fact2) / _Tp(__ll - __m); + __y_mm = __y_mp1m; + __y_mp1m = __y_lm; + } + + return __y_lm; + } + } + } + } + + + + + + +} +# 54 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 1 3 +# 51 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + namespace __detail + { +# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + template + void + __bessel_ik(_Tp __nu, _Tp __x, + _Tp & __Inu, _Tp & __Knu, _Tp & __Ipnu, _Tp & __Kpnu) + { + if (__x == _Tp(0)) + { + if (__nu == _Tp(0)) + { + __Inu = _Tp(1); + __Ipnu = _Tp(0); + } + else if (__nu == _Tp(1)) + { + __Inu = _Tp(0); + __Ipnu = _Tp(0.5L); + } + else + { + __Inu = _Tp(0); + __Ipnu = _Tp(0); + } + __Knu = std::numeric_limits<_Tp>::infinity(); + __Kpnu = -std::numeric_limits<_Tp>::infinity(); + return; + } + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __fp_min = _Tp(10) * std::numeric_limits<_Tp>::epsilon(); + const int __max_iter = 15000; + const _Tp __x_min = _Tp(2); + + const int __nl = static_cast(__nu + _Tp(0.5L)); + + const _Tp __mu = __nu - __nl; + const _Tp __mu2 = __mu * __mu; + const _Tp __xi = _Tp(1) / __x; + const _Tp __xi2 = _Tp(2) * __xi; + _Tp __h = __nu * __xi; + if ( __h < __fp_min ) + __h = __fp_min; + _Tp __b = __xi2 * __nu; + _Tp __d = _Tp(0); + _Tp __c = __h; + int __i; + for ( __i = 1; __i <= __max_iter; ++__i ) + { + __b += __xi2; + __d = _Tp(1) / (__b + __d); + __c = __b + _Tp(1) / __c; + const _Tp __del = __c * __d; + __h *= __del; + if (std::abs(__del - _Tp(1)) < __eps) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Argument x too large " "in __bessel_ik; " "try asymptotic expansion.") + + ); + _Tp __Inul = __fp_min; + _Tp __Ipnul = __h * __Inul; + _Tp __Inul1 = __Inul; + _Tp __Ipnu1 = __Ipnul; + _Tp __fact = __nu * __xi; + for (int __l = __nl; __l >= 1; --__l) + { + const _Tp __Inutemp = __fact * __Inul + __Ipnul; + __fact -= __xi; + __Ipnul = __fact * __Inutemp + __Inul; + __Inul = __Inutemp; + } + _Tp __f = __Ipnul / __Inul; + _Tp __Kmu, __Knu1; + if (__x < __x_min) + { + const _Tp __x2 = __x / _Tp(2); + const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu; + const _Tp __fact = (std::abs(__pimu) < __eps + ? _Tp(1) : __pimu / std::sin(__pimu)); + _Tp __d = -std::log(__x2); + _Tp __e = __mu * __d; + const _Tp __fact2 = (std::abs(__e) < __eps + ? _Tp(1) : std::sinh(__e) / __e); + _Tp __gam1, __gam2, __gampl, __gammi; + __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi); + _Tp __ff = __fact + * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d); + _Tp __sum = __ff; + __e = std::exp(__e); + _Tp __p = __e / (_Tp(2) * __gampl); + _Tp __q = _Tp(1) / (_Tp(2) * __e * __gammi); + _Tp __c = _Tp(1); + __d = __x2 * __x2; + _Tp __sum1 = __p; + int __i; + for (__i = 1; __i <= __max_iter; ++__i) + { + __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2); + __c *= __d / __i; + __p /= __i - __mu; + __q /= __i + __mu; + const _Tp __del = __c * __ff; + __sum += __del; + const _Tp __del1 = __c * (__p - __i * __ff); + __sum1 += __del1; + if (std::abs(__del) < __eps * std::abs(__sum)) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Bessel k series failed to converge " "in __bessel_ik.") + ); + __Kmu = __sum; + __Knu1 = __sum1 * __xi2; + } + else + { + _Tp __b = _Tp(2) * (_Tp(1) + __x); + _Tp __d = _Tp(1) / __b; + _Tp __delh = __d; + _Tp __h = __delh; + _Tp __q1 = _Tp(0); + _Tp __q2 = _Tp(1); + _Tp __a1 = _Tp(0.25L) - __mu2; + _Tp __q = __c = __a1; + _Tp __a = -__a1; + _Tp __s = _Tp(1) + __q * __delh; + int __i; + for (__i = 2; __i <= __max_iter; ++__i) + { + __a -= 2 * (__i - 1); + __c = -__a * __c / __i; + const _Tp __qnew = (__q1 - __b * __q2) / __a; + __q1 = __q2; + __q2 = __qnew; + __q += __c * __qnew; + __b += _Tp(2); + __d = _Tp(1) / (__b + __a * __d); + __delh = (__b * __d - _Tp(1)) * __delh; + __h += __delh; + const _Tp __dels = __q * __delh; + __s += __dels; + if ( std::abs(__dels / __s) < __eps ) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Steed's method failed " "in __bessel_ik.") + ); + __h = __a1 * __h; + __Kmu = std::sqrt(__numeric_constants<_Tp>::__pi() / (_Tp(2) * __x)) + * std::exp(-__x) / __s; + __Knu1 = __Kmu * (__mu + __x + _Tp(0.5L) - __h) * __xi; + } + + _Tp __Kpmu = __mu * __xi * __Kmu - __Knu1; + _Tp __Inumu = __xi / (__f * __Kmu - __Kpmu); + __Inu = __Inumu * __Inul1 / __Inul; + __Ipnu = __Inumu * __Ipnu1 / __Inul; + for ( __i = 1; __i <= __nl; ++__i ) + { + const _Tp __Knutemp = (__mu + __i) * __xi2 * __Knu1 + __Kmu; + __Kmu = __Knu1; + __Knu1 = __Knutemp; + } + __Knu = __Kmu; + __Kpnu = __nu * __xi * __Kmu - __Knu1; + + return; + } +# 267 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + template + _Tp + __cyl_bessel_i(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_i.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x * __x < _Tp(10) * (__nu + _Tp(1))) + return __cyl_bessel_ij_series(__nu, __x, +_Tp(1), 200); + else + { + _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + return __I_nu; + } + } +# 303 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + template + _Tp + __cyl_bessel_k(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_k.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + { + _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + return __K_nu; + } + } +# 337 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + template + void + __sph_bessel_ik(unsigned int __n, _Tp __x, + _Tp & __i_n, _Tp & __k_n, _Tp & __ip_n, _Tp & __kp_n) + { + const _Tp __nu = _Tp(__n) + _Tp(0.5L); + + _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + + const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2() + / std::sqrt(__x); + + __i_n = __factor * __I_nu; + __k_n = __factor * __K_nu; + __ip_n = __factor * __Ip_nu - __i_n / (_Tp(2) * __x); + __kp_n = __factor * __Kp_nu - __k_n / (_Tp(2) * __x); + + return; + } +# 373 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + template + void + __airy(_Tp __x, _Tp & __Ai, _Tp & __Bi, _Tp & __Aip, _Tp & __Bip) + { + const _Tp __absx = std::abs(__x); + const _Tp __rootx = std::sqrt(__absx); + const _Tp __z = _Tp(2) * __absx * __rootx / _Tp(3); + const _Tp _S_inf = std::numeric_limits<_Tp>::infinity(); + + if (__isnan(__x)) + __Bip = __Aip = __Bi = __Ai = std::numeric_limits<_Tp>::quiet_NaN(); + else if (__z == _S_inf) + { + __Aip = __Ai = _Tp(0); + __Bip = __Bi = _S_inf; + } + else if (__z == -_S_inf) + __Bip = __Aip = __Bi = __Ai = _Tp(0); + else if (__x > _Tp(0)) + { + _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu; + + __bessel_ik(_Tp(1) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + __Ai = __rootx * __K_nu + / (__numeric_constants<_Tp>::__sqrt3() + * __numeric_constants<_Tp>::__pi()); + __Bi = __rootx * (__K_nu / __numeric_constants<_Tp>::__pi() + + _Tp(2) * __I_nu / __numeric_constants<_Tp>::__sqrt3()); + + __bessel_ik(_Tp(2) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + __Aip = -__x * __K_nu + / (__numeric_constants<_Tp>::__sqrt3() + * __numeric_constants<_Tp>::__pi()); + __Bip = __x * (__K_nu / __numeric_constants<_Tp>::__pi() + + _Tp(2) * __I_nu + / __numeric_constants<_Tp>::__sqrt3()); + } + else if (__x < _Tp(0)) + { + _Tp __J_nu, __Jp_nu, __N_nu, __Np_nu; + + __bessel_jn(_Tp(1) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu); + __Ai = __rootx * (__J_nu + - __N_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2); + __Bi = -__rootx * (__N_nu + + __J_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2); + + __bessel_jn(_Tp(2) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu); + __Aip = __absx * (__N_nu / __numeric_constants<_Tp>::__sqrt3() + + __J_nu) / _Tp(2); + __Bip = __absx * (__J_nu / __numeric_constants<_Tp>::__sqrt3() + - __N_nu) / _Tp(2); + } + else + { + + + + __Ai = _Tp(0.35502805388781723926L); + __Bi = __Ai * __numeric_constants<_Tp>::__sqrt3(); + + + + + __Aip = -_Tp(0.25881940379280679840L); + __Bip = -__Aip * __numeric_constants<_Tp>::__sqrt3(); + } + + return; + } + } + + + + + +} +# 55 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 1 3 +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 56 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 + namespace __detail + { +# 72 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 + template + _Tp + __poly_hermite_recursion(unsigned int __n, _Tp __x) + { + + _Tp __H_0 = 1; + if (__n == 0) + return __H_0; + + + _Tp __H_1 = 2 * __x; + if (__n == 1) + return __H_1; + + + _Tp __H_n, __H_nm1, __H_nm2; + unsigned int __i; + for (__H_nm2 = __H_0, __H_nm1 = __H_1, __i = 2; __i <= __n; ++__i) + { + __H_n = 2 * (__x * __H_nm1 - (__i - 1) * __H_nm2); + __H_nm2 = __H_nm1; + __H_nm1 = __H_n; + } + + return __H_n; + } +# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 + template + inline _Tp + __poly_hermite(unsigned int __n, _Tp __x) + { + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __poly_hermite_recursion(__n, __x); + } + } + + + + + +} +# 56 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 1 3 +# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + namespace __detail + { +# 75 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre_large_n(unsigned __n, _Tpa __alpha1, _Tp __x) + { + const _Tp __a = -_Tp(__n); + const _Tp __b = _Tp(__alpha1) + _Tp(1); + const _Tp __eta = _Tp(2) * __b - _Tp(4) * __a; + const _Tp __cos2th = __x / __eta; + const _Tp __sin2th = _Tp(1) - __cos2th; + const _Tp __th = std::acos(std::sqrt(__cos2th)); + const _Tp __pre_h = __numeric_constants<_Tp>::__pi_2() + * __numeric_constants<_Tp>::__pi_2() + * __eta * __eta * __cos2th * __sin2th; + + + const _Tp __lg_b = ::std::lgamma(_Tp(__n) + __b); + const _Tp __lnfact = ::std::lgamma(_Tp(__n + 1)); + + + + + + _Tp __pre_term1 = _Tp(0.5L) * (_Tp(1) - __b) + * std::log(_Tp(0.25L) * __x * __eta); + _Tp __pre_term2 = _Tp(0.25L) * std::log(__pre_h); + _Tp __lnpre = __lg_b - __lnfact + _Tp(0.5L) * __x + + __pre_term1 - __pre_term2; + _Tp __ser_term1 = std::sin(__a * __numeric_constants<_Tp>::__pi()); + _Tp __ser_term2 = std::sin(_Tp(0.25L) * __eta + * (_Tp(2) * __th + - std::sin(_Tp(2) * __th)) + + __numeric_constants<_Tp>::__pi_4()); + _Tp __ser = __ser_term1 + __ser_term2; + + return std::exp(__lnpre) * __ser; + } +# 129 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre_hyperg(unsigned int __n, _Tpa __alpha1, _Tp __x) + { + const _Tp __b = _Tp(__alpha1) + _Tp(1); + const _Tp __mx = -__x; + const _Tp __tc_sgn = (__x < _Tp(0) ? _Tp(1) + : ((__n % 2 == 1) ? -_Tp(1) : _Tp(1))); + + _Tp __tc = _Tp(1); + const _Tp __ax = std::abs(__x); + for (unsigned int __k = 1; __k <= __n; ++__k) + __tc *= (__ax / __k); + + _Tp __term = __tc * __tc_sgn; + _Tp __sum = __term; + for (int __k = int(__n) - 1; __k >= 0; --__k) + { + __term *= ((__b + _Tp(__k)) / _Tp(int(__n) - __k)) + * _Tp(__k + 1) / __mx; + __sum += __term; + } + + return __sum; + } +# 185 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre_recursion(unsigned int __n, _Tpa __alpha1, _Tp __x) + { + + _Tp __l_0 = _Tp(1); + if (__n == 0) + return __l_0; + + + _Tp __l_1 = -__x + _Tp(1) + _Tp(__alpha1); + if (__n == 1) + return __l_1; + + + _Tp __l_n2 = __l_0; + _Tp __l_n1 = __l_1; + _Tp __l_n = _Tp(0); + for (unsigned int __nn = 2; __nn <= __n; ++__nn) + { + __l_n = (_Tp(2 * __nn - 1) + _Tp(__alpha1) - __x) + * __l_n1 / _Tp(__nn) + - (_Tp(__nn - 1) + _Tp(__alpha1)) * __l_n2 / _Tp(__nn); + __l_n2 = __l_n1; + __l_n1 = __l_n; + } + + return __l_n; + } +# 244 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre(unsigned int __n, _Tpa __alpha1, _Tp __x) + { + if (__x < _Tp(0)) + std::__throw_domain_error(("Negative argument " "in __poly_laguerre.") + ); + + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__n == 0) + return _Tp(1); + else if (__n == 1) + return _Tp(1) + _Tp(__alpha1) - __x; + else if (__x == _Tp(0)) + { + _Tp __prod = _Tp(__alpha1) + _Tp(1); + for (unsigned int __k = 2; __k <= __n; ++__k) + __prod *= (_Tp(__alpha1) + _Tp(__k)) / _Tp(__k); + return __prod; + } + else if (__n > 10000000 && _Tp(__alpha1) > -_Tp(1) + && __x < _Tp(2) * (_Tp(__alpha1) + _Tp(1)) + _Tp(4 * __n)) + return __poly_laguerre_large_n(__n, __alpha1, __x); + else if (_Tp(__alpha1) >= _Tp(0) + || (__x > _Tp(0) && _Tp(__alpha1) < -_Tp(__n + 1))) + return __poly_laguerre_recursion(__n, __alpha1, __x); + else + return __poly_laguerre_hyperg(__n, __alpha1, __x); + } +# 296 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + inline _Tp + __assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x) + { return __poly_laguerre(__n, __m, __x); } +# 316 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + inline _Tp + __laguerre(unsigned int __n, _Tp __x) + { return __poly_laguerre(__n, 0, __x); } + } + + + + + + +} +# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + namespace __detail + { +# 78 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_sum(_Tp __s) + { + + if (__s < _Tp(1)) + std::__throw_domain_error(("Bad argument in zeta sum.")); + + const unsigned int max_iter = 10000; + _Tp __zeta = _Tp(0); + for (unsigned int __k = 1; __k < max_iter; ++__k) + { + _Tp __term = std::pow(static_cast<_Tp>(__k), -__s); + if (__term < std::numeric_limits<_Tp>::epsilon()) + { + break; + } + __zeta += __term; + } + + return __zeta; + } +# 115 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_alt(_Tp __s) + { + _Tp __sgn = _Tp(1); + _Tp __zeta = _Tp(0); + for (unsigned int __i = 1; __i < 10000000; ++__i) + { + _Tp __term = __sgn / std::pow(__i, __s); + if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon()) + break; + __zeta += __term; + __sgn *= _Tp(-1); + } + __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s); + + return __zeta; + } +# 157 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_glob(_Tp __s) + { + _Tp __zeta = _Tp(0); + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + + + if (__s < _Tp(0)) + { + + if (::std::fmod(__s,_Tp(2)) == _Tp(0)) + return _Tp(0); + else + + { + _Tp __zeta = __riemann_zeta_glob(_Tp(1) - __s); + __zeta *= std::pow(_Tp(2) + * __numeric_constants<_Tp>::__pi(), __s) + * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) + + * std::exp(::std::lgamma(_Tp(1) - __s)) + + + + / __numeric_constants<_Tp>::__pi(); + return __zeta; + } + } + + _Tp __num = _Tp(0.5L); + const unsigned int __maxit = 10000; + for (unsigned int __i = 0; __i < __maxit; ++__i) + { + bool __punt = false; + _Tp __sgn = _Tp(1); + _Tp __term = _Tp(0); + for (unsigned int __j = 0; __j <= __i; ++__j) + { + + _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i)) + - ::std::lgamma(_Tp(1 + __j)) + - ::std::lgamma(_Tp(1 + __i - __j)); + + + + + + if (__bincoeff > __max_bincoeff) + { + + __punt = true; + break; + } + __bincoeff = std::exp(__bincoeff); + __term += __sgn * __bincoeff * std::pow(_Tp(1 + __j), -__s); + __sgn *= _Tp(-1); + } + if (__punt) + break; + __term *= __num; + __zeta += __term; + if (std::abs(__term/__zeta) < __eps) + break; + __num *= _Tp(0.5L); + } + + __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s); + + return __zeta; + } +# 252 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_product(_Tp __s) + { + static const _Tp __prime[] = { + _Tp(2), _Tp(3), _Tp(5), _Tp(7), _Tp(11), _Tp(13), _Tp(17), _Tp(19), + _Tp(23), _Tp(29), _Tp(31), _Tp(37), _Tp(41), _Tp(43), _Tp(47), + _Tp(53), _Tp(59), _Tp(61), _Tp(67), _Tp(71), _Tp(73), _Tp(79), + _Tp(83), _Tp(89), _Tp(97), _Tp(101), _Tp(103), _Tp(107), _Tp(109) + }; + static const unsigned int __num_primes = sizeof(__prime) / sizeof(_Tp); + + _Tp __zeta = _Tp(1); + for (unsigned int __i = 0; __i < __num_primes; ++__i) + { + const _Tp __fact = _Tp(1) - std::pow(__prime[__i], -__s); + __zeta *= __fact; + if (_Tp(1) - __fact < std::numeric_limits<_Tp>::epsilon()) + break; + } + + __zeta = _Tp(1) / __zeta; + + return __zeta; + } +# 293 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta(_Tp __s) + { + if (__isnan(__s)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__s == _Tp(1)) + return std::numeric_limits<_Tp>::infinity(); + else if (__s < -_Tp(19)) + { + _Tp __zeta = __riemann_zeta_product(_Tp(1) - __s); + __zeta *= std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s) + * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) + + * std::exp(::std::lgamma(_Tp(1) - __s)) + + + + / __numeric_constants<_Tp>::__pi(); + return __zeta; + } + else if (__s < _Tp(20)) + { + + bool __glob = true; + if (__glob) + return __riemann_zeta_glob(__s); + else + { + if (__s > _Tp(1)) + return __riemann_zeta_sum(__s); + else + { + _Tp __zeta = std::pow(_Tp(2) + * __numeric_constants<_Tp>::__pi(), __s) + * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) + + * ::std::tgamma(_Tp(1) - __s) + + + + * __riemann_zeta_sum(_Tp(1) - __s); + return __zeta; + } + } + } + else + return __riemann_zeta_product(__s); + } +# 365 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __hurwitz_zeta_glob(_Tp __a, _Tp __s) + { + _Tp __zeta = _Tp(0); + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + const unsigned int __maxit = 10000; + for (unsigned int __i = 0; __i < __maxit; ++__i) + { + bool __punt = false; + _Tp __sgn = _Tp(1); + _Tp __term = _Tp(0); + for (unsigned int __j = 0; __j <= __i; ++__j) + { + + _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i)) + - ::std::lgamma(_Tp(1 + __j)) + - ::std::lgamma(_Tp(1 + __i - __j)); + + + + + + if (__bincoeff > __max_bincoeff) + { + + __punt = true; + break; + } + __bincoeff = std::exp(__bincoeff); + __term += __sgn * __bincoeff * std::pow(_Tp(__a + __j), -__s); + __sgn *= _Tp(-1); + } + if (__punt) + break; + __term /= _Tp(__i + 1); + if (std::abs(__term / __zeta) < __eps) + break; + __zeta += __term; + } + + __zeta /= __s - _Tp(1); + + return __zeta; + } +# 430 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + inline _Tp + __hurwitz_zeta(_Tp __a, _Tp __s) + { return __hurwitz_zeta_glob(__a, __s); } + } + + + + + + +} +# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 203 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + assoc_laguerref(unsigned int __n, unsigned int __m, float __x) + { return __detail::__assoc_laguerre(__n, __m, __x); } + + + + + + + + inline long double + assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x) + { return __detail::__assoc_laguerre(__n, __m, __x); } +# 248 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__assoc_laguerre<__type>(__n, __m, __x); + } +# 264 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + assoc_legendref(unsigned int __l, unsigned int __m, float __x) + { return __detail::__assoc_legendre_p(__l, __m, __x); } + + + + + + + inline long double + assoc_legendrel(unsigned int __l, unsigned int __m, long double __x) + { return __detail::__assoc_legendre_p(__l, __m, __x); } +# 294 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__assoc_legendre_p<__type>(__l, __m, __x); + } +# 309 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + betaf(float __a, float __b) + { return __detail::__beta(__a, __b); } + + + + + + + + inline long double + betal(long double __a, long double __b) + { return __detail::__beta(__a, __b); } +# 339 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type + beta(_Tpa __a, _Tpb __b) + { + typedef typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type __type; + return __detail::__beta<__type>(__a, __b); + } +# 355 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + comp_ellint_1f(float __k) + { return __detail::__comp_ellint_1(__k); } + + + + + + + + inline long double + comp_ellint_1l(long double __k) + { return __detail::__comp_ellint_1(__k); } +# 387 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + comp_ellint_1(_Tp __k) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__comp_ellint_1<__type>(__k); + } +# 403 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + comp_ellint_2f(float __k) + { return __detail::__comp_ellint_2(__k); } + + + + + + + + inline long double + comp_ellint_2l(long double __k) + { return __detail::__comp_ellint_2(__k); } +# 434 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + comp_ellint_2(_Tp __k) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__comp_ellint_2<__type>(__k); + } +# 450 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + comp_ellint_3f(float __k, float __nu) + { return __detail::__comp_ellint_3(__k, __nu); } + + + + + + + + inline long double + comp_ellint_3l(long double __k, long double __nu) + { return __detail::__comp_ellint_3(__k, __nu); } +# 485 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type + comp_ellint_3(_Tp __k, _Tpn __nu) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type; + return __detail::__comp_ellint_3<__type>(__k, __nu); + } +# 501 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + cyl_bessel_if(float __nu, float __x) + { return __detail::__cyl_bessel_i(__nu, __x); } + + + + + + + + inline long double + cyl_bessel_il(long double __nu, long double __x) + { return __detail::__cyl_bessel_i(__nu, __x); } +# 531 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_bessel_i(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_bessel_i<__type>(__nu, __x); + } +# 547 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + cyl_bessel_jf(float __nu, float __x) + { return __detail::__cyl_bessel_j(__nu, __x); } + + + + + + + + inline long double + cyl_bessel_jl(long double __nu, long double __x) + { return __detail::__cyl_bessel_j(__nu, __x); } +# 577 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_bessel_j(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_bessel_j<__type>(__nu, __x); + } +# 593 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + cyl_bessel_kf(float __nu, float __x) + { return __detail::__cyl_bessel_k(__nu, __x); } + + + + + + + + inline long double + cyl_bessel_kl(long double __nu, long double __x) + { return __detail::__cyl_bessel_k(__nu, __x); } +# 629 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_bessel_k(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_bessel_k<__type>(__nu, __x); + } +# 645 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + cyl_neumannf(float __nu, float __x) + { return __detail::__cyl_neumann_n(__nu, __x); } + + + + + + + + inline long double + cyl_neumannl(long double __nu, long double __x) + { return __detail::__cyl_neumann_n(__nu, __x); } +# 677 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_neumann(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_neumann_n<__type>(__nu, __x); + } +# 693 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + ellint_1f(float __k, float __phi) + { return __detail::__ellint_1(__k, __phi); } + + + + + + + + inline long double + ellint_1l(long double __k, long double __phi) + { return __detail::__ellint_1(__k, __phi); } +# 725 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type + ellint_1(_Tp __k, _Tpp __phi) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type; + return __detail::__ellint_1<__type>(__k, __phi); + } +# 741 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + ellint_2f(float __k, float __phi) + { return __detail::__ellint_2(__k, __phi); } + + + + + + + + inline long double + ellint_2l(long double __k, long double __phi) + { return __detail::__ellint_2(__k, __phi); } +# 773 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type + ellint_2(_Tp __k, _Tpp __phi) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type; + return __detail::__ellint_2<__type>(__k, __phi); + } +# 789 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + ellint_3f(float __k, float __nu, float __phi) + { return __detail::__ellint_3(__k, __nu, __phi); } + + + + + + + + inline long double + ellint_3l(long double __k, long double __nu, long double __phi) + { return __detail::__ellint_3(__k, __nu, __phi); } +# 826 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type + ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi) + { + typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type; + return __detail::__ellint_3<__type>(__k, __nu, __phi); + } +# 841 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + expintf(float __x) + { return __detail::__expint(__x); } + + + + + + + + inline long double + expintl(long double __x) + { return __detail::__expint(__x); } +# 866 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + expint(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__expint<__type>(__x); + } +# 882 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + hermitef(unsigned int __n, float __x) + { return __detail::__poly_hermite(__n, __x); } + + + + + + + + inline long double + hermitel(unsigned int __n, long double __x) + { return __detail::__poly_hermite(__n, __x); } +# 914 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + hermite(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__poly_hermite<__type>(__n, __x); + } +# 930 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + laguerref(unsigned int __n, float __x) + { return __detail::__laguerre(__n, __x); } + + + + + + + + inline long double + laguerrel(unsigned int __n, long double __x) + { return __detail::__laguerre(__n, __x); } +# 958 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + laguerre(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__laguerre<__type>(__n, __x); + } +# 974 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + legendref(unsigned int __l, float __x) + { return __detail::__poly_legendre_p(__l, __x); } + + + + + + + + inline long double + legendrel(unsigned int __l, long double __x) + { return __detail::__poly_legendre_p(__l, __x); } +# 1003 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + legendre(unsigned int __l, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__poly_legendre_p<__type>(__l, __x); + } +# 1019 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + riemann_zetaf(float __s) + { return __detail::__riemann_zeta(__s); } + + + + + + + + inline long double + riemann_zetal(long double __s) + { return __detail::__riemann_zeta(__s); } +# 1054 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + riemann_zeta(_Tp __s) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__riemann_zeta<__type>(__s); + } +# 1070 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + sph_besself(unsigned int __n, float __x) + { return __detail::__sph_bessel(__n, __x); } + + + + + + + + inline long double + sph_bessell(unsigned int __n, long double __x) + { return __detail::__sph_bessel(__n, __x); } +# 1098 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + sph_bessel(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__sph_bessel<__type>(__n, __x); + } +# 1114 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + sph_legendref(unsigned int __l, unsigned int __m, float __theta) + { return __detail::__sph_legendre(__l, __m, __theta); } +# 1125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline long double + sph_legendrel(unsigned int __l, unsigned int __m, long double __theta) + { return __detail::__sph_legendre(__l, __m, __theta); } +# 1145 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__sph_legendre<__type>(__l, __m, __theta); + } +# 1161 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + sph_neumannf(unsigned int __n, float __x) + { return __detail::__sph_neumann(__n, __x); } + + + + + + + + inline long double + sph_neumannl(unsigned int __n, long double __x) + { return __detail::__sph_neumann(__n, __x); } +# 1189 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + sph_neumann(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__sph_neumann<__type>(__n, __x); + } + + + + +} + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 1216 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + airy_aif(float __x) + { + float __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Ai; + } + + + + + inline long double + airy_ail(long double __x) + { + long double __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Ai; + } + + + + + template + inline typename __gnu_cxx::__promote<_Tp>::__type + airy_ai(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + __type __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy<__type>(__x, __Ai, __Bi, __Aip, __Bip); + return __Ai; + } + + + + + inline float + airy_bif(float __x) + { + float __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Bi; + } + + + + + inline long double + airy_bil(long double __x) + { + long double __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Bi; + } + + + + + template + inline typename __gnu_cxx::__promote<_Tp>::__type + airy_bi(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + __type __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy<__type>(__x, __Ai, __Bi, __Aip, __Bip); + return __Bi; + } +# 1292 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + conf_hypergf(float __a, float __c, float __x) + { return std::__detail::__conf_hyperg(__a, __c, __x); } +# 1303 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline long double + conf_hypergl(long double __a, long double __c, long double __x) + { return std::__detail::__conf_hyperg(__a, __c, __x); } +# 1323 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type + conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x) + { + typedef typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type __type; + return std::__detail::__conf_hyperg<__type>(__a, __c, __x); + } +# 1340 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + hypergf(float __a, float __b, float __c, float __x) + { return std::__detail::__hyperg(__a, __b, __c, __x); } +# 1351 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline long double + hypergl(long double __a, long double __b, long double __c, long double __x) + { return std::__detail::__hyperg(__a, __b, __c, __x); } +# 1372 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type + hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x) + { + typedef typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp> + ::__type __type; + return std::__detail::__hyperg<__type>(__a, __b, __c, __x); + } + + + +} +# 3907 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 + + +} +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/math.h" 2 3 + +using std::abs; +using std::acos; +using std::asin; +using std::atan; +using std::atan2; +using std::cos; +using std::sin; +using std::tan; +using std::cosh; +using std::sinh; +using std::tanh; +using std::exp; +using std::frexp; +using std::ldexp; +using std::log; +using std::log10; +using std::modf; +using std::pow; +using std::sqrt; +using std::ceil; +using std::fabs; +using std::floor; +using std::fmod; + + +using std::fpclassify; +using std::isfinite; +using std::isinf; +using std::isnan; +using std::isnormal; +using std::signbit; +using std::isgreater; +using std::isgreaterequal; +using std::isless; +using std::islessequal; +using std::islessgreater; +using std::isunordered; + + + +using std::acosh; +using std::asinh; +using std::atanh; +using std::cbrt; +using std::copysign; +using std::erf; +using std::erfc; +using std::exp2; +using std::expm1; +using std::fdim; +using std::fma; +using std::fmax; +using std::fmin; +using std::hypot; +using std::ilogb; +using std::lgamma; +using std::llrint; +using std::llround; +using std::log1p; +using std::log2; +using std::logb; +using std::lrint; +using std::lround; +using std::nearbyint; +using std::nextafter; +using std::nexttoward; +using std::remainder; +using std::remquo; +using std::rint; +using std::round; +using std::scalbln; +using std::scalbn; +using std::tgamma; +using std::trunc; +# 4578 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h" 1 3 +# 4579 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +# 4582 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +# 4583 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 4653 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + +# 4653 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool signbit(float x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool signbit(double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool signbit(long double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isfinite(float x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isfinite(double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isfinite(long double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isnan(float x); + + + + +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isnan(double x); + +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isnan(long double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isinf(float x); + + + + +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isinf(double x); + +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isinf(long double x); +} +# 4832 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std +{ + template extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) T __pow_helper(T, int); + template extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) T __cmath_power(T, unsigned int); +} + +using std::abs; +using std::fabs; +using std::ceil; +using std::floor; +using std::sqrt; + +using std::pow; + +using std::log; +using std::log10; +using std::fmod; +using std::modf; +using std::exp; +using std::frexp; +using std::ldexp; +using std::asin; +using std::sin; +using std::sinh; +using std::acos; +using std::cos; +using std::cosh; +using std::atan; +using std::atan2; +using std::tan; +using std::tanh; +# 5243 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +# 5252 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int abs(long long int); +# 5272 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int abs(long int a); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float abs(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double abs(double); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float fabs(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float ceil(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float floor(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sqrt(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float pow(float, float); + + + + +template +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) +typename __gnu_cxx::__promote_2<_Tp, _Up>::__type pow(_Tp, _Up); + + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float log(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float log10(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float fmod(float, float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float modf(float, float*); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float exp(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float frexp(float, int*); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float ldexp(float, int); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float asin(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sin(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sinh(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float acos(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cos(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cosh(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float atan(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float atan2(float, float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float tan(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float tanh(float); +# 5399 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +} +# 5505 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float logb(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr int ilogb(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float scalbn(float a, int b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float scalbln(float a, long int b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float exp2(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float expm1(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float log2(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float log1p(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float acosh(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float asinh(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float atanh(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float hypot(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float cbrt(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float erf(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float erfc(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float lgamma(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float tgamma(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float copysign(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float nextafter(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float remainder(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float remquo(float a, float b, int *quo); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float round(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr long int lround(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr long long int llround(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float trunc(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float rint(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr long int lrint(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr long long int llrint(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float nearbyint(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float fdim(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float fma(float a, float b, float c); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float fmax(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float fmin(float a, float b); +} +# 5644 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float exp10(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float rsqrt(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float rcbrt(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sinpi(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cospi(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void sincospi(const float a, float *const sptr, float *const cptr); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void sincos(const float a, float *const sptr, float *const cptr); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float j0(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float j1(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float jn(const int n, const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float y0(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float y1(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float yn(const int n, const float a); + +static inline __attribute__((device)) __attribute__((cudart_builtin)) float cyl_bessel_i0(const float a); + +static inline __attribute__((device)) __attribute__((cudart_builtin)) float cyl_bessel_i1(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfinv(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfcinv(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float normcdfinv(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float normcdf(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfcx(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double copysign(const double a, const float b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double copysign(const float a, const double b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(const unsigned int a, const unsigned int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(const int a, const unsigned int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(const unsigned int a, const int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int min(const long int a, const long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(const unsigned long int a, const unsigned long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(const long int a, const unsigned long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(const unsigned long int a, const long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int min(const long long int a, const long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(const unsigned long long int a, const unsigned long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(const long long int a, const unsigned long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(const unsigned long long int a, const long long int b); +# 5785 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float min(const float a, const float b); +# 5796 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(const double a, const double b); +# 5806 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(const float a, const double b); +# 5816 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(const double a, const float b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(const unsigned int a, const unsigned int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(const int a, const unsigned int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(const unsigned int a, const int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int max(const long int a, const long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(const unsigned long int a, const unsigned long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(const long int a, const unsigned long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(const unsigned long int a, const long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int max(const long long int a, const long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(const unsigned long long int a, const unsigned long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(const long long int a, const unsigned long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(const unsigned long long int a, const long long int b); +# 5915 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float max(const float a, const float b); +# 5926 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const double a, const double b); +# 5936 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const float a, const double b); +# 5946 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const double a, const float b); +# 5958 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern "C"{ +inline __attribute__((device)) void *__nv_aligned_device_malloc(size_t size, size_t align) +{ + __attribute__((device)) void *__nv_aligned_device_malloc_impl(size_t, size_t); + return __nv_aligned_device_malloc_impl(size, align); +} +} +# 6248 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" 1 +# 77 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 78 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 79 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" 2 +# 758 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +static inline __attribute__((host)) __attribute__((device)) float exp10(const float a) +{ + return exp10f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float rsqrt(const float a) +{ + return rsqrtf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float rcbrt(const float a) +{ + return rcbrtf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float sinpi(const float a) +{ + return sinpif(a); +} + +static inline __attribute__((host)) __attribute__((device)) float cospi(const float a) +{ + return cospif(a); +} + +static inline __attribute__((host)) __attribute__((device)) void sincospi(const float a, float *const sptr, float *const cptr) +{ + sincospif(a, sptr, cptr); +} + +static inline __attribute__((host)) __attribute__((device)) void sincos(const float a, float *const sptr, float *const cptr) +{ + sincosf(a, sptr, cptr); +} + +static inline __attribute__((host)) __attribute__((device)) float j0(const float a) +{ + return j0f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float j1(const float a) +{ + return j1f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float jn(const int n, const float a) +{ + return jnf(n, a); +} + +static inline __attribute__((host)) __attribute__((device)) float y0(const float a) +{ + return y0f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float y1(const float a) +{ + return y1f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float yn(const int n, const float a) +{ + return ynf(n, a); +} + +static inline __attribute__((device)) float cyl_bessel_i0(const float a) +{ + return cyl_bessel_i0f(a); +} + +static inline __attribute__((device)) float cyl_bessel_i1(const float a) +{ + return cyl_bessel_i1f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float erfinv(const float a) +{ + return erfinvf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float erfcinv(const float a) +{ + return erfcinvf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float normcdfinv(const float a) +{ + return normcdfinvf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float normcdf(const float a) +{ + return normcdff(a); +} + +static inline __attribute__((host)) __attribute__((device)) float erfcx(const float a) +{ + return erfcxf(a); +} + +static inline __attribute__((host)) __attribute__((device)) double copysign(const double a, const float b) +{ + return copysign(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) double copysign(const float a, const double b) +{ + return copysign(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int min(const unsigned int a, const unsigned int b) +{ + return umin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int min(const int a, const unsigned int b) +{ + return umin(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int min(const unsigned int a, const int b) +{ + return umin(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) long int min(const long int a, const long int b) +{ + long int retval; + + + + + + + if (sizeof(long int) == sizeof(int)) { + + + + retval = static_cast(min(static_cast(a), static_cast(b))); + } else { + retval = static_cast(llmin(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int min(const unsigned long int a, const unsigned long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umin(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmin(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int min(const long int a, const unsigned long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umin(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmin(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int min(const unsigned long int a, const long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umin(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmin(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) long long int min(const long long int a, const long long int b) +{ + return llmin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(const unsigned long long int a, const unsigned long long int b) +{ + return ullmin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(const long long int a, const unsigned long long int b) +{ + return ullmin(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(const unsigned long long int a, const long long int b) +{ + return ullmin(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) float min(const float a, const float b) +{ + return fminf(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double min(const double a, const double b) +{ + return fmin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double min(const float a, const double b) +{ + return fmin(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) double min(const double a, const float b) +{ + return fmin(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int max(const unsigned int a, const unsigned int b) +{ + return umax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int max(const int a, const unsigned int b) +{ + return umax(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int max(const unsigned int a, const int b) +{ + return umax(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) long int max(const long int a, const long int b) +{ + long int retval; + + + + + + if (sizeof(long int) == sizeof(int)) { + + + + retval = static_cast(max(static_cast(a), static_cast(b))); + } else { + retval = static_cast(llmax(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int max(const unsigned long int a, const unsigned long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umax(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmax(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int max(const long int a, const unsigned long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umax(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmax(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int max(const unsigned long int a, const long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umax(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmax(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) long long int max(const long long int a, const long long int b) +{ + return llmax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(const unsigned long long int a, const unsigned long long int b) +{ + return ullmax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(const long long int a, const unsigned long long int b) +{ + return ullmax(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(const unsigned long long int a, const long long int b) +{ + return ullmax(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) float max(const float a, const float b) +{ + return fmaxf(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double max(const double a, const double b) +{ + return fmax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double max(const float a, const double b) +{ + return fmax(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) double max(const double a, const float b) +{ + return fmax(a, static_cast(b)); +} +# 6249 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 304 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 118 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 1 +# 81 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 82 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" 1 +# 83 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +extern "C" +{ +# 106 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __mulhi(int x, int y); +# 116 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __umulhi(unsigned int x, unsigned int y); +# 126 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __mul64hi(long long int x, long long int y); +# 136 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __umul64hi(unsigned long long int x, unsigned long long int y); +# 145 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int_as_float(int x); +# 154 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float_as_int(float x); +# 163 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint_as_float(unsigned int x); +# 172 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float_as_uint(float x); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __syncthreads(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __prof_trigger(int); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __threadfence(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __threadfence_block(void); +__attribute__((device)) __attribute__((cudart_builtin)) + +__attribute__((__noreturn__)) + + + +__attribute__((device_builtin)) void __trap(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __brkpt(); +# 196 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __saturatef(float x); +# 215 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __sad(int x, int y, unsigned int z); +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __usad(unsigned int x, unsigned int y, unsigned int z); +# 243 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __mul24(int x, int y); +# 253 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __umul24(unsigned int x, unsigned int y); +# 269 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float fdividef(float x, float y); +# 289 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdividef(float x, float y); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) double fdivide(double x, double y); +# 303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __sinf(float x) +# 303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 315 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __cosf(float x) +# 315 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 315 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __tanf(float x) +# 328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __tanhf(float x) +# 340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void __sincosf(float x, float *sptr, float *cptr) +# 353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 371 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __expf(float x) +# 371 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 371 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 385 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __exp10f(float x) +# 385 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 385 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 398 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __log2f(float x) +# 398 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 398 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __log10f(float x) +# 411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 428 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __logf(float x) +# 428 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 428 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 443 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __powf(float x, float y) +# 443 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 443 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 453 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rn(float x); +# 463 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rz(float x); +# 473 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_ru(float); +# 483 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rd(float x); +# 493 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rn(float x); +# 503 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rz(float x); +# 513 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_ru(float x); +# 523 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rd(float x); +# 532 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rn(int x); +# 541 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rz(int x); +# 550 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_ru(int x); +# 559 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rd(int x); +# 568 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rn(unsigned int x); +# 577 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rz(unsigned int x); +# 586 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_ru(unsigned int x); +# 595 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rd(unsigned int x); +# 605 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rn(float x); +# 615 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rz(float x); +# 625 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_ru(float x); +# 635 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rd(float x); +# 645 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rn(float x); +# 655 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rz(float x); +# 665 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_ru(float x); +# 675 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rd(float x); +# 684 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rn(long long int x); +# 693 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rz(long long int x); +# 702 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_ru(long long int x); +# 711 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rd(long long int x); +# 720 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rn(unsigned long long int x); +# 729 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rz(unsigned long long int x); +# 738 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_ru(unsigned long long int x); +# 747 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rd(unsigned long long int x); +# 766 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rn(float x, float y); +# 785 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rz(float x, float y); +# 804 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_ru(float x, float y); +# 823 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rd(float x, float y); +# 842 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rn(float x, float y); +# 861 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rz(float x, float y); +# 880 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_ru(float x, float y); +# 899 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rd(float x, float y); +# 917 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rn(float x, float y); +# 935 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rz(float x, float y); +# 953 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_ru(float x, float y); +# 971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rd(float x, float y); +# 1015 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rn(float x, float y, float z); +# 1059 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rz(float x, float y, float z); +# 1103 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_ru(float x, float y, float z); +# 1147 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rd(float x, float y, float z); +# 1164 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rn(float x); +# 1181 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rz(float x); +# 1198 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_ru(float x); +# 1215 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rd(float x); +# 1233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rn(float x); +# 1251 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rz(float x); +# 1269 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_ru(float x); +# 1287 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rd(float x); +# 1305 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frsqrt_rn(float x); +# 1324 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rn(float x, float y); +# 1343 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rz(float x, float y); +# 1362 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_ru(float x, float y); +# 1381 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rd(float x, float y); +# 1390 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __clz(int x); +# 1401 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __ffs(int x); +# 1410 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __popc(unsigned int x); +# 1419 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __brev(unsigned int x); +# 1428 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __clzll(long long int x); +# 1439 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __ffsll(long long int x); +# 1450 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __popcll(unsigned long long int x); +# 1459 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __brevll(unsigned long long int x); +# 1482 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __byte_perm(unsigned int x, unsigned int y, unsigned int s); +# 1494 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __hadd(int x, int y); +# 1507 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __rhadd(int x, int y); +# 1519 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __uhadd(unsigned int x, unsigned int y); +# 1532 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __urhadd(unsigned int x, unsigned int y); +# 1543 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __double2int_rz(double x); +# 1553 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __double2uint_rz(double x); +# 1563 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __double2ll_rz(double x); +# 1573 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __double2ull_rz(double x); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __pm0(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __pm1(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __pm2(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __pm3(void); +# 1603 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabs2(unsigned int a); +# 1614 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsss2(unsigned int a); +# 1625 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vadd2(unsigned int a, unsigned int b); +# 1636 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddss2 (unsigned int a, unsigned int b); +# 1646 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddus2 (unsigned int a, unsigned int b); +# 1657 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgs2(unsigned int a, unsigned int b); +# 1668 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgu2(unsigned int a, unsigned int b); +# 1679 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vhaddu2(unsigned int a, unsigned int b); +# 1690 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpeq2(unsigned int a, unsigned int b); +# 1701 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpges2(unsigned int a, unsigned int b); +# 1712 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgeu2(unsigned int a, unsigned int b); +# 1723 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgts2(unsigned int a, unsigned int b); +# 1734 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgtu2(unsigned int a, unsigned int b); +# 1745 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmples2(unsigned int a, unsigned int b); +# 1756 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpleu2(unsigned int a, unsigned int b); +# 1767 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmplts2(unsigned int a, unsigned int b); +# 1778 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpltu2(unsigned int a, unsigned int b); +# 1789 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpne2(unsigned int a, unsigned int b); +# 1800 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffu2(unsigned int a, unsigned int b); +# 1811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxs2(unsigned int a, unsigned int b); +# 1822 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxu2(unsigned int a, unsigned int b); +# 1833 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmins2(unsigned int a, unsigned int b); +# 1844 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vminu2(unsigned int a, unsigned int b); +# 1855 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vseteq2(unsigned int a, unsigned int b); +# 1866 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetges2(unsigned int a, unsigned int b); +# 1877 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgeu2(unsigned int a, unsigned int b); +# 1888 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgts2(unsigned int a, unsigned int b); +# 1899 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgtu2(unsigned int a, unsigned int b); +# 1910 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetles2(unsigned int a, unsigned int b); +# 1921 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetleu2(unsigned int a, unsigned int b); +# 1932 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetlts2(unsigned int a, unsigned int b); +# 1943 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetltu2(unsigned int a, unsigned int b); +# 1954 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetne2(unsigned int a, unsigned int b); +# 1965 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsadu2(unsigned int a, unsigned int b); +# 1976 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsub2(unsigned int a, unsigned int b); +# 1987 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubss2 (unsigned int a, unsigned int b); +# 1998 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubus2 (unsigned int a, unsigned int b); +# 2008 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vneg2(unsigned int a); +# 2018 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vnegss2(unsigned int a); +# 2029 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffs2(unsigned int a, unsigned int b); +# 2040 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsads2(unsigned int a, unsigned int b); +# 2050 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabs4(unsigned int a); +# 2061 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsss4(unsigned int a); +# 2072 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vadd4(unsigned int a, unsigned int b); +# 2083 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddss4 (unsigned int a, unsigned int b); +# 2093 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddus4 (unsigned int a, unsigned int b); +# 2104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgs4(unsigned int a, unsigned int b); +# 2115 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgu4(unsigned int a, unsigned int b); +# 2126 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vhaddu4(unsigned int a, unsigned int b); +# 2137 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpeq4(unsigned int a, unsigned int b); +# 2148 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpges4(unsigned int a, unsigned int b); +# 2159 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgeu4(unsigned int a, unsigned int b); +# 2170 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgts4(unsigned int a, unsigned int b); +# 2181 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgtu4(unsigned int a, unsigned int b); +# 2192 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmples4(unsigned int a, unsigned int b); +# 2203 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpleu4(unsigned int a, unsigned int b); +# 2214 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmplts4(unsigned int a, unsigned int b); +# 2225 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpltu4(unsigned int a, unsigned int b); +# 2236 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpne4(unsigned int a, unsigned int b); +# 2247 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffu4(unsigned int a, unsigned int b); +# 2258 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxs4(unsigned int a, unsigned int b); +# 2269 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxu4(unsigned int a, unsigned int b); +# 2280 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmins4(unsigned int a, unsigned int b); +# 2291 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vminu4(unsigned int a, unsigned int b); +# 2302 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vseteq4(unsigned int a, unsigned int b); +# 2313 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetles4(unsigned int a, unsigned int b); +# 2324 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetleu4(unsigned int a, unsigned int b); +# 2335 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetlts4(unsigned int a, unsigned int b); +# 2346 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetltu4(unsigned int a, unsigned int b); +# 2357 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetges4(unsigned int a, unsigned int b); +# 2368 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgeu4(unsigned int a, unsigned int b); +# 2379 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgts4(unsigned int a, unsigned int b); +# 2390 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgtu4(unsigned int a, unsigned int b); +# 2401 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetne4(unsigned int a, unsigned int b); +# 2412 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsadu4(unsigned int a, unsigned int b); +# 2423 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsub4(unsigned int a, unsigned int b); +# 2434 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubss4(unsigned int a, unsigned int b); +# 2445 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubus4(unsigned int a, unsigned int b); +# 2455 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vneg4(unsigned int a); +# 2465 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vnegss4(unsigned int a); +# 2476 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffs4(unsigned int a, unsigned int b); +# 2487 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsads4(unsigned int a, unsigned int b); +# 2497 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax_s32_relu(const int a, const int b); +# 2509 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax_s16x2_relu(const unsigned int a, const unsigned int b); +# 2518 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin_s32_relu(const int a, const int b); +# 2530 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin_s16x2_relu(const unsigned int a, const unsigned int b); +# 2539 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax3_s32(const int a, const int b, const int c); +# 2551 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_s16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2560 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_u32(const unsigned int a, const unsigned int b, const unsigned int c); +# 2572 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_u16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2581 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin3_s32(const int a, const int b, const int c); +# 2593 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_s16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2602 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_u32(const unsigned int a, const unsigned int b, const unsigned int c); +# 2614 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_u16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2623 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax3_s32_relu(const int a, const int b, const int c); +# 2635 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c); +# 2644 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin3_s32_relu(const int a, const int b, const int c); +# 2656 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c); +# 2665 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmax_s32(const int a, const int b, const int c); +# 2677 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_s16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2686 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_u32(const unsigned int a, const unsigned int b, const unsigned int c); +# 2698 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_u16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2707 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmin_s32(const int a, const int b, const int c); +# 2719 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_s16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2728 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_u32(const unsigned int a, const unsigned int b, const unsigned int c); +# 2740 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_u16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2750 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmax_s32_relu(const int a, const int b, const int c); +# 2762 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c); +# 2772 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmin_s32_relu(const int a, const int b, const int c); +# 2784 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c); +# 2793 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vibmax_s32(const int a, const int b, bool* const pred); +# 2802 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_u32(const unsigned int a, const unsigned int b, bool* const pred); +# 2811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vibmin_s32(const int a, const int b, bool* const pred); +# 2820 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_u32(const unsigned int a, const unsigned int b, bool* const pred); +# 2834 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_s16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo); +# 2848 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo); +# 2862 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_s16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo); +# 2876 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo); + + + + + + +} +# 2899 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" 1 +# 81 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 82 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" 2 +# 116 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +static __attribute__((host)) __attribute__((device)) short __internal_cast_u2s(unsigned short x) +{ + short res; + + (void)memcpy(&res, &x, sizeof(x)); + + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax_s32_relu(const int a, const int b){ + + + + + + + int ans = max(a, b); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax_s16x2_relu(const unsigned int a, const unsigned int b){ + unsigned int res; + + + + res = __vmaxs2(__vmaxs2(a, b), 0U); +# 178 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin_s32_relu(const int a, const int b){ + + + + + + + int ans = min(a, b); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin_s16x2_relu(const unsigned int a, const unsigned int b){ + unsigned int res; + + + + res = __vmaxs2(__vmins2(a, b), 0U); +# 232 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax3_s32(const int a, const int b, const int c){ +# 245 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return max(max(a, b), c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_s16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 262 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned int ansU_lo = (unsigned int)max(max(aS_lo, bS_lo), cS_lo); + unsigned int ansU_hi = (unsigned int)max(max(aS_hi, bS_hi), cS_hi); + + + res = (ansU_lo & 0x0000FFFFU) | (ansU_hi << 16); + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_u32(const unsigned int a, const unsigned int b, const unsigned int c){ +# 301 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return max(max(a, b), c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_u16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; + + + + + + + res = __vmaxu2(__vmaxu2(a, b), c); +# 334 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin3_s32(const int a, const int b, const int c){ +# 347 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return min(min(a, b), c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_s16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 363 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned int ansU_lo = (unsigned int)min(min(aS_lo, bS_lo), cS_lo); + unsigned int ansU_hi = (unsigned int)min(min(aS_hi, bS_hi), cS_hi); + + + res = (ansU_lo & 0x0000FFFFU) | (ansU_hi << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_u32(const unsigned int a, const unsigned int b, const unsigned int c){ +# 403 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return min(min(a, b), c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_u16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; + + + + + + + res = __vminu2(__vminu2(a, b), c); +# 436 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax3_s32_relu(const int a, const int b, const int c){ +# 449 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = max(max(a, b), c); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 467 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned ansU_lo = (unsigned)max(0, max(max(aS_lo, bS_lo), cS_lo)); + unsigned ansU_hi = (unsigned)max(0, max(max(aS_hi, bS_hi), cS_hi)); + + + res = ansU_lo | (ansU_hi << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin3_s32_relu(const int a, const int b, const int c){ +# 507 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = min(min(a, b), c); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned res; +# 525 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned ansU_lo = (unsigned)max(0, min(min(aS_lo, bS_lo), cS_lo)); + unsigned ansU_hi = (unsigned)max(0, min(min(aS_hi, bS_hi), cS_hi)); + + + res = ansU_lo | (ansU_hi << 16); + + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmax_s32(const int a, const int b, const int c){ +# 566 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return max(a + b, c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_s16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; + + + + + + + res = __vmaxs2(__vadd2(a, b), c); +# 609 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_u32(const unsigned int a, const unsigned int b, const unsigned int c){ +# 622 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return max(a + b, c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_u16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; + + + + + + + res = __vmaxu2(__vadd2(a, b), c); +# 655 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmin_s32(const int a, const int b, const int c){ +# 668 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return min(a + b, c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_s16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; + + + + + + + res = __vmins2(__vadd2(a, b), c); +# 711 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_u32(const unsigned int a, const unsigned int b, const unsigned int c){ +# 724 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return min(a + b, c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_u16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; + + + + + + + res = __vminu2(__vadd2(a, b), c); +# 757 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmax_s32_relu(const int a, const int b, const int c){ +# 770 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = max(a + b, c); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; + + + + + + + res = __vimax_s16x2_relu(__vadd2(a, b), c); +# 815 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmin_s32_relu(const int a, const int b, const int c){ +# 828 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = min(a + b, c); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; + + + + + + + res = __vimin_s16x2_relu(__vadd2(a, b), c); +# 873 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return res; +} + + + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vibmax_s32(const int a, const int b, bool* const pred){ +# 892 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = max(a, b); + + *pred = (a >= b); + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_u32(const unsigned int a, const unsigned int b, bool* const pred){ +# 913 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned int ans = max(a, b); + + *pred = (a >= b); + return ans; + +} + + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vibmin_s32(const int a, const int b, bool* const pred){ +# 935 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = min(a, b); + + *pred = (a <= b); + return ans; + +} + + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_u32(const unsigned int a, const unsigned int b, bool* const pred){ +# 957 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned int ans = min(a, b); + + *pred = (a <= b); + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_s16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 986 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + + unsigned int ansU_lo = (unsigned int)max(aS_lo, bS_lo); + unsigned int ansU_hi = (unsigned int)max(aS_hi, bS_hi); + + *pred_hi = (aS_hi >= bS_hi); + *pred_lo = (aS_lo >= bS_lo); + + + unsigned int ans = (ansU_lo & 0x0000FFFFU) | (ansU_hi << 16); + + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 1035 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + unsigned short ansU_lo = (unsigned short)max(aU_lo, bU_lo); + unsigned short ansU_hi = (unsigned short)max(aU_hi, bU_hi); + + *pred_hi = (aU_hi >= bU_hi); + *pred_lo = (aU_lo >= bU_lo); + + + unsigned int ans = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_s16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 1077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + + unsigned int ansU_lo = (unsigned int)min(aS_lo, bS_lo); + unsigned int ansU_hi = (unsigned int)min(aS_hi, bS_hi); + + *pred_hi = (aS_hi <= bS_hi); + *pred_lo = (aS_lo <= bS_lo); + + + unsigned int ans = (ansU_lo & 0x0000FFFFU) | (ansU_hi << 16); + + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 1126 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + unsigned short ansU_lo = (unsigned short)min(aU_lo, bU_lo); + unsigned short ansU_hi = (unsigned short)min(aU_hi, bU_hi); + + *pred_hi = (aU_hi <= bU_hi); + *pred_lo = (aU_lo <= bU_lo); + + + unsigned int ans = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + return ans; + +} +# 2900 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" 1 +# 89 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +static __inline__ __attribute__((device)) int atomicAdd(int *address, int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicAdd(unsigned int *address, unsigned int val) ; + +static __inline__ __attribute__((device)) int atomicSub(int *address, int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicSub(unsigned int *address, unsigned int val) ; + +static __inline__ __attribute__((device)) int atomicExch(int *address, int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicExch(unsigned int *address, unsigned int val) ; + +static __inline__ __attribute__((device)) float atomicExch(float *address, float val) ; + +static __inline__ __attribute__((device)) int atomicMin(int *address, int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicMin(unsigned int *address, unsigned int val) ; + +static __inline__ __attribute__((device)) int atomicMax(int *address, int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicMax(unsigned int *address, unsigned int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicInc(unsigned int *address, unsigned int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicDec(unsigned int *address, unsigned int val) ; + +static __inline__ __attribute__((device)) int atomicAnd(int *address, int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicAnd(unsigned int *address, unsigned int val) ; + +static __inline__ __attribute__((device)) int atomicOr(int *address, int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicOr(unsigned int *address, unsigned int val) ; + +static __inline__ __attribute__((device)) int atomicXor(int *address, int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicXor(unsigned int *address, unsigned int val) ; + +static __inline__ __attribute__((device)) int atomicCAS(int *address, int compare, int val) ; + +static __inline__ __attribute__((device)) unsigned int atomicCAS(unsigned int *address, unsigned int compare, unsigned int val) ; +# 156 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) __attribute__((deprecated("__any""() is deprecated in favor of ""__any""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __any(int cond); +extern __attribute__((device)) __attribute__((device_builtin)) __attribute__((deprecated("__all""() is deprecated in favor of ""__all""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __all(int cond); +} +# 169 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +static __inline__ __attribute__((device)) unsigned long long int atomicAdd(unsigned long long int *address, unsigned long long int val) ; + +static __inline__ __attribute__((device)) unsigned long long int atomicExch(unsigned long long int *address, unsigned long long int val) ; + +static __inline__ __attribute__((device)) unsigned long long int atomicCAS(unsigned long long int *address, unsigned long long int compare, unsigned long long int val) ; + +static __inline__ __attribute__((device)) __attribute__((deprecated("__any""() is deprecated in favor of ""__any""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) bool any(bool cond) ; + +static __inline__ __attribute__((device)) __attribute__((deprecated("__all""() is deprecated in favor of ""__all""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) bool all(bool cond) ; +# 188 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.hpp" 1 +# 62 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.hpp" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicAdd(int *address, int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicAdd(unsigned int *address, unsigned int val); +extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicExch(int *address, int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicExch(unsigned int *address, unsigned int val); +extern __attribute__((device)) __attribute__((device_builtin)) float __fAtomicExch(float *address, float val); +extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicMin(int *address, int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicMin(unsigned int *address, unsigned int val); +extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicMax(int *address, int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicMax(unsigned int *address, unsigned int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicInc(unsigned int *address, unsigned int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicDec(unsigned int *address, unsigned int val); +extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicAnd(int *address, int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicAnd(unsigned int *address, unsigned int val); +extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicOr(int *address, int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicOr(unsigned int *address, unsigned int val); +extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicXor(int *address, int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicXor(unsigned int *address, unsigned int val); +extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicCAS(int *address, int compare, int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicCAS(unsigned int *address, unsigned int compare, unsigned int val); + + +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __ullAtomicAdd(unsigned long long int *address, unsigned long long int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __ullAtomicExch(unsigned long long int *address, unsigned long long int val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __ullAtomicCAS(unsigned long long int *address, unsigned long long int compare, unsigned long long int val); +} +# 105 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.hpp" +static __inline__ __attribute__((device)) int atomicAdd(int *address, int val) +{ + return __iAtomicAdd(address, val); +} + +static __inline__ __attribute__((device)) unsigned int atomicAdd(unsigned int *address, unsigned int val) +{ + return __uAtomicAdd(address, val); +} + +static __inline__ __attribute__((device)) int atomicSub(int *address, int val) +{ + return __iAtomicAdd(address, (unsigned int)-(int)val); +} + +static __inline__ __attribute__((device)) unsigned int atomicSub(unsigned int *address, unsigned int val) +{ + return __uAtomicAdd(address, (unsigned int)-(int)val); +} + +static __inline__ __attribute__((device)) int atomicExch(int *address, int val) +{ + return __iAtomicExch(address, val); +} + +static __inline__ __attribute__((device)) unsigned int atomicExch(unsigned int *address, unsigned int val) +{ + return __uAtomicExch(address, val); +} + +static __inline__ __attribute__((device)) float atomicExch(float *address, float val) +{ + return __fAtomicExch(address, val); +} + +static __inline__ __attribute__((device)) int atomicMin(int *address, int val) +{ + return __iAtomicMin(address, val); +} + +static __inline__ __attribute__((device)) unsigned int atomicMin(unsigned int *address, unsigned int val) +{ + return __uAtomicMin(address, val); +} + +static __inline__ __attribute__((device)) int atomicMax(int *address, int val) +{ + return __iAtomicMax(address, val); +} + +static __inline__ __attribute__((device)) unsigned int atomicMax(unsigned int *address, unsigned int val) +{ + return __uAtomicMax(address, val); +} + +static __inline__ __attribute__((device)) unsigned int atomicInc(unsigned int *address, unsigned int val) +{ + return __uAtomicInc(address, val); +} + +static __inline__ __attribute__((device)) unsigned int atomicDec(unsigned int *address, unsigned int val) +{ + return __uAtomicDec(address, val); +} + +static __inline__ __attribute__((device)) int atomicAnd(int *address, int val) +{ + return __iAtomicAnd(address, val); +} + +static __inline__ __attribute__((device)) unsigned int atomicAnd(unsigned int *address, unsigned int val) +{ + return __uAtomicAnd(address, val); +} + +static __inline__ __attribute__((device)) int atomicOr(int *address, int val) +{ + return __iAtomicOr(address, val); +} + +static __inline__ __attribute__((device)) unsigned int atomicOr(unsigned int *address, unsigned int val) +{ + return __uAtomicOr(address, val); +} + +static __inline__ __attribute__((device)) int atomicXor(int *address, int val) +{ + return __iAtomicXor(address, val); +} + +static __inline__ __attribute__((device)) unsigned int atomicXor(unsigned int *address, unsigned int val) +{ + return __uAtomicXor(address, val); +} + +static __inline__ __attribute__((device)) int atomicCAS(int *address, int compare, int val) +{ + return __iAtomicCAS(address, compare, val); +} + +static __inline__ __attribute__((device)) unsigned int atomicCAS(unsigned int *address, unsigned int compare, unsigned int val) +{ + return __uAtomicCAS(address, compare, val); +} +# 224 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.hpp" +static __inline__ __attribute__((device)) unsigned long long int atomicAdd(unsigned long long int *address, unsigned long long int val) +{ + return __ullAtomicAdd(address, val); +} + +static __inline__ __attribute__((device)) unsigned long long int atomicExch(unsigned long long int *address, unsigned long long int val) +{ + return __ullAtomicExch(address, val); +} + +static __inline__ __attribute__((device)) unsigned long long int atomicCAS(unsigned long long int *address, unsigned long long int compare, unsigned long long int val) +{ + return __ullAtomicCAS(address, compare, val); +} + +static __inline__ __attribute__((device)) bool any(bool cond) +{ + return (bool)__any((int)cond); +} + +static __inline__ __attribute__((device)) bool all(bool cond) +{ + return (bool)__all((int)cond); +} +# 189 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" 2 +# 2903 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" 1 +# 83 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" 2 + + + + +extern "C" +{ +# 100 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double_as_longlong(double x); +# 109 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __longlong_as_double(long long int x); +# 266 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rn(double x, double y, double z); +# 423 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rz(double x, double y, double z); +# 580 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_ru(double x, double y, double z); +# 737 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rd(double x, double y, double z); +# 749 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rn(double x, double y); +# 761 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rz(double x, double y); +# 773 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_ru(double x, double y); +# 785 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rd(double x, double y); +# 797 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rn(double x, double y); +# 809 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rz(double x, double y); +# 821 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_ru(double x, double y); +# 833 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rd(double x, double y); +# 845 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rn(double x, double y); +# 857 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rz(double x, double y); +# 869 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_ru(double x, double y); +# 881 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rd(double x, double y); +# 890 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rn(double x); +# 899 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rz(double x); +# 908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_ru(double x); +# 917 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rd(double x); +# 926 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rn(double x); +# 935 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_ru(double x); +# 944 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rd(double x); +# 953 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rn(double x); +# 962 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_ru(double x); +# 971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rd(double x); +# 980 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rn(double x); +# 989 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_ru(double x); +# 998 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rd(double x); +# 1007 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rn(double x); +# 1016 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_ru(double x); +# 1025 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rd(double x); + + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) double __int2double_rn(int x); + + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) double __uint2double_rn(unsigned int x); +# 1050 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rn(long long int x); +# 1059 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rz(long long int x); +# 1068 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_ru(long long int x); +# 1077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rd(long long int x); +# 1086 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rn(unsigned long long int x); +# 1095 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rz(unsigned long long int x); +# 1104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_ru(unsigned long long int x); +# 1113 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rd(unsigned long long int x); +# 1122 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2hiint(double x); +# 1131 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2loint(double x); +# 1141 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __hiloint2double(int hi, int lo); +} + + + + + + + +static __inline__ __attribute__((device)) double fma(double a, double b, double c, enum cudaRoundMode mode); + + + +static __inline__ __attribute__((device)) double dmul(double a, double b, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double dadd(double a, double b, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double dsub(double a, double b, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) int double2int(double a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) unsigned int double2uint(double a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) long long int double2ll(double a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) unsigned long long int double2ull(double a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) double ll2double(long long int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double ull2double(unsigned long long int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double int2double(int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double uint2double(unsigned int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double float2double(float a, enum cudaRoundMode mode = cudaRoundNearest); + + + + + + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" 1 +# 83 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" 2 + + + + + + + +static __inline__ __attribute__((device)) double fma(double a, double b, double c, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __fma_rz(a, b, c) : + mode == cudaRoundPosInf ? __fma_ru(a, b, c) : + mode == cudaRoundMinInf ? __fma_rd(a, b, c) : + __fma_rn(a, b, c); +} + +static __inline__ __attribute__((device)) double dmul(double a, double b, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __dmul_rz(a, b) : + mode == cudaRoundPosInf ? __dmul_ru(a, b) : + mode == cudaRoundMinInf ? __dmul_rd(a, b) : + __dmul_rn(a, b); +} + +static __inline__ __attribute__((device)) double dadd(double a, double b, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __dadd_rz(a, b) : + mode == cudaRoundPosInf ? __dadd_ru(a, b) : + mode == cudaRoundMinInf ? __dadd_rd(a, b) : + __dadd_rn(a, b); +} + +static __inline__ __attribute__((device)) double dsub(double a, double b, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __dsub_rz(a, b) : + mode == cudaRoundPosInf ? __dsub_ru(a, b) : + mode == cudaRoundMinInf ? __dsub_rd(a, b) : + __dsub_rn(a, b); +} + +static __inline__ __attribute__((device)) int double2int(double a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __double2int_rn(a) : + mode == cudaRoundPosInf ? __double2int_ru(a) : + mode == cudaRoundMinInf ? __double2int_rd(a) : + __double2int_rz(a); +} + +static __inline__ __attribute__((device)) unsigned int double2uint(double a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __double2uint_rn(a) : + mode == cudaRoundPosInf ? __double2uint_ru(a) : + mode == cudaRoundMinInf ? __double2uint_rd(a) : + __double2uint_rz(a); +} + +static __inline__ __attribute__((device)) long long int double2ll(double a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __double2ll_rn(a) : + mode == cudaRoundPosInf ? __double2ll_ru(a) : + mode == cudaRoundMinInf ? __double2ll_rd(a) : + __double2ll_rz(a); +} + +static __inline__ __attribute__((device)) unsigned long long int double2ull(double a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __double2ull_rn(a) : + mode == cudaRoundPosInf ? __double2ull_ru(a) : + mode == cudaRoundMinInf ? __double2ull_rd(a) : + __double2ull_rz(a); +} + +static __inline__ __attribute__((device)) double ll2double(long long int a, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __ll2double_rz(a) : + mode == cudaRoundPosInf ? __ll2double_ru(a) : + mode == cudaRoundMinInf ? __ll2double_rd(a) : + __ll2double_rn(a); +} + +static __inline__ __attribute__((device)) double ull2double(unsigned long long int a, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __ull2double_rz(a) : + mode == cudaRoundPosInf ? __ull2double_ru(a) : + mode == cudaRoundMinInf ? __ull2double_rd(a) : + __ull2double_rn(a); +} + +static __inline__ __attribute__((device)) double int2double(int a, enum cudaRoundMode mode) +{ + return (double)a; +} + +static __inline__ __attribute__((device)) double uint2double(unsigned int a, enum cudaRoundMode mode) +{ + return (double)a; +} + +static __inline__ __attribute__((device)) double float2double(float a, enum cudaRoundMode mode) +{ + return (double)a; +} +# 1185 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" 2 +# 2904 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_atomic_functions.h" 1 +# 88 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_atomic_functions.h" +static __inline__ __attribute__((device)) float atomicAdd(float *address, float val) ; + + + + + + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_atomic_functions.hpp" 1 +# 54 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_atomic_functions.hpp" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) float __fAtomicAdd(float *address, float val); +} +# 82 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_atomic_functions.hpp" +static __inline__ __attribute__((device)) float atomicAdd(float *address, float val) +{ + return __fAtomicAdd(address, val); +} +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_atomic_functions.h" 2 +# 2905 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" 1 +# 89 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +static __inline__ __attribute__((device)) long long atomicMin(long long *address, long long val) ; + +static __inline__ __attribute__((device)) long long atomicMax(long long *address, long long val) ; + +static __inline__ __attribute__((device)) long long atomicAnd(long long *address, long long val) ; + +static __inline__ __attribute__((device)) long long atomicOr(long long *address, long long val) ; + +static __inline__ __attribute__((device)) long long atomicXor(long long *address, long long val) ; + +static __inline__ __attribute__((device)) unsigned long long atomicMin(unsigned long long *address, unsigned long long val) ; + +static __inline__ __attribute__((device)) unsigned long long atomicMax(unsigned long long *address, unsigned long long val) ; + +static __inline__ __attribute__((device)) unsigned long long atomicAnd(unsigned long long *address, unsigned long long val) ; + +static __inline__ __attribute__((device)) unsigned long long atomicOr(unsigned long long *address, unsigned long long val) ; + +static __inline__ __attribute__((device)) unsigned long long atomicXor(unsigned long long *address, unsigned long long val) ; +# 117 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.hpp" 1 +# 54 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.hpp" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) long long __illAtomicMin(long long *address, long long val); +extern __attribute__((device)) __attribute__((device_builtin)) long long __illAtomicMax(long long *address, long long val); +extern __attribute__((device)) __attribute__((device_builtin)) long long __llAtomicAnd(long long *address, long long val); +extern __attribute__((device)) __attribute__((device_builtin)) long long __llAtomicOr(long long *address, long long val); +extern __attribute__((device)) __attribute__((device_builtin)) long long __llAtomicXor(long long *address, long long val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long __ullAtomicMin(unsigned long long *address, unsigned long long val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long __ullAtomicMax(unsigned long long *address, unsigned long long val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long __ullAtomicAnd(unsigned long long *address, unsigned long long val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long __ullAtomicOr (unsigned long long *address, unsigned long long val); +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long __ullAtomicXor(unsigned long long *address, unsigned long long val); +} +# 94 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.hpp" +static __inline__ __attribute__((device)) long long atomicMin(long long *address, long long val) +{ + return __illAtomicMin(address, val); +} + +static __inline__ __attribute__((device)) long long atomicMax(long long *address, long long val) +{ + return __illAtomicMax(address, val); +} + +static __inline__ __attribute__((device)) long long atomicAnd(long long *address, long long val) +{ + return __llAtomicAnd(address, val); +} + +static __inline__ __attribute__((device)) long long atomicOr(long long *address, long long val) +{ + return __llAtomicOr(address, val); +} + +static __inline__ __attribute__((device)) long long atomicXor(long long *address, long long val) +{ + return __llAtomicXor(address, val); +} + +static __inline__ __attribute__((device)) unsigned long long atomicMin(unsigned long long *address, unsigned long long val) +{ + return __ullAtomicMin(address, val); +} + +static __inline__ __attribute__((device)) unsigned long long atomicMax(unsigned long long *address, unsigned long long val) +{ + return __ullAtomicMax(address, val); +} + +static __inline__ __attribute__((device)) unsigned long long atomicAnd(unsigned long long *address, unsigned long long val) +{ + return __ullAtomicAnd(address, val); +} + +static __inline__ __attribute__((device)) unsigned long long atomicOr(unsigned long long *address, unsigned long long val) +{ + return __ullAtomicOr(address, val); +} + +static __inline__ __attribute__((device)) unsigned long long atomicXor(unsigned long long *address, unsigned long long val) +{ + return __ullAtomicXor(address, val); +} +# 118 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" 2 +# 2906 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_35_atomic_functions.h" 1 +# 56 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_35_atomic_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" 1 +# 57 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_35_atomic_functions.h" 2 +# 2907 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" 1 +# 325 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.hpp" 1 +# 61 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.hpp" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) double __dAtomicAdd(double *address, double val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicAdd_block(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicAdd_system(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicAdd_block(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicAdd_system(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicAdd_block(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicAdd_system(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +float __fAtomicAdd_block(float *address, float val); + +extern __attribute__((device)) __attribute__((device_builtin)) +float __fAtomicAdd_system(float *address, float val); + +extern __attribute__((device)) __attribute__((device_builtin)) +double __dAtomicAdd_block(double *address, double val); + +extern __attribute__((device)) __attribute__((device_builtin)) +double __dAtomicAdd_system(double *address, double val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicExch_block(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicExch_system(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicExch_block(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicExch_system(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicExch_block(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicExch_system(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +float __fAtomicExch_block(float *address, float val); + +extern __attribute__((device)) __attribute__((device_builtin)) +float __fAtomicExch_system(float *address, float val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicMin_block(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicMin_system(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +long long __illAtomicMin_block(long long *address, long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +long long __illAtomicMin_system(long long *address, long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicMin_block(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicMin_system(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicMin_block(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicMin_system(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicMax_block(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicMax_system(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +long long __illAtomicMax_block(long long *address, long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +long long __illAtomicMax_system(long long *address, long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicMax_block(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicMax_system(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicMax_block(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicMax_system(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicInc_block(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicInc_system(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicDec_block(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicDec_system(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicCAS_block(int *address, int compare, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicCAS_system(int *address, int compare, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicCAS_block(unsigned int *address, unsigned int compare, + unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicCAS_system(unsigned int *address, unsigned int compare, + unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicCAS_block(unsigned long long int *address, + unsigned long long int compare, + unsigned long long int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicCAS_system(unsigned long long int *address, + unsigned long long int compare, + unsigned long long int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicAnd_block(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicAnd_system(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +long long __llAtomicAnd_block(long long *address, long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +long long __llAtomicAnd_system(long long *address, long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicAnd_block(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicAnd_system(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicAnd_block(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicAnd_system(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicOr_block(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicOr_system(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +long long __llAtomicOr_block(long long *address, long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +long long __llAtomicOr_system(long long *address, long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicOr_block(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicOr_system(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicOr_block(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicOr_system(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicXor_block(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +int __iAtomicXor_system(int *address, int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +long long __llAtomicXor_block(long long *address, long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +long long __llAtomicXor_system(long long *address, long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicXor_block(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned int __uAtomicXor_system(unsigned int *address, unsigned int val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicXor_block(unsigned long long *address, unsigned long long val); + +extern __attribute__((device)) __attribute__((device_builtin)) +unsigned long long __ullAtomicXor_system(unsigned long long *address, unsigned long long val); +} +# 326 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" 2 +# 2908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" 1 +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) void __threadfence_system(void); +# 119 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rn(double x, double y); +# 139 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rz(double x, double y); +# 159 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_ru(double x, double y); +# 179 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rd(double x, double y); +# 194 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rn(double x); +# 209 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rz(double x); +# 224 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_ru(double x); +# 239 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rd(double x); +# 254 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rn(double x); +# 269 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rz(double x); +# 284 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_ru(double x); +# 299 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rd(double x); +extern __attribute__((device)) __attribute__((device_builtin)) __attribute__((deprecated("__ballot""() is deprecated in favor of ""__ballot""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __ballot(int); +extern __attribute__((device)) __attribute__((device_builtin)) int __syncthreads_count(int); +extern __attribute__((device)) __attribute__((device_builtin)) int __syncthreads_and(int); +extern __attribute__((device)) __attribute__((device_builtin)) int __syncthreads_or(int); +extern __attribute__((device)) __attribute__((device_builtin)) long long int clock64(void); +# 314 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rn(float x, float y, float z); +# 323 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rd(float x, float y, float z); +# 332 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_ru(float x, float y, float z); +# 341 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rz(float x, float y, float z); +# 354 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double_as_longlong(double x); +# 363 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __longlong_as_double(long long int x); +# 407 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rn(double x, double y, double z); +# 451 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rz(double x, double y, double z); +# 495 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_ru(double x, double y, double z); +# 539 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rd(double x, double y, double z); +# 558 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rn(double x, double y); +# 577 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rz(double x, double y); +# 596 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_ru(double x, double y); +# 615 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rd(double x, double y); +# 634 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rn(double x, double y); +# 653 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rz(double x, double y); +# 672 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_ru(double x, double y); +# 691 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rd(double x, double y); +# 709 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rn(double x, double y); +# 727 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rz(double x, double y); +# 745 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_ru(double x, double y); +# 763 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rd(double x, double y); +# 772 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rn(double x); +# 781 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rz(double x); +# 790 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_ru(double x); +# 799 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rd(double x); +# 809 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rn(double x); +# 819 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_ru(double x); +# 829 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rd(double x); +# 839 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rn(double x); +# 849 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_ru(double x); +# 859 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rd(double x); +# 869 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rn(double x); +# 879 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_ru(double x); +# 889 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rd(double x); +# 899 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rn(double x); +# 909 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_ru(double x); +# 919 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rd(double x); + + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) double __int2double_rn(int x); + + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) double __uint2double_rn(unsigned int x); +# 944 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rn(long long int x); +# 953 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rz(long long int x); +# 962 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_ru(long long int x); +# 971 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rd(long long int x); +# 980 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rn(unsigned long long int x); +# 989 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rz(unsigned long long int x); +# 998 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_ru(unsigned long long int x); +# 1007 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rd(unsigned long long int x); +# 1016 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2hiint(double x); +# 1025 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2loint(double x); +# 1035 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __hiloint2double(int hi, int lo); + + +} + + + + + + +static __inline__ __attribute__((device)) __attribute__((deprecated("__ballot""() is deprecated in favor of ""__ballot""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int ballot(bool pred) ; + +static __inline__ __attribute__((device)) int syncthreads_count(bool pred) ; + +static __inline__ __attribute__((device)) bool syncthreads_and(bool pred) ; + +static __inline__ __attribute__((device)) bool syncthreads_or(bool pred) ; + + + + +static __inline__ __attribute__((device)) unsigned int __isGlobal(const void *ptr) ; +static __inline__ __attribute__((device)) unsigned int __isShared(const void *ptr) ; +static __inline__ __attribute__((device)) unsigned int __isConstant(const void *ptr) ; +static __inline__ __attribute__((device)) unsigned int __isLocal(const void *ptr) ; + + + +static __inline__ __attribute__((device)) size_t __cvta_generic_to_global(const void *ptr) ; +static __inline__ __attribute__((device)) size_t __cvta_generic_to_shared(const void *ptr) ; +static __inline__ __attribute__((device)) size_t __cvta_generic_to_constant(const void *ptr) ; +static __inline__ __attribute__((device)) size_t __cvta_generic_to_local(const void *ptr) ; + + + + +static __inline__ __attribute__((device)) void * __cvta_global_to_generic(size_t rawbits) ; +static __inline__ __attribute__((device)) void * __cvta_shared_to_generic(size_t rawbits) ; +static __inline__ __attribute__((device)) void * __cvta_constant_to_generic(size_t rawbits) ; +static __inline__ __attribute__((device)) void * __cvta_local_to_generic(size_t rawbits) ; +# 1140 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +static __inline__ __attribute__((host)) __attribute__((device)) unsigned short __nv_bswap16(unsigned short in); +static __inline__ __attribute__((host)) __attribute__((device)) unsigned int __nv_bswap32(unsigned int in); +static __inline__ __attribute__((host)) __attribute__((device)) unsigned long long __nv_bswap64(unsigned long long in); +# 1152 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.hpp" 1 +# 77 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.hpp" +static __inline__ __attribute__((device)) unsigned int ballot(bool pred) +{ + return __ballot((int)pred); +} + +static __inline__ __attribute__((device)) int syncthreads_count(bool pred) +{ + return __syncthreads_count((int)pred); +} + +static __inline__ __attribute__((device)) bool syncthreads_and(bool pred) +{ + return (bool)__syncthreads_and((int)pred); +} + +static __inline__ __attribute__((device)) bool syncthreads_or(bool pred) +{ + return (bool)__syncthreads_or((int)pred); +} + + +extern "C" { + __attribute__((device)) unsigned __nv_isGlobal_impl(const void *); + __attribute__((device)) unsigned __nv_isShared_impl(const void *); + __attribute__((device)) unsigned __nv_isConstant_impl(const void *); + __attribute__((device)) unsigned __nv_isLocal_impl(const void *); + __attribute__((device)) unsigned __nv_isGridConstant_impl(const void *); +} + +static __inline__ __attribute__((device)) unsigned int __isGlobal(const void *ptr) +{ + return __nv_isGlobal_impl(ptr); +} + +static __inline__ __attribute__((device)) unsigned int __isShared(const void *ptr) +{ + return __nv_isShared_impl(ptr); +} + +static __inline__ __attribute__((device)) unsigned int __isConstant(const void *ptr) +{ + return __nv_isConstant_impl(ptr); +} + +static __inline__ __attribute__((device)) unsigned int __isLocal(const void *ptr) +{ + return __nv_isLocal_impl(ptr); +} +# 133 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.hpp" +extern "C" { + __attribute__((device)) size_t __nv_cvta_generic_to_global_impl(const void *); + __attribute__((device)) size_t __nv_cvta_generic_to_shared_impl(const void *); + __attribute__((device)) size_t __nv_cvta_generic_to_constant_impl(const void *); + __attribute__((device)) size_t __nv_cvta_generic_to_local_impl(const void *); + __attribute__((device)) void * __nv_cvta_global_to_generic_impl(size_t); + __attribute__((device)) void * __nv_cvta_shared_to_generic_impl(size_t); + __attribute__((device)) void * __nv_cvta_constant_to_generic_impl(size_t); + __attribute__((device)) void * __nv_cvta_local_to_generic_impl(size_t); +} + +static __inline__ __attribute__((device)) size_t __cvta_generic_to_global(const void *p) +{ + return __nv_cvta_generic_to_global_impl(p); +} + +static __inline__ __attribute__((device)) size_t __cvta_generic_to_shared(const void *p) +{ + return __nv_cvta_generic_to_shared_impl(p); +} + +static __inline__ __attribute__((device)) size_t __cvta_generic_to_constant(const void *p) +{ + return __nv_cvta_generic_to_constant_impl(p); +} + +static __inline__ __attribute__((device)) size_t __cvta_generic_to_local(const void *p) +{ + return __nv_cvta_generic_to_local_impl(p); +} + +static __inline__ __attribute__((device)) void * __cvta_global_to_generic(size_t rawbits) +{ + return __nv_cvta_global_to_generic_impl(rawbits); +} + +static __inline__ __attribute__((device)) void * __cvta_shared_to_generic(size_t rawbits) +{ + return __nv_cvta_shared_to_generic_impl(rawbits); +} + +static __inline__ __attribute__((device)) void * __cvta_constant_to_generic(size_t rawbits) +{ + return __nv_cvta_constant_to_generic_impl(rawbits); +} + +static __inline__ __attribute__((device)) void * __cvta_local_to_generic(size_t rawbits) +{ + return __nv_cvta_local_to_generic_impl(rawbits); +} +# 217 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.hpp" +extern "C" { + __attribute__((device)) unsigned short __nv_bswap16_impl(unsigned short); + __attribute__((device)) unsigned int __nv_bswap32_impl(unsigned int); + __attribute__((device)) unsigned long long __nv_bswap64_impl(unsigned long long); +} + +static __inline__ __attribute__((host)) __attribute__((device)) unsigned short __nv_bswap16(unsigned short in) { + return __nv_bswap16_impl(in); +} + +static __inline__ __attribute__((host)) __attribute__((device)) unsigned int __nv_bswap32(unsigned int in) { + return __nv_bswap32_impl(in); +} + +static __inline__ __attribute__((host)) __attribute__((device)) unsigned long long __nv_bswap64(unsigned long long in) { + return __nv_bswap64_impl(in); +} +# 1153 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" 2 +# 2909 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" 1 +# 123 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +static __attribute__((device)) __inline__ unsigned __fns(unsigned mask, unsigned base, int offset) ; +static __attribute__((device)) __inline__ void __barrier_sync(unsigned id) ; +static __attribute__((device)) __inline__ void __barrier_sync_count(unsigned id, unsigned cnt) ; +static __attribute__((device)) __inline__ void __syncwarp(unsigned mask=0xFFFFFFFF) ; +static __attribute__((device)) __inline__ int __all_sync(unsigned mask, int pred) ; +static __attribute__((device)) __inline__ int __any_sync(unsigned mask, int pred) ; +static __attribute__((device)) __inline__ int __uni_sync(unsigned mask, int pred) ; +static __attribute__((device)) __inline__ unsigned __ballot_sync(unsigned mask, int pred) ; +static __attribute__((device)) __inline__ unsigned __activemask() ; +# 140 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __shfl(int var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __shfl(unsigned int var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __shfl_up(int var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __shfl_up(unsigned int var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __shfl_down(int var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __shfl_down(unsigned int var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __shfl_xor(int var, int laneMask, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __shfl_xor(unsigned int var, int laneMask, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) float __shfl(float var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) float __shfl_up(float var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) float __shfl_down(float var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) float __shfl_xor(float var, int laneMask, int width=32) ; + + +static __attribute__((device)) __inline__ int __shfl_sync(unsigned mask, int var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ unsigned int __shfl_sync(unsigned mask, unsigned int var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ int __shfl_up_sync(unsigned mask, int var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ unsigned int __shfl_up_sync(unsigned mask, unsigned int var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ int __shfl_down_sync(unsigned mask, int var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ unsigned int __shfl_down_sync(unsigned mask, unsigned int var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ int __shfl_xor_sync(unsigned mask, int var, int laneMask, int width=32) ; +static __attribute__((device)) __inline__ unsigned int __shfl_xor_sync(unsigned mask, unsigned int var, int laneMask, int width=32) ; +static __attribute__((device)) __inline__ float __shfl_sync(unsigned mask, float var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ float __shfl_up_sync(unsigned mask, float var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ float __shfl_down_sync(unsigned mask, float var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ float __shfl_xor_sync(unsigned mask, float var, int laneMask, int width=32) ; + + + +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long long __shfl(unsigned long long var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long long __shfl(long long var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long long __shfl_up(long long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long long __shfl_up(unsigned long long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long long __shfl_down(long long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long long __shfl_down(unsigned long long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long long __shfl_xor(long long var, int laneMask, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long long __shfl_xor(unsigned long long var, int laneMask, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) double __shfl(double var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) double __shfl_up(double var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) double __shfl_down(double var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) double __shfl_xor(double var, int laneMask, int width=32) ; + + +static __attribute__((device)) __inline__ long long __shfl_sync(unsigned mask, long long var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ unsigned long long __shfl_sync(unsigned mask, unsigned long long var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ long long __shfl_up_sync(unsigned mask, long long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ unsigned long long __shfl_up_sync(unsigned mask, unsigned long long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ long long __shfl_down_sync(unsigned mask, long long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ unsigned long long __shfl_down_sync(unsigned mask, unsigned long long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ long long __shfl_xor_sync(unsigned mask, long long var, int laneMask, int width=32) ; +static __attribute__((device)) __inline__ unsigned long long __shfl_xor_sync(unsigned mask, unsigned long long var, int laneMask, int width=32) ; +static __attribute__((device)) __inline__ double __shfl_sync(unsigned mask, double var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ double __shfl_up_sync(unsigned mask, double var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ double __shfl_down_sync(unsigned mask, double var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ double __shfl_xor_sync(unsigned mask, double var, int laneMask, int width=32) ; + + + +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long __shfl(long var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long __shfl(unsigned long var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long __shfl_up(long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long __shfl_up(unsigned long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long __shfl_down(long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long __shfl_down(unsigned long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long __shfl_xor(long var, int laneMask, int width=32) ; +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long __shfl_xor(unsigned long var, int laneMask, int width=32) ; + + +static __attribute__((device)) __inline__ long __shfl_sync(unsigned mask, long var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ unsigned long __shfl_sync(unsigned mask, unsigned long var, int srcLane, int width=32) ; +static __attribute__((device)) __inline__ long __shfl_up_sync(unsigned mask, long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ unsigned long __shfl_up_sync(unsigned mask, unsigned long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ long __shfl_down_sync(unsigned mask, long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ unsigned long __shfl_down_sync(unsigned mask, unsigned long var, unsigned int delta, int width=32) ; +static __attribute__((device)) __inline__ long __shfl_xor_sync(unsigned mask, long var, int laneMask, int width=32) ; +static __attribute__((device)) __inline__ unsigned long __shfl_xor_sync(unsigned mask, unsigned long var, int laneMask, int width=32) ; +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.hpp" 1 +# 73 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.hpp" +extern "C" +{ +} +# 89 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.hpp" +static __attribute__((device)) __inline__ +unsigned __fns(unsigned mask, unsigned base, int offset) { + extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __nvvm_fns(unsigned int mask, unsigned int base, int offset); + return __nvvm_fns(mask, base, offset); +} + +static __attribute__((device)) __inline__ +void __barrier_sync(unsigned id) { + extern __attribute__((device)) __attribute__((device_builtin)) void __nvvm_barrier_sync(unsigned id); + return __nvvm_barrier_sync(id); +} + +static __attribute__((device)) __inline__ +void __barrier_sync_count(unsigned id, unsigned cnt) { + extern __attribute__((device)) __attribute__((device_builtin)) void __nvvm_barrier_sync_cnt(unsigned id, unsigned cnt); + return __nvvm_barrier_sync_cnt(id, cnt); +} + +static __attribute__((device)) __inline__ +void __syncwarp(unsigned mask) { + extern __attribute__((device)) __attribute__((device_builtin)) void __nvvm_bar_warp_sync(unsigned mask); + return __nvvm_bar_warp_sync(mask); +} + +static __attribute__((device)) __inline__ +int __all_sync(unsigned mask, int pred) { + extern __attribute__((device)) __attribute__((device_builtin)) int __nvvm_vote_all_sync(unsigned int mask, int pred); + return __nvvm_vote_all_sync(mask, pred); +} + +static __attribute__((device)) __inline__ +int __any_sync(unsigned mask, int pred) { + extern __attribute__((device)) __attribute__((device_builtin)) int __nvvm_vote_any_sync(unsigned int mask, int pred); + return __nvvm_vote_any_sync(mask, pred); +} + +static __attribute__((device)) __inline__ +int __uni_sync(unsigned mask, int pred) { + extern __attribute__((device)) __attribute__((device_builtin)) int __nvvm_vote_uni_sync(unsigned int mask, int pred); + return __nvvm_vote_uni_sync(mask, pred); +} + +static __attribute__((device)) __inline__ +unsigned __ballot_sync(unsigned mask, int pred) { + extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __nvvm_vote_ballot_sync(unsigned int mask, int pred); + return __nvvm_vote_ballot_sync(mask, pred); +} + +static __attribute__((device)) __inline__ +unsigned __activemask() { + unsigned ret; + asm volatile ("activemask.b32 %0;" : "=r"(ret)); + return ret; +} + + + + +static __attribute__((device)) __inline__ int __shfl(int var, int srcLane, int width) { + int ret; + int c = ((32 -width) << 8) | 0x1f; + asm volatile ("shfl.idx.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(var), "r"(srcLane), "r"(c)); + return ret; +} + +static __attribute__((device)) __inline__ unsigned int __shfl(unsigned int var, int srcLane, int width) { + return (unsigned int) __shfl((int)var, srcLane, width); +} + +static __attribute__((device)) __inline__ int __shfl_up(int var, unsigned int delta, int width) { + int ret; + int c = (32 -width) << 8; + asm volatile ("shfl.up.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(var), "r"(delta), "r"(c)); + return ret; +} + +static __attribute__((device)) __inline__ unsigned int __shfl_up(unsigned int var, unsigned int delta, int width) { + return (unsigned int) __shfl_up((int)var, delta, width); +} + +static __attribute__((device)) __inline__ int __shfl_down(int var, unsigned int delta, int width) { + int ret; + int c = ((32 -width) << 8) | 0x1f; + asm volatile ("shfl.down.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(var), "r"(delta), "r"(c)); + return ret; +} + +static __attribute__((device)) __inline__ unsigned int __shfl_down(unsigned int var, unsigned int delta, int width) { + return (unsigned int) __shfl_down((int)var, delta, width); +} + +static __attribute__((device)) __inline__ int __shfl_xor(int var, int laneMask, int width) { + int ret; + int c = ((32 -width) << 8) | 0x1f; + asm volatile ("shfl.bfly.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(var), "r"(laneMask), "r"(c)); + return ret; +} + +static __attribute__((device)) __inline__ unsigned int __shfl_xor(unsigned int var, int laneMask, int width) { + return (unsigned int) __shfl_xor((int)var, laneMask, width); +} + +static __attribute__((device)) __inline__ float __shfl(float var, int srcLane, int width) { + float ret; + int c; + c = ((32 -width) << 8) | 0x1f; + asm volatile ("shfl.idx.b32 %0, %1, %2, %3;" : "=f"(ret) : "f"(var), "r"(srcLane), "r"(c)); + return ret; +} + +static __attribute__((device)) __inline__ float __shfl_up(float var, unsigned int delta, int width) { + float ret; + int c; + c = (32 -width) << 8; + asm volatile ("shfl.up.b32 %0, %1, %2, %3;" : "=f"(ret) : "f"(var), "r"(delta), "r"(c)); + return ret; +} + +static __attribute__((device)) __inline__ float __shfl_down(float var, unsigned int delta, int width) { + float ret; + int c; + c = ((32 -width) << 8) | 0x1f; + asm volatile ("shfl.down.b32 %0, %1, %2, %3;" : "=f"(ret) : "f"(var), "r"(delta), "r"(c)); + return ret; +} + +static __attribute__((device)) __inline__ float __shfl_xor(float var, int laneMask, int width) { + float ret; + int c; + c = ((32 -width) << 8) | 0x1f; + asm volatile ("shfl.bfly.b32 %0, %1, %2, %3;" : "=f"(ret) : "f"(var), "r"(laneMask), "r"(c)); + return ret; +} + + + +static __attribute__((device)) __inline__ long long __shfl(long long var, int srcLane, int width) { + int lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(var)); + hi = __shfl(hi, srcLane, width); + lo = __shfl(lo, srcLane, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=l"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ unsigned long long __shfl(unsigned long long var, int srcLane, int width) { + return (unsigned long long) __shfl((long long) var, srcLane, width); +} + +static __attribute__((device)) __inline__ long long __shfl_up(long long var, unsigned int delta, int width) { + int lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(var)); + hi = __shfl_up(hi, delta, width); + lo = __shfl_up(lo, delta, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=l"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ unsigned long long __shfl_up(unsigned long long var, unsigned int delta, int width) { + return (unsigned long long) __shfl_up((long long) var, delta, width); +} + +static __attribute__((device)) __inline__ long long __shfl_down(long long var, unsigned int delta, int width) { + int lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(var)); + hi = __shfl_down(hi, delta, width); + lo = __shfl_down(lo, delta, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=l"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ unsigned long long __shfl_down(unsigned long long var, unsigned int delta, int width) { + return (unsigned long long) __shfl_down((long long) var, delta, width); +} + +static __attribute__((device)) __inline__ long long __shfl_xor(long long var, int laneMask, int width) { + int lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(var)); + hi = __shfl_xor(hi, laneMask, width); + lo = __shfl_xor(lo, laneMask, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=l"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ unsigned long long __shfl_xor(unsigned long long var, int laneMask, int width) { + return (unsigned long long) __shfl_xor((long long) var, laneMask, width); +} + +static __attribute__((device)) __inline__ double __shfl(double var, int srcLane, int width) { + unsigned lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "d"(var)); + hi = __shfl(hi, srcLane, width); + lo = __shfl(lo, srcLane, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=d"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ double __shfl_up(double var, unsigned int delta, int width) { + unsigned lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "d"(var)); + hi = __shfl_up(hi, delta, width); + lo = __shfl_up(lo, delta, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=d"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ double __shfl_down(double var, unsigned int delta, int width) { + unsigned lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "d"(var)); + hi = __shfl_down(hi, delta, width); + lo = __shfl_down(lo, delta, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=d"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ double __shfl_xor(double var, int laneMask, int width) { + unsigned lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "d"(var)); + hi = __shfl_xor(hi, laneMask, width); + lo = __shfl_xor(lo, laneMask, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=d"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ long __shfl(long var, int srcLane, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl((long long) var, srcLane, width) : + __shfl((int) var, srcLane, width); +} + +static __attribute__((device)) __inline__ unsigned long __shfl(unsigned long var, int srcLane, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl((unsigned long long) var, srcLane, width) : + __shfl((unsigned int) var, srcLane, width); +} + +static __attribute__((device)) __inline__ long __shfl_up(long var, unsigned int delta, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_up((long long) var, delta, width) : + __shfl_up((int) var, delta, width); +} + +static __attribute__((device)) __inline__ unsigned long __shfl_up(unsigned long var, unsigned int delta, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_up((unsigned long long) var, delta, width) : + __shfl_up((unsigned int) var, delta, width); +} + +static __attribute__((device)) __inline__ long __shfl_down(long var, unsigned int delta, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_down((long long) var, delta, width) : + __shfl_down((int) var, delta, width); +} + +static __attribute__((device)) __inline__ unsigned long __shfl_down(unsigned long var, unsigned int delta, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_down((unsigned long long) var, delta, width) : + __shfl_down((unsigned int) var, delta, width); +} + +static __attribute__((device)) __inline__ long __shfl_xor(long var, int laneMask, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_xor((long long) var, laneMask, width) : + __shfl_xor((int) var, laneMask, width); +} + +static __attribute__((device)) __inline__ unsigned long __shfl_xor(unsigned long var, int laneMask, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_xor((unsigned long long) var, laneMask, width) : + __shfl_xor((unsigned int) var, laneMask, width); +} +# 369 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.hpp" +static __attribute__((device)) __inline__ int __shfl_sync(unsigned mask, int var, int srcLane, int width) { + extern __attribute__((device)) __attribute__((device_builtin)) unsigned __nvvm_shfl_idx_sync(unsigned mask, unsigned a, unsigned b, unsigned c); + int ret; + int c = ((32 -width) << 8) | 0x1f; + ret = __nvvm_shfl_idx_sync(mask, var, srcLane, c); + return ret; +} + +static __attribute__((device)) __inline__ unsigned int __shfl_sync(unsigned mask, unsigned int var, int srcLane, int width) { + return (unsigned int) __shfl_sync(mask, (int)var, srcLane, width); +} + +static __attribute__((device)) __inline__ int __shfl_up_sync(unsigned mask, int var, unsigned int delta, int width) { + extern __attribute__((device)) __attribute__((device_builtin)) unsigned __nvvm_shfl_up_sync(unsigned mask, unsigned a, unsigned b, unsigned c); + int ret; + int c = (32 -width) << 8; + ret = __nvvm_shfl_up_sync(mask, var, delta, c); + return ret; +} + +static __attribute__((device)) __inline__ unsigned int __shfl_up_sync(unsigned mask, unsigned int var, unsigned int delta, int width) { + return (unsigned int) __shfl_up_sync(mask, (int)var, delta, width); +} + +static __attribute__((device)) __inline__ int __shfl_down_sync(unsigned mask, int var, unsigned int delta, int width) { + extern __attribute__((device)) __attribute__((device_builtin)) unsigned __nvvm_shfl_down_sync(unsigned mask, unsigned a, unsigned b, unsigned c); + int ret; + int c = ((32 -width) << 8) | 0x1f; + ret = __nvvm_shfl_down_sync(mask, var, delta, c); + return ret; +} + +static __attribute__((device)) __inline__ unsigned int __shfl_down_sync(unsigned mask, unsigned int var, unsigned int delta, int width) { + return (unsigned int) __shfl_down_sync(mask, (int)var, delta, width); +} + +static __attribute__((device)) __inline__ int __shfl_xor_sync(unsigned mask, int var, int laneMask, int width) { + extern __attribute__((device)) __attribute__((device_builtin)) unsigned __nvvm_shfl_bfly_sync(unsigned mask, unsigned a, unsigned b, unsigned c); + int ret; + int c = ((32 -width) << 8) | 0x1f; + ret = __nvvm_shfl_bfly_sync(mask, var, laneMask, c); + return ret; +} + +static __attribute__((device)) __inline__ unsigned int __shfl_xor_sync(unsigned mask, unsigned int var, int laneMask, int width) { + return (unsigned int) __shfl_xor_sync(mask, (int)var, laneMask, width); +} + +static __attribute__((device)) __inline__ float __shfl_sync(unsigned mask, float var, int srcLane, int width) { + extern __attribute__((device)) __attribute__((device_builtin)) unsigned __nvvm_shfl_idx_sync(unsigned mask, unsigned a, unsigned b, unsigned c); + int ret; + int c; + c = ((32 -width) << 8) | 0x1f; + ret = __nvvm_shfl_idx_sync(mask, __float_as_int(var), srcLane, c); + return __int_as_float(ret); +} + +static __attribute__((device)) __inline__ float __shfl_up_sync(unsigned mask, float var, unsigned int delta, int width) { + extern __attribute__((device)) __attribute__((device_builtin)) unsigned __nvvm_shfl_up_sync(unsigned mask, unsigned a, unsigned b, unsigned c); + int ret; + int c; + c = (32 -width) << 8; + ret = __nvvm_shfl_up_sync(mask, __float_as_int(var), delta, c); + return __int_as_float(ret); +} + +static __attribute__((device)) __inline__ float __shfl_down_sync(unsigned mask, float var, unsigned int delta, int width) { + extern __attribute__((device)) __attribute__((device_builtin)) unsigned __nvvm_shfl_down_sync(unsigned mask, unsigned a, unsigned b, unsigned c); + int ret; + int c; + c = ((32 -width) << 8) | 0x1f; + ret = __nvvm_shfl_down_sync(mask, __float_as_int(var), delta, c); + return __int_as_float(ret); +} + +static __attribute__((device)) __inline__ float __shfl_xor_sync(unsigned mask, float var, int laneMask, int width) { + extern __attribute__((device)) __attribute__((device_builtin)) unsigned __nvvm_shfl_bfly_sync(unsigned mask, unsigned a, unsigned b, unsigned c); + int ret; + int c; + c = ((32 -width) << 8) | 0x1f; + ret = __nvvm_shfl_bfly_sync(mask, __float_as_int(var), laneMask, c); + return __int_as_float(ret); +} + + +static __attribute__((device)) __inline__ long long __shfl_sync(unsigned mask, long long var, int srcLane, int width) { + int lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(var)); + hi = __shfl_sync(mask, hi, srcLane, width); + lo = __shfl_sync(mask, lo, srcLane, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=l"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ unsigned long long __shfl_sync(unsigned mask, unsigned long long var, int srcLane, int width) { + return (unsigned long long) __shfl_sync(mask, (long long) var, srcLane, width); +} + +static __attribute__((device)) __inline__ long long __shfl_up_sync(unsigned mask, long long var, unsigned int delta, int width) { + int lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(var)); + hi = __shfl_up_sync(mask, hi, delta, width); + lo = __shfl_up_sync(mask, lo, delta, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=l"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ unsigned long long __shfl_up_sync(unsigned mask, unsigned long long var, unsigned int delta, int width) { + return (unsigned long long) __shfl_up_sync(mask, (long long) var, delta, width); +} + +static __attribute__((device)) __inline__ long long __shfl_down_sync(unsigned mask, long long var, unsigned int delta, int width) { + int lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(var)); + hi = __shfl_down_sync(mask, hi, delta, width); + lo = __shfl_down_sync(mask, lo, delta, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=l"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ unsigned long long __shfl_down_sync(unsigned mask, unsigned long long var, unsigned int delta, int width) { + return (unsigned long long) __shfl_down_sync(mask, (long long) var, delta, width); +} + +static __attribute__((device)) __inline__ long long __shfl_xor_sync(unsigned mask, long long var, int laneMask, int width) { + int lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(var)); + hi = __shfl_xor_sync(mask, hi, laneMask, width); + lo = __shfl_xor_sync(mask, lo, laneMask, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=l"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ unsigned long long __shfl_xor_sync(unsigned mask, unsigned long long var, int laneMask, int width) { + return (unsigned long long) __shfl_xor_sync(mask, (long long) var, laneMask, width); +} + +static __attribute__((device)) __inline__ double __shfl_sync(unsigned mask, double var, int srcLane, int width) { + unsigned lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "d"(var)); + hi = __shfl_sync(mask, hi, srcLane, width); + lo = __shfl_sync(mask, lo, srcLane, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=d"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ double __shfl_up_sync(unsigned mask, double var, unsigned int delta, int width) { + unsigned lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "d"(var)); + hi = __shfl_up_sync(mask, hi, delta, width); + lo = __shfl_up_sync(mask, lo, delta, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=d"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ double __shfl_down_sync(unsigned mask, double var, unsigned int delta, int width) { + unsigned lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "d"(var)); + hi = __shfl_down_sync(mask, hi, delta, width); + lo = __shfl_down_sync(mask, lo, delta, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=d"(var) : "r"(lo), "r"(hi)); + return var; +} + +static __attribute__((device)) __inline__ double __shfl_xor_sync(unsigned mask, double var, int laneMask, int width) { + unsigned lo, hi; + asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "d"(var)); + hi = __shfl_xor_sync(mask, hi, laneMask, width); + lo = __shfl_xor_sync(mask, lo, laneMask, width); + asm volatile("mov.b64 %0, {%1,%2};" : "=d"(var) : "r"(lo), "r"(hi)); + return var; +} + + + +static __attribute__((device)) __inline__ long __shfl_sync(unsigned mask, long var, int srcLane, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_sync(mask, (long long) var, srcLane, width) : + __shfl_sync(mask, (int) var, srcLane, width); +} + +static __attribute__((device)) __inline__ unsigned long __shfl_sync(unsigned mask, unsigned long var, int srcLane, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_sync(mask, (unsigned long long) var, srcLane, width) : + __shfl_sync(mask, (unsigned int) var, srcLane, width); +} + +static __attribute__((device)) __inline__ long __shfl_up_sync(unsigned mask, long var, unsigned int delta, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_up_sync(mask, (long long) var, delta, width) : + __shfl_up_sync(mask, (int) var, delta, width); +} + +static __attribute__((device)) __inline__ unsigned long __shfl_up_sync(unsigned mask, unsigned long var, unsigned int delta, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_up_sync(mask, (unsigned long long) var, delta, width) : + __shfl_up_sync(mask, (unsigned int) var, delta, width); +} + +static __attribute__((device)) __inline__ long __shfl_down_sync(unsigned mask, long var, unsigned int delta, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_down_sync(mask, (long long) var, delta, width) : + __shfl_down_sync(mask, (int) var, delta, width); +} + +static __attribute__((device)) __inline__ unsigned long __shfl_down_sync(unsigned mask, unsigned long var, unsigned int delta, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_down_sync(mask, (unsigned long long) var, delta, width) : + __shfl_down_sync(mask, (unsigned int) var, delta, width); +} + +static __attribute__((device)) __inline__ long __shfl_xor_sync(unsigned mask, long var, int laneMask, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_xor_sync(mask, (long long) var, laneMask, width) : + __shfl_xor_sync(mask, (int) var, laneMask, width); +} + +static __attribute__((device)) __inline__ unsigned long __shfl_xor_sync(unsigned mask, unsigned long var, int laneMask, int width) { + return (sizeof(long) == sizeof(long long)) ? + __shfl_xor_sync(mask, (unsigned long long) var, laneMask, width) : + __shfl_xor_sync(mask, (unsigned int) var, laneMask, width); +} +# 234 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" 2 +# 2910 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" 1 +# 91 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ long __ldg(const long *ptr) ; +static __attribute__((device)) __inline__ unsigned long __ldg(const unsigned long *ptr) ; + +static __attribute__((device)) __inline__ char __ldg(const char *ptr) ; +static __attribute__((device)) __inline__ signed char __ldg(const signed char *ptr) ; +static __attribute__((device)) __inline__ short __ldg(const short *ptr) ; +static __attribute__((device)) __inline__ int __ldg(const int *ptr) ; +static __attribute__((device)) __inline__ long long __ldg(const long long *ptr) ; +static __attribute__((device)) __inline__ char2 __ldg(const char2 *ptr) ; +static __attribute__((device)) __inline__ char4 __ldg(const char4 *ptr) ; +static __attribute__((device)) __inline__ short2 __ldg(const short2 *ptr) ; +static __attribute__((device)) __inline__ short4 __ldg(const short4 *ptr) ; +static __attribute__((device)) __inline__ int2 __ldg(const int2 *ptr) ; +static __attribute__((device)) __inline__ int4 __ldg(const int4 *ptr) ; +static __attribute__((device)) __inline__ longlong2 __ldg(const longlong2 *ptr) ; + +static __attribute__((device)) __inline__ unsigned char __ldg(const unsigned char *ptr) ; +static __attribute__((device)) __inline__ unsigned short __ldg(const unsigned short *ptr) ; +static __attribute__((device)) __inline__ unsigned int __ldg(const unsigned int *ptr) ; +static __attribute__((device)) __inline__ unsigned long long __ldg(const unsigned long long *ptr) ; +static __attribute__((device)) __inline__ uchar2 __ldg(const uchar2 *ptr) ; +static __attribute__((device)) __inline__ uchar4 __ldg(const uchar4 *ptr) ; +static __attribute__((device)) __inline__ ushort2 __ldg(const ushort2 *ptr) ; +static __attribute__((device)) __inline__ ushort4 __ldg(const ushort4 *ptr) ; +static __attribute__((device)) __inline__ uint2 __ldg(const uint2 *ptr) ; +static __attribute__((device)) __inline__ uint4 __ldg(const uint4 *ptr) ; +static __attribute__((device)) __inline__ ulonglong2 __ldg(const ulonglong2 *ptr) ; + +static __attribute__((device)) __inline__ float __ldg(const float *ptr) ; +static __attribute__((device)) __inline__ double __ldg(const double *ptr) ; +static __attribute__((device)) __inline__ float2 __ldg(const float2 *ptr) ; +static __attribute__((device)) __inline__ float4 __ldg(const float4 *ptr) ; +static __attribute__((device)) __inline__ double2 __ldg(const double2 *ptr) ; + + + + +static __attribute__((device)) __inline__ long __ldcg(const long *ptr) ; +static __attribute__((device)) __inline__ unsigned long __ldcg(const unsigned long *ptr) ; + +static __attribute__((device)) __inline__ char __ldcg(const char *ptr) ; +static __attribute__((device)) __inline__ signed char __ldcg(const signed char *ptr) ; +static __attribute__((device)) __inline__ short __ldcg(const short *ptr) ; +static __attribute__((device)) __inline__ int __ldcg(const int *ptr) ; +static __attribute__((device)) __inline__ long long __ldcg(const long long *ptr) ; +static __attribute__((device)) __inline__ char2 __ldcg(const char2 *ptr) ; +static __attribute__((device)) __inline__ char4 __ldcg(const char4 *ptr) ; +static __attribute__((device)) __inline__ short2 __ldcg(const short2 *ptr) ; +static __attribute__((device)) __inline__ short4 __ldcg(const short4 *ptr) ; +static __attribute__((device)) __inline__ int2 __ldcg(const int2 *ptr) ; +static __attribute__((device)) __inline__ int4 __ldcg(const int4 *ptr) ; +static __attribute__((device)) __inline__ longlong2 __ldcg(const longlong2 *ptr) ; + +static __attribute__((device)) __inline__ unsigned char __ldcg(const unsigned char *ptr) ; +static __attribute__((device)) __inline__ unsigned short __ldcg(const unsigned short *ptr) ; +static __attribute__((device)) __inline__ unsigned int __ldcg(const unsigned int *ptr) ; +static __attribute__((device)) __inline__ unsigned long long __ldcg(const unsigned long long *ptr) ; +static __attribute__((device)) __inline__ uchar2 __ldcg(const uchar2 *ptr) ; +static __attribute__((device)) __inline__ uchar4 __ldcg(const uchar4 *ptr) ; +static __attribute__((device)) __inline__ ushort2 __ldcg(const ushort2 *ptr) ; +static __attribute__((device)) __inline__ ushort4 __ldcg(const ushort4 *ptr) ; +static __attribute__((device)) __inline__ uint2 __ldcg(const uint2 *ptr) ; +static __attribute__((device)) __inline__ uint4 __ldcg(const uint4 *ptr) ; +static __attribute__((device)) __inline__ ulonglong2 __ldcg(const ulonglong2 *ptr) ; + +static __attribute__((device)) __inline__ float __ldcg(const float *ptr) ; +static __attribute__((device)) __inline__ double __ldcg(const double *ptr) ; +static __attribute__((device)) __inline__ float2 __ldcg(const float2 *ptr) ; +static __attribute__((device)) __inline__ float4 __ldcg(const float4 *ptr) ; +static __attribute__((device)) __inline__ double2 __ldcg(const double2 *ptr) ; + + + +static __attribute__((device)) __inline__ long __ldca(const long *ptr) ; +static __attribute__((device)) __inline__ unsigned long __ldca(const unsigned long *ptr) ; + +static __attribute__((device)) __inline__ char __ldca(const char *ptr) ; +static __attribute__((device)) __inline__ signed char __ldca(const signed char *ptr) ; +static __attribute__((device)) __inline__ short __ldca(const short *ptr) ; +static __attribute__((device)) __inline__ int __ldca(const int *ptr) ; +static __attribute__((device)) __inline__ long long __ldca(const long long *ptr) ; +static __attribute__((device)) __inline__ char2 __ldca(const char2 *ptr) ; +static __attribute__((device)) __inline__ char4 __ldca(const char4 *ptr) ; +static __attribute__((device)) __inline__ short2 __ldca(const short2 *ptr) ; +static __attribute__((device)) __inline__ short4 __ldca(const short4 *ptr) ; +static __attribute__((device)) __inline__ int2 __ldca(const int2 *ptr) ; +static __attribute__((device)) __inline__ int4 __ldca(const int4 *ptr) ; +static __attribute__((device)) __inline__ longlong2 __ldca(const longlong2 *ptr) ; + +static __attribute__((device)) __inline__ unsigned char __ldca(const unsigned char *ptr) ; +static __attribute__((device)) __inline__ unsigned short __ldca(const unsigned short *ptr) ; +static __attribute__((device)) __inline__ unsigned int __ldca(const unsigned int *ptr) ; +static __attribute__((device)) __inline__ unsigned long long __ldca(const unsigned long long *ptr) ; +static __attribute__((device)) __inline__ uchar2 __ldca(const uchar2 *ptr) ; +static __attribute__((device)) __inline__ uchar4 __ldca(const uchar4 *ptr) ; +static __attribute__((device)) __inline__ ushort2 __ldca(const ushort2 *ptr) ; +static __attribute__((device)) __inline__ ushort4 __ldca(const ushort4 *ptr) ; +static __attribute__((device)) __inline__ uint2 __ldca(const uint2 *ptr) ; +static __attribute__((device)) __inline__ uint4 __ldca(const uint4 *ptr) ; +static __attribute__((device)) __inline__ ulonglong2 __ldca(const ulonglong2 *ptr) ; + +static __attribute__((device)) __inline__ float __ldca(const float *ptr) ; +static __attribute__((device)) __inline__ double __ldca(const double *ptr) ; +static __attribute__((device)) __inline__ float2 __ldca(const float2 *ptr) ; +static __attribute__((device)) __inline__ float4 __ldca(const float4 *ptr) ; +static __attribute__((device)) __inline__ double2 __ldca(const double2 *ptr) ; + + + +static __attribute__((device)) __inline__ long __ldcs(const long *ptr) ; +static __attribute__((device)) __inline__ unsigned long __ldcs(const unsigned long *ptr) ; + +static __attribute__((device)) __inline__ char __ldcs(const char *ptr) ; +static __attribute__((device)) __inline__ signed char __ldcs(const signed char *ptr) ; +static __attribute__((device)) __inline__ short __ldcs(const short *ptr) ; +static __attribute__((device)) __inline__ int __ldcs(const int *ptr) ; +static __attribute__((device)) __inline__ long long __ldcs(const long long *ptr) ; +static __attribute__((device)) __inline__ char2 __ldcs(const char2 *ptr) ; +static __attribute__((device)) __inline__ char4 __ldcs(const char4 *ptr) ; +static __attribute__((device)) __inline__ short2 __ldcs(const short2 *ptr) ; +static __attribute__((device)) __inline__ short4 __ldcs(const short4 *ptr) ; +static __attribute__((device)) __inline__ int2 __ldcs(const int2 *ptr) ; +static __attribute__((device)) __inline__ int4 __ldcs(const int4 *ptr) ; +static __attribute__((device)) __inline__ longlong2 __ldcs(const longlong2 *ptr) ; + +static __attribute__((device)) __inline__ unsigned char __ldcs(const unsigned char *ptr) ; +static __attribute__((device)) __inline__ unsigned short __ldcs(const unsigned short *ptr) ; +static __attribute__((device)) __inline__ unsigned int __ldcs(const unsigned int *ptr) ; +static __attribute__((device)) __inline__ unsigned long long __ldcs(const unsigned long long *ptr) ; +static __attribute__((device)) __inline__ uchar2 __ldcs(const uchar2 *ptr) ; +static __attribute__((device)) __inline__ uchar4 __ldcs(const uchar4 *ptr) ; +static __attribute__((device)) __inline__ ushort2 __ldcs(const ushort2 *ptr) ; +static __attribute__((device)) __inline__ ushort4 __ldcs(const ushort4 *ptr) ; +static __attribute__((device)) __inline__ uint2 __ldcs(const uint2 *ptr) ; +static __attribute__((device)) __inline__ uint4 __ldcs(const uint4 *ptr) ; +static __attribute__((device)) __inline__ ulonglong2 __ldcs(const ulonglong2 *ptr) ; + +static __attribute__((device)) __inline__ float __ldcs(const float *ptr) ; +static __attribute__((device)) __inline__ double __ldcs(const double *ptr) ; +static __attribute__((device)) __inline__ float2 __ldcs(const float2 *ptr) ; +static __attribute__((device)) __inline__ float4 __ldcs(const float4 *ptr) ; +static __attribute__((device)) __inline__ double2 __ldcs(const double2 *ptr) ; + + + +static __attribute__((device)) __inline__ long __ldlu(const long *ptr) ; +static __attribute__((device)) __inline__ unsigned long __ldlu(const unsigned long *ptr) ; + +static __attribute__((device)) __inline__ char __ldlu(const char *ptr) ; +static __attribute__((device)) __inline__ signed char __ldlu(const signed char *ptr) ; +static __attribute__((device)) __inline__ short __ldlu(const short *ptr) ; +static __attribute__((device)) __inline__ int __ldlu(const int *ptr) ; +static __attribute__((device)) __inline__ long long __ldlu(const long long *ptr) ; +static __attribute__((device)) __inline__ char2 __ldlu(const char2 *ptr) ; +static __attribute__((device)) __inline__ char4 __ldlu(const char4 *ptr) ; +static __attribute__((device)) __inline__ short2 __ldlu(const short2 *ptr) ; +static __attribute__((device)) __inline__ short4 __ldlu(const short4 *ptr) ; +static __attribute__((device)) __inline__ int2 __ldlu(const int2 *ptr) ; +static __attribute__((device)) __inline__ int4 __ldlu(const int4 *ptr) ; +static __attribute__((device)) __inline__ longlong2 __ldlu(const longlong2 *ptr) ; + +static __attribute__((device)) __inline__ unsigned char __ldlu(const unsigned char *ptr) ; +static __attribute__((device)) __inline__ unsigned short __ldlu(const unsigned short *ptr) ; +static __attribute__((device)) __inline__ unsigned int __ldlu(const unsigned int *ptr) ; +static __attribute__((device)) __inline__ unsigned long long __ldlu(const unsigned long long *ptr) ; +static __attribute__((device)) __inline__ uchar2 __ldlu(const uchar2 *ptr) ; +static __attribute__((device)) __inline__ uchar4 __ldlu(const uchar4 *ptr) ; +static __attribute__((device)) __inline__ ushort2 __ldlu(const ushort2 *ptr) ; +static __attribute__((device)) __inline__ ushort4 __ldlu(const ushort4 *ptr) ; +static __attribute__((device)) __inline__ uint2 __ldlu(const uint2 *ptr) ; +static __attribute__((device)) __inline__ uint4 __ldlu(const uint4 *ptr) ; +static __attribute__((device)) __inline__ ulonglong2 __ldlu(const ulonglong2 *ptr) ; + +static __attribute__((device)) __inline__ float __ldlu(const float *ptr) ; +static __attribute__((device)) __inline__ double __ldlu(const double *ptr) ; +static __attribute__((device)) __inline__ float2 __ldlu(const float2 *ptr) ; +static __attribute__((device)) __inline__ float4 __ldlu(const float4 *ptr) ; +static __attribute__((device)) __inline__ double2 __ldlu(const double2 *ptr) ; + + + +static __attribute__((device)) __inline__ long __ldcv(const long *ptr) ; +static __attribute__((device)) __inline__ unsigned long __ldcv(const unsigned long *ptr) ; + +static __attribute__((device)) __inline__ char __ldcv(const char *ptr) ; +static __attribute__((device)) __inline__ signed char __ldcv(const signed char *ptr) ; +static __attribute__((device)) __inline__ short __ldcv(const short *ptr) ; +static __attribute__((device)) __inline__ int __ldcv(const int *ptr) ; +static __attribute__((device)) __inline__ long long __ldcv(const long long *ptr) ; +static __attribute__((device)) __inline__ char2 __ldcv(const char2 *ptr) ; +static __attribute__((device)) __inline__ char4 __ldcv(const char4 *ptr) ; +static __attribute__((device)) __inline__ short2 __ldcv(const short2 *ptr) ; +static __attribute__((device)) __inline__ short4 __ldcv(const short4 *ptr) ; +static __attribute__((device)) __inline__ int2 __ldcv(const int2 *ptr) ; +static __attribute__((device)) __inline__ int4 __ldcv(const int4 *ptr) ; +static __attribute__((device)) __inline__ longlong2 __ldcv(const longlong2 *ptr) ; + +static __attribute__((device)) __inline__ unsigned char __ldcv(const unsigned char *ptr) ; +static __attribute__((device)) __inline__ unsigned short __ldcv(const unsigned short *ptr) ; +static __attribute__((device)) __inline__ unsigned int __ldcv(const unsigned int *ptr) ; +static __attribute__((device)) __inline__ unsigned long long __ldcv(const unsigned long long *ptr) ; +static __attribute__((device)) __inline__ uchar2 __ldcv(const uchar2 *ptr) ; +static __attribute__((device)) __inline__ uchar4 __ldcv(const uchar4 *ptr) ; +static __attribute__((device)) __inline__ ushort2 __ldcv(const ushort2 *ptr) ; +static __attribute__((device)) __inline__ ushort4 __ldcv(const ushort4 *ptr) ; +static __attribute__((device)) __inline__ uint2 __ldcv(const uint2 *ptr) ; +static __attribute__((device)) __inline__ uint4 __ldcv(const uint4 *ptr) ; +static __attribute__((device)) __inline__ ulonglong2 __ldcv(const ulonglong2 *ptr) ; + +static __attribute__((device)) __inline__ float __ldcv(const float *ptr) ; +static __attribute__((device)) __inline__ double __ldcv(const double *ptr) ; +static __attribute__((device)) __inline__ float2 __ldcv(const float2 *ptr) ; +static __attribute__((device)) __inline__ float4 __ldcv(const float4 *ptr) ; +static __attribute__((device)) __inline__ double2 __ldcv(const double2 *ptr) ; + + + +static __attribute__((device)) __inline__ void __stwb(long *ptr, long value) ; +static __attribute__((device)) __inline__ void __stwb(unsigned long *ptr, unsigned long value) ; + +static __attribute__((device)) __inline__ void __stwb(char *ptr, char value) ; +static __attribute__((device)) __inline__ void __stwb(signed char *ptr, signed char value) ; +static __attribute__((device)) __inline__ void __stwb(short *ptr, short value) ; +static __attribute__((device)) __inline__ void __stwb(int *ptr, int value) ; +static __attribute__((device)) __inline__ void __stwb(long long *ptr, long long value) ; +static __attribute__((device)) __inline__ void __stwb(char2 *ptr, char2 value) ; +static __attribute__((device)) __inline__ void __stwb(char4 *ptr, char4 value) ; +static __attribute__((device)) __inline__ void __stwb(short2 *ptr, short2 value) ; +static __attribute__((device)) __inline__ void __stwb(short4 *ptr, short4 value) ; +static __attribute__((device)) __inline__ void __stwb(int2 *ptr, int2 value) ; +static __attribute__((device)) __inline__ void __stwb(int4 *ptr, int4 value) ; +static __attribute__((device)) __inline__ void __stwb(longlong2 *ptr, longlong2 value) ; + +static __attribute__((device)) __inline__ void __stwb(unsigned char *ptr, unsigned char value) ; +static __attribute__((device)) __inline__ void __stwb(unsigned short *ptr, unsigned short value) ; +static __attribute__((device)) __inline__ void __stwb(unsigned int *ptr, unsigned int value) ; +static __attribute__((device)) __inline__ void __stwb(unsigned long long *ptr, unsigned long long value) ; +static __attribute__((device)) __inline__ void __stwb(uchar2 *ptr, uchar2 value) ; +static __attribute__((device)) __inline__ void __stwb(uchar4 *ptr, uchar4 value) ; +static __attribute__((device)) __inline__ void __stwb(ushort2 *ptr, ushort2 value) ; +static __attribute__((device)) __inline__ void __stwb(ushort4 *ptr, ushort4 value) ; +static __attribute__((device)) __inline__ void __stwb(uint2 *ptr, uint2 value) ; +static __attribute__((device)) __inline__ void __stwb(uint4 *ptr, uint4 value) ; +static __attribute__((device)) __inline__ void __stwb(ulonglong2 *ptr, ulonglong2 value) ; + +static __attribute__((device)) __inline__ void __stwb(float *ptr, float value) ; +static __attribute__((device)) __inline__ void __stwb(double *ptr, double value) ; +static __attribute__((device)) __inline__ void __stwb(float2 *ptr, float2 value) ; +static __attribute__((device)) __inline__ void __stwb(float4 *ptr, float4 value) ; +static __attribute__((device)) __inline__ void __stwb(double2 *ptr, double2 value) ; + + + +static __attribute__((device)) __inline__ void __stcg(long *ptr, long value) ; +static __attribute__((device)) __inline__ void __stcg(unsigned long *ptr, unsigned long value) ; + +static __attribute__((device)) __inline__ void __stcg(char *ptr, char value) ; +static __attribute__((device)) __inline__ void __stcg(signed char *ptr, signed char value) ; +static __attribute__((device)) __inline__ void __stcg(short *ptr, short value) ; +static __attribute__((device)) __inline__ void __stcg(int *ptr, int value) ; +static __attribute__((device)) __inline__ void __stcg(long long *ptr, long long value) ; +static __attribute__((device)) __inline__ void __stcg(char2 *ptr, char2 value) ; +static __attribute__((device)) __inline__ void __stcg(char4 *ptr, char4 value) ; +static __attribute__((device)) __inline__ void __stcg(short2 *ptr, short2 value) ; +static __attribute__((device)) __inline__ void __stcg(short4 *ptr, short4 value) ; +static __attribute__((device)) __inline__ void __stcg(int2 *ptr, int2 value) ; +static __attribute__((device)) __inline__ void __stcg(int4 *ptr, int4 value) ; +static __attribute__((device)) __inline__ void __stcg(longlong2 *ptr, longlong2 value) ; + +static __attribute__((device)) __inline__ void __stcg(unsigned char *ptr, unsigned char value) ; +static __attribute__((device)) __inline__ void __stcg(unsigned short *ptr, unsigned short value) ; +static __attribute__((device)) __inline__ void __stcg(unsigned int *ptr, unsigned int value) ; +static __attribute__((device)) __inline__ void __stcg(unsigned long long *ptr, unsigned long long value) ; +static __attribute__((device)) __inline__ void __stcg(uchar2 *ptr, uchar2 value) ; +static __attribute__((device)) __inline__ void __stcg(uchar4 *ptr, uchar4 value) ; +static __attribute__((device)) __inline__ void __stcg(ushort2 *ptr, ushort2 value) ; +static __attribute__((device)) __inline__ void __stcg(ushort4 *ptr, ushort4 value) ; +static __attribute__((device)) __inline__ void __stcg(uint2 *ptr, uint2 value) ; +static __attribute__((device)) __inline__ void __stcg(uint4 *ptr, uint4 value) ; +static __attribute__((device)) __inline__ void __stcg(ulonglong2 *ptr, ulonglong2 value) ; + +static __attribute__((device)) __inline__ void __stcg(float *ptr, float value) ; +static __attribute__((device)) __inline__ void __stcg(double *ptr, double value) ; +static __attribute__((device)) __inline__ void __stcg(float2 *ptr, float2 value) ; +static __attribute__((device)) __inline__ void __stcg(float4 *ptr, float4 value) ; +static __attribute__((device)) __inline__ void __stcg(double2 *ptr, double2 value) ; + + + +static __attribute__((device)) __inline__ void __stcs(long *ptr, long value) ; +static __attribute__((device)) __inline__ void __stcs(unsigned long *ptr, unsigned long value) ; + +static __attribute__((device)) __inline__ void __stcs(char *ptr, char value) ; +static __attribute__((device)) __inline__ void __stcs(signed char *ptr, signed char value) ; +static __attribute__((device)) __inline__ void __stcs(short *ptr, short value) ; +static __attribute__((device)) __inline__ void __stcs(int *ptr, int value) ; +static __attribute__((device)) __inline__ void __stcs(long long *ptr, long long value) ; +static __attribute__((device)) __inline__ void __stcs(char2 *ptr, char2 value) ; +static __attribute__((device)) __inline__ void __stcs(char4 *ptr, char4 value) ; +static __attribute__((device)) __inline__ void __stcs(short2 *ptr, short2 value) ; +static __attribute__((device)) __inline__ void __stcs(short4 *ptr, short4 value) ; +static __attribute__((device)) __inline__ void __stcs(int2 *ptr, int2 value) ; +static __attribute__((device)) __inline__ void __stcs(int4 *ptr, int4 value) ; +static __attribute__((device)) __inline__ void __stcs(longlong2 *ptr, longlong2 value) ; + +static __attribute__((device)) __inline__ void __stcs(unsigned char *ptr, unsigned char value) ; +static __attribute__((device)) __inline__ void __stcs(unsigned short *ptr, unsigned short value) ; +static __attribute__((device)) __inline__ void __stcs(unsigned int *ptr, unsigned int value) ; +static __attribute__((device)) __inline__ void __stcs(unsigned long long *ptr, unsigned long long value) ; +static __attribute__((device)) __inline__ void __stcs(uchar2 *ptr, uchar2 value) ; +static __attribute__((device)) __inline__ void __stcs(uchar4 *ptr, uchar4 value) ; +static __attribute__((device)) __inline__ void __stcs(ushort2 *ptr, ushort2 value) ; +static __attribute__((device)) __inline__ void __stcs(ushort4 *ptr, ushort4 value) ; +static __attribute__((device)) __inline__ void __stcs(uint2 *ptr, uint2 value) ; +static __attribute__((device)) __inline__ void __stcs(uint4 *ptr, uint4 value) ; +static __attribute__((device)) __inline__ void __stcs(ulonglong2 *ptr, ulonglong2 value) ; + +static __attribute__((device)) __inline__ void __stcs(float *ptr, float value) ; +static __attribute__((device)) __inline__ void __stcs(double *ptr, double value) ; +static __attribute__((device)) __inline__ void __stcs(float2 *ptr, float2 value) ; +static __attribute__((device)) __inline__ void __stcs(float4 *ptr, float4 value) ; +static __attribute__((device)) __inline__ void __stcs(double2 *ptr, double2 value) ; + + + +static __attribute__((device)) __inline__ void __stwt(long *ptr, long value) ; +static __attribute__((device)) __inline__ void __stwt(unsigned long *ptr, unsigned long value) ; + +static __attribute__((device)) __inline__ void __stwt(char *ptr, char value) ; +static __attribute__((device)) __inline__ void __stwt(signed char *ptr, signed char value) ; +static __attribute__((device)) __inline__ void __stwt(short *ptr, short value) ; +static __attribute__((device)) __inline__ void __stwt(int *ptr, int value) ; +static __attribute__((device)) __inline__ void __stwt(long long *ptr, long long value) ; +static __attribute__((device)) __inline__ void __stwt(char2 *ptr, char2 value) ; +static __attribute__((device)) __inline__ void __stwt(char4 *ptr, char4 value) ; +static __attribute__((device)) __inline__ void __stwt(short2 *ptr, short2 value) ; +static __attribute__((device)) __inline__ void __stwt(short4 *ptr, short4 value) ; +static __attribute__((device)) __inline__ void __stwt(int2 *ptr, int2 value) ; +static __attribute__((device)) __inline__ void __stwt(int4 *ptr, int4 value) ; +static __attribute__((device)) __inline__ void __stwt(longlong2 *ptr, longlong2 value) ; + +static __attribute__((device)) __inline__ void __stwt(unsigned char *ptr, unsigned char value) ; +static __attribute__((device)) __inline__ void __stwt(unsigned short *ptr, unsigned short value) ; +static __attribute__((device)) __inline__ void __stwt(unsigned int *ptr, unsigned int value) ; +static __attribute__((device)) __inline__ void __stwt(unsigned long long *ptr, unsigned long long value) ; +static __attribute__((device)) __inline__ void __stwt(uchar2 *ptr, uchar2 value) ; +static __attribute__((device)) __inline__ void __stwt(uchar4 *ptr, uchar4 value) ; +static __attribute__((device)) __inline__ void __stwt(ushort2 *ptr, ushort2 value) ; +static __attribute__((device)) __inline__ void __stwt(ushort4 *ptr, ushort4 value) ; +static __attribute__((device)) __inline__ void __stwt(uint2 *ptr, uint2 value) ; +static __attribute__((device)) __inline__ void __stwt(uint4 *ptr, uint4 value) ; +static __attribute__((device)) __inline__ void __stwt(ulonglong2 *ptr, ulonglong2 value) ; + +static __attribute__((device)) __inline__ void __stwt(float *ptr, float value) ; +static __attribute__((device)) __inline__ void __stwt(double *ptr, double value) ; +static __attribute__((device)) __inline__ void __stwt(float2 *ptr, float2 value) ; +static __attribute__((device)) __inline__ void __stwt(float4 *ptr, float4 value) ; +static __attribute__((device)) __inline__ void __stwt(double2 *ptr, double2 value) ; +# 465 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_l(unsigned int lo, unsigned int hi, unsigned int shift) ; +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_lc(unsigned int lo, unsigned int hi, unsigned int shift) ; +# 490 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_r(unsigned int lo, unsigned int hi, unsigned int shift) ; +# 502 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_rc(unsigned int lo, unsigned int hi, unsigned int shift) ; +# 512 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.hpp" 1 +# 73 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.hpp" +extern "C" +{ + + +} +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.hpp" +static __attribute__((device)) __inline__ long __ldg(const long *ptr) { unsigned long ret; asm volatile ("ld.global.nc.s64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return (long)ret; } +static __attribute__((device)) __inline__ unsigned long __ldg(const unsigned long *ptr) { unsigned long ret; asm volatile ("ld.global.nc.u64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return ret; } + + + + + + +static __attribute__((device)) __inline__ char __ldg(const char *ptr) { unsigned int ret; asm volatile ("ld.global.nc.s8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (char)ret; } +static __attribute__((device)) __inline__ signed char __ldg(const signed char *ptr) { unsigned int ret; asm volatile ("ld.global.nc.s8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (signed char)ret; } +static __attribute__((device)) __inline__ short __ldg(const short *ptr) { unsigned short ret; asm volatile ("ld.global.nc.s16 %0, [%1];" : "=h"(ret) : "l" (ptr)); return (short)ret; } +static __attribute__((device)) __inline__ int __ldg(const int *ptr) { unsigned int ret; asm volatile ("ld.global.nc.s32 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (int)ret; } +static __attribute__((device)) __inline__ long long __ldg(const long long *ptr) { unsigned long long ret; asm volatile ("ld.global.nc.s64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return (long long)ret; } +static __attribute__((device)) __inline__ char2 __ldg(const char2 *ptr) { char2 ret; int2 tmp; asm volatile ("ld.global.nc.v2.s8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr)); ret.x = (char)tmp.x; ret.y = (char)tmp.y; return ret; } +static __attribute__((device)) __inline__ char4 __ldg(const char4 *ptr) { char4 ret; int4 tmp; asm volatile ("ld.global.nc.v4.s8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr)); ret.x = (char)tmp.x; ret.y = (char)tmp.y; ret.z = (char)tmp.z; ret.w = (char)tmp.w; return ret; } +static __attribute__((device)) __inline__ short2 __ldg(const short2 *ptr) { short2 ret; asm volatile ("ld.global.nc.v2.s16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ short4 __ldg(const short4 *ptr) { short4 ret; asm volatile ("ld.global.nc.v4.s16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ int2 __ldg(const int2 *ptr) { int2 ret; asm volatile ("ld.global.nc.v2.s32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ int4 __ldg(const int4 *ptr) { int4 ret; asm volatile ("ld.global.nc.v4.s32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ longlong2 __ldg(const longlong2 *ptr) { longlong2 ret; asm volatile ("ld.global.nc.v2.s64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr)); return ret; } + +static __attribute__((device)) __inline__ unsigned char __ldg(const unsigned char *ptr) { unsigned int ret; asm volatile ("ld.global.nc.u8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (unsigned char)ret; } +static __attribute__((device)) __inline__ unsigned short __ldg(const unsigned short *ptr) { unsigned short ret; asm volatile ("ld.global.nc.u16 %0, [%1];" : "=h"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ unsigned int __ldg(const unsigned int *ptr) { unsigned int ret; asm volatile ("ld.global.nc.u32 %0, [%1];" : "=r"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ unsigned long long __ldg(const unsigned long long *ptr) { unsigned long long ret; asm volatile ("ld.global.nc.u64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uchar2 __ldg(const uchar2 *ptr) { uchar2 ret; uint2 tmp; asm volatile ("ld.global.nc.v2.u8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr)); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; return ret; } +static __attribute__((device)) __inline__ uchar4 __ldg(const uchar4 *ptr) { uchar4 ret; uint4 tmp; asm volatile ("ld.global.nc.v4.u8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr)); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; ret.z = (unsigned char)tmp.z; ret.w = (unsigned char)tmp.w; return ret; } +static __attribute__((device)) __inline__ ushort2 __ldg(const ushort2 *ptr) { ushort2 ret; asm volatile ("ld.global.nc.v2.u16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ ushort4 __ldg(const ushort4 *ptr) { ushort4 ret; asm volatile ("ld.global.nc.v4.u16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uint2 __ldg(const uint2 *ptr) { uint2 ret; asm volatile ("ld.global.nc.v2.u32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uint4 __ldg(const uint4 *ptr) { uint4 ret; asm volatile ("ld.global.nc.v4.u32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ ulonglong2 __ldg(const ulonglong2 *ptr) { ulonglong2 ret; asm volatile ("ld.global.nc.v2.u64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr)); return ret; } + +static __attribute__((device)) __inline__ float __ldg(const float *ptr) { float ret; asm volatile ("ld.global.nc.f32 %0, [%1];" : "=f"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ double __ldg(const double *ptr) { double ret; asm volatile ("ld.global.nc.f64 %0, [%1];" : "=d"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ float2 __ldg(const float2 *ptr) { float2 ret; asm volatile ("ld.global.nc.v2.f32 {%0,%1}, [%2];" : "=f"(ret.x), "=f"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ float4 __ldg(const float4 *ptr) { float4 ret; asm volatile ("ld.global.nc.v4.f32 {%0,%1,%2,%3}, [%4];" : "=f"(ret.x), "=f"(ret.y), "=f"(ret.z), "=f"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ double2 __ldg(const double2 *ptr) { double2 ret; asm volatile ("ld.global.nc.v2.f64 {%0,%1}, [%2];" : "=d"(ret.x), "=d"(ret.y) : "l" (ptr)); return ret; } +# 147 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.hpp" +static __attribute__((device)) __inline__ long __ldcg(const long *ptr) { unsigned long ret; asm volatile ("ld.global.cg.s64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return (long)ret; } +static __attribute__((device)) __inline__ unsigned long __ldcg(const unsigned long *ptr) { unsigned long ret; asm volatile ("ld.global.cg.u64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return ret; } + + + + + + +static __attribute__((device)) __inline__ char __ldcg(const char *ptr) { unsigned int ret; asm volatile ("ld.global.cg.s8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (char)ret; } +static __attribute__((device)) __inline__ signed char __ldcg(const signed char *ptr) { unsigned int ret; asm volatile ("ld.global.cg.s8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (signed char)ret; } +static __attribute__((device)) __inline__ short __ldcg(const short *ptr) { unsigned short ret; asm volatile ("ld.global.cg.s16 %0, [%1];" : "=h"(ret) : "l" (ptr)); return (short)ret; } +static __attribute__((device)) __inline__ int __ldcg(const int *ptr) { unsigned int ret; asm volatile ("ld.global.cg.s32 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (int)ret; } +static __attribute__((device)) __inline__ long long __ldcg(const long long *ptr) { unsigned long long ret; asm volatile ("ld.global.cg.s64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return (long long)ret; } +static __attribute__((device)) __inline__ char2 __ldcg(const char2 *ptr) { char2 ret; int2 tmp; asm volatile ("ld.global.cg.v2.s8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr)); ret.x = (char)tmp.x; ret.y = (char)tmp.y; return ret; } +static __attribute__((device)) __inline__ char4 __ldcg(const char4 *ptr) { char4 ret; int4 tmp; asm volatile ("ld.global.cg.v4.s8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr)); ret.x = (char)tmp.x; ret.y = (char)tmp.y; ret.z = (char)tmp.z; ret.w = (char)tmp.w; return ret; } +static __attribute__((device)) __inline__ short2 __ldcg(const short2 *ptr) { short2 ret; asm volatile ("ld.global.cg.v2.s16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ short4 __ldcg(const short4 *ptr) { short4 ret; asm volatile ("ld.global.cg.v4.s16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ int2 __ldcg(const int2 *ptr) { int2 ret; asm volatile ("ld.global.cg.v2.s32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ int4 __ldcg(const int4 *ptr) { int4 ret; asm volatile ("ld.global.cg.v4.s32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ longlong2 __ldcg(const longlong2 *ptr) { longlong2 ret; asm volatile ("ld.global.cg.v2.s64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr)); return ret; } + +static __attribute__((device)) __inline__ unsigned char __ldcg(const unsigned char *ptr) { unsigned int ret; asm volatile ("ld.global.cg.u8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (unsigned char)ret; } +static __attribute__((device)) __inline__ unsigned short __ldcg(const unsigned short *ptr) { unsigned short ret; asm volatile ("ld.global.cg.u16 %0, [%1];" : "=h"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ unsigned int __ldcg(const unsigned int *ptr) { unsigned int ret; asm volatile ("ld.global.cg.u32 %0, [%1];" : "=r"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ unsigned long long __ldcg(const unsigned long long *ptr) { unsigned long long ret; asm volatile ("ld.global.cg.u64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uchar2 __ldcg(const uchar2 *ptr) { uchar2 ret; uint2 tmp; asm volatile ("ld.global.cg.v2.u8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr)); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; return ret; } +static __attribute__((device)) __inline__ uchar4 __ldcg(const uchar4 *ptr) { uchar4 ret; uint4 tmp; asm volatile ("ld.global.cg.v4.u8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr)); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; ret.z = (unsigned char)tmp.z; ret.w = (unsigned char)tmp.w; return ret; } +static __attribute__((device)) __inline__ ushort2 __ldcg(const ushort2 *ptr) { ushort2 ret; asm volatile ("ld.global.cg.v2.u16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ ushort4 __ldcg(const ushort4 *ptr) { ushort4 ret; asm volatile ("ld.global.cg.v4.u16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uint2 __ldcg(const uint2 *ptr) { uint2 ret; asm volatile ("ld.global.cg.v2.u32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uint4 __ldcg(const uint4 *ptr) { uint4 ret; asm volatile ("ld.global.cg.v4.u32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ ulonglong2 __ldcg(const ulonglong2 *ptr) { ulonglong2 ret; asm volatile ("ld.global.cg.v2.u64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr)); return ret; } + +static __attribute__((device)) __inline__ float __ldcg(const float *ptr) { float ret; asm volatile ("ld.global.cg.f32 %0, [%1];" : "=f"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ double __ldcg(const double *ptr) { double ret; asm volatile ("ld.global.cg.f64 %0, [%1];" : "=d"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ float2 __ldcg(const float2 *ptr) { float2 ret; asm volatile ("ld.global.cg.v2.f32 {%0,%1}, [%2];" : "=f"(ret.x), "=f"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ float4 __ldcg(const float4 *ptr) { float4 ret; asm volatile ("ld.global.cg.v4.f32 {%0,%1,%2,%3}, [%4];" : "=f"(ret.x), "=f"(ret.y), "=f"(ret.z), "=f"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ double2 __ldcg(const double2 *ptr) { double2 ret; asm volatile ("ld.global.cg.v2.f64 {%0,%1}, [%2];" : "=d"(ret.x), "=d"(ret.y) : "l" (ptr)); return ret; } + + + + + + + +static __attribute__((device)) __inline__ long __ldca(const long *ptr) { unsigned long ret; asm volatile ("ld.global.ca.s64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return (long)ret; } +static __attribute__((device)) __inline__ unsigned long __ldca(const unsigned long *ptr) { unsigned long ret; asm volatile ("ld.global.ca.u64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return ret; } + + + + + + +static __attribute__((device)) __inline__ char __ldca(const char *ptr) { unsigned int ret; asm volatile ("ld.global.ca.s8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (char)ret; } +static __attribute__((device)) __inline__ signed char __ldca(const signed char *ptr) { unsigned int ret; asm volatile ("ld.global.ca.s8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (signed char)ret; } +static __attribute__((device)) __inline__ short __ldca(const short *ptr) { unsigned short ret; asm volatile ("ld.global.ca.s16 %0, [%1];" : "=h"(ret) : "l" (ptr)); return (short)ret; } +static __attribute__((device)) __inline__ int __ldca(const int *ptr) { unsigned int ret; asm volatile ("ld.global.ca.s32 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (int)ret; } +static __attribute__((device)) __inline__ long long __ldca(const long long *ptr) { unsigned long long ret; asm volatile ("ld.global.ca.s64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return (long long)ret; } +static __attribute__((device)) __inline__ char2 __ldca(const char2 *ptr) { char2 ret; int2 tmp; asm volatile ("ld.global.ca.v2.s8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr)); ret.x = (char)tmp.x; ret.y = (char)tmp.y; return ret; } +static __attribute__((device)) __inline__ char4 __ldca(const char4 *ptr) { char4 ret; int4 tmp; asm volatile ("ld.global.ca.v4.s8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr)); ret.x = (char)tmp.x; ret.y = (char)tmp.y; ret.z = (char)tmp.z; ret.w = (char)tmp.w; return ret; } +static __attribute__((device)) __inline__ short2 __ldca(const short2 *ptr) { short2 ret; asm volatile ("ld.global.ca.v2.s16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ short4 __ldca(const short4 *ptr) { short4 ret; asm volatile ("ld.global.ca.v4.s16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ int2 __ldca(const int2 *ptr) { int2 ret; asm volatile ("ld.global.ca.v2.s32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ int4 __ldca(const int4 *ptr) { int4 ret; asm volatile ("ld.global.ca.v4.s32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ longlong2 __ldca(const longlong2 *ptr) { longlong2 ret; asm volatile ("ld.global.ca.v2.s64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr)); return ret; } + +static __attribute__((device)) __inline__ unsigned char __ldca(const unsigned char *ptr) { unsigned int ret; asm volatile ("ld.global.ca.u8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (unsigned char)ret; } +static __attribute__((device)) __inline__ unsigned short __ldca(const unsigned short *ptr) { unsigned short ret; asm volatile ("ld.global.ca.u16 %0, [%1];" : "=h"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ unsigned int __ldca(const unsigned int *ptr) { unsigned int ret; asm volatile ("ld.global.ca.u32 %0, [%1];" : "=r"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ unsigned long long __ldca(const unsigned long long *ptr) { unsigned long long ret; asm volatile ("ld.global.ca.u64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uchar2 __ldca(const uchar2 *ptr) { uchar2 ret; uint2 tmp; asm volatile ("ld.global.ca.v2.u8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr)); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; return ret; } +static __attribute__((device)) __inline__ uchar4 __ldca(const uchar4 *ptr) { uchar4 ret; uint4 tmp; asm volatile ("ld.global.ca.v4.u8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr)); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; ret.z = (unsigned char)tmp.z; ret.w = (unsigned char)tmp.w; return ret; } +static __attribute__((device)) __inline__ ushort2 __ldca(const ushort2 *ptr) { ushort2 ret; asm volatile ("ld.global.ca.v2.u16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ ushort4 __ldca(const ushort4 *ptr) { ushort4 ret; asm volatile ("ld.global.ca.v4.u16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uint2 __ldca(const uint2 *ptr) { uint2 ret; asm volatile ("ld.global.ca.v2.u32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uint4 __ldca(const uint4 *ptr) { uint4 ret; asm volatile ("ld.global.ca.v4.u32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ ulonglong2 __ldca(const ulonglong2 *ptr) { ulonglong2 ret; asm volatile ("ld.global.ca.v2.u64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr)); return ret; } + +static __attribute__((device)) __inline__ float __ldca(const float *ptr) { float ret; asm volatile ("ld.global.ca.f32 %0, [%1];" : "=f"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ double __ldca(const double *ptr) { double ret; asm volatile ("ld.global.ca.f64 %0, [%1];" : "=d"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ float2 __ldca(const float2 *ptr) { float2 ret; asm volatile ("ld.global.ca.v2.f32 {%0,%1}, [%2];" : "=f"(ret.x), "=f"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ float4 __ldca(const float4 *ptr) { float4 ret; asm volatile ("ld.global.ca.v4.f32 {%0,%1,%2,%3}, [%4];" : "=f"(ret.x), "=f"(ret.y), "=f"(ret.z), "=f"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ double2 __ldca(const double2 *ptr) { double2 ret; asm volatile ("ld.global.ca.v2.f64 {%0,%1}, [%2];" : "=d"(ret.x), "=d"(ret.y) : "l" (ptr)); return ret; } + + + + + + + +static __attribute__((device)) __inline__ long __ldcs(const long *ptr) { unsigned long ret; asm volatile ("ld.global.cs.s64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return (long)ret; } +static __attribute__((device)) __inline__ unsigned long __ldcs(const unsigned long *ptr) { unsigned long ret; asm volatile ("ld.global.cs.u64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return ret; } + + + + + + +static __attribute__((device)) __inline__ char __ldcs(const char *ptr) { unsigned int ret; asm volatile ("ld.global.cs.s8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (char)ret; } +static __attribute__((device)) __inline__ signed char __ldcs(const signed char *ptr) { unsigned int ret; asm volatile ("ld.global.cs.s8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (signed char)ret; } +static __attribute__((device)) __inline__ short __ldcs(const short *ptr) { unsigned short ret; asm volatile ("ld.global.cs.s16 %0, [%1];" : "=h"(ret) : "l" (ptr)); return (short)ret; } +static __attribute__((device)) __inline__ int __ldcs(const int *ptr) { unsigned int ret; asm volatile ("ld.global.cs.s32 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (int)ret; } +static __attribute__((device)) __inline__ long long __ldcs(const long long *ptr) { unsigned long long ret; asm volatile ("ld.global.cs.s64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return (long long)ret; } +static __attribute__((device)) __inline__ char2 __ldcs(const char2 *ptr) { char2 ret; int2 tmp; asm volatile ("ld.global.cs.v2.s8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr)); ret.x = (char)tmp.x; ret.y = (char)tmp.y; return ret; } +static __attribute__((device)) __inline__ char4 __ldcs(const char4 *ptr) { char4 ret; int4 tmp; asm volatile ("ld.global.cs.v4.s8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr)); ret.x = (char)tmp.x; ret.y = (char)tmp.y; ret.z = (char)tmp.z; ret.w = (char)tmp.w; return ret; } +static __attribute__((device)) __inline__ short2 __ldcs(const short2 *ptr) { short2 ret; asm volatile ("ld.global.cs.v2.s16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ short4 __ldcs(const short4 *ptr) { short4 ret; asm volatile ("ld.global.cs.v4.s16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ int2 __ldcs(const int2 *ptr) { int2 ret; asm volatile ("ld.global.cs.v2.s32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ int4 __ldcs(const int4 *ptr) { int4 ret; asm volatile ("ld.global.cs.v4.s32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ longlong2 __ldcs(const longlong2 *ptr) { longlong2 ret; asm volatile ("ld.global.cs.v2.s64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr)); return ret; } + +static __attribute__((device)) __inline__ unsigned char __ldcs(const unsigned char *ptr) { unsigned int ret; asm volatile ("ld.global.cs.u8 %0, [%1];" : "=r"(ret) : "l" (ptr)); return (unsigned char)ret; } +static __attribute__((device)) __inline__ unsigned short __ldcs(const unsigned short *ptr) { unsigned short ret; asm volatile ("ld.global.cs.u16 %0, [%1];" : "=h"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ unsigned int __ldcs(const unsigned int *ptr) { unsigned int ret; asm volatile ("ld.global.cs.u32 %0, [%1];" : "=r"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ unsigned long long __ldcs(const unsigned long long *ptr) { unsigned long long ret; asm volatile ("ld.global.cs.u64 %0, [%1];" : "=l"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uchar2 __ldcs(const uchar2 *ptr) { uchar2 ret; uint2 tmp; asm volatile ("ld.global.cs.v2.u8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr)); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; return ret; } +static __attribute__((device)) __inline__ uchar4 __ldcs(const uchar4 *ptr) { uchar4 ret; uint4 tmp; asm volatile ("ld.global.cs.v4.u8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr)); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; ret.z = (unsigned char)tmp.z; ret.w = (unsigned char)tmp.w; return ret; } +static __attribute__((device)) __inline__ ushort2 __ldcs(const ushort2 *ptr) { ushort2 ret; asm volatile ("ld.global.cs.v2.u16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ ushort4 __ldcs(const ushort4 *ptr) { ushort4 ret; asm volatile ("ld.global.cs.v4.u16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uint2 __ldcs(const uint2 *ptr) { uint2 ret; asm volatile ("ld.global.cs.v2.u32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ uint4 __ldcs(const uint4 *ptr) { uint4 ret; asm volatile ("ld.global.cs.v4.u32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ ulonglong2 __ldcs(const ulonglong2 *ptr) { ulonglong2 ret; asm volatile ("ld.global.cs.v2.u64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr)); return ret; } + +static __attribute__((device)) __inline__ float __ldcs(const float *ptr) { float ret; asm volatile ("ld.global.cs.f32 %0, [%1];" : "=f"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ double __ldcs(const double *ptr) { double ret; asm volatile ("ld.global.cs.f64 %0, [%1];" : "=d"(ret) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ float2 __ldcs(const float2 *ptr) { float2 ret; asm volatile ("ld.global.cs.v2.f32 {%0,%1}, [%2];" : "=f"(ret.x), "=f"(ret.y) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ float4 __ldcs(const float4 *ptr) { float4 ret; asm volatile ("ld.global.cs.v4.f32 {%0,%1,%2,%3}, [%4];" : "=f"(ret.x), "=f"(ret.y), "=f"(ret.z), "=f"(ret.w) : "l" (ptr)); return ret; } +static __attribute__((device)) __inline__ double2 __ldcs(const double2 *ptr) { double2 ret; asm volatile ("ld.global.cs.v2.f64 {%0,%1}, [%2];" : "=d"(ret.x), "=d"(ret.y) : "l" (ptr)); return ret; } + + + + + + + +static __attribute__((device)) __inline__ long __ldlu(const long *ptr) { unsigned long ret; asm ("ld.global.lu.s64 %0, [%1];" : "=l"(ret) : "l" (ptr) : "memory"); return (long)ret; } +static __attribute__((device)) __inline__ unsigned long __ldlu(const unsigned long *ptr) { unsigned long ret; asm ("ld.global.lu.u64 %0, [%1];" : "=l"(ret) : "l" (ptr) : "memory"); return ret; } + + + + + + +static __attribute__((device)) __inline__ char __ldlu(const char *ptr) { unsigned int ret; asm ("ld.global.lu.s8 %0, [%1];" : "=r"(ret) : "l" (ptr) : "memory"); return (char)ret; } +static __attribute__((device)) __inline__ signed char __ldlu(const signed char *ptr) { unsigned int ret; asm ("ld.global.lu.s8 %0, [%1];" : "=r"(ret) : "l" (ptr) : "memory"); return (signed char)ret; } +static __attribute__((device)) __inline__ short __ldlu(const short *ptr) { unsigned short ret; asm ("ld.global.lu.s16 %0, [%1];" : "=h"(ret) : "l" (ptr) : "memory"); return (short)ret; } +static __attribute__((device)) __inline__ int __ldlu(const int *ptr) { unsigned int ret; asm ("ld.global.lu.s32 %0, [%1];" : "=r"(ret) : "l" (ptr) : "memory"); return (int)ret; } +static __attribute__((device)) __inline__ long long __ldlu(const long long *ptr) { unsigned long long ret; asm ("ld.global.lu.s64 %0, [%1];" : "=l"(ret) : "l" (ptr) : "memory"); return (long long)ret; } +static __attribute__((device)) __inline__ char2 __ldlu(const char2 *ptr) { char2 ret; int2 tmp; asm ("ld.global.lu.v2.s8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr) : "memory"); ret.x = (char)tmp.x; ret.y = (char)tmp.y; return ret; } +static __attribute__((device)) __inline__ char4 __ldlu(const char4 *ptr) { char4 ret; int4 tmp; asm ("ld.global.lu.v4.s8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr) : "memory"); ret.x = (char)tmp.x; ret.y = (char)tmp.y; ret.z = (char)tmp.z; ret.w = (char)tmp.w; return ret; } +static __attribute__((device)) __inline__ short2 __ldlu(const short2 *ptr) { short2 ret; asm ("ld.global.lu.v2.s16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ short4 __ldlu(const short4 *ptr) { short4 ret; asm ("ld.global.lu.v4.s16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ int2 __ldlu(const int2 *ptr) { int2 ret; asm ("ld.global.lu.v2.s32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ int4 __ldlu(const int4 *ptr) { int4 ret; asm ("ld.global.lu.v4.s32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ longlong2 __ldlu(const longlong2 *ptr) { longlong2 ret; asm ("ld.global.lu.v2.s64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr) : "memory"); return ret; } + +static __attribute__((device)) __inline__ unsigned char __ldlu(const unsigned char *ptr) { unsigned int ret; asm ("ld.global.lu.u8 %0, [%1];" : "=r"(ret) : "l" (ptr) : "memory"); return (unsigned char)ret; } +static __attribute__((device)) __inline__ unsigned short __ldlu(const unsigned short *ptr) { unsigned short ret; asm ("ld.global.lu.u16 %0, [%1];" : "=h"(ret) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ unsigned int __ldlu(const unsigned int *ptr) { unsigned int ret; asm ("ld.global.lu.u32 %0, [%1];" : "=r"(ret) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ unsigned long long __ldlu(const unsigned long long *ptr) { unsigned long long ret; asm ("ld.global.lu.u64 %0, [%1];" : "=l"(ret) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ uchar2 __ldlu(const uchar2 *ptr) { uchar2 ret; uint2 tmp; asm ("ld.global.lu.v2.u8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr) : "memory"); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; return ret; } +static __attribute__((device)) __inline__ uchar4 __ldlu(const uchar4 *ptr) { uchar4 ret; uint4 tmp; asm ("ld.global.lu.v4.u8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr) : "memory"); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; ret.z = (unsigned char)tmp.z; ret.w = (unsigned char)tmp.w; return ret; } +static __attribute__((device)) __inline__ ushort2 __ldlu(const ushort2 *ptr) { ushort2 ret; asm ("ld.global.lu.v2.u16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ ushort4 __ldlu(const ushort4 *ptr) { ushort4 ret; asm ("ld.global.lu.v4.u16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ uint2 __ldlu(const uint2 *ptr) { uint2 ret; asm ("ld.global.lu.v2.u32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ uint4 __ldlu(const uint4 *ptr) { uint4 ret; asm ("ld.global.lu.v4.u32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ ulonglong2 __ldlu(const ulonglong2 *ptr) { ulonglong2 ret; asm ("ld.global.lu.v2.u64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr) : "memory"); return ret; } + +static __attribute__((device)) __inline__ float __ldlu(const float *ptr) { float ret; asm ("ld.global.lu.f32 %0, [%1];" : "=f"(ret) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ double __ldlu(const double *ptr) { double ret; asm ("ld.global.lu.f64 %0, [%1];" : "=d"(ret) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ float2 __ldlu(const float2 *ptr) { float2 ret; asm ("ld.global.lu.v2.f32 {%0,%1}, [%2];" : "=f"(ret.x), "=f"(ret.y) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ float4 __ldlu(const float4 *ptr) { float4 ret; asm ("ld.global.lu.v4.f32 {%0,%1,%2,%3}, [%4];" : "=f"(ret.x), "=f"(ret.y), "=f"(ret.z), "=f"(ret.w) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ double2 __ldlu(const double2 *ptr) { double2 ret; asm ("ld.global.lu.v2.f64 {%0,%1}, [%2];" : "=d"(ret.x), "=d"(ret.y) : "l" (ptr) : "memory"); return ret; } + + + + + + + +static __attribute__((device)) __inline__ long __ldcv(const long *ptr) { unsigned long ret; asm ("ld.global.cv.s64 %0, [%1];" : "=l"(ret) : "l" (ptr) : "memory"); return (long)ret; } +static __attribute__((device)) __inline__ unsigned long __ldcv(const unsigned long *ptr) { unsigned long ret; asm ("ld.global.cv.u64 %0, [%1];" : "=l"(ret) : "l" (ptr) : "memory"); return ret; } + + + + + + +static __attribute__((device)) __inline__ char __ldcv(const char *ptr) { unsigned int ret; asm ("ld.global.cv.s8 %0, [%1];" : "=r"(ret) : "l" (ptr) : "memory"); return (char)ret; } +static __attribute__((device)) __inline__ signed char __ldcv(const signed char *ptr) { unsigned int ret; asm ("ld.global.cv.s8 %0, [%1];" : "=r"(ret) : "l" (ptr) : "memory"); return (signed char)ret; } +static __attribute__((device)) __inline__ short __ldcv(const short *ptr) { unsigned short ret; asm ("ld.global.cv.s16 %0, [%1];" : "=h"(ret) : "l" (ptr) : "memory"); return (short)ret; } +static __attribute__((device)) __inline__ int __ldcv(const int *ptr) { unsigned int ret; asm ("ld.global.cv.s32 %0, [%1];" : "=r"(ret) : "l" (ptr) : "memory"); return (int)ret; } +static __attribute__((device)) __inline__ long long __ldcv(const long long *ptr) { unsigned long long ret; asm ("ld.global.cv.s64 %0, [%1];" : "=l"(ret) : "l" (ptr) : "memory"); return (long long)ret; } +static __attribute__((device)) __inline__ char2 __ldcv(const char2 *ptr) { char2 ret; int2 tmp; asm ("ld.global.cv.v2.s8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr) : "memory"); ret.x = (char)tmp.x; ret.y = (char)tmp.y; return ret; } +static __attribute__((device)) __inline__ char4 __ldcv(const char4 *ptr) { char4 ret; int4 tmp; asm ("ld.global.cv.v4.s8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr) : "memory"); ret.x = (char)tmp.x; ret.y = (char)tmp.y; ret.z = (char)tmp.z; ret.w = (char)tmp.w; return ret; } +static __attribute__((device)) __inline__ short2 __ldcv(const short2 *ptr) { short2 ret; asm ("ld.global.cv.v2.s16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ short4 __ldcv(const short4 *ptr) { short4 ret; asm ("ld.global.cv.v4.s16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ int2 __ldcv(const int2 *ptr) { int2 ret; asm ("ld.global.cv.v2.s32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ int4 __ldcv(const int4 *ptr) { int4 ret; asm ("ld.global.cv.v4.s32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ longlong2 __ldcv(const longlong2 *ptr) { longlong2 ret; asm ("ld.global.cv.v2.s64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr) : "memory"); return ret; } + +static __attribute__((device)) __inline__ unsigned char __ldcv(const unsigned char *ptr) { unsigned int ret; asm ("ld.global.cv.u8 %0, [%1];" : "=r"(ret) : "l" (ptr) : "memory"); return (unsigned char)ret; } +static __attribute__((device)) __inline__ unsigned short __ldcv(const unsigned short *ptr) { unsigned short ret; asm ("ld.global.cv.u16 %0, [%1];" : "=h"(ret) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ unsigned int __ldcv(const unsigned int *ptr) { unsigned int ret; asm ("ld.global.cv.u32 %0, [%1];" : "=r"(ret) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ unsigned long long __ldcv(const unsigned long long *ptr) { unsigned long long ret; asm ("ld.global.cv.u64 %0, [%1];" : "=l"(ret) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ uchar2 __ldcv(const uchar2 *ptr) { uchar2 ret; uint2 tmp; asm ("ld.global.cv.v2.u8 {%0,%1}, [%2];" : "=r"(tmp.x), "=r"(tmp.y) : "l" (ptr) : "memory"); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; return ret; } +static __attribute__((device)) __inline__ uchar4 __ldcv(const uchar4 *ptr) { uchar4 ret; uint4 tmp; asm ("ld.global.cv.v4.u8 {%0,%1,%2,%3}, [%4];" : "=r"(tmp.x), "=r"(tmp.y), "=r"(tmp.z), "=r"(tmp.w) : "l" (ptr) : "memory"); ret.x = (unsigned char)tmp.x; ret.y = (unsigned char)tmp.y; ret.z = (unsigned char)tmp.z; ret.w = (unsigned char)tmp.w; return ret; } +static __attribute__((device)) __inline__ ushort2 __ldcv(const ushort2 *ptr) { ushort2 ret; asm ("ld.global.cv.v2.u16 {%0,%1}, [%2];" : "=h"(ret.x), "=h"(ret.y) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ ushort4 __ldcv(const ushort4 *ptr) { ushort4 ret; asm ("ld.global.cv.v4.u16 {%0,%1,%2,%3}, [%4];" : "=h"(ret.x), "=h"(ret.y), "=h"(ret.z), "=h"(ret.w) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ uint2 __ldcv(const uint2 *ptr) { uint2 ret; asm ("ld.global.cv.v2.u32 {%0,%1}, [%2];" : "=r"(ret.x), "=r"(ret.y) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ uint4 __ldcv(const uint4 *ptr) { uint4 ret; asm ("ld.global.cv.v4.u32 {%0,%1,%2,%3}, [%4];" : "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ ulonglong2 __ldcv(const ulonglong2 *ptr) { ulonglong2 ret; asm ("ld.global.cv.v2.u64 {%0,%1}, [%2];" : "=l"(ret.x), "=l"(ret.y) : "l" (ptr) : "memory"); return ret; } + +static __attribute__((device)) __inline__ float __ldcv(const float *ptr) { float ret; asm ("ld.global.cv.f32 %0, [%1];" : "=f"(ret) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ double __ldcv(const double *ptr) { double ret; asm ("ld.global.cv.f64 %0, [%1];" : "=d"(ret) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ float2 __ldcv(const float2 *ptr) { float2 ret; asm ("ld.global.cv.v2.f32 {%0,%1}, [%2];" : "=f"(ret.x), "=f"(ret.y) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ float4 __ldcv(const float4 *ptr) { float4 ret; asm ("ld.global.cv.v4.f32 {%0,%1,%2,%3}, [%4];" : "=f"(ret.x), "=f"(ret.y), "=f"(ret.z), "=f"(ret.w) : "l" (ptr) : "memory"); return ret; } +static __attribute__((device)) __inline__ double2 __ldcv(const double2 *ptr) { double2 ret; asm ("ld.global.cv.v2.f64 {%0,%1}, [%2];" : "=d"(ret.x), "=d"(ret.y) : "l" (ptr) : "memory"); return ret; } + + + + + + + +static __attribute__((device)) __inline__ void __stwb(long *ptr, long value) { asm ("st.global.wb.s64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(unsigned long *ptr, unsigned long value) { asm ("st.global.wb.u64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } + + + + + + +static __attribute__((device)) __inline__ void __stwb(char *ptr, char value) { asm ("st.global.wb.s8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(signed char *ptr, signed char value) { asm ("st.global.wb.s8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(short *ptr, short value) { asm ("st.global.wb.s16 [%0], %1;" :: "l" (ptr), "h"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(int *ptr, int value) { asm ("st.global.wb.s32 [%0], %1;" :: "l" (ptr), "r"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(long long *ptr, long long value) { asm ("st.global.wb.s64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(char2 *ptr, char2 value) { const int x = value.x, y = value.y; asm ("st.global.wb.v2.s8 [%0], {%1,%2};" :: "l" (ptr), "r"(x), "r"(y) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(char4 *ptr, char4 value) { const int x = value.x, y = value.y, z = value.z, w = value.w; asm ("st.global.wb.v4.s8 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(x), "r"(y), "r"(z), "r"(w) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(short2 *ptr, short2 value) { asm ("st.global.wb.v2.s16 [%0], {%1,%2};" :: "l" (ptr), "h"(value.x), "h"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(short4 *ptr, short4 value) { asm ("st.global.wb.v4.s16 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "h"(value.x), "h"(value.y), "h"(value.z), "h"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(int2 *ptr, int2 value) { asm ("st.global.wb.v2.s32 [%0], {%1,%2};" :: "l" (ptr), "r"(value.x), "r"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(int4 *ptr, int4 value) { asm ("st.global.wb.v4.s32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(value.x), "r"(value.y), "r"(value.z), "r"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(longlong2 *ptr, longlong2 value) { asm ("st.global.wb.v2.s64 [%0], {%1,%2};" :: "l" (ptr), "l"(value.x), "l"(value.y) : "memory"); } + +static __attribute__((device)) __inline__ void __stwb(unsigned char *ptr, unsigned char value) { asm ("st.global.wb.u8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(unsigned short *ptr, unsigned short value) { asm ("st.global.wb.u16 [%0], %1;" :: "l" (ptr), "h"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(unsigned int *ptr, unsigned int value) { asm ("st.global.wb.u32 [%0], %1;" :: "l" (ptr), "r"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(unsigned long long *ptr, unsigned long long value) { asm ("st.global.wb.u64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(uchar2 *ptr, uchar2 value) { const int x = value.x, y = value.y; asm ("st.global.wb.v2.u8 [%0], {%1,%2};" :: "l" (ptr), "r"(x), "r"(y) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(uchar4 *ptr, uchar4 value) { const int x = value.x, y = value.y, z = value.z, w = value.w; asm ("st.global.wb.v4.u8 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(x), "r"(y), "r"(z), "r"(w) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(ushort2 *ptr, ushort2 value) { asm ("st.global.wb.v2.u16 [%0], {%1,%2};" :: "l" (ptr), "h"(value.x), "h"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(ushort4 *ptr, ushort4 value) { asm ("st.global.wb.v4.u16 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "h"(value.x), "h"(value.y), "h"(value.z), "h"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(uint2 *ptr, uint2 value) { asm ("st.global.wb.v2.u32 [%0], {%1,%2};" :: "l" (ptr), "r"(value.x), "r"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(uint4 *ptr, uint4 value) { asm ("st.global.wb.v4.u32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(value.x), "r"(value.y), "r"(value.z), "r"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(ulonglong2 *ptr, ulonglong2 value) { asm ("st.global.wb.v2.u64 [%0], {%1,%2};" :: "l" (ptr), "l"(value.x), "l"(value.y) : "memory"); } + +static __attribute__((device)) __inline__ void __stwb(float *ptr, float value) { asm ("st.global.wb.f32 [%0], %1;" :: "l" (ptr), "f"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(double *ptr, double value) { asm ("st.global.wb.f64 [%0], %1;" :: "l" (ptr), "d"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(float2 *ptr, float2 value) { asm ("st.global.wb.v2.f32 [%0], {%1,%2};" :: "l" (ptr), "f"(value.x), "f"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(float4 *ptr, float4 value) { asm ("st.global.wb.v4.f32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "f"(value.x), "f"(value.y), "f"(value.z), "f"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stwb(double2 *ptr, double2 value) { asm ("st.global.wb.v2.f64 [%0], {%1,%2};" :: "l" (ptr), "d"(value.x), "d"(value.y) : "memory"); } + + + + + + + +static __attribute__((device)) __inline__ void __stcg(long *ptr, long value) { asm ("st.global.cg.s64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(unsigned long *ptr, unsigned long value) { asm ("st.global.cg.u64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } + + + + + + +static __attribute__((device)) __inline__ void __stcg(char *ptr, char value) { asm ("st.global.cg.s8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(signed char *ptr, signed char value) { asm ("st.global.cg.s8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(short *ptr, short value) { asm ("st.global.cg.s16 [%0], %1;" :: "l" (ptr), "h"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(int *ptr, int value) { asm ("st.global.cg.s32 [%0], %1;" :: "l" (ptr), "r"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(long long *ptr, long long value) { asm ("st.global.cg.s64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(char2 *ptr, char2 value) { const int x = value.x, y = value.y; asm ("st.global.cg.v2.s8 [%0], {%1,%2};" :: "l" (ptr), "r"(x), "r"(y) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(char4 *ptr, char4 value) { const int x = value.x, y = value.y, z = value.z, w = value.w; asm ("st.global.cg.v4.s8 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(x), "r"(y), "r"(z), "r"(w) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(short2 *ptr, short2 value) { asm ("st.global.cg.v2.s16 [%0], {%1,%2};" :: "l" (ptr), "h"(value.x), "h"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(short4 *ptr, short4 value) { asm ("st.global.cg.v4.s16 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "h"(value.x), "h"(value.y), "h"(value.z), "h"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(int2 *ptr, int2 value) { asm ("st.global.cg.v2.s32 [%0], {%1,%2};" :: "l" (ptr), "r"(value.x), "r"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(int4 *ptr, int4 value) { asm ("st.global.cg.v4.s32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(value.x), "r"(value.y), "r"(value.z), "r"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(longlong2 *ptr, longlong2 value) { asm ("st.global.cg.v2.s64 [%0], {%1,%2};" :: "l" (ptr), "l"(value.x), "l"(value.y) : "memory"); } + +static __attribute__((device)) __inline__ void __stcg(unsigned char *ptr, unsigned char value) { asm ("st.global.cg.u8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(unsigned short *ptr, unsigned short value) { asm ("st.global.cg.u16 [%0], %1;" :: "l" (ptr), "h"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(unsigned int *ptr, unsigned int value) { asm ("st.global.cg.u32 [%0], %1;" :: "l" (ptr), "r"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(unsigned long long *ptr, unsigned long long value) { asm ("st.global.cg.u64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(uchar2 *ptr, uchar2 value) { const int x = value.x, y = value.y; asm ("st.global.cg.v2.u8 [%0], {%1,%2};" :: "l" (ptr), "r"(x), "r"(y) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(uchar4 *ptr, uchar4 value) { const int x = value.x, y = value.y, z = value.z, w = value.w; asm ("st.global.cg.v4.u8 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(x), "r"(y), "r"(z), "r"(w) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(ushort2 *ptr, ushort2 value) { asm ("st.global.cg.v2.u16 [%0], {%1,%2};" :: "l" (ptr), "h"(value.x), "h"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(ushort4 *ptr, ushort4 value) { asm ("st.global.cg.v4.u16 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "h"(value.x), "h"(value.y), "h"(value.z), "h"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(uint2 *ptr, uint2 value) { asm ("st.global.cg.v2.u32 [%0], {%1,%2};" :: "l" (ptr), "r"(value.x), "r"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(uint4 *ptr, uint4 value) { asm ("st.global.cg.v4.u32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(value.x), "r"(value.y), "r"(value.z), "r"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(ulonglong2 *ptr, ulonglong2 value) { asm ("st.global.cg.v2.u64 [%0], {%1,%2};" :: "l" (ptr), "l"(value.x), "l"(value.y) : "memory"); } + +static __attribute__((device)) __inline__ void __stcg(float *ptr, float value) { asm ("st.global.cg.f32 [%0], %1;" :: "l" (ptr), "f"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(double *ptr, double value) { asm ("st.global.cg.f64 [%0], %1;" :: "l" (ptr), "d"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(float2 *ptr, float2 value) { asm ("st.global.cg.v2.f32 [%0], {%1,%2};" :: "l" (ptr), "f"(value.x), "f"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(float4 *ptr, float4 value) { asm ("st.global.cg.v4.f32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "f"(value.x), "f"(value.y), "f"(value.z), "f"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stcg(double2 *ptr, double2 value) { asm ("st.global.cg.v2.f64 [%0], {%1,%2};" :: "l" (ptr), "d"(value.x), "d"(value.y) : "memory"); } + + + + + + + +static __attribute__((device)) __inline__ void __stcs(long *ptr, long value) { asm ("st.global.cs.s64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(unsigned long *ptr, unsigned long value) { asm ("st.global.cs.u64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } + + + + + + +static __attribute__((device)) __inline__ void __stcs(char *ptr, char value) { asm ("st.global.cs.s8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(signed char *ptr, signed char value) { asm ("st.global.cs.s8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(short *ptr, short value) { asm ("st.global.cs.s16 [%0], %1;" :: "l" (ptr), "h"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(int *ptr, int value) { asm ("st.global.cs.s32 [%0], %1;" :: "l" (ptr), "r"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(long long *ptr, long long value) { asm ("st.global.cs.s64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(char2 *ptr, char2 value) { const int x = value.x, y = value.y; asm ("st.global.cs.v2.s8 [%0], {%1,%2};" :: "l" (ptr), "r"(x), "r"(y) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(char4 *ptr, char4 value) { const int x = value.x, y = value.y, z = value.z, w = value.w; asm ("st.global.cs.v4.s8 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(x), "r"(y), "r"(z), "r"(w) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(short2 *ptr, short2 value) { asm ("st.global.cs.v2.s16 [%0], {%1,%2};" :: "l" (ptr), "h"(value.x), "h"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(short4 *ptr, short4 value) { asm ("st.global.cs.v4.s16 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "h"(value.x), "h"(value.y), "h"(value.z), "h"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(int2 *ptr, int2 value) { asm ("st.global.cs.v2.s32 [%0], {%1,%2};" :: "l" (ptr), "r"(value.x), "r"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(int4 *ptr, int4 value) { asm ("st.global.cs.v4.s32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(value.x), "r"(value.y), "r"(value.z), "r"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(longlong2 *ptr, longlong2 value) { asm ("st.global.cs.v2.s64 [%0], {%1,%2};" :: "l" (ptr), "l"(value.x), "l"(value.y) : "memory"); } + +static __attribute__((device)) __inline__ void __stcs(unsigned char *ptr, unsigned char value) { asm ("st.global.cs.u8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(unsigned short *ptr, unsigned short value) { asm ("st.global.cs.u16 [%0], %1;" :: "l" (ptr), "h"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(unsigned int *ptr, unsigned int value) { asm ("st.global.cs.u32 [%0], %1;" :: "l" (ptr), "r"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(unsigned long long *ptr, unsigned long long value) { asm ("st.global.cs.u64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(uchar2 *ptr, uchar2 value) { const int x = value.x, y = value.y; asm ("st.global.cs.v2.u8 [%0], {%1,%2};" :: "l" (ptr), "r"(x), "r"(y) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(uchar4 *ptr, uchar4 value) { const int x = value.x, y = value.y, z = value.z, w = value.w; asm ("st.global.cs.v4.u8 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(x), "r"(y), "r"(z), "r"(w) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(ushort2 *ptr, ushort2 value) { asm ("st.global.cs.v2.u16 [%0], {%1,%2};" :: "l" (ptr), "h"(value.x), "h"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(ushort4 *ptr, ushort4 value) { asm ("st.global.cs.v4.u16 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "h"(value.x), "h"(value.y), "h"(value.z), "h"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(uint2 *ptr, uint2 value) { asm ("st.global.cs.v2.u32 [%0], {%1,%2};" :: "l" (ptr), "r"(value.x), "r"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(uint4 *ptr, uint4 value) { asm ("st.global.cs.v4.u32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(value.x), "r"(value.y), "r"(value.z), "r"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(ulonglong2 *ptr, ulonglong2 value) { asm ("st.global.cs.v2.u64 [%0], {%1,%2};" :: "l" (ptr), "l"(value.x), "l"(value.y) : "memory"); } + +static __attribute__((device)) __inline__ void __stcs(float *ptr, float value) { asm ("st.global.cs.f32 [%0], %1;" :: "l" (ptr), "f"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(double *ptr, double value) { asm ("st.global.cs.f64 [%0], %1;" :: "l" (ptr), "d"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(float2 *ptr, float2 value) { asm ("st.global.cs.v2.f32 [%0], {%1,%2};" :: "l" (ptr), "f"(value.x), "f"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(float4 *ptr, float4 value) { asm ("st.global.cs.v4.f32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "f"(value.x), "f"(value.y), "f"(value.z), "f"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stcs(double2 *ptr, double2 value) { asm ("st.global.cs.v2.f64 [%0], {%1,%2};" :: "l" (ptr), "d"(value.x), "d"(value.y) : "memory"); } + + + + + + + +static __attribute__((device)) __inline__ void __stwt(long *ptr, long value) { asm ("st.global.wt.s64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(unsigned long *ptr, unsigned long value) { asm ("st.global.wt.u64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } + + + + + + +static __attribute__((device)) __inline__ void __stwt(char *ptr, char value) { asm ("st.global.wt.s8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(signed char *ptr, signed char value) { asm ("st.global.wt.s8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(short *ptr, short value) { asm ("st.global.wt.s16 [%0], %1;" :: "l" (ptr), "h"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(int *ptr, int value) { asm ("st.global.wt.s32 [%0], %1;" :: "l" (ptr), "r"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(long long *ptr, long long value) { asm ("st.global.wt.s64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(char2 *ptr, char2 value) { const int x = value.x, y = value.y; asm ("st.global.wt.v2.s8 [%0], {%1,%2};" :: "l" (ptr), "r"(x), "r"(y) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(char4 *ptr, char4 value) { const int x = value.x, y = value.y, z = value.z, w = value.w; asm ("st.global.wt.v4.s8 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(x), "r"(y), "r"(z), "r"(w) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(short2 *ptr, short2 value) { asm ("st.global.wt.v2.s16 [%0], {%1,%2};" :: "l" (ptr), "h"(value.x), "h"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(short4 *ptr, short4 value) { asm ("st.global.wt.v4.s16 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "h"(value.x), "h"(value.y), "h"(value.z), "h"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(int2 *ptr, int2 value) { asm ("st.global.wt.v2.s32 [%0], {%1,%2};" :: "l" (ptr), "r"(value.x), "r"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(int4 *ptr, int4 value) { asm ("st.global.wt.v4.s32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(value.x), "r"(value.y), "r"(value.z), "r"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(longlong2 *ptr, longlong2 value) { asm ("st.global.wt.v2.s64 [%0], {%1,%2};" :: "l" (ptr), "l"(value.x), "l"(value.y) : "memory"); } + +static __attribute__((device)) __inline__ void __stwt(unsigned char *ptr, unsigned char value) { asm ("st.global.wt.u8 [%0], %1;" :: "l" (ptr), "r"((int)value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(unsigned short *ptr, unsigned short value) { asm ("st.global.wt.u16 [%0], %1;" :: "l" (ptr), "h"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(unsigned int *ptr, unsigned int value) { asm ("st.global.wt.u32 [%0], %1;" :: "l" (ptr), "r"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(unsigned long long *ptr, unsigned long long value) { asm ("st.global.wt.u64 [%0], %1;" :: "l" (ptr), "l"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(uchar2 *ptr, uchar2 value) { const int x = value.x, y = value.y; asm ("st.global.wt.v2.u8 [%0], {%1,%2};" :: "l" (ptr), "r"(x), "r"(y) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(uchar4 *ptr, uchar4 value) { const int x = value.x, y = value.y, z = value.z, w = value.w; asm ("st.global.wt.v4.u8 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(x), "r"(y), "r"(z), "r"(w) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(ushort2 *ptr, ushort2 value) { asm ("st.global.wt.v2.u16 [%0], {%1,%2};" :: "l" (ptr), "h"(value.x), "h"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(ushort4 *ptr, ushort4 value) { asm ("st.global.wt.v4.u16 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "h"(value.x), "h"(value.y), "h"(value.z), "h"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(uint2 *ptr, uint2 value) { asm ("st.global.wt.v2.u32 [%0], {%1,%2};" :: "l" (ptr), "r"(value.x), "r"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(uint4 *ptr, uint4 value) { asm ("st.global.wt.v4.u32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "r"(value.x), "r"(value.y), "r"(value.z), "r"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(ulonglong2 *ptr, ulonglong2 value) { asm ("st.global.wt.v2.u64 [%0], {%1,%2};" :: "l" (ptr), "l"(value.x), "l"(value.y) : "memory"); } + +static __attribute__((device)) __inline__ void __stwt(float *ptr, float value) { asm ("st.global.wt.f32 [%0], %1;" :: "l" (ptr), "f"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(double *ptr, double value) { asm ("st.global.wt.f64 [%0], %1;" :: "l" (ptr), "d"(value) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(float2 *ptr, float2 value) { asm ("st.global.wt.v2.f32 [%0], {%1,%2};" :: "l" (ptr), "f"(value.x), "f"(value.y) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(float4 *ptr, float4 value) { asm ("st.global.wt.v4.f32 [%0], {%1,%2,%3,%4};" :: "l" (ptr), "f"(value.x), "f"(value.y), "f"(value.z), "f"(value.w) : "memory"); } +static __attribute__((device)) __inline__ void __stwt(double2 *ptr, double2 value) { asm ("st.global.wt.v2.f64 [%0], {%1,%2};" :: "l" (ptr), "d"(value.x), "d"(value.y) : "memory"); } +# 553 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.hpp" +static __attribute__((device)) __inline__ unsigned int __funnelshift_l(unsigned int lo, unsigned int hi, unsigned int shift) +{ + unsigned int ret; + asm volatile ("shf.l.wrap.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(lo), "r"(hi), "r"(shift)); + return ret; +} +static __attribute__((device)) __inline__ unsigned int __funnelshift_lc(unsigned int lo, unsigned int hi, unsigned int shift) +{ + unsigned int ret; + asm volatile ("shf.l.clamp.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(lo), "r"(hi), "r"(shift)); + return ret; +} + + +static __attribute__((device)) __inline__ unsigned int __funnelshift_r(unsigned int lo, unsigned int hi, unsigned int shift) +{ + unsigned int ret; + asm volatile ("shf.r.wrap.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(lo), "r"(hi), "r"(shift)); + return ret; +} +static __attribute__((device)) __inline__ unsigned int __funnelshift_rc(unsigned int lo, unsigned int hi, unsigned int shift) +{ + unsigned int ret; + asm volatile ("shf.r.clamp.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(lo), "r"(hi), "r"(shift)); + return ret; +} +# 513 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" 2 +# 2911 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_35_intrinsics.h" 1 +# 2912 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" 1 +# 235 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.hpp" 1 +# 236 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" 2 +# 2913 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" 1 +# 128 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.hpp" 1 +# 129 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" 2 +# 2914 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" 1 +# 156 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.hpp" 1 +# 157 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" 2 +# 2915 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" 1 +# 273 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.hpp" 1 +# 274 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" 2 +# 2916 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" 1 +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.hpp" 1 +# 245 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" 2 +# 2917 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" 1 +# 65 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template struct __nv_itex_trait { }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1Dfetch(T *ptr, cudaTextureObject_t obj, int x) +{ + __nv_tex_surf_handler("__itex1Dfetch", ptr, obj, x); +} + +template +static __attribute__((device)) T tex1Dfetch(cudaTextureObject_t texObject, int x) +{ + T ret; + tex1Dfetch(&ret, texObject, x); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1D(T *ptr, cudaTextureObject_t obj, float x) +{ + __nv_tex_surf_handler("__itex1D", ptr, obj, x); +} + + +template +static __attribute__((device)) T tex1D(cudaTextureObject_t texObject, float x) +{ + T ret; + tex1D(&ret, texObject, x); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2D(T *ptr, cudaTextureObject_t obj, float x, float y) +{ + __nv_tex_surf_handler("__itex2D", ptr, obj, x, y); +} + +template +static __attribute__((device)) T tex2D(cudaTextureObject_t texObject, float x, float y) +{ + T ret; + tex2D(&ret, texObject, x, y); + return ret; +} +# 173 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template +static __attribute__((device)) typename __nv_itex_trait::type tex3D(T *ptr, cudaTextureObject_t obj, float x, float y, float z) +{ + __nv_tex_surf_handler("__itex3D", ptr, obj, x, y, z); +} + +template +static __attribute__((device)) T tex3D(cudaTextureObject_t texObject, float x, float y, float z) +{ + T ret; + tex3D(&ret, texObject, x, y, z); + return ret; +} +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DLayered(T *ptr, cudaTextureObject_t obj, float x, int layer) +{ + __nv_tex_surf_handler("__itex1DLayered", ptr, obj, x, layer); +} + +template +static __attribute__((device)) T tex1DLayered(cudaTextureObject_t texObject, float x, int layer) +{ + T ret; + tex1DLayered(&ret, texObject, x, layer); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayered(T *ptr, cudaTextureObject_t obj, float x, float y, int layer) +{ + __nv_tex_surf_handler("__itex2DLayered", ptr, obj, x, y, layer); +} + +template +static __attribute__((device)) T tex2DLayered(cudaTextureObject_t texObject, float x, float y, int layer) +{ + T ret; + tex2DLayered(&ret, texObject, x, y, layer); + return ret; +} +# 254 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemap(T *ptr, cudaTextureObject_t obj, float x, float y, float z) +{ + __nv_tex_surf_handler("__itexCubemap", ptr, obj, x, y, z); +} + + +template +static __attribute__((device)) T texCubemap(cudaTextureObject_t texObject, float x, float y, float z) +{ + T ret; + texCubemap(&ret, texObject, x, y, z); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapLayered(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer) +{ + __nv_tex_surf_handler("__itexCubemapLayered", ptr, obj, x, y, z, layer); +} + +template +static __attribute__((device)) T texCubemapLayered(cudaTextureObject_t texObject, float x, float y, float z, int layer) +{ + T ret; + texCubemapLayered(&ret, texObject, x, y, z, layer); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2Dgather(T *ptr, cudaTextureObject_t obj, float x, float y, int comp = 0) +{ + __nv_tex_surf_handler("__itex2Dgather", ptr, obj, x, y, comp); +} + +template +static __attribute__((device)) T tex2Dgather(cudaTextureObject_t to, float x, float y, int comp = 0) +{ + T ret; + tex2Dgather(&ret, to, x, y, comp); + return ret; +} +# 317 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DLod(T *ptr, cudaTextureObject_t obj, float x, float level) +{ + __nv_tex_surf_handler("__itex1DLod", ptr, obj, x, level); +} + +template +static __attribute__((device)) T tex1DLod(cudaTextureObject_t texObject, float x, float level) +{ + T ret; + tex1DLod(&ret, texObject, x, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float level) +{ + __nv_tex_surf_handler("__itex2DLod", ptr, obj, x, y, level); +} + +template +static __attribute__((device)) T tex2DLod(cudaTextureObject_t texObject, float x, float y, float level) +{ + T ret; + tex2DLod(&ret, texObject, x, y, level); + return ret; +} +# 367 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template +static __attribute__((device)) typename __nv_itex_trait::type tex3DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level) +{ + __nv_tex_surf_handler("__itex3DLod", ptr, obj, x, y, z, level); +} + +template +static __attribute__((device)) T tex3DLod(cudaTextureObject_t texObject, float x, float y, float z, float level) +{ + T ret; + tex3DLod(&ret, texObject, x, y, z, level); + return ret; +} +# 401 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, int layer, float level) +{ + __nv_tex_surf_handler("__itex1DLayeredLod", ptr, obj, x, layer, level); +} + +template +static __attribute__((device)) T tex1DLayeredLod(cudaTextureObject_t texObject, float x, int layer, float level) +{ + T ret; + tex1DLayeredLod(&ret, texObject, x, layer, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, float level) +{ + __nv_tex_surf_handler("__itex2DLayeredLod", ptr, obj, x, y, layer, level); +} + +template +static __attribute__((device)) T tex2DLayeredLod(cudaTextureObject_t texObject, float x, float y, int layer, float level) +{ + T ret; + tex2DLayeredLod(&ret, texObject, x, y, layer, level); + return ret; +} +# 448 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level) +{ + __nv_tex_surf_handler("__itexCubemapLod", ptr, obj, x, y, z, level); +} + +template +static __attribute__((device)) T texCubemapLod(cudaTextureObject_t texObject, float x, float y, float z, float level) +{ + T ret; + texCubemapLod(&ret, texObject, x, y, z, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + __nv_tex_surf_handler("__itexCubemapGrad_v2", ptr, obj, x, y, z, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T texCubemapGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + T ret; + texCubemapGrad(&ret, texObject, x, y, z, dPdx, dPdy); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer, float level) +{ + __nv_tex_surf_handler("__itexCubemapLayeredLod", ptr, obj, x, y, z, layer, level); +} + +template +static __attribute__((device)) T texCubemapLayeredLod(cudaTextureObject_t texObject, float x, float y, float z, int layer, float level) +{ + T ret; + texCubemapLayeredLod(&ret, texObject, x, y, z, layer, level); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DGrad(T *ptr, cudaTextureObject_t obj, float x, float dPdx, float dPdy) +{ + __nv_tex_surf_handler("__itex1DGrad", ptr, obj, x, dPdx, dPdy); +} + +template +static __attribute__((device)) T tex1DGrad(cudaTextureObject_t texObject, float x, float dPdx, float dPdy) +{ + T ret; + tex1DGrad(&ret, texObject, x, dPdx, dPdy); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float2 dPdx, float2 dPdy) +{ + __nv_tex_surf_handler("__itex2DGrad_v2", ptr, obj, x, y, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T tex2DGrad(cudaTextureObject_t texObject, float x, float y, float2 dPdx, float2 dPdy) +{ + T ret; + tex2DGrad(&ret, texObject, x, y, dPdx, dPdy); + return ret; +} +# 539 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template +static __attribute__((device)) typename __nv_itex_trait::type tex3DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + __nv_tex_surf_handler("__itex3DGrad_v2", ptr, obj, x, y, z, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T tex3DGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + T ret; + tex3DGrad(&ret, texObject, x, y, z, dPdx, dPdy); + return ret; +} +# 573 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DLayeredGrad(T *ptr, cudaTextureObject_t obj, float x, int layer, float dPdx, float dPdy) +{ + __nv_tex_surf_handler("__itex1DLayeredGrad", ptr, obj, x, layer, dPdx, dPdy); +} + +template +static __attribute__((device)) T tex1DLayeredGrad(cudaTextureObject_t texObject, float x, int layer, float dPdx, float dPdy) +{ + T ret; + tex1DLayeredGrad(&ret, texObject, x, layer, dPdx, dPdy); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayeredGrad(T * ptr, cudaTextureObject_t obj, float x, float y, int layer, float2 dPdx, float2 dPdy) +{ + __nv_tex_surf_handler("__itex2DLayeredGrad_v2", ptr, obj, x, y, layer, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T tex2DLayeredGrad(cudaTextureObject_t texObject, float x, float y, int layer, float2 dPdx, float2 dPdy) +{ + T ret; + tex2DLayeredGrad(&ret, texObject, x, y, layer, dPdx, dPdy); + return ret; +} +# 621 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapLayeredGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer, float4 dPdx, float4 dPdy) +{ + __nv_tex_surf_handler("__itexCubemapLayeredGrad_v2", ptr, obj, x, y, z, layer, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T texCubemapLayeredGrad(cudaTextureObject_t texObject, float x, float y, float z, int layer, float4 dPdx, float4 dPdy) +{ + T ret; + texCubemapLayeredGrad(&ret, texObject, x, y, z, layer, dPdx, dPdy); + return ret; +} +# 2919 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" 1 +# 58 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template struct __nv_isurf_trait { }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; + +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; + +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; + + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf1Dread(T *ptr, cudaSurfaceObject_t obj, int x, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf1Dread", ptr, obj, x, mode); +} + +template +static __attribute__((device)) T surf1Dread(cudaSurfaceObject_t surfObject, int x, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf1Dread(&ret, surfObject, x, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf2Dread(T *ptr, cudaSurfaceObject_t obj, int x, int y, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf2Dread", ptr, obj, x, y, mode); +} + +template +static __attribute__((device)) T surf2Dread(cudaSurfaceObject_t surfObject, int x, int y, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf2Dread(&ret, surfObject, x, y, boundaryMode); + return ret; +} + + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf3Dread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int z, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf3Dread", ptr, obj, x, y, z, mode); +} + +template +static __attribute__((device)) T surf3Dread(cudaSurfaceObject_t surfObject, int x, int y, int z, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf3Dread(&ret, surfObject, x, y, z, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf1DLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf1DLayeredread", ptr, obj, x, layer, mode); +} + +template +static __attribute__((device)) T surf1DLayeredread(cudaSurfaceObject_t surfObject, int x, int layer, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf1DLayeredread(&ret, surfObject, x, layer, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf2DLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf2DLayeredread", ptr, obj, x, y, layer, mode); +} + +template +static __attribute__((device)) T surf2DLayeredread(cudaSurfaceObject_t surfObject, int x, int y, int layer, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf2DLayeredread(&ret, surfObject, x, y, layer, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surfCubemapread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int face, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurfCubemapread", ptr, obj, x, y, face, mode); +} + +template +static __attribute__((device)) T surfCubemapread(cudaSurfaceObject_t surfObject, int x, int y, int face, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surfCubemapread(&ret, surfObject, x, y, face, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surfCubemapLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int layerface, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurfCubemapLayeredread", ptr, obj, x, y, layerface, mode); +} + +template +static __attribute__((device)) T surfCubemapLayeredread(cudaSurfaceObject_t surfObject, int x, int y, int layerface, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surfCubemapLayeredread(&ret, surfObject, x, y, layerface, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf1Dwrite(T val, cudaSurfaceObject_t obj, int x, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf1Dwrite_v2", &val, obj, x, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf2Dwrite(T val, cudaSurfaceObject_t obj, int x, int y, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf2Dwrite_v2", &val, obj, x, y, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf3Dwrite(T val, cudaSurfaceObject_t obj, int x, int y, int z, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf3Dwrite_v2", &val, obj, x, y, z, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf1DLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf1DLayeredwrite_v2", &val, obj, x, layer, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf2DLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int y, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf2DLayeredwrite_v2", &val, obj, x, y, layer, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surfCubemapwrite(T val, cudaSurfaceObject_t obj, int x, int y, int face, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurfCubemapwrite_v2", &val, obj, x, y, face, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surfCubemapLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int y, int layerface, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurfCubemapLayeredwrite_v2", &val, obj, x, y, layerface, mode); +} +# 2920 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/cudacc_ext.h" 1 +# 2922 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 + + +extern "C" __attribute__((host)) __attribute__((device)) unsigned __cudaPushCallConfiguration(dim3 gridDim, + dim3 blockDim, + size_t sharedMem = 0, + struct CUstream_st *stream = 0); +# 2969 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +enum { + __NV_ATOMIC_RELAXED, + __NV_ATOMIC_CONSUME, + __NV_ATOMIC_ACQUIRE, + __NV_ATOMIC_RELEASE, + __NV_ATOMIC_ACQ_REL, + __NV_ATOMIC_SEQ_CST +}; + +enum { + __NV_THREAD_SCOPE_THREAD, + __NV_THREAD_SCOPE_BLOCK, + __NV_THREAD_SCOPE_CLUSTER, + __NV_THREAD_SCOPE_DEVICE, + __NV_THREAD_SCOPE_SYSTEM +}; +# 119 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/device_launch_parameters.h" 1 +# 68 "/opt/cuda/bin/../targets/x86_64-linux/include/device_launch_parameters.h" +extern "C" { + + +uint3 __attribute__((device_builtin)) extern const threadIdx; +uint3 __attribute__((device_builtin)) extern const blockIdx; +dim3 __attribute__((device_builtin)) extern const blockDim; +dim3 __attribute__((device_builtin)) extern const gridDim; +int __attribute__((device_builtin)) extern const warpSize; + + + + +} +# 120 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 148 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 1 3 +# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 + +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 1 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 + +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + namespace rel_ops + { +# 86 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 + template + inline bool + operator!=(const _Tp& __x, const _Tp& __y) + { return !(__x == __y); } +# 99 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 + template + inline bool + operator>(const _Tp& __x, const _Tp& __y) + { return __y < __x; } +# 112 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 + template + inline bool + operator<=(const _Tp& __x, const _Tp& __y) + { return !(__y < __x); } +# 125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 + template + inline bool + operator>=(const _Tp& __x, const _Tp& __y) + { return !(__x < __y); } + } + + +} +# 69 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 2 3 + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/initializer_list" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/initializer_list" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/initializer_list" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + template + class initializer_list + { + public: + typedef _E value_type; + typedef const _E& reference; + typedef const _E& const_reference; + typedef size_t size_type; + typedef const _E* iterator; + typedef const _E* const_iterator; + + private: + iterator _M_array; + size_type _M_len; + + + constexpr initializer_list(const_iterator __a, size_type __l) + : _M_array(__a), _M_len(__l) { } + + public: + constexpr initializer_list() noexcept + : _M_array(0), _M_len(0) { } + + + constexpr size_type + size() const noexcept { return _M_len; } + + + constexpr const_iterator + begin() const noexcept { return _M_array; } + + + constexpr const_iterator + end() const noexcept { return begin() + size(); } + }; + + + + + + + + template + constexpr const _Tp* + begin(initializer_list<_Tp> __ils) noexcept + { return __ils.begin(); } + + + + + + + + template + constexpr const _Tp* + end(initializer_list<_Tp> __ils) noexcept + { return __ils.end(); } +} +# 74 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 2 3 +# 96 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 97 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template + + inline _Tp + exchange(_Tp& __obj, _Up&& __new_val) + noexcept(__and_, + is_nothrow_assignable<_Tp&, _Up>>::value) + { return std::__exchange(__obj, std::forward<_Up>(__new_val)); } + + + + template + [[nodiscard]] + constexpr add_const_t<_Tp>& + as_const(_Tp& __t) noexcept + { return __t; } + + template + void as_const(const _Tp&&) = delete; +# 230 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 + +} +# 149 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" + +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchKernel( + T *func, + dim3 gridDim, + dim3 blockDim, + void **args, + size_t sharedMem = 0, + cudaStream_t stream = 0 +) +{ + return ::cudaLaunchKernel((const void *)func, gridDim, blockDim, args, sharedMem, stream); +} +# 279 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchKernelEx( + const cudaLaunchConfig_t *config, + void (*kernel)(ExpTypes...), + ActTypes &&... args +) +{ + return [&](ExpTypes... coercedArgs){ + void *pArgs[] = { &coercedArgs... }; + return ::cudaLaunchKernelExC(config, (const void *)kernel, pArgs); + }(std::forward(args)...); +} +# 348 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchKernelEx( + const cudaLaunchConfig_t *config, + const cudaKernel_t kernel, + ActTypes &&... args +) +{ + void *pArgs[] = { &args... }; + return ::cudaLaunchKernelExC(config, (const void *)kernel, pArgs); +} +# 410 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchCooperativeKernel( + T *func, + dim3 gridDim, + dim3 blockDim, + void **args, + size_t sharedMem = 0, + cudaStream_t stream = 0 +) +{ + return ::cudaLaunchCooperativeKernel((const void *)func, gridDim, blockDim, args, sharedMem, stream); +} +# 454 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaEventCreate( + cudaEvent_t *event, + unsigned int flags +) +{ + return ::cudaEventCreateWithFlags(event, flags); +} +# 498 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaGraphInstantiate( + cudaGraphExec_t *pGraphExec, + cudaGraph_t graph, + cudaGraphNode_t *pErrorNode, + char *pLogBuffer, + size_t bufferSize +) +{ + (void)pErrorNode; + (void)pLogBuffer; + (void)bufferSize; + return ::cudaGraphInstantiate(pGraphExec, graph, 0); +} +# 569 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaMallocHost( + void **ptr, + size_t size, + unsigned int flags +) +{ + return ::cudaHostAlloc(ptr, size, flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaHostAlloc( + T **ptr, + size_t size, + unsigned int flags +) +{ + return ::cudaHostAlloc((void**)(void*)ptr, size, flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaHostGetDevicePointer( + T **pDevice, + void *pHost, + unsigned int flags +) +{ + return ::cudaHostGetDevicePointer((void**)(void*)pDevice, pHost, flags); +} +# 698 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocManaged( + T **devPtr, + size_t size, + unsigned int flags = 0x01 +) +{ + return ::cudaMallocManaged((void**)(void*)devPtr, size, flags); +} +# 716 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +cudaError_t cudaMemAdvise( + T *devPtr, + size_t count, + enum cudaMemoryAdvise advice, + struct cudaMemLocation location +) +{ + return ::cudaMemAdvise_v2((const void *)devPtr, count, advice, location); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMemPrefetchAsync( + T *devPtr, + size_t count, + struct cudaMemLocation location, + unsigned int flags, + cudaStream_t stream = 0 +) +{ + return ::cudaMemPrefetchAsync_v2((const void *)devPtr, count, location, flags, stream); +} +# 819 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaStreamAttachMemAsync( + cudaStream_t stream, + T *devPtr, + size_t length = 0, + unsigned int flags = 0x04 +) +{ + return ::cudaStreamAttachMemAsync(stream, (void*)devPtr, length, flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMalloc( + T **devPtr, + size_t size +) +{ + return ::cudaMalloc((void**)(void*)devPtr, size); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocHost( + T **ptr, + size_t size, + unsigned int flags = 0 +) +{ + return cudaMallocHost((void**)(void*)ptr, size, flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocPitch( + T **devPtr, + size_t *pitch, + size_t width, + size_t height +) +{ + return ::cudaMallocPitch((void**)(void*)devPtr, pitch, width, height); +} +# 869 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaMallocAsync( + void **ptr, + size_t size, + cudaMemPool_t memPool, + cudaStream_t stream +) +{ + return ::cudaMallocFromPoolAsync(ptr, size, memPool, stream); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocAsync( + T **ptr, + size_t size, + cudaMemPool_t memPool, + cudaStream_t stream +) +{ + return ::cudaMallocFromPoolAsync((void**)(void*)ptr, size, memPool, stream); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocAsync( + T **ptr, + size_t size, + cudaStream_t stream +) +{ + return ::cudaMallocAsync((void**)(void*)ptr, size, stream); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocFromPoolAsync( + T **ptr, + size_t size, + cudaMemPool_t memPool, + cudaStream_t stream +) +{ + return ::cudaMallocFromPoolAsync((void**)(void*)ptr, size, memPool, stream); +} +# 919 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyBatchAsync( + T **dsts, U **srcs, size_t *sizes, size_t count, struct cudaMemcpyAttributes *attrs, + size_t *attrsIdxs, size_t numAttrs, size_t *failIdx, cudaStream_t hStream +) +{ + return ::cudaMemcpyBatchAsync((void **)dsts, (void **)srcs, sizes, count, attrs, attrsIdxs, numAttrs, failIdx, hStream); +} +# 938 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyBatchAsync( + T **dsts, U **srcs, size_t *sizes, size_t count, struct cudaMemcpyAttributes attr, size_t *failIdx, cudaStream_t hStream +) +{ + size_t attrsIdxs = 0; + return ::cudaMemcpyBatchAsync((void **)dsts, (void **)srcs, sizes, count, &attr, &attrsIdxs, 1, failIdx, hStream); +} +# 984 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyToSymbol( + const T &symbol, + const void *src, + size_t count, + size_t offset = 0, + enum cudaMemcpyKind kind = cudaMemcpyHostToDevice +) +{ + return ::cudaMemcpyToSymbol((const void*)&symbol, src, count, offset, kind); +} +# 1038 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyToSymbolAsync( + const T &symbol, + const void *src, + size_t count, + size_t offset = 0, + enum cudaMemcpyKind kind = cudaMemcpyHostToDevice, + cudaStream_t stream = 0 +) +{ + return ::cudaMemcpyToSymbolAsync((const void*)&symbol, src, count, offset, kind, stream); +} +# 1086 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyFromSymbol( + void *dst, + const T &symbol, + size_t count, + size_t offset = 0, + enum cudaMemcpyKind kind = cudaMemcpyDeviceToHost +) +{ + return ::cudaMemcpyFromSymbol(dst, (const void*)&symbol, count, offset, kind); +} +# 1140 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyFromSymbolAsync( + void *dst, + const T &symbol, + size_t count, + size_t offset = 0, + enum cudaMemcpyKind kind = cudaMemcpyDeviceToHost, + cudaStream_t stream = 0 +) +{ + return ::cudaMemcpyFromSymbolAsync(dst, (const void*)&symbol, count, offset, kind, stream); +} +# 1209 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphAddMemcpyNodeToSymbol( + cudaGraphNode_t *pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t *pDependencies, + size_t numDependencies, + const T &symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphAddMemcpyNodeToSymbol(pGraphNode, graph, pDependencies, numDependencies, (const void*)&symbol, src, count, offset, kind); +} +# 1280 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphAddMemcpyNodeFromSymbol( + cudaGraphNode_t* pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t* pDependencies, + size_t numDependencies, + void* dst, + const T &symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphAddMemcpyNodeFromSymbol(pGraphNode, graph, pDependencies, numDependencies, dst, (const void*)&symbol, count, offset, kind); +} +# 1331 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParamsToSymbol( + cudaGraphNode_t node, + const T &symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphMemcpyNodeSetParamsToSymbol(node, (const void*)&symbol, src, count, offset, kind); +} +# 1379 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParamsFromSymbol( + cudaGraphNode_t node, + void* dst, + const T &symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphMemcpyNodeSetParamsFromSymbol(node, dst, (const void*)&symbol, count, offset, kind); +} +# 1437 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParamsToSymbol( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + const T &symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphExecMemcpyNodeSetParamsToSymbol(hGraphExec, node, (const void*)&symbol, src, count, offset, kind); +} +# 1496 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParamsFromSymbol( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + void* dst, + const T &symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphExecMemcpyNodeSetParamsFromSymbol(hGraphExec, node, dst, (const void*)&symbol, count, offset, kind); +} + + +static __inline__ __attribute__((host)) cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphNode_t *hErrorNode_out, enum cudaGraphExecUpdateResult *updateResult_out) +{ + cudaGraphExecUpdateResultInfo resultInfo; + cudaError_t status = cudaGraphExecUpdate(hGraphExec, hGraph, &resultInfo); + if (hErrorNode_out) { + *hErrorNode_out = resultInfo.errorNode; + } + if (updateResult_out) { + *updateResult_out = resultInfo.result; + } + return status; +} +# 1549 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaUserObjectCreate( + cudaUserObject_t *object_out, + T *objectToWrap, + unsigned int initialRefcount, + unsigned int flags) +{ + return ::cudaUserObjectCreate( + object_out, + objectToWrap, + [](void *vpObj) { delete reinterpret_cast(vpObj); }, + initialRefcount, + flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaUserObjectCreate( + cudaUserObject_t *object_out, + T *objectToWrap, + unsigned int initialRefcount, + cudaUserObjectFlags flags) +{ + return cudaUserObjectCreate(object_out, objectToWrap, initialRefcount, (unsigned int)flags); +} +# 1599 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetSymbolAddress( + void **devPtr, + const T &symbol +) +{ + return ::cudaGetSymbolAddress(devPtr, (const void*)&symbol); +} +# 1631 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetSymbolSize( + size_t *size, + const T &symbol +) +{ + return ::cudaGetSymbolSize(size, (const void*)&symbol); +} +# 1683 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncSetCacheConfig( + T *func, + enum cudaFuncCache cacheConfig +) +{ + return ::cudaFuncSetCacheConfig((const void*)func, cacheConfig); +} + +template +static __inline__ +__attribute__((deprecated)) +__attribute__((host)) cudaError_t cudaFuncSetSharedMemConfig( + T *func, + enum cudaSharedMemConfig config +) +{ + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + + return ::cudaFuncSetSharedMemConfig((const void*)func, config); + +#pragma GCC diagnostic pop + +} +# 1743 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor( + int *numBlocks, + T func, + int blockSize, + size_t dynamicSMemSize) +{ + return ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, (const void*)func, blockSize, dynamicSMemSize, 0x00); +} +# 1796 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags( + int *numBlocks, + T func, + int blockSize, + size_t dynamicSMemSize, + unsigned int flags) +{ + return ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, (const void*)func, blockSize, dynamicSMemSize, flags); +} + + + + +class __cudaOccupancyB2DHelper { + size_t n; +public: + inline __attribute__((host)) __attribute__((device)) __cudaOccupancyB2DHelper(size_t n_) : n(n_) {} + inline __attribute__((host)) __attribute__((device)) size_t operator()(int) + { + return n; + } +}; +# 1866 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) __attribute__((device)) cudaError_t cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags( + int *minGridSize, + int *blockSize, + T func, + UnaryFunction blockSizeToDynamicSMemSize, + int blockSizeLimit = 0, + unsigned int flags = 0) +{ + cudaError_t status; + + + int device; + struct cudaFuncAttributes attr; + + + int maxThreadsPerMultiProcessor; + int warpSize; + int devMaxThreadsPerBlock; + int multiProcessorCount; + int funcMaxThreadsPerBlock; + int occupancyLimit; + int granularity; + + + int maxBlockSize = 0; + int numBlocks = 0; + int maxOccupancy = 0; + + + int blockSizeToTryAligned; + int blockSizeToTry; + int blockSizeLimitAligned; + int occupancyInBlocks; + int occupancyInThreads; + size_t dynamicSMemSize; + + + + + + if (!minGridSize || !blockSize || !func) { + return cudaErrorInvalidValue; + } + + + + + + status = ::cudaGetDevice(&device); + if (status != cudaSuccess) { + return status; + } + + status = cudaDeviceGetAttribute( + &maxThreadsPerMultiProcessor, + cudaDevAttrMaxThreadsPerMultiProcessor, + device); + if (status != cudaSuccess) { + return status; + } + + status = cudaDeviceGetAttribute( + &warpSize, + cudaDevAttrWarpSize, + device); + if (status != cudaSuccess) { + return status; + } + + status = cudaDeviceGetAttribute( + &devMaxThreadsPerBlock, + cudaDevAttrMaxThreadsPerBlock, + device); + if (status != cudaSuccess) { + return status; + } + + status = cudaDeviceGetAttribute( + &multiProcessorCount, + cudaDevAttrMultiProcessorCount, + device); + if (status != cudaSuccess) { + return status; + } + + status = cudaFuncGetAttributes(&attr, func); + if (status != cudaSuccess) { + return status; + } + + funcMaxThreadsPerBlock = attr.maxThreadsPerBlock; + + + + + + occupancyLimit = maxThreadsPerMultiProcessor; + granularity = warpSize; + + if (blockSizeLimit == 0) { + blockSizeLimit = devMaxThreadsPerBlock; + } + + if (devMaxThreadsPerBlock < blockSizeLimit) { + blockSizeLimit = devMaxThreadsPerBlock; + } + + if (funcMaxThreadsPerBlock < blockSizeLimit) { + blockSizeLimit = funcMaxThreadsPerBlock; + } + + blockSizeLimitAligned = ((blockSizeLimit + (granularity - 1)) / granularity) * granularity; + + for (blockSizeToTryAligned = blockSizeLimitAligned; blockSizeToTryAligned > 0; blockSizeToTryAligned -= granularity) { + + + + if (blockSizeLimit < blockSizeToTryAligned) { + blockSizeToTry = blockSizeLimit; + } else { + blockSizeToTry = blockSizeToTryAligned; + } + + dynamicSMemSize = blockSizeToDynamicSMemSize(blockSizeToTry); + + status = cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags( + &occupancyInBlocks, + func, + blockSizeToTry, + dynamicSMemSize, + flags); + + if (status != cudaSuccess) { + return status; + } + + occupancyInThreads = blockSizeToTry * occupancyInBlocks; + + if (occupancyInThreads > maxOccupancy) { + maxBlockSize = blockSizeToTry; + numBlocks = occupancyInBlocks; + maxOccupancy = occupancyInThreads; + } + + + + if (occupancyLimit == maxOccupancy) { + break; + } + } + + + + + + + + *minGridSize = numBlocks * multiProcessorCount; + *blockSize = maxBlockSize; + + return status; +} +# 2062 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) __attribute__((device)) cudaError_t cudaOccupancyMaxPotentialBlockSizeVariableSMem( + int *minGridSize, + int *blockSize, + T func, + UnaryFunction blockSizeToDynamicSMemSize, + int blockSizeLimit = 0) +{ + return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, blockSizeToDynamicSMemSize, blockSizeLimit, 0x00); +} +# 2108 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) __attribute__((device)) cudaError_t cudaOccupancyMaxPotentialBlockSize( + int *minGridSize, + int *blockSize, + T func, + size_t dynamicSMemSize = 0, + int blockSizeLimit = 0) +{ + return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, __cudaOccupancyB2DHelper(dynamicSMemSize), blockSizeLimit, 0x00); +} +# 2147 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock( + size_t *dynamicSmemSize, + T *func, + int numBlocks, + int blockSize) +{ + return ::cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, (const void*)func, numBlocks, blockSize); +} +# 2206 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) __attribute__((device)) cudaError_t cudaOccupancyMaxPotentialBlockSizeWithFlags( + int *minGridSize, + int *blockSize, + T func, + size_t dynamicSMemSize = 0, + int blockSizeLimit = 0, + unsigned int flags = 0) +{ + return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, __cudaOccupancyB2DHelper(dynamicSMemSize), blockSizeLimit, flags); +} +# 2251 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxPotentialClusterSize( + int *clusterSize, + T *func, + const cudaLaunchConfig_t *config) +{ + return ::cudaOccupancyMaxPotentialClusterSize(clusterSize, (const void*)func, config); +} +# 2295 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxActiveClusters( + int *numClusters, + T *func, + const cudaLaunchConfig_t *config) +{ + return ::cudaOccupancyMaxActiveClusters(numClusters, (const void*)func, config); +} +# 2336 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncGetAttributes( + struct cudaFuncAttributes *attr, + T *entry +) +{ + return ::cudaFuncGetAttributes(attr, (const void*)entry); +} +# 2402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncSetAttribute( + T *func, + enum cudaFuncAttribute attr, + int value +) +{ + return ::cudaFuncSetAttribute((const void*)func, attr, value); +} +# 2435 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncGetName( + const char **name, + T *func +) +{ + return ::cudaFuncGetName(name, (const void *)func); +} +# 2458 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetKernel( + cudaKernel_t *kernelPtr, + T *func +) +{ + return ::cudaGetKernel(kernelPtr, (const void *)func); +} +# 2496 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLibraryGetGlobal(T **dptr, size_t *bytes, cudaLibrary_t library, const char *name) +{ + return ::cudaLibraryGetGlobal((void**)(void*)dptr, bytes, library, name); +} +# 2530 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLibraryGetManaged(T **dptr, size_t *bytes, cudaLibrary_t library, const char *name) +{ + return ::cudaLibraryGetManaged((void**)(void*)dptr, bytes, library, name); +} +# 2560 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLibraryGetUnifiedFunction(T **fptr, cudaLibrary_t library, const char *symbol) +{ + return ::cudaLibraryGetUnifiedFunction((void**)(void*)fptr, library, symbol); +} +# 2576 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +#pragma GCC diagnostic pop +# 0 "" 2 +# 1 "CMakeCUDACompilerId.cu" +# 477 "CMakeCUDACompilerId.cu" +char const* info_compiler = "INFO" ":" "compiler[" "NVIDIA" "]"; + +char const* info_simulate = "INFO" ":" "simulate[" "GNU" "]"; +# 790 "CMakeCUDACompilerId.cu" +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + ('0' + (((12) / 10000000)%10)), ('0' + (((12) / 1000000)%10)), ('0' + (((12) / 100000)%10)), ('0' + (((12) / 10000)%10)), ('0' + (((12) / 1000)%10)), ('0' + (((12) / 100)%10)), ('0' + (((12) / 10)%10)), ('0' + ((12) % 10)), + + '.', ('0' + (((8) / 10000000)%10)), ('0' + (((8) / 1000000)%10)), ('0' + (((8) / 100000)%10)), ('0' + (((8) / 10000)%10)), ('0' + (((8) / 1000)%10)), ('0' + (((8) / 100)%10)), ('0' + (((8) / 10)%10)), ('0' + ((8) % 10)), + + '.', ('0' + (((93) / 10000000)%10)), ('0' + (((93) / 1000000)%10)), ('0' + (((93) / 100000)%10)), ('0' + (((93) / 10000)%10)), ('0' + (((93) / 1000)%10)), ('0' + (((93) / 100)%10)), ('0' + (((93) / 10)%10)), ('0' + ((93) % 10)), + + + + + + ']','\0'}; +# 819 "CMakeCUDACompilerId.cu" +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + ('0' + (((14) / 10000000)%10)), ('0' + (((14) / 1000000)%10)), ('0' + (((14) / 100000)%10)), ('0' + (((14) / 10000)%10)), ('0' + (((14) / 1000)%10)), ('0' + (((14) / 100)%10)), ('0' + (((14) / 10)%10)), ('0' + ((14) % 10)), + + '.', ('0' + (((2) / 10000000)%10)), ('0' + (((2) / 1000000)%10)), ('0' + (((2) / 100000)%10)), ('0' + (((2) / 10000)%10)), ('0' + (((2) / 1000)%10)), ('0' + (((2) / 100)%10)), ('0' + (((2) / 10)%10)), ('0' + ((2) % 10)), + + + + + + + + ']','\0'}; + + + + + + +char const* info_platform = "INFO" ":" "platform[" "Linux" "]"; +char const* info_arch = "INFO" ":" "arch[" "]"; + + + + +char const* info_host_compiler = "INFO" ":" "host_compiler[" "GNU" "]"; + + + + +char const info_host_compiler_version[] = { + 'I', 'N', 'F', 'O', ':','h','o','s','t','_', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + ('0' + (((14) / 10000000)%10)), ('0' + (((14) / 1000000)%10)), ('0' + (((14) / 100000)%10)), ('0' + (((14) / 10000)%10)), ('0' + (((14) / 1000)%10)), ('0' + (((14) / 100)%10)), ('0' + (((14) / 10)%10)), ('0' + ((14) % 10)), + + '.', ('0' + (((2) / 10000000)%10)), ('0' + (((2) / 1000000)%10)), ('0' + (((2) / 100000)%10)), ('0' + (((2) / 10000)%10)), ('0' + (((2) / 1000)%10)), ('0' + (((2) / 100)%10)), ('0' + (((2) / 10)%10)), ('0' + ((2) % 10)), + + '.', ('0' + (((1) / 10000000)%10)), ('0' + (((1) / 1000000)%10)), ('0' + (((1) / 100000)%10)), ('0' + (((1) / 10000)%10)), ('0' + (((1) / 1000)%10)), ('0' + (((1) / 100)%10)), ('0' + (((1) / 10)%10)), ('0' + ((1) % 10)), + + + + + + ']','\0'}; +# 882 "CMakeCUDACompilerId.cu" +const char* info_language_standard_default = "INFO" ":" "standard_default[" + + + + + + + + "17" + + + + + + + +"]"; + +const char* info_language_extensions_default = "INFO" ":" "extensions_default[" + + + "ON" + + + +"]"; + + + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; + + require += info_version[argc]; + + + require += info_simulate[argc]; + + + require += info_simulate_version[argc]; + + + require += info_host_compiler[argc]; + + + require += info_host_compiler_version[argc]; + + require += info_language_standard_default[argc]; + require += info_language_extensions_default[argc]; + (void)argv; + return require; +} diff --git a/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp4.ii b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp4.ii new file mode 100644 index 0000000..1a04387 --- /dev/null +++ b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp4.ii @@ -0,0 +1,34363 @@ +# 0 "CMakeCUDACompilerId.cu" +# 0 "" +# 0 "" +# 1 "/usr/include/stdc-predef.h" 1 3 4 +# 0 "" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 1 +# 61 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +#pragma GCC diagnostic push + + +#pragma GCC diagnostic ignored "-Wunused-function" +# 82 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_config.h" 1 +# 216 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_config.h" +# 1 "/usr/include/features.h" 1 3 4 +# 415 "/usr/include/features.h" 3 4 +# 1 "/usr/include/features-time64.h" 1 3 4 +# 20 "/usr/include/features-time64.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 21 "/usr/include/features-time64.h" 2 3 4 +# 1 "/usr/include/bits/timesize.h" 1 3 4 +# 19 "/usr/include/bits/timesize.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/bits/timesize.h" 2 3 4 +# 22 "/usr/include/features-time64.h" 2 3 4 +# 416 "/usr/include/features.h" 2 3 4 +# 524 "/usr/include/features.h" 3 4 +# 1 "/usr/include/sys/cdefs.h" 1 3 4 +# 730 "/usr/include/sys/cdefs.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 731 "/usr/include/sys/cdefs.h" 2 3 4 +# 1 "/usr/include/bits/long-double.h" 1 3 4 +# 732 "/usr/include/sys/cdefs.h" 2 3 4 +# 525 "/usr/include/features.h" 2 3 4 +# 548 "/usr/include/features.h" 3 4 +# 1 "/usr/include/gnu/stubs.h" 1 3 4 +# 10 "/usr/include/gnu/stubs.h" 3 4 +# 1 "/usr/include/gnu/stubs-64.h" 1 3 4 +# 11 "/usr/include/gnu/stubs.h" 2 3 4 +# 549 "/usr/include/features.h" 2 3 4 +# 217 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_config.h" 2 +# 83 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + + + + + + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 56 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" 1 +# 59 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 64 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" +# 1 "/usr/include/ctype.h" 1 3 4 +# 26 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/bits/types.h" 1 3 4 +# 27 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/bits/types.h" 2 3 4 +# 1 "/usr/include/bits/timesize.h" 1 3 4 +# 19 "/usr/include/bits/timesize.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/bits/timesize.h" 2 3 4 +# 29 "/usr/include/bits/types.h" 2 3 4 + + + +# 31 "/usr/include/bits/types.h" 3 4 +typedef unsigned char __u_char; +typedef unsigned short int __u_short; +typedef unsigned int __u_int; +typedef unsigned long int __u_long; + + +typedef signed char __int8_t; +typedef unsigned char __uint8_t; +typedef signed short int __int16_t; +typedef unsigned short int __uint16_t; +typedef signed int __int32_t; +typedef unsigned int __uint32_t; + +typedef signed long int __int64_t; +typedef unsigned long int __uint64_t; + + + + + + +typedef __int8_t __int_least8_t; +typedef __uint8_t __uint_least8_t; +typedef __int16_t __int_least16_t; +typedef __uint16_t __uint_least16_t; +typedef __int32_t __int_least32_t; +typedef __uint32_t __uint_least32_t; +typedef __int64_t __int_least64_t; +typedef __uint64_t __uint_least64_t; + + + +typedef long int __quad_t; +typedef unsigned long int __u_quad_t; + + + + + + + +typedef long int __intmax_t; +typedef unsigned long int __uintmax_t; +# 141 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/typesizes.h" 1 3 4 +# 142 "/usr/include/bits/types.h" 2 3 4 +# 1 "/usr/include/bits/time64.h" 1 3 4 +# 143 "/usr/include/bits/types.h" 2 3 4 + + +typedef unsigned long int __dev_t; +typedef unsigned int __uid_t; +typedef unsigned int __gid_t; +typedef unsigned long int __ino_t; +typedef unsigned long int __ino64_t; +typedef unsigned int __mode_t; +typedef unsigned long int __nlink_t; +typedef long int __off_t; +typedef long int __off64_t; +typedef int __pid_t; +typedef struct { int __val[2]; } __fsid_t; +typedef long int __clock_t; +typedef unsigned long int __rlim_t; +typedef unsigned long int __rlim64_t; +typedef unsigned int __id_t; +typedef long int __time_t; +typedef unsigned int __useconds_t; +typedef long int __suseconds_t; +typedef long int __suseconds64_t; + +typedef int __daddr_t; +typedef int __key_t; + + +typedef int __clockid_t; + + +typedef void * __timer_t; + + +typedef long int __blksize_t; + + + + +typedef long int __blkcnt_t; +typedef long int __blkcnt64_t; + + +typedef unsigned long int __fsblkcnt_t; +typedef unsigned long int __fsblkcnt64_t; + + +typedef unsigned long int __fsfilcnt_t; +typedef unsigned long int __fsfilcnt64_t; + + +typedef long int __fsword_t; + +typedef long int __ssize_t; + + +typedef long int __syscall_slong_t; + +typedef unsigned long int __syscall_ulong_t; + + + +typedef __off64_t __loff_t; +typedef char *__caddr_t; + + +typedef long int __intptr_t; + + +typedef unsigned int __socklen_t; + + + + +typedef int __sig_atomic_t; +# 27 "/usr/include/ctype.h" 2 3 4 + +extern "C" { +# 39 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/bits/endian.h" 1 3 4 +# 35 "/usr/include/bits/endian.h" 3 4 +# 1 "/usr/include/bits/endianness.h" 1 3 4 +# 36 "/usr/include/bits/endian.h" 2 3 4 +# 40 "/usr/include/ctype.h" 2 3 4 + + + + + + +enum +{ + _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), + _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), + _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), + _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), + _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), + _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), + _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), + _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), + _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), + _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), + _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), + _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8)) +}; +# 79 "/usr/include/ctype.h" 3 4 +extern const unsigned short int **__ctype_b_loc (void) + noexcept (true) __attribute__ ((__const__)); +extern const __int32_t **__ctype_tolower_loc (void) + noexcept (true) __attribute__ ((__const__)); +extern const __int32_t **__ctype_toupper_loc (void) + noexcept (true) __attribute__ ((__const__)); +# 108 "/usr/include/ctype.h" 3 4 +extern int isalnum (int) noexcept (true); +extern int isalpha (int) noexcept (true); +extern int iscntrl (int) noexcept (true); +extern int isdigit (int) noexcept (true); +extern int islower (int) noexcept (true); +extern int isgraph (int) noexcept (true); +extern int isprint (int) noexcept (true); +extern int ispunct (int) noexcept (true); +extern int isspace (int) noexcept (true); +extern int isupper (int) noexcept (true); +extern int isxdigit (int) noexcept (true); + + + +extern int tolower (int __c) noexcept (true); + + +extern int toupper (int __c) noexcept (true); + + + + +extern int isblank (int) noexcept (true); + + + + +extern int isctype (int __c, int __mask) noexcept (true); + + + + + + +extern int isascii (int __c) noexcept (true); + + + +extern int toascii (int __c) noexcept (true); + + + +extern int _toupper (int) noexcept (true); +extern int _tolower (int) noexcept (true); +# 237 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/bits/types/locale_t.h" 1 3 4 +# 22 "/usr/include/bits/types/locale_t.h" 3 4 +# 1 "/usr/include/bits/types/__locale_t.h" 1 3 4 +# 27 "/usr/include/bits/types/__locale_t.h" 3 4 +struct __locale_struct +{ + + struct __locale_data *__locales[13]; + + + const unsigned short int *__ctype_b; + const int *__ctype_tolower; + const int *__ctype_toupper; + + + const char *__names[13]; +}; + +typedef struct __locale_struct *__locale_t; +# 23 "/usr/include/bits/types/locale_t.h" 2 3 4 + +typedef __locale_t locale_t; +# 238 "/usr/include/ctype.h" 2 3 4 +# 251 "/usr/include/ctype.h" 3 4 +extern int isalnum_l (int, locale_t) noexcept (true); +extern int isalpha_l (int, locale_t) noexcept (true); +extern int iscntrl_l (int, locale_t) noexcept (true); +extern int isdigit_l (int, locale_t) noexcept (true); +extern int islower_l (int, locale_t) noexcept (true); +extern int isgraph_l (int, locale_t) noexcept (true); +extern int isprint_l (int, locale_t) noexcept (true); +extern int ispunct_l (int, locale_t) noexcept (true); +extern int isspace_l (int, locale_t) noexcept (true); +extern int isupper_l (int, locale_t) noexcept (true); +extern int isxdigit_l (int, locale_t) noexcept (true); + +extern int isblank_l (int, locale_t) noexcept (true); + + + +extern int __tolower_l (int __c, locale_t __l) noexcept (true); +extern int tolower_l (int __c, locale_t __l) noexcept (true); + + +extern int __toupper_l (int __c, locale_t __l) noexcept (true); +extern int toupper_l (int __c, locale_t __l) noexcept (true); +# 327 "/usr/include/ctype.h" 3 4 +} +# 65 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 2 +# 60 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" 2 +# 68 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" + +# 68 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" +enum __attribute__((device_builtin)) cudaRoundMode +{ + cudaRoundNearest, + cudaRoundZero, + cudaRoundPosInf, + cudaRoundMinInf +}; +# 57 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 1 +# 59 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 60 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" 1 +# 65 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 66 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" 2 +# 104 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +struct __attribute__((device_builtin)) char1 +{ + signed char x; +}; + +struct __attribute__((device_builtin)) uchar1 +{ + unsigned char x; +}; + + +struct __attribute__((device_builtin)) __attribute__((aligned(2))) char2 +{ + signed char x, y; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(2))) uchar2 +{ + unsigned char x, y; +}; + +struct __attribute__((device_builtin)) char3 +{ + signed char x, y, z; +}; + +struct __attribute__((device_builtin)) uchar3 +{ + unsigned char x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(4))) char4 +{ + signed char x, y, z, w; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(4))) uchar4 +{ + unsigned char x, y, z, w; +}; + +struct __attribute__((device_builtin)) short1 +{ + short x; +}; + +struct __attribute__((device_builtin)) ushort1 +{ + unsigned short x; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(4))) short2 +{ + short x, y; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(4))) ushort2 +{ + unsigned short x, y; +}; + +struct __attribute__((device_builtin)) short3 +{ + short x, y, z; +}; + +struct __attribute__((device_builtin)) ushort3 +{ + unsigned short x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(8))) short4 { short x; short y; short z; short w; }; +struct __attribute__((device_builtin)) __attribute__((aligned(8))) ushort4 { unsigned short x; unsigned short y; unsigned short z; unsigned short w; }; + +struct __attribute__((device_builtin)) int1 +{ + int x; +}; + +struct __attribute__((device_builtin)) uint1 +{ + unsigned int x; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(8))) int2 { int x; int y; }; +struct __attribute__((device_builtin)) __attribute__((aligned(8))) uint2 { unsigned int x; unsigned int y; }; + +struct __attribute__((device_builtin)) int3 +{ + int x, y, z; +}; + +struct __attribute__((device_builtin)) uint3 +{ + unsigned int x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) int4 +{ + int x, y, z, w; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) uint4 +{ + unsigned int x, y, z, w; +}; + +struct __attribute__((device_builtin)) long1 +{ + long int x; +}; + +struct __attribute__((device_builtin)) ulong1 +{ + unsigned long x; +}; + + + + + + +struct __attribute__((device_builtin)) __attribute__((aligned(2*sizeof(long int)))) long2 +{ + long int x, y; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(2*sizeof(unsigned long int)))) ulong2 +{ + unsigned long int x, y; +}; + + + +struct __attribute__((device_builtin)) long3 +{ + long int x, y, z; +}; + +struct __attribute__((device_builtin)) ulong3 +{ + unsigned long int x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) long4 +{ + long int x, y, z, w; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) ulong4 +{ + unsigned long int x, y, z, w; +}; + +struct __attribute__((device_builtin)) float1 +{ + float x; +}; +# 280 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +struct __attribute__((device_builtin)) __attribute__((aligned(8))) float2 { float x; float y; }; + + + + +struct __attribute__((device_builtin)) float3 +{ + float x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) float4 +{ + float x, y, z, w; +}; + +struct __attribute__((device_builtin)) longlong1 +{ + long long int x; +}; + +struct __attribute__((device_builtin)) ulonglong1 +{ + unsigned long long int x; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) longlong2 +{ + long long int x, y; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) ulonglong2 +{ + unsigned long long int x, y; +}; + +struct __attribute__((device_builtin)) longlong3 +{ + long long int x, y, z; +}; + +struct __attribute__((device_builtin)) ulonglong3 +{ + unsigned long long int x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) longlong4 +{ + long long int x, y, z ,w; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) ulonglong4 +{ + unsigned long long int x, y, z, w; +}; + +struct __attribute__((device_builtin)) double1 +{ + double x; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) double2 +{ + double x, y; +}; + +struct __attribute__((device_builtin)) double3 +{ + double x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) double4 +{ + double x, y, z, w; +}; +# 367 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +typedef __attribute__((device_builtin)) struct char1 char1; +typedef __attribute__((device_builtin)) struct uchar1 uchar1; +typedef __attribute__((device_builtin)) struct char2 char2; +typedef __attribute__((device_builtin)) struct uchar2 uchar2; +typedef __attribute__((device_builtin)) struct char3 char3; +typedef __attribute__((device_builtin)) struct uchar3 uchar3; +typedef __attribute__((device_builtin)) struct char4 char4; +typedef __attribute__((device_builtin)) struct uchar4 uchar4; +typedef __attribute__((device_builtin)) struct short1 short1; +typedef __attribute__((device_builtin)) struct ushort1 ushort1; +typedef __attribute__((device_builtin)) struct short2 short2; +typedef __attribute__((device_builtin)) struct ushort2 ushort2; +typedef __attribute__((device_builtin)) struct short3 short3; +typedef __attribute__((device_builtin)) struct ushort3 ushort3; +typedef __attribute__((device_builtin)) struct short4 short4; +typedef __attribute__((device_builtin)) struct ushort4 ushort4; +typedef __attribute__((device_builtin)) struct int1 int1; +typedef __attribute__((device_builtin)) struct uint1 uint1; +typedef __attribute__((device_builtin)) struct int2 int2; +typedef __attribute__((device_builtin)) struct uint2 uint2; +typedef __attribute__((device_builtin)) struct int3 int3; +typedef __attribute__((device_builtin)) struct uint3 uint3; +typedef __attribute__((device_builtin)) struct int4 int4; +typedef __attribute__((device_builtin)) struct uint4 uint4; +typedef __attribute__((device_builtin)) struct long1 long1; +typedef __attribute__((device_builtin)) struct ulong1 ulong1; +typedef __attribute__((device_builtin)) struct long2 long2; +typedef __attribute__((device_builtin)) struct ulong2 ulong2; +typedef __attribute__((device_builtin)) struct long3 long3; +typedef __attribute__((device_builtin)) struct ulong3 ulong3; +typedef __attribute__((device_builtin)) struct long4 long4; +typedef __attribute__((device_builtin)) struct ulong4 ulong4; +typedef __attribute__((device_builtin)) struct float1 float1; +typedef __attribute__((device_builtin)) struct float2 float2; +typedef __attribute__((device_builtin)) struct float3 float3; +typedef __attribute__((device_builtin)) struct float4 float4; +typedef __attribute__((device_builtin)) struct longlong1 longlong1; +typedef __attribute__((device_builtin)) struct ulonglong1 ulonglong1; +typedef __attribute__((device_builtin)) struct longlong2 longlong2; +typedef __attribute__((device_builtin)) struct ulonglong2 ulonglong2; +typedef __attribute__((device_builtin)) struct longlong3 longlong3; +typedef __attribute__((device_builtin)) struct ulonglong3 ulonglong3; +typedef __attribute__((device_builtin)) struct longlong4 longlong4; +typedef __attribute__((device_builtin)) struct ulonglong4 ulonglong4; +typedef __attribute__((device_builtin)) struct double1 double1; +typedef __attribute__((device_builtin)) struct double2 double2; +typedef __attribute__((device_builtin)) struct double3 double3; +typedef __attribute__((device_builtin)) struct double4 double4; +# 426 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +struct __attribute__((device_builtin)) dim3 +{ + unsigned int x, y, z; + + + __attribute__((host)) __attribute__((device)) constexpr dim3(unsigned int vx = 1, unsigned int vy = 1, unsigned int vz = 1) : x(vx), y(vy), z(vz) {} + __attribute__((host)) __attribute__((device)) constexpr dim3(uint3 v) : x(v.x), y(v.y), z(v.z) {} + __attribute__((host)) __attribute__((device)) constexpr operator uint3(void) const { return uint3{x, y, z}; } + + + + + + +}; + +typedef __attribute__((device_builtin)) struct dim3 dim3; +# 62 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 2 +# 83 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 1 3 4 +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/syslimits.h" 1 3 4 + + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 1 3 4 +# 210 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 3 4 +# 1 "/usr/include/limits.h" 1 3 4 +# 26 "/usr/include/limits.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/limits.h" 2 3 4 +# 195 "/usr/include/limits.h" 3 4 +# 1 "/usr/include/bits/posix1_lim.h" 1 3 4 +# 27 "/usr/include/bits/posix1_lim.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/bits/posix1_lim.h" 2 3 4 +# 161 "/usr/include/bits/posix1_lim.h" 3 4 +# 1 "/usr/include/bits/local_lim.h" 1 3 4 +# 38 "/usr/include/bits/local_lim.h" 3 4 +# 1 "/usr/include/linux/limits.h" 1 3 4 +# 39 "/usr/include/bits/local_lim.h" 2 3 4 +# 81 "/usr/include/bits/local_lim.h" 3 4 +# 1 "/usr/include/bits/pthread_stack_min-dynamic.h" 1 3 4 +# 23 "/usr/include/bits/pthread_stack_min-dynamic.h" 3 4 + +# 23 "/usr/include/bits/pthread_stack_min-dynamic.h" 3 4 +extern "C" { +extern long int __sysconf (int __name) noexcept (true); +} +# 82 "/usr/include/bits/local_lim.h" 2 3 4 +# 162 "/usr/include/bits/posix1_lim.h" 2 3 4 +# 196 "/usr/include/limits.h" 2 3 4 + + + +# 1 "/usr/include/bits/posix2_lim.h" 1 3 4 +# 200 "/usr/include/limits.h" 2 3 4 + + + +# 1 "/usr/include/bits/xopen_lim.h" 1 3 4 +# 64 "/usr/include/bits/xopen_lim.h" 3 4 +# 1 "/usr/include/bits/uio_lim.h" 1 3 4 +# 65 "/usr/include/bits/xopen_lim.h" 2 3 4 +# 204 "/usr/include/limits.h" 2 3 4 +# 211 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 2 3 4 +# 8 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/syslimits.h" 2 3 4 +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h" 2 3 4 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 2 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 145 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 4 +typedef long int ptrdiff_t; +# 214 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 4 +typedef long unsigned int size_t; +# 425 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 4 +typedef struct { + long long __max_align_ll __attribute__((__aligned__(__alignof__(long long)))); + long double __max_align_ld __attribute__((__aligned__(__alignof__(long double)))); +# 436 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 4 +} max_align_t; + + + + + + + typedef decltype(nullptr) nullptr_t; +# 85 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 2 +# 205 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + +# 205 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +enum __attribute__((device_builtin)) cudaError +{ + + + + + + cudaSuccess = 0, + + + + + + cudaErrorInvalidValue = 1, + + + + + + cudaErrorMemoryAllocation = 2, + + + + + + cudaErrorInitializationError = 3, + + + + + + + cudaErrorCudartUnloading = 4, + + + + + + + cudaErrorProfilerDisabled = 5, + + + + + + + + cudaErrorProfilerNotInitialized = 6, + + + + + + + cudaErrorProfilerAlreadyStarted = 7, + + + + + + + cudaErrorProfilerAlreadyStopped = 8, + + + + + + + + cudaErrorInvalidConfiguration = 9, + + + + + + cudaErrorInvalidPitchValue = 12, + + + + + + cudaErrorInvalidSymbol = 13, + + + + + + + + cudaErrorInvalidHostPointer = 16, + + + + + + + + cudaErrorInvalidDevicePointer = 17, + + + + + cudaErrorInvalidTexture = 18, + + + + + + cudaErrorInvalidTextureBinding = 19, + + + + + + + cudaErrorInvalidChannelDescriptor = 20, + + + + + + cudaErrorInvalidMemcpyDirection = 21, +# 336 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorAddressOfConstant = 22, +# 345 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorTextureFetchFailed = 23, +# 354 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorTextureNotBound = 24, +# 363 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSynchronizationError = 25, + + + + + cudaErrorInvalidFilterSetting = 26, + + + + + + cudaErrorInvalidNormSetting = 27, + + + + + + + + cudaErrorMixedDeviceExecution = 28, + + + + + + + + cudaErrorNotYetImplemented = 31, +# 399 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorMemoryValueTooLarge = 32, + + + + + + cudaErrorStubLibrary = 34, + + + + + + + cudaErrorInsufficientDriver = 35, + + + + + + + cudaErrorCallRequiresNewerDriver = 36, + + + + + + cudaErrorInvalidSurface = 37, + + + + + + cudaErrorDuplicateVariableName = 43, + + + + + + cudaErrorDuplicateTextureName = 44, + + + + + + cudaErrorDuplicateSurfaceName = 45, +# 453 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorDevicesUnavailable = 46, +# 466 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorIncompatibleDriverContext = 49, + + + + + + cudaErrorMissingConfiguration = 52, +# 481 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorPriorLaunchFailure = 53, + + + + + + cudaErrorLaunchMaxDepthExceeded = 65, + + + + + + + + cudaErrorLaunchFileScopedTex = 66, + + + + + + + + cudaErrorLaunchFileScopedSurf = 67, +# 519 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSyncDepthExceeded = 68, +# 531 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorLaunchPendingCountExceeded = 69, + + + + + + cudaErrorInvalidDeviceFunction = 98, + + + + + + cudaErrorNoDevice = 100, + + + + + + + cudaErrorInvalidDevice = 101, + + + + + cudaErrorDeviceNotLicensed = 102, +# 564 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSoftwareValidityNotEstablished = 103, + + + + + cudaErrorStartupFailure = 127, + + + + + cudaErrorInvalidKernelImage = 200, +# 584 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorDeviceUninitialized = 201, + + + + + cudaErrorMapBufferObjectFailed = 205, + + + + + cudaErrorUnmapBufferObjectFailed = 206, + + + + + + cudaErrorArrayIsMapped = 207, + + + + + cudaErrorAlreadyMapped = 208, + + + + + + + + cudaErrorNoKernelImageForDevice = 209, + + + + + cudaErrorAlreadyAcquired = 210, + + + + + cudaErrorNotMapped = 211, + + + + + + cudaErrorNotMappedAsArray = 212, + + + + + + cudaErrorNotMappedAsPointer = 213, + + + + + + cudaErrorECCUncorrectable = 214, + + + + + + cudaErrorUnsupportedLimit = 215, + + + + + + cudaErrorDeviceAlreadyInUse = 216, + + + + + + cudaErrorPeerAccessUnsupported = 217, + + + + + + cudaErrorInvalidPtx = 218, + + + + + cudaErrorInvalidGraphicsContext = 219, + + + + + + cudaErrorNvlinkUncorrectable = 220, + + + + + + + cudaErrorJitCompilerNotFound = 221, + + + + + + + cudaErrorUnsupportedPtxVersion = 222, + + + + + + + cudaErrorJitCompilationDisabled = 223, + + + + + cudaErrorUnsupportedExecAffinity = 224, + + + + + + cudaErrorUnsupportedDevSideSync = 225, +# 719 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorContained = 226, + + + + + cudaErrorInvalidSource = 300, + + + + + cudaErrorFileNotFound = 301, + + + + + cudaErrorSharedObjectSymbolNotFound = 302, + + + + + cudaErrorSharedObjectInitFailed = 303, + + + + + cudaErrorOperatingSystem = 304, + + + + + + + cudaErrorInvalidResourceHandle = 400, + + + + + + cudaErrorIllegalState = 401, + + + + + + + + cudaErrorLossyQuery = 402, + + + + + + + cudaErrorSymbolNotFound = 500, + + + + + + + + cudaErrorNotReady = 600, + + + + + + + + cudaErrorIllegalAddress = 700, +# 797 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorLaunchOutOfResources = 701, +# 808 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorLaunchTimeout = 702, + + + + + + cudaErrorLaunchIncompatibleTexturing = 703, + + + + + + + cudaErrorPeerAccessAlreadyEnabled = 704, + + + + + + + cudaErrorPeerAccessNotEnabled = 705, +# 841 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSetOnActiveProcess = 708, + + + + + + + cudaErrorContextIsDestroyed = 709, + + + + + + + cudaErrorAssert = 710, + + + + + + + cudaErrorTooManyPeers = 711, + + + + + + cudaErrorHostMemoryAlreadyRegistered = 712, + + + + + + cudaErrorHostMemoryNotRegistered = 713, +# 883 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorHardwareStackError = 714, + + + + + + + + cudaErrorIllegalInstruction = 715, +# 900 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorMisalignedAddress = 716, +# 911 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorInvalidAddressSpace = 717, + + + + + + + + cudaErrorInvalidPc = 718, +# 930 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorLaunchFailure = 719, +# 939 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorCooperativeLaunchTooLarge = 720, + + + + + + + + cudaErrorTensorMemoryLeak = 721, + + + + + cudaErrorNotPermitted = 800, + + + + + + cudaErrorNotSupported = 801, +# 967 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSystemNotReady = 802, + + + + + + + cudaErrorSystemDriverMismatch = 803, +# 983 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorCompatNotSupportedOnDevice = 804, + + + + + cudaErrorMpsConnectionFailed = 805, + + + + + cudaErrorMpsRpcFailure = 806, + + + + + + cudaErrorMpsServerNotReady = 807, + + + + + cudaErrorMpsMaxClientsReached = 808, + + + + + cudaErrorMpsMaxConnectionsReached = 809, + + + + + cudaErrorMpsClientTerminated = 810, + + + + + cudaErrorCdpNotSupported = 811, + + + + + cudaErrorCdpVersionMismatch = 812, + + + + + cudaErrorStreamCaptureUnsupported = 900, + + + + + + cudaErrorStreamCaptureInvalidated = 901, + + + + + + cudaErrorStreamCaptureMerge = 902, + + + + + cudaErrorStreamCaptureUnmatched = 903, + + + + + + cudaErrorStreamCaptureUnjoined = 904, + + + + + + + cudaErrorStreamCaptureIsolation = 905, + + + + + + cudaErrorStreamCaptureImplicit = 906, + + + + + + cudaErrorCapturedEvent = 907, + + + + + + + cudaErrorStreamCaptureWrongThread = 908, + + + + + cudaErrorTimeout = 909, + + + + + + cudaErrorGraphExecUpdateFailure = 910, +# 1099 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorExternalDevice = 911, + + + + + + cudaErrorInvalidClusterSize = 912, + + + + + + cudaErrorFunctionNotLoaded = 913, + + + + + + cudaErrorInvalidResourceType = 914, + + + + + + cudaErrorInvalidResourceConfiguration = 915, + + + + + cudaErrorUnknown = 999 + + + + + + + + , cudaErrorApiFailureBase = 10000 +}; + + + + +enum __attribute__((device_builtin)) cudaChannelFormatKind +{ + cudaChannelFormatKindSigned = 0, + cudaChannelFormatKindUnsigned = 1, + cudaChannelFormatKindFloat = 2, + cudaChannelFormatKindNone = 3, + cudaChannelFormatKindNV12 = 4, + cudaChannelFormatKindUnsignedNormalized8X1 = 5, + cudaChannelFormatKindUnsignedNormalized8X2 = 6, + cudaChannelFormatKindUnsignedNormalized8X4 = 7, + cudaChannelFormatKindUnsignedNormalized16X1 = 8, + cudaChannelFormatKindUnsignedNormalized16X2 = 9, + cudaChannelFormatKindUnsignedNormalized16X4 = 10, + cudaChannelFormatKindSignedNormalized8X1 = 11, + cudaChannelFormatKindSignedNormalized8X2 = 12, + cudaChannelFormatKindSignedNormalized8X4 = 13, + cudaChannelFormatKindSignedNormalized16X1 = 14, + cudaChannelFormatKindSignedNormalized16X2 = 15, + cudaChannelFormatKindSignedNormalized16X4 = 16, + cudaChannelFormatKindUnsignedBlockCompressed1 = 17, + cudaChannelFormatKindUnsignedBlockCompressed1SRGB = 18, + cudaChannelFormatKindUnsignedBlockCompressed2 = 19, + cudaChannelFormatKindUnsignedBlockCompressed2SRGB = 20, + cudaChannelFormatKindUnsignedBlockCompressed3 = 21, + cudaChannelFormatKindUnsignedBlockCompressed3SRGB = 22, + cudaChannelFormatKindUnsignedBlockCompressed4 = 23, + cudaChannelFormatKindSignedBlockCompressed4 = 24, + cudaChannelFormatKindUnsignedBlockCompressed5 = 25, + cudaChannelFormatKindSignedBlockCompressed5 = 26, + cudaChannelFormatKindUnsignedBlockCompressed6H = 27, + cudaChannelFormatKindSignedBlockCompressed6H = 28, + cudaChannelFormatKindUnsignedBlockCompressed7 = 29, + cudaChannelFormatKindUnsignedBlockCompressed7SRGB = 30, + cudaChannelFormatKindUnsignedNormalized1010102 = 31 + +}; + + + + +struct __attribute__((device_builtin)) cudaChannelFormatDesc +{ + int x; + int y; + int z; + int w; + enum cudaChannelFormatKind f; +}; + + + + +typedef struct cudaArray *cudaArray_t; + + + + +typedef const struct cudaArray *cudaArray_const_t; + +struct cudaArray; + + + + +typedef struct cudaMipmappedArray *cudaMipmappedArray_t; + + + + +typedef const struct cudaMipmappedArray *cudaMipmappedArray_const_t; + +struct cudaMipmappedArray; +# 1223 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct __attribute__((device_builtin)) cudaArraySparseProperties { + struct { + unsigned int width; + unsigned int height; + unsigned int depth; + } tileExtent; + unsigned int miptailFirstLevel; + unsigned long long miptailSize; + unsigned int flags; + unsigned int reserved[4]; +}; + + + + +struct __attribute__((device_builtin)) cudaArrayMemoryRequirements { + size_t size; + size_t alignment; + unsigned int reserved[4]; +}; + + + + +enum __attribute__((device_builtin)) cudaMemoryType +{ + cudaMemoryTypeUnregistered = 0, + cudaMemoryTypeHost = 1, + cudaMemoryTypeDevice = 2, + cudaMemoryTypeManaged = 3 +}; + + + + +enum __attribute__((device_builtin)) cudaMemcpyKind +{ + cudaMemcpyHostToHost = 0, + cudaMemcpyHostToDevice = 1, + cudaMemcpyDeviceToHost = 2, + cudaMemcpyDeviceToDevice = 3, + cudaMemcpyDefault = 4 +}; + + + + + + +struct __attribute__((device_builtin)) cudaPitchedPtr +{ + void *ptr; + size_t pitch; + size_t xsize; + size_t ysize; +}; + + + + + + +struct __attribute__((device_builtin)) cudaExtent +{ + size_t width; + size_t height; + size_t depth; +}; + + + + + + +struct __attribute__((device_builtin)) cudaPos +{ + size_t x; + size_t y; + size_t z; +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpy3DParms +{ + cudaArray_t srcArray; + struct cudaPos srcPos; + struct cudaPitchedPtr srcPtr; + + cudaArray_t dstArray; + struct cudaPos dstPos; + struct cudaPitchedPtr dstPtr; + + struct cudaExtent extent; + enum cudaMemcpyKind kind; +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpyNodeParams { + int flags; + int reserved[3]; + struct cudaMemcpy3DParms copyParams; +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpy3DPeerParms +{ + cudaArray_t srcArray; + struct cudaPos srcPos; + struct cudaPitchedPtr srcPtr; + int srcDevice; + + cudaArray_t dstArray; + struct cudaPos dstPos; + struct cudaPitchedPtr dstPtr; + int dstDevice; + + struct cudaExtent extent; +}; + + + + +struct __attribute__((device_builtin)) cudaMemsetParams { + void *dst; + size_t pitch; + unsigned int value; + unsigned int elementSize; + size_t width; + size_t height; +}; + + + + +struct __attribute__((device_builtin)) cudaMemsetParamsV2 { + void *dst; + size_t pitch; + unsigned int value; + unsigned int elementSize; + size_t width; + size_t height; +}; + + + + +enum __attribute__((device_builtin)) cudaAccessProperty { + cudaAccessPropertyNormal = 0, + cudaAccessPropertyStreaming = 1, + cudaAccessPropertyPersisting = 2 +}; +# 1392 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct __attribute__((device_builtin)) cudaAccessPolicyWindow { + void *base_ptr; + size_t num_bytes; + float hitRatio; + enum cudaAccessProperty hitProp; + enum cudaAccessProperty missProp; +}; +# 1410 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef void ( *cudaHostFn_t)(void *userData); + + + + +struct __attribute__((device_builtin)) cudaHostNodeParams { + cudaHostFn_t fn; + void* userData; +}; + + + + +struct __attribute__((device_builtin)) cudaHostNodeParamsV2 { + cudaHostFn_t fn; + void* userData; +}; + + + + +enum __attribute__((device_builtin)) cudaStreamCaptureStatus { + cudaStreamCaptureStatusNone = 0, + cudaStreamCaptureStatusActive = 1, + cudaStreamCaptureStatusInvalidated = 2 + +}; + + + + + +enum __attribute__((device_builtin)) cudaStreamCaptureMode { + cudaStreamCaptureModeGlobal = 0, + cudaStreamCaptureModeThreadLocal = 1, + cudaStreamCaptureModeRelaxed = 2 +}; + +enum __attribute__((device_builtin)) cudaSynchronizationPolicy { + cudaSyncPolicyAuto = 1, + cudaSyncPolicySpin = 2, + cudaSyncPolicyYield = 3, + cudaSyncPolicyBlockingSync = 4 +}; + + + + +enum __attribute__((device_builtin)) cudaClusterSchedulingPolicy { + cudaClusterSchedulingPolicyDefault = 0, + cudaClusterSchedulingPolicySpread = 1, + cudaClusterSchedulingPolicyLoadBalancing = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaStreamUpdateCaptureDependenciesFlags { + cudaStreamAddCaptureDependencies = 0x0, + cudaStreamSetCaptureDependencies = 0x1 +}; + + + + +enum __attribute__((device_builtin)) cudaUserObjectFlags { + cudaUserObjectNoDestructorSync = 0x1 +}; + + + + +enum __attribute__((device_builtin)) cudaUserObjectRetainFlags { + cudaGraphUserObjectMove = 0x1 +}; + + + + +struct cudaGraphicsResource; + + + + +enum __attribute__((device_builtin)) cudaGraphicsRegisterFlags +{ + cudaGraphicsRegisterFlagsNone = 0, + cudaGraphicsRegisterFlagsReadOnly = 1, + cudaGraphicsRegisterFlagsWriteDiscard = 2, + cudaGraphicsRegisterFlagsSurfaceLoadStore = 4, + cudaGraphicsRegisterFlagsTextureGather = 8 +}; + + + + +enum __attribute__((device_builtin)) cudaGraphicsMapFlags +{ + cudaGraphicsMapFlagsNone = 0, + cudaGraphicsMapFlagsReadOnly = 1, + cudaGraphicsMapFlagsWriteDiscard = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaGraphicsCubeFace +{ + cudaGraphicsCubeFacePositiveX = 0x00, + cudaGraphicsCubeFaceNegativeX = 0x01, + cudaGraphicsCubeFacePositiveY = 0x02, + cudaGraphicsCubeFaceNegativeY = 0x03, + cudaGraphicsCubeFacePositiveZ = 0x04, + cudaGraphicsCubeFaceNegativeZ = 0x05 +}; + + + + +enum __attribute__((device_builtin)) cudaResourceType +{ + cudaResourceTypeArray = 0x00, + cudaResourceTypeMipmappedArray = 0x01, + cudaResourceTypeLinear = 0x02, + cudaResourceTypePitch2D = 0x03 +}; + + + + +enum __attribute__((device_builtin)) cudaResourceViewFormat +{ + cudaResViewFormatNone = 0x00, + cudaResViewFormatUnsignedChar1 = 0x01, + cudaResViewFormatUnsignedChar2 = 0x02, + cudaResViewFormatUnsignedChar4 = 0x03, + cudaResViewFormatSignedChar1 = 0x04, + cudaResViewFormatSignedChar2 = 0x05, + cudaResViewFormatSignedChar4 = 0x06, + cudaResViewFormatUnsignedShort1 = 0x07, + cudaResViewFormatUnsignedShort2 = 0x08, + cudaResViewFormatUnsignedShort4 = 0x09, + cudaResViewFormatSignedShort1 = 0x0a, + cudaResViewFormatSignedShort2 = 0x0b, + cudaResViewFormatSignedShort4 = 0x0c, + cudaResViewFormatUnsignedInt1 = 0x0d, + cudaResViewFormatUnsignedInt2 = 0x0e, + cudaResViewFormatUnsignedInt4 = 0x0f, + cudaResViewFormatSignedInt1 = 0x10, + cudaResViewFormatSignedInt2 = 0x11, + cudaResViewFormatSignedInt4 = 0x12, + cudaResViewFormatHalf1 = 0x13, + cudaResViewFormatHalf2 = 0x14, + cudaResViewFormatHalf4 = 0x15, + cudaResViewFormatFloat1 = 0x16, + cudaResViewFormatFloat2 = 0x17, + cudaResViewFormatFloat4 = 0x18, + cudaResViewFormatUnsignedBlockCompressed1 = 0x19, + cudaResViewFormatUnsignedBlockCompressed2 = 0x1a, + cudaResViewFormatUnsignedBlockCompressed3 = 0x1b, + cudaResViewFormatUnsignedBlockCompressed4 = 0x1c, + cudaResViewFormatSignedBlockCompressed4 = 0x1d, + cudaResViewFormatUnsignedBlockCompressed5 = 0x1e, + cudaResViewFormatSignedBlockCompressed5 = 0x1f, + cudaResViewFormatUnsignedBlockCompressed6H = 0x20, + cudaResViewFormatSignedBlockCompressed6H = 0x21, + cudaResViewFormatUnsignedBlockCompressed7 = 0x22 +}; + + + + +struct __attribute__((device_builtin)) cudaResourceDesc { + enum cudaResourceType resType; + + union { + struct { + cudaArray_t array; + } array; + struct { + cudaMipmappedArray_t mipmap; + } mipmap; + struct { + void *devPtr; + struct cudaChannelFormatDesc desc; + size_t sizeInBytes; + } linear; + struct { + void *devPtr; + struct cudaChannelFormatDesc desc; + size_t width; + size_t height; + size_t pitchInBytes; + } pitch2D; + } res; +}; + + + + +struct __attribute__((device_builtin)) cudaResourceViewDesc +{ + enum cudaResourceViewFormat format; + size_t width; + size_t height; + size_t depth; + unsigned int firstMipmapLevel; + unsigned int lastMipmapLevel; + unsigned int firstLayer; + unsigned int lastLayer; +}; + + + + +struct __attribute__((device_builtin)) cudaPointerAttributes +{ + + + + + enum cudaMemoryType type; +# 1642 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + int device; + + + + + + void *devicePointer; +# 1657 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + void *hostPointer; +}; + + + + +struct __attribute__((device_builtin)) cudaFuncAttributes +{ + + + + + + size_t sharedSizeBytes; + + + + + + size_t constSizeBytes; + + + + + size_t localSizeBytes; + + + + + + + int maxThreadsPerBlock; + + + + + int numRegs; + + + + + + + int ptxVersion; + + + + + + + int binaryVersion; + + + + + + int cacheModeCA; + + + + + + + int maxDynamicSharedSizeBytes; +# 1729 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + int preferredShmemCarveout; + + + + + + int clusterDimMustBeSet; +# 1746 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + int requiredClusterWidth; + int requiredClusterHeight; + int requiredClusterDepth; + + + + + + int clusterSchedulingPolicyPreference; +# 1776 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + int nonPortableClusterSizeAllowed; + + + + + int reserved[16]; +}; + + + + +enum __attribute__((device_builtin)) cudaFuncAttribute +{ + cudaFuncAttributeMaxDynamicSharedMemorySize = 8, + cudaFuncAttributePreferredSharedMemoryCarveout = 9, + cudaFuncAttributeClusterDimMustBeSet = 10, + cudaFuncAttributeRequiredClusterWidth = 11, + cudaFuncAttributeRequiredClusterHeight = 12, + cudaFuncAttributeRequiredClusterDepth = 13, + cudaFuncAttributeNonPortableClusterSizeAllowed = 14, + cudaFuncAttributeClusterSchedulingPolicyPreference = 15, + cudaFuncAttributeMax +}; + + + + +enum __attribute__((device_builtin)) cudaFuncCache +{ + cudaFuncCachePreferNone = 0, + cudaFuncCachePreferShared = 1, + cudaFuncCachePreferL1 = 2, + cudaFuncCachePreferEqual = 3 +}; + + + + + +enum __attribute__((device_builtin)) cudaSharedMemConfig +{ + cudaSharedMemBankSizeDefault = 0, + cudaSharedMemBankSizeFourByte = 1, + cudaSharedMemBankSizeEightByte = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaSharedCarveout { + cudaSharedmemCarveoutDefault = -1, + cudaSharedmemCarveoutMaxShared = 100, + cudaSharedmemCarveoutMaxL1 = 0 +}; + + + + +enum __attribute__((device_builtin)) cudaComputeMode +{ + cudaComputeModeDefault = 0, + cudaComputeModeExclusive = 1, + cudaComputeModeProhibited = 2, + cudaComputeModeExclusiveProcess = 3 +}; + + + + +enum __attribute__((device_builtin)) cudaLimit +{ + cudaLimitStackSize = 0x00, + cudaLimitPrintfFifoSize = 0x01, + cudaLimitMallocHeapSize = 0x02, + cudaLimitDevRuntimeSyncDepth = 0x03, + cudaLimitDevRuntimePendingLaunchCount = 0x04, + cudaLimitMaxL2FetchGranularity = 0x05, + cudaLimitPersistingL2CacheSize = 0x06 +}; + + + + +enum __attribute__((device_builtin)) cudaMemoryAdvise +{ + cudaMemAdviseSetReadMostly = 1, + cudaMemAdviseUnsetReadMostly = 2, + cudaMemAdviseSetPreferredLocation = 3, + cudaMemAdviseUnsetPreferredLocation = 4, + cudaMemAdviseSetAccessedBy = 5, + cudaMemAdviseUnsetAccessedBy = 6 +}; + + + + +enum __attribute__((device_builtin)) cudaMemRangeAttribute +{ + cudaMemRangeAttributeReadMostly = 1, + cudaMemRangeAttributePreferredLocation = 2, + cudaMemRangeAttributeAccessedBy = 3, + cudaMemRangeAttributeLastPrefetchLocation = 4 + , cudaMemRangeAttributePreferredLocationType = 5 + , cudaMemRangeAttributePreferredLocationId = 6 + , cudaMemRangeAttributeLastPrefetchLocationType = 7 + , cudaMemRangeAttributeLastPrefetchLocationId = 8 +}; + + + + +enum __attribute__((device_builtin)) cudaFlushGPUDirectRDMAWritesOptions { + cudaFlushGPUDirectRDMAWritesOptionHost = 1<<0, + cudaFlushGPUDirectRDMAWritesOptionMemOps = 1<<1 +}; + + + + +enum __attribute__((device_builtin)) cudaGPUDirectRDMAWritesOrdering { + cudaGPUDirectRDMAWritesOrderingNone = 0, + cudaGPUDirectRDMAWritesOrderingOwner = 100, + cudaGPUDirectRDMAWritesOrderingAllDevices = 200 +}; + + + + +enum __attribute__((device_builtin)) cudaFlushGPUDirectRDMAWritesScope { + cudaFlushGPUDirectRDMAWritesToOwner = 100, + cudaFlushGPUDirectRDMAWritesToAllDevices = 200 +}; + + + + +enum __attribute__((device_builtin)) cudaFlushGPUDirectRDMAWritesTarget { + cudaFlushGPUDirectRDMAWritesTargetCurrentDevice +}; + + + + + +enum __attribute__((device_builtin)) cudaDeviceAttr +{ + cudaDevAttrMaxThreadsPerBlock = 1, + cudaDevAttrMaxBlockDimX = 2, + cudaDevAttrMaxBlockDimY = 3, + cudaDevAttrMaxBlockDimZ = 4, + cudaDevAttrMaxGridDimX = 5, + cudaDevAttrMaxGridDimY = 6, + cudaDevAttrMaxGridDimZ = 7, + cudaDevAttrMaxSharedMemoryPerBlock = 8, + cudaDevAttrTotalConstantMemory = 9, + cudaDevAttrWarpSize = 10, + cudaDevAttrMaxPitch = 11, + cudaDevAttrMaxRegistersPerBlock = 12, + cudaDevAttrClockRate = 13, + cudaDevAttrTextureAlignment = 14, + cudaDevAttrGpuOverlap = 15, + cudaDevAttrMultiProcessorCount = 16, + cudaDevAttrKernelExecTimeout = 17, + cudaDevAttrIntegrated = 18, + cudaDevAttrCanMapHostMemory = 19, + cudaDevAttrComputeMode = 20, + cudaDevAttrMaxTexture1DWidth = 21, + cudaDevAttrMaxTexture2DWidth = 22, + cudaDevAttrMaxTexture2DHeight = 23, + cudaDevAttrMaxTexture3DWidth = 24, + cudaDevAttrMaxTexture3DHeight = 25, + cudaDevAttrMaxTexture3DDepth = 26, + cudaDevAttrMaxTexture2DLayeredWidth = 27, + cudaDevAttrMaxTexture2DLayeredHeight = 28, + cudaDevAttrMaxTexture2DLayeredLayers = 29, + cudaDevAttrSurfaceAlignment = 30, + cudaDevAttrConcurrentKernels = 31, + cudaDevAttrEccEnabled = 32, + cudaDevAttrPciBusId = 33, + cudaDevAttrPciDeviceId = 34, + cudaDevAttrTccDriver = 35, + cudaDevAttrMemoryClockRate = 36, + cudaDevAttrGlobalMemoryBusWidth = 37, + cudaDevAttrL2CacheSize = 38, + cudaDevAttrMaxThreadsPerMultiProcessor = 39, + cudaDevAttrAsyncEngineCount = 40, + cudaDevAttrUnifiedAddressing = 41, + cudaDevAttrMaxTexture1DLayeredWidth = 42, + cudaDevAttrMaxTexture1DLayeredLayers = 43, + cudaDevAttrMaxTexture2DGatherWidth = 45, + cudaDevAttrMaxTexture2DGatherHeight = 46, + cudaDevAttrMaxTexture3DWidthAlt = 47, + cudaDevAttrMaxTexture3DHeightAlt = 48, + cudaDevAttrMaxTexture3DDepthAlt = 49, + cudaDevAttrPciDomainId = 50, + cudaDevAttrTexturePitchAlignment = 51, + cudaDevAttrMaxTextureCubemapWidth = 52, + cudaDevAttrMaxTextureCubemapLayeredWidth = 53, + cudaDevAttrMaxTextureCubemapLayeredLayers = 54, + cudaDevAttrMaxSurface1DWidth = 55, + cudaDevAttrMaxSurface2DWidth = 56, + cudaDevAttrMaxSurface2DHeight = 57, + cudaDevAttrMaxSurface3DWidth = 58, + cudaDevAttrMaxSurface3DHeight = 59, + cudaDevAttrMaxSurface3DDepth = 60, + cudaDevAttrMaxSurface1DLayeredWidth = 61, + cudaDevAttrMaxSurface1DLayeredLayers = 62, + cudaDevAttrMaxSurface2DLayeredWidth = 63, + cudaDevAttrMaxSurface2DLayeredHeight = 64, + cudaDevAttrMaxSurface2DLayeredLayers = 65, + cudaDevAttrMaxSurfaceCubemapWidth = 66, + cudaDevAttrMaxSurfaceCubemapLayeredWidth = 67, + cudaDevAttrMaxSurfaceCubemapLayeredLayers = 68, + cudaDevAttrMaxTexture1DLinearWidth = 69, + cudaDevAttrMaxTexture2DLinearWidth = 70, + cudaDevAttrMaxTexture2DLinearHeight = 71, + cudaDevAttrMaxTexture2DLinearPitch = 72, + cudaDevAttrMaxTexture2DMipmappedWidth = 73, + cudaDevAttrMaxTexture2DMipmappedHeight = 74, + cudaDevAttrComputeCapabilityMajor = 75, + cudaDevAttrComputeCapabilityMinor = 76, + cudaDevAttrMaxTexture1DMipmappedWidth = 77, + cudaDevAttrStreamPrioritiesSupported = 78, + cudaDevAttrGlobalL1CacheSupported = 79, + cudaDevAttrLocalL1CacheSupported = 80, + cudaDevAttrMaxSharedMemoryPerMultiprocessor = 81, + cudaDevAttrMaxRegistersPerMultiprocessor = 82, + cudaDevAttrManagedMemory = 83, + cudaDevAttrIsMultiGpuBoard = 84, + cudaDevAttrMultiGpuBoardGroupID = 85, + cudaDevAttrHostNativeAtomicSupported = 86, + cudaDevAttrSingleToDoublePrecisionPerfRatio = 87, + cudaDevAttrPageableMemoryAccess = 88, + cudaDevAttrConcurrentManagedAccess = 89, + cudaDevAttrComputePreemptionSupported = 90, + cudaDevAttrCanUseHostPointerForRegisteredMem = 91, + cudaDevAttrReserved92 = 92, + cudaDevAttrReserved93 = 93, + cudaDevAttrReserved94 = 94, + cudaDevAttrCooperativeLaunch = 95, + cudaDevAttrCooperativeMultiDeviceLaunch = 96, + cudaDevAttrMaxSharedMemoryPerBlockOptin = 97, + cudaDevAttrCanFlushRemoteWrites = 98, + cudaDevAttrHostRegisterSupported = 99, + cudaDevAttrPageableMemoryAccessUsesHostPageTables = 100, + cudaDevAttrDirectManagedMemAccessFromHost = 101, + cudaDevAttrMaxBlocksPerMultiprocessor = 106, + cudaDevAttrMaxPersistingL2CacheSize = 108, + cudaDevAttrMaxAccessPolicyWindowSize = 109, + cudaDevAttrReservedSharedMemoryPerBlock = 111, + cudaDevAttrSparseCudaArraySupported = 112, + cudaDevAttrHostRegisterReadOnlySupported = 113, + cudaDevAttrTimelineSemaphoreInteropSupported = 114, + cudaDevAttrMaxTimelineSemaphoreInteropSupported = 114, + cudaDevAttrMemoryPoolsSupported = 115, + cudaDevAttrGPUDirectRDMASupported = 116, + cudaDevAttrGPUDirectRDMAFlushWritesOptions = 117, + cudaDevAttrGPUDirectRDMAWritesOrdering = 118, + cudaDevAttrMemoryPoolSupportedHandleTypes = 119, + cudaDevAttrClusterLaunch = 120, + cudaDevAttrDeferredMappingCudaArraySupported = 121, + cudaDevAttrReserved122 = 122, + cudaDevAttrReserved123 = 123, + cudaDevAttrReserved124 = 124, + cudaDevAttrIpcEventSupport = 125, + cudaDevAttrMemSyncDomainCount = 126, + cudaDevAttrReserved127 = 127, + cudaDevAttrReserved128 = 128, + cudaDevAttrReserved129 = 129, + cudaDevAttrNumaConfig = 130, + cudaDevAttrNumaId = 131, + cudaDevAttrReserved132 = 132, + cudaDevAttrMpsEnabled = 133, + cudaDevAttrHostNumaId = 134, + cudaDevAttrD3D12CigSupported = 135, + cudaDevAttrGpuPciDeviceId = 139, + cudaDevAttrGpuPciSubsystemId = 140, + cudaDevAttrHostNumaMultinodeIpcSupported = 143, + cudaDevAttrMax +}; + + + + +enum __attribute__((device_builtin)) cudaMemPoolAttr +{ +# 2070 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaMemPoolReuseFollowEventDependencies = 0x1, + + + + + + + cudaMemPoolReuseAllowOpportunistic = 0x2, + + + + + + + + cudaMemPoolReuseAllowInternalDependencies = 0x3, +# 2096 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaMemPoolAttrReleaseThreshold = 0x4, + + + + + + cudaMemPoolAttrReservedMemCurrent = 0x5, + + + + + + + cudaMemPoolAttrReservedMemHigh = 0x6, + + + + + + cudaMemPoolAttrUsedMemCurrent = 0x7, + + + + + + + cudaMemPoolAttrUsedMemHigh = 0x8 +}; + + + + +enum __attribute__((device_builtin)) cudaMemLocationType { + cudaMemLocationTypeInvalid = 0, + cudaMemLocationTypeDevice = 1 + , cudaMemLocationTypeHost = 2 + , cudaMemLocationTypeHostNuma = 3 + , cudaMemLocationTypeHostNumaCurrent = 4 +}; + + + + + + + +struct __attribute__((device_builtin)) cudaMemLocation { + enum cudaMemLocationType type; + int id; +}; + + + + +enum __attribute__((device_builtin)) cudaMemAccessFlags { + cudaMemAccessFlagsProtNone = 0, + cudaMemAccessFlagsProtRead = 1, + cudaMemAccessFlagsProtReadWrite = 3 +}; + + + + +struct __attribute__((device_builtin)) cudaMemAccessDesc { + struct cudaMemLocation location; + enum cudaMemAccessFlags flags; +}; + + + + +enum __attribute__((device_builtin)) cudaMemAllocationType { + cudaMemAllocationTypeInvalid = 0x0, + + + + cudaMemAllocationTypePinned = 0x1, + cudaMemAllocationTypeMax = 0x7FFFFFFF +}; + + + + +enum __attribute__((device_builtin)) cudaMemAllocationHandleType { + cudaMemHandleTypeNone = 0x0, + cudaMemHandleTypePosixFileDescriptor = 0x1, + cudaMemHandleTypeWin32 = 0x2, + cudaMemHandleTypeWin32Kmt = 0x4, + cudaMemHandleTypeFabric = 0x8 +}; +# 2196 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct __attribute__((device_builtin)) cudaMemPoolProps { + enum cudaMemAllocationType allocType; + enum cudaMemAllocationHandleType handleTypes; + struct cudaMemLocation location; + + + + + + + void *win32SecurityAttributes; + size_t maxSize; + unsigned short usage; + unsigned char reserved[54]; +}; + + + + +struct __attribute__((device_builtin)) cudaMemPoolPtrExportData { + unsigned char reserved[64]; +}; + + + + +struct __attribute__((device_builtin)) cudaMemAllocNodeParams { + + + + + struct cudaMemPoolProps poolProps; + const struct cudaMemAccessDesc *accessDescs; + size_t accessDescCount; + size_t bytesize; + void *dptr; +}; + + + + +struct __attribute__((device_builtin)) cudaMemAllocNodeParamsV2 { + + + + + struct cudaMemPoolProps poolProps; + const struct cudaMemAccessDesc *accessDescs; + size_t accessDescCount; + size_t bytesize; + void *dptr; +}; + + + + +struct __attribute__((device_builtin)) cudaMemFreeNodeParams { + void *dptr; +}; + + + + +enum __attribute__((device_builtin)) cudaGraphMemAttributeType { + + + + + cudaGraphMemAttrUsedMemCurrent = 0x0, + + + + + + + cudaGraphMemAttrUsedMemHigh = 0x1, + + + + + + + cudaGraphMemAttrReservedMemCurrent = 0x2, + + + + + + + cudaGraphMemAttrReservedMemHigh = 0x3 +}; + + + + +enum __attribute__((device_builtin)) cudaMemcpyFlags { + cudaMemcpyFlagDefault = 0x0, + + + + + cudaMemcpyFlagPreferOverlapWithCompute = 0x1 +}; + +enum __attribute__((device_builtin)) cudaMemcpySrcAccessOrder { + + + + cudaMemcpySrcAccessOrderInvalid = 0x0, + + + + + cudaMemcpySrcAccessOrderStream = 0x1, +# 2320 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaMemcpySrcAccessOrderDuringApiCall = 0x2, +# 2329 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaMemcpySrcAccessOrderAny = 0x3, + + cudaMemcpySrcAccessOrderMax = 0x7FFFFFFF +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpyAttributes { + enum cudaMemcpySrcAccessOrder srcAccessOrder; + struct cudaMemLocation srcLocHint; + struct cudaMemLocation dstLocHint; + unsigned int flags; +}; + + + + +enum __attribute__((device_builtin)) cudaMemcpy3DOperandType { + cudaMemcpyOperandTypePointer = 0x1, + cudaMemcpyOperandTypeArray = 0x2, + cudaMemcpyOperandTypeMax = 0x7FFFFFFF +}; + + + + +struct __attribute__((device_builtin)) cudaOffset3D { + size_t x; + size_t y; + size_t z; +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpy3DOperand { + enum cudaMemcpy3DOperandType type; + union { + + + + struct { + void *ptr; + size_t rowLength; + size_t layerHeight; + struct cudaMemLocation locHint; + } ptr; + + + + + struct { + cudaArray_t array; + struct cudaOffset3D offset; + } array; + } op; +}; + +struct __attribute__((device_builtin)) cudaMemcpy3DBatchOp { + struct cudaMemcpy3DOperand src; + struct cudaMemcpy3DOperand dst; + struct cudaExtent extent; + enum cudaMemcpySrcAccessOrder srcAccessOrder; + unsigned int flags; +}; + + + + + +enum __attribute__((device_builtin)) cudaDeviceP2PAttr { + cudaDevP2PAttrPerformanceRank = 1, + cudaDevP2PAttrAccessSupported = 2, + cudaDevP2PAttrNativeAtomicSupported = 3, + cudaDevP2PAttrCudaArrayAccessSupported = 4 +}; + + + + + + +struct __attribute__((device_builtin)) CUuuid_st { + char bytes[16]; +}; +typedef __attribute__((device_builtin)) struct CUuuid_st CUuuid; + +typedef __attribute__((device_builtin)) struct CUuuid_st cudaUUID_t; + + + + +struct __attribute__((device_builtin)) cudaDeviceProp +{ + char name[256]; + cudaUUID_t uuid; + char luid[8]; + unsigned int luidDeviceNodeMask; + size_t totalGlobalMem; + size_t sharedMemPerBlock; + int regsPerBlock; + int warpSize; + size_t memPitch; + int maxThreadsPerBlock; + int maxThreadsDim[3]; + int maxGridSize[3]; + int clockRate; + size_t totalConstMem; + int major; + int minor; + size_t textureAlignment; + size_t texturePitchAlignment; + int deviceOverlap; + int multiProcessorCount; + int kernelExecTimeoutEnabled; + int integrated; + int canMapHostMemory; + int computeMode; + int maxTexture1D; + int maxTexture1DMipmap; + int maxTexture1DLinear; + int maxTexture2D[2]; + int maxTexture2DMipmap[2]; + int maxTexture2DLinear[3]; + int maxTexture2DGather[2]; + int maxTexture3D[3]; + int maxTexture3DAlt[3]; + int maxTextureCubemap; + int maxTexture1DLayered[2]; + int maxTexture2DLayered[3]; + int maxTextureCubemapLayered[2]; + int maxSurface1D; + int maxSurface2D[2]; + int maxSurface3D[3]; + int maxSurface1DLayered[2]; + int maxSurface2DLayered[3]; + int maxSurfaceCubemap; + int maxSurfaceCubemapLayered[2]; + size_t surfaceAlignment; + int concurrentKernels; + int ECCEnabled; + int pciBusID; + int pciDeviceID; + int pciDomainID; + int tccDriver; + int asyncEngineCount; + int unifiedAddressing; + int memoryClockRate; + int memoryBusWidth; + int l2CacheSize; + int persistingL2CacheMaxSize; + int maxThreadsPerMultiProcessor; + int streamPrioritiesSupported; + int globalL1CacheSupported; + int localL1CacheSupported; + size_t sharedMemPerMultiprocessor; + int regsPerMultiprocessor; + int managedMemory; + int isMultiGpuBoard; + int multiGpuBoardGroupID; + int hostNativeAtomicSupported; + int singleToDoublePrecisionPerfRatio; + int pageableMemoryAccess; + int concurrentManagedAccess; + int computePreemptionSupported; + int canUseHostPointerForRegisteredMem; + int cooperativeLaunch; + int cooperativeMultiDeviceLaunch; + size_t sharedMemPerBlockOptin; + int pageableMemoryAccessUsesHostPageTables; + int directManagedMemAccessFromHost; + int maxBlocksPerMultiProcessor; + int accessPolicyMaxWindowSize; + size_t reservedSharedMemPerBlock; + int hostRegisterSupported; + int sparseCudaArraySupported; + int hostRegisterReadOnlySupported; + int timelineSemaphoreInteropSupported; + int memoryPoolsSupported; + int gpuDirectRDMASupported; + unsigned int gpuDirectRDMAFlushWritesOptions; + int gpuDirectRDMAWritesOrdering; + unsigned int memoryPoolSupportedHandleTypes; + int deferredMappingCudaArraySupported; + int ipcEventSupported; + int clusterLaunch; + int unifiedFunctionPointers; + int reserved[63]; +}; +# 2528 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef __attribute__((device_builtin)) struct __attribute__((device_builtin)) cudaIpcEventHandle_st +{ + char reserved[64]; +}cudaIpcEventHandle_t; + + + + +typedef __attribute__((device_builtin)) struct __attribute__((device_builtin)) cudaIpcMemHandle_st +{ + char reserved[64]; +}cudaIpcMemHandle_t; + + + + +typedef __attribute__((device_builtin)) struct __attribute__((device_builtin)) cudaMemFabricHandle_st +{ + char reserved[64]; +}cudaMemFabricHandle_t; + + + + +enum __attribute__((device_builtin)) cudaExternalMemoryHandleType { + + + + cudaExternalMemoryHandleTypeOpaqueFd = 1, + + + + cudaExternalMemoryHandleTypeOpaqueWin32 = 2, + + + + cudaExternalMemoryHandleTypeOpaqueWin32Kmt = 3, + + + + cudaExternalMemoryHandleTypeD3D12Heap = 4, + + + + cudaExternalMemoryHandleTypeD3D12Resource = 5, + + + + cudaExternalMemoryHandleTypeD3D11Resource = 6, + + + + cudaExternalMemoryHandleTypeD3D11ResourceKmt = 7, + + + + cudaExternalMemoryHandleTypeNvSciBuf = 8 +}; +# 2627 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct __attribute__((device_builtin)) cudaExternalMemoryHandleDesc { + + + + enum cudaExternalMemoryHandleType type; + union { + + + + + + int fd; +# 2654 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + + + + void *handle; + + + + + const void *name; + } win32; + + + + + const void *nvSciBufObject; + } handle; + + + + unsigned long long size; + + + + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalMemoryBufferDesc { + + + + unsigned long long offset; + + + + unsigned long long size; + + + + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalMemoryMipmappedArrayDesc { + + + + + unsigned long long offset; + + + + struct cudaChannelFormatDesc formatDesc; + + + + struct cudaExtent extent; + + + + + unsigned int flags; + + + + unsigned int numLevels; +}; + + + + +enum __attribute__((device_builtin)) cudaExternalSemaphoreHandleType { + + + + cudaExternalSemaphoreHandleTypeOpaqueFd = 1, + + + + cudaExternalSemaphoreHandleTypeOpaqueWin32 = 2, + + + + cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3, + + + + cudaExternalSemaphoreHandleTypeD3D12Fence = 4, + + + + cudaExternalSemaphoreHandleTypeD3D11Fence = 5, + + + + cudaExternalSemaphoreHandleTypeNvSciSync = 6, + + + + cudaExternalSemaphoreHandleTypeKeyedMutex = 7, + + + + cudaExternalSemaphoreHandleTypeKeyedMutexKmt = 8, + + + + cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9, + + + + cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10 +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreHandleDesc { + + + + enum cudaExternalSemaphoreHandleType type; + union { + + + + + + + int fd; +# 2804 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + + + + void *handle; + + + + + const void *name; + } win32; + + + + const void* nvSciSyncObj; + } handle; + + + + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalParams_v1 { + struct { + + + + struct { + + + + unsigned long long value; + } fence; + union { + + + + + void *fence; + unsigned long long reserved; + } nvSciSync; + + + + struct { + + + + unsigned long long key; + } keyedMutex; + } params; +# 2868 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitParams_v1 { + struct { + + + + struct { + + + + unsigned long long value; + } fence; + union { + + + + + void *fence; + unsigned long long reserved; + } nvSciSync; + + + + struct { + + + + unsigned long long key; + + + + unsigned int timeoutMs; + } keyedMutex; + } params; +# 2917 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalParams{ + struct { + + + + struct { + + + + unsigned long long value; + } fence; + union { + + + + + void *fence; + unsigned long long reserved; + } nvSciSync; + + + + struct { + + + + unsigned long long key; + } keyedMutex; + unsigned int reserved[12]; + } params; +# 2963 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned int flags; + unsigned int reserved[16]; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitParams { + struct { + + + + struct { + + + + unsigned long long value; + } fence; + union { + + + + + void *fence; + unsigned long long reserved; + } nvSciSync; + + + + struct { + + + + unsigned long long key; + + + + unsigned int timeoutMs; + } keyedMutex; + unsigned int reserved[10]; + } params; +# 3014 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned int flags; + unsigned int reserved[16]; +}; +# 3027 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef __attribute__((device_builtin)) enum cudaError cudaError_t; + + + + +typedef __attribute__((device_builtin)) struct CUstream_st *cudaStream_t; + + + + +typedef __attribute__((device_builtin)) struct CUevent_st *cudaEvent_t; + + + + +typedef __attribute__((device_builtin)) struct cudaGraphicsResource *cudaGraphicsResource_t; + + + + +typedef __attribute__((device_builtin)) struct CUexternalMemory_st *cudaExternalMemory_t; + + + + +typedef __attribute__((device_builtin)) struct CUexternalSemaphore_st *cudaExternalSemaphore_t; + + + + +typedef __attribute__((device_builtin)) struct CUgraph_st *cudaGraph_t; + + + + +typedef __attribute__((device_builtin)) struct CUgraphNode_st *cudaGraphNode_t; + + + + +typedef __attribute__((device_builtin)) struct CUuserObject_st *cudaUserObject_t; + + + + +typedef __attribute__((device_builtin)) unsigned long long cudaGraphConditionalHandle; + + + + +typedef __attribute__((device_builtin)) struct CUfunc_st *cudaFunction_t; + + + + +typedef __attribute__((device_builtin)) struct CUkern_st *cudaKernel_t; + + + + +enum __attribute__((device_builtin)) cudaJitOption +{ + + + + + + cudaJitMaxRegisters = 0, +# 3108 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitThreadsPerBlock = 1, + + + + + + + + cudaJitWallTime = 2, +# 3125 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitInfoLogBuffer = 3, +# 3134 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitInfoLogBufferSizeBytes = 4, +# 3143 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitErrorLogBuffer = 5, +# 3152 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitErrorLogBufferSizeBytes = 6, + + + + + + + + cudaJitOptimizationLevel = 7, + + + + + + + + cudaJitFallbackStrategy = 10, + + + + + + + + cudaJitGenerateDebugInfo = 11, + + + + + + + cudaJitLogVerbose = 12, + + + + + + + cudaJitGenerateLineInfo = 13, + + + + + + + + cudaJitCacheMode = 14, + + + + + + + cudaJitPositionIndependentCode = 30, +# 3218 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitMinCtaPerSm = 31, +# 3231 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitMaxThreadsPerBlock = 32, +# 3241 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaJitOverrideDirectiveValues = 33, +}; + + + + + +enum __attribute__((device_builtin)) cudaLibraryOption +{ + cudaLibraryHostUniversalFunctionAndDataTable = 0, +# 3261 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaLibraryBinaryIsPreserved = 1, +}; + +struct __attribute__((device_builtin)) cudalibraryHostUniversalFunctionAndDataTable +{ + void *functionTable; + size_t functionWindowSize; + void *dataTable; + size_t dataWindowSize; +}; + + + + +enum __attribute__((device_builtin)) cudaJit_CacheMode +{ + cudaJitCacheOptionNone = 0, + cudaJitCacheOptionCG, + cudaJitCacheOptionCA +}; + + + + +enum __attribute__((device_builtin)) cudaJit_Fallback +{ + cudaPreferPtx = 0, + + cudaPreferBinary +}; + + + + +typedef __attribute__((device_builtin)) struct CUlib_st *cudaLibrary_t; + + + + +typedef __attribute__((device_builtin)) struct CUmemPoolHandle_st *cudaMemPool_t; + + + + +enum __attribute__((device_builtin)) cudaCGScope { + cudaCGScopeInvalid = 0, + cudaCGScopeGrid = 1, + cudaCGScopeMultiGrid = 2 +}; + + + + +struct __attribute__((device_builtin)) cudaLaunchParams +{ + void *func; + dim3 gridDim; + dim3 blockDim; + void **args; + size_t sharedMem; + cudaStream_t stream; +}; + + + + +struct __attribute__((device_builtin)) cudaKernelNodeParams { + void* func; + dim3 gridDim; + dim3 blockDim; + unsigned int sharedMemBytes; + void **kernelParams; + void **extra; +}; + + + + +struct __attribute__((device_builtin)) cudaKernelNodeParamsV2 { + void* func; + + dim3 gridDim; + dim3 blockDim; + + + + + + unsigned int sharedMemBytes; + void **kernelParams; + void **extra; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalNodeParams { + cudaExternalSemaphore_t* extSemArray; + const struct cudaExternalSemaphoreSignalParams* paramsArray; + unsigned int numExtSems; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalNodeParamsV2 { + cudaExternalSemaphore_t* extSemArray; + const struct cudaExternalSemaphoreSignalParams* paramsArray; + unsigned int numExtSems; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitNodeParams { + cudaExternalSemaphore_t* extSemArray; + const struct cudaExternalSemaphoreWaitParams* paramsArray; + unsigned int numExtSems; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitNodeParamsV2 { + cudaExternalSemaphore_t* extSemArray; + const struct cudaExternalSemaphoreWaitParams* paramsArray; + unsigned int numExtSems; +}; + +enum __attribute__((device_builtin)) cudaGraphConditionalHandleFlags { + cudaGraphCondAssignDefault = 1 +}; + + + + +enum __attribute__((device_builtin)) cudaGraphConditionalNodeType { + cudaGraphCondTypeIf = 0, + cudaGraphCondTypeWhile = 1, + cudaGraphCondTypeSwitch = 2, +}; + + + + +struct __attribute__((device_builtin)) cudaConditionalNodeParams { + cudaGraphConditionalHandle handle; + + + enum cudaGraphConditionalNodeType type; + unsigned int size; + + cudaGraph_t *phGraph_out; +# 3432 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +}; + + + + +enum __attribute__((device_builtin)) cudaGraphNodeType { + cudaGraphNodeTypeKernel = 0x00, + cudaGraphNodeTypeMemcpy = 0x01, + cudaGraphNodeTypeMemset = 0x02, + cudaGraphNodeTypeHost = 0x03, + cudaGraphNodeTypeGraph = 0x04, + cudaGraphNodeTypeEmpty = 0x05, + cudaGraphNodeTypeWaitEvent = 0x06, + cudaGraphNodeTypeEventRecord = 0x07, + cudaGraphNodeTypeExtSemaphoreSignal = 0x08, + cudaGraphNodeTypeExtSemaphoreWait = 0x09, + cudaGraphNodeTypeMemAlloc = 0x0a, + cudaGraphNodeTypeMemFree = 0x0b, + cudaGraphNodeTypeConditional = 0x0d, +# 3467 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaGraphNodeTypeCount +}; + + + + +struct __attribute__((device_builtin)) cudaChildGraphNodeParams { + cudaGraph_t graph; + +}; + + + + +struct __attribute__((device_builtin)) cudaEventRecordNodeParams { + cudaEvent_t event; +}; + + + + +struct __attribute__((device_builtin)) cudaEventWaitNodeParams { + cudaEvent_t event; +}; + + + + +struct __attribute__((device_builtin)) cudaGraphNodeParams { + enum cudaGraphNodeType type; + int reserved0[3]; + + union { + long long reserved1[29]; + struct cudaKernelNodeParamsV2 kernel; + struct cudaMemcpyNodeParams memcpy; + struct cudaMemsetParamsV2 memset; + struct cudaHostNodeParamsV2 host; + struct cudaChildGraphNodeParams graph; + struct cudaEventWaitNodeParams eventWait; + struct cudaEventRecordNodeParams eventRecord; + struct cudaExternalSemaphoreSignalNodeParamsV2 extSemSignal; + struct cudaExternalSemaphoreWaitNodeParamsV2 extSemWait; + struct cudaMemAllocNodeParamsV2 alloc; + struct cudaMemFreeNodeParams free; + struct cudaConditionalNodeParams conditional; + }; + + long long reserved2; +}; + + + + +typedef __attribute__((device_builtin)) enum cudaGraphDependencyType_enum { + cudaGraphDependencyTypeDefault = 0, + cudaGraphDependencyTypeProgrammatic = 1 + + + + +} cudaGraphDependencyType; + + + + + + +typedef __attribute__((device_builtin)) struct cudaGraphEdgeData_st { + unsigned char from_port; +# 3546 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned char to_port; + + + + + + + unsigned char type; + + + unsigned char reserved[5]; + +} cudaGraphEdgeData; +# 3579 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef struct CUgraphExec_st* cudaGraphExec_t; + + + + +enum __attribute__((device_builtin)) cudaGraphExecUpdateResult { + cudaGraphExecUpdateSuccess = 0x0, + cudaGraphExecUpdateError = 0x1, + cudaGraphExecUpdateErrorTopologyChanged = 0x2, + cudaGraphExecUpdateErrorNodeTypeChanged = 0x3, + cudaGraphExecUpdateErrorFunctionChanged = 0x4, + cudaGraphExecUpdateErrorParametersChanged = 0x5, + cudaGraphExecUpdateErrorNotSupported = 0x6, + cudaGraphExecUpdateErrorUnsupportedFunctionChange = 0x7, + cudaGraphExecUpdateErrorAttributesChanged = 0x8 +}; + + + + +typedef __attribute__((device_builtin)) enum cudaGraphInstantiateResult { + cudaGraphInstantiateSuccess = 0, + cudaGraphInstantiateError = 1, + cudaGraphInstantiateInvalidStructure = 2, + cudaGraphInstantiateNodeOperationNotSupported = 3, + cudaGraphInstantiateMultipleDevicesNotSupported = 4, + cudaGraphInstantiateConditionalHandleUnused = 5 +} cudaGraphInstantiateResult; + + + + +typedef __attribute__((device_builtin)) struct cudaGraphInstantiateParams_st +{ + unsigned long long flags; + cudaStream_t uploadStream; + cudaGraphNode_t errNode_out; + cudaGraphInstantiateResult result_out; +} cudaGraphInstantiateParams; + + + + +typedef __attribute__((device_builtin)) struct cudaGraphExecUpdateResultInfo_st { + + + + enum cudaGraphExecUpdateResult result; + + + + + + + cudaGraphNode_t errorNode; + + + + + cudaGraphNode_t errorFromNode; +} cudaGraphExecUpdateResultInfo; + + + + +typedef struct CUgraphDeviceUpdatableNode_st* cudaGraphDeviceNode_t; + + + + +enum __attribute__((device_builtin)) cudaGraphKernelNodeField +{ + cudaGraphKernelNodeFieldInvalid = 0, + cudaGraphKernelNodeFieldGridDim, + cudaGraphKernelNodeFieldParam, + cudaGraphKernelNodeFieldEnabled +}; + + + + +struct __attribute__((device_builtin)) cudaGraphKernelNodeUpdate { + cudaGraphDeviceNode_t node; + enum cudaGraphKernelNodeField field; + union { + + dim3 gridDim; + + + + + struct { + const void *pValue; + size_t offset; + size_t size; + } param; + unsigned int isEnabled; + } updateData; +}; + + + + + +enum __attribute__((device_builtin)) cudaGetDriverEntryPointFlags { + cudaEnableDefault = 0x0, + cudaEnableLegacyStream = 0x1, + cudaEnablePerThreadDefaultStream = 0x2 +}; + + + + +enum __attribute__((device_builtin)) cudaDriverEntryPointQueryResult { + cudaDriverEntryPointSuccess = 0, + cudaDriverEntryPointSymbolNotFound = 1, + cudaDriverEntryPointVersionNotSufficent = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaGraphDebugDotFlags { + cudaGraphDebugDotFlagsVerbose = 1<<0, + cudaGraphDebugDotFlagsKernelNodeParams = 1<<2, + cudaGraphDebugDotFlagsMemcpyNodeParams = 1<<3, + cudaGraphDebugDotFlagsMemsetNodeParams = 1<<4, + cudaGraphDebugDotFlagsHostNodeParams = 1<<5, + cudaGraphDebugDotFlagsEventNodeParams = 1<<6, + cudaGraphDebugDotFlagsExtSemasSignalNodeParams = 1<<7, + cudaGraphDebugDotFlagsExtSemasWaitNodeParams = 1<<8, + cudaGraphDebugDotFlagsKernelNodeAttributes = 1<<9, + cudaGraphDebugDotFlagsHandles = 1<<10, + cudaGraphDebugDotFlagsConditionalNodeParams = 1<<15, +}; + + + + +enum __attribute__((device_builtin)) cudaGraphInstantiateFlags { + cudaGraphInstantiateFlagAutoFreeOnLaunch = 1 + , cudaGraphInstantiateFlagUpload = 2 + + + , cudaGraphInstantiateFlagDeviceLaunch = 4 + + + , cudaGraphInstantiateFlagUseNodePriority = 8 + +}; +# 3746 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef __attribute__((device_builtin)) enum cudaLaunchMemSyncDomain { + cudaLaunchMemSyncDomainDefault = 0, + cudaLaunchMemSyncDomainRemote = 1 +} cudaLaunchMemSyncDomain; +# 3762 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef __attribute__((device_builtin)) struct cudaLaunchMemSyncDomainMap_st { + unsigned char default_; + unsigned char remote; +} cudaLaunchMemSyncDomainMap; + + + + +typedef __attribute__((device_builtin)) enum cudaLaunchAttributeID { + cudaLaunchAttributeIgnore = 0 + , cudaLaunchAttributeAccessPolicyWindow = 1 + + , cudaLaunchAttributeCooperative = 2 + + , cudaLaunchAttributeSynchronizationPolicy = 3 + , cudaLaunchAttributeClusterDimension = 4 + + , cudaLaunchAttributeClusterSchedulingPolicyPreference = 5 + + , cudaLaunchAttributeProgrammaticStreamSerialization = 6 +# 3792 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributeProgrammaticEvent = 7 +# 3818 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributePriority = 8 + + , cudaLaunchAttributeMemSyncDomainMap = 9 + + , cudaLaunchAttributeMemSyncDomain = 10 + + , cudaLaunchAttributePreferredClusterDimension = 11 +# 3860 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributeLaunchCompletionEvent = 12 +# 3882 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributeDeviceUpdatableKernelNode = 13 +# 3910 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributePreferredSharedMemoryCarveout = 14 + + + + + + +} cudaLaunchAttributeID; + + + + +typedef __attribute__((device_builtin)) union cudaLaunchAttributeValue { + char pad[64]; + struct cudaAccessPolicyWindow accessPolicyWindow; + int cooperative; + + enum cudaSynchronizationPolicy syncPolicy; +# 3941 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + unsigned int x; + unsigned int y; + unsigned int z; + } clusterDim; + enum cudaClusterSchedulingPolicy clusterSchedulingPolicyPreference; + + + int programmaticStreamSerializationAllowed; +# 3960 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + cudaEvent_t event; + int flags; + int triggerAtBlockStart; + } programmaticEvent; + int priority; + cudaLaunchMemSyncDomainMap memSyncDomainMap; + + + cudaLaunchMemSyncDomain memSyncDomain; +# 3984 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + unsigned int x; + unsigned int y; + unsigned int z; + } preferredClusterDim; +# 3997 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + cudaEvent_t event; + int flags; + } launchCompletionEvent; + + + + + + + + struct { + int deviceUpdatable; + cudaGraphDeviceNode_t devNode; + } deviceUpdatableKernelNode; + unsigned int sharedMemCarveout; +} cudaLaunchAttributeValue; + + + + +typedef __attribute__((device_builtin)) struct cudaLaunchAttribute_st { + cudaLaunchAttributeID id; + char pad[8 - sizeof(cudaLaunchAttributeID)]; + cudaLaunchAttributeValue val; +} cudaLaunchAttribute; + + + + +typedef __attribute__((device_builtin)) struct cudaLaunchConfig_st { + dim3 gridDim; + dim3 blockDim; + size_t dynamicSmemBytes; + cudaStream_t stream; + cudaLaunchAttribute *attrs; + unsigned int numAttrs; +} cudaLaunchConfig_t; +# 4061 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +enum __attribute__((device_builtin)) cudaDeviceNumaConfig { + cudaDeviceNumaConfigNone = 0, + cudaDeviceNumaConfigNumaNode, +}; + + + + +typedef struct cudaAsyncCallbackEntry* cudaAsyncCallbackHandle_t; + +struct cudaAsyncCallbackEntry; + + + + +typedef __attribute__((device_builtin)) enum cudaAsyncNotificationType_enum { + cudaAsyncNotificationTypeOverBudget = 0x1 +} cudaAsyncNotificationType; + + + + +typedef __attribute__((device_builtin)) struct cudaAsyncNotificationInfo +{ + cudaAsyncNotificationType type; + union { + struct { + unsigned long long bytesOverBudget; + } overBudget; + } info; +} cudaAsyncNotificationInfo_t; + +typedef void (*cudaAsyncCallback)(cudaAsyncNotificationInfo_t*, void*, cudaAsyncCallbackHandle_t); +# 60 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_types.h" 1 +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_types.h" +enum __attribute__((device_builtin)) cudaSurfaceBoundaryMode +{ + cudaBoundaryModeZero = 0, + cudaBoundaryModeClamp = 1, + cudaBoundaryModeTrap = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaSurfaceFormatMode +{ + cudaFormatModeForced = 0, + cudaFormatModeAuto = 1 +}; + + + + +typedef __attribute__((device_builtin)) unsigned long long cudaSurfaceObject_t; +# 63 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_types.h" 1 +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_types.h" +enum __attribute__((device_builtin)) cudaTextureAddressMode +{ + cudaAddressModeWrap = 0, + cudaAddressModeClamp = 1, + cudaAddressModeMirror = 2, + cudaAddressModeBorder = 3 +}; + + + + +enum __attribute__((device_builtin)) cudaTextureFilterMode +{ + cudaFilterModePoint = 0, + cudaFilterModeLinear = 1 +}; + + + + +enum __attribute__((device_builtin)) cudaTextureReadMode +{ + cudaReadModeElementType = 0, + cudaReadModeNormalizedFloat = 1 +}; + + + + +struct __attribute__((device_builtin)) cudaTextureDesc +{ + + + + enum cudaTextureAddressMode addressMode[3]; + + + + enum cudaTextureFilterMode filterMode; + + + + enum cudaTextureReadMode readMode; + + + + int sRGB; + + + + float borderColor[4]; + + + + int normalizedCoords; + + + + unsigned int maxAnisotropy; + + + + enum cudaTextureFilterMode mipmapFilterMode; + + + + float mipmapLevelBias; + + + + float minMipmapLevelClamp; + + + + float maxMipmapLevelClamp; + + + + int disableTrilinearOptimization; + + + + int seamlessCubemap; +}; + + + + +typedef __attribute__((device_builtin)) unsigned long long cudaTextureObject_t; +# 64 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 2 +# 91 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/library_types.h" 1 +# 57 "/opt/cuda/bin/../targets/x86_64-linux/include/library_types.h" +typedef enum cudaDataType_t +{ + CUDA_R_16F = 2, + CUDA_C_16F = 6, + CUDA_R_16BF = 14, + CUDA_C_16BF = 15, + CUDA_R_32F = 0, + CUDA_C_32F = 4, + CUDA_R_64F = 1, + CUDA_C_64F = 5, + CUDA_R_4I = 16, + CUDA_C_4I = 17, + CUDA_R_4U = 18, + CUDA_C_4U = 19, + CUDA_R_8I = 3, + CUDA_C_8I = 7, + CUDA_R_8U = 8, + CUDA_C_8U = 9, + CUDA_R_16I = 20, + CUDA_C_16I = 21, + CUDA_R_16U = 22, + CUDA_C_16U = 23, + CUDA_R_32I = 10, + CUDA_C_32I = 11, + CUDA_R_32U = 12, + CUDA_C_32U = 13, + CUDA_R_64I = 24, + CUDA_C_64I = 25, + CUDA_R_64U = 26, + CUDA_C_64U = 27, + CUDA_R_8F_E4M3 = 28, + CUDA_R_8F_UE4M3 = CUDA_R_8F_E4M3, + CUDA_R_8F_E5M2 = 29, + CUDA_R_8F_UE8M0 = 30, + CUDA_R_6F_E2M3 = 31, + CUDA_R_6F_E3M2 = 32, + CUDA_R_4F_E2M1 = 33, +} cudaDataType; + + +typedef enum libraryPropertyType_t +{ + MAJOR_VERSION, + MINOR_VERSION, + PATCH_LEVEL +} libraryPropertyType; +# 92 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" 1 +# 61 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 1 +# 148 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 149 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 151 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" 1 +# 54 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h" 1 3 +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 308 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 + +# 308 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + typedef long unsigned int size_t; + typedef long int ptrdiff_t; + + + typedef decltype(nullptr) nullptr_t; + + +#pragma GCC visibility push(default) + + + extern "C++" __attribute__ ((__noreturn__, __always_inline__)) + inline void __terminate() noexcept + { + void terminate() noexcept __attribute__ ((__noreturn__,__cold__)); + terminate(); + } +#pragma GCC visibility pop +} +# 341 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +namespace __gnu_cxx +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +# 534 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ +#pragma GCC visibility push(default) + + + + + __attribute__((__always_inline__)) + constexpr inline bool + __is_constant_evaluated() noexcept + { + + + + + + return __builtin_is_constant_evaluated(); + + + + } +#pragma GCC visibility pop +} +# 573 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ +#pragma GCC visibility push(default) + + extern "C++" __attribute__ ((__noreturn__)) + void + __glibcxx_assert_fail + (const char* __file, int __line, const char* __function, + const char* __condition) + noexcept; +#pragma GCC visibility pop +} +# 604 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + __attribute__((__always_inline__,__visibility__("default"))) + inline void + __glibcxx_assert_fail() + { } +} +# 683 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3 +# 684 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3 +# 687 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 828 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace __gnu_cxx +{ + typedef __decltype(0.0bf16) __bfloat16_t; +} +# 890 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/pstl/pstl_config.h" 1 3 +# 891 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 2 3 +# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +# 1 "/usr/include/stdlib.h" 1 3 4 +# 26 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/stdlib.h" 2 3 4 + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 33 "/usr/include/stdlib.h" 2 3 4 + +extern "C" { + + + + + +# 1 "/usr/include/bits/waitflags.h" 1 3 4 +# 41 "/usr/include/stdlib.h" 2 3 4 +# 1 "/usr/include/bits/waitstatus.h" 1 3 4 +# 42 "/usr/include/stdlib.h" 2 3 4 +# 56 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/floatn.h" 1 3 4 +# 131 "/usr/include/bits/floatn.h" 3 4 +# 1 "/usr/include/bits/floatn-common.h" 1 3 4 +# 24 "/usr/include/bits/floatn-common.h" 3 4 +# 1 "/usr/include/bits/long-double.h" 1 3 4 +# 25 "/usr/include/bits/floatn-common.h" 2 3 4 +# 132 "/usr/include/bits/floatn.h" 2 3 4 +# 57 "/usr/include/stdlib.h" 2 3 4 + + +typedef struct + { + int quot; + int rem; + } div_t; + + + +typedef struct + { + long int quot; + long int rem; + } ldiv_t; + + + + + +__extension__ typedef struct + { + long long int quot; + long long int rem; + } lldiv_t; +# 98 "/usr/include/stdlib.h" 3 4 +extern size_t __ctype_get_mb_cur_max (void) noexcept (true) ; + + + +extern double atof (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern int atoi (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern long int atol (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +__extension__ extern long long int atoll (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +extern double strtod (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern float strtof (const char *__restrict __nptr, + char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern long double strtold (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 141 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float64 strtof64 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float128 strtof128 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float32x strtof32x (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float64x strtof64x (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 177 "/usr/include/stdlib.h" 3 4 +extern long int strtol (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern unsigned long int strtoul (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern long int strtol (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtol") + + + __attribute__ ((__nonnull__ (1))); +extern unsigned long int strtoul (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoul") + + + + __attribute__ ((__nonnull__ (1))); + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") + + + __attribute__ ((__nonnull__ (1))); +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") + + + + __attribute__ ((__nonnull__ (1))); + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") + + + __attribute__ ((__nonnull__ (1))); +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") + + + + __attribute__ ((__nonnull__ (1))); +# 278 "/usr/include/stdlib.h" 3 4 +extern int strfromd (char *__dest, size_t __size, const char *__format, + double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfromf (char *__dest, size_t __size, const char *__format, + float __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfroml (char *__dest, size_t __size, const char *__format, + long double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 298 "/usr/include/stdlib.h" 3 4 +extern int strfromf32 (char *__dest, size_t __size, const char * __format, + _Float32 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64 (char *__dest, size_t __size, const char * __format, + _Float64 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf128 (char *__dest, size_t __size, const char * __format, + _Float128 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf32x (char *__dest, size_t __size, const char * __format, + _Float32x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64x (char *__dest, size_t __size, const char * __format, + _Float64x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 340 "/usr/include/stdlib.h" 3 4 +extern long int strtol_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +extern unsigned long int strtoul_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + + + + + +extern long int strtol_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtol_l") + + + + __attribute__ ((__nonnull__ (1, 4))); +extern unsigned long int strtoul_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoul_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoll_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoull_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +# 415 "/usr/include/stdlib.h" 3 4 +extern double strtod_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern float strtof_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern long double strtold_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 436 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64 strtof64_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float128 strtof128_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float32x strtof32x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64x strtof64x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 505 "/usr/include/stdlib.h" 3 4 +extern char *l64a (long int __n) noexcept (true) ; + + +extern long int a64l (const char *__s) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + + +# 1 "/usr/include/sys/types.h" 1 3 4 +# 27 "/usr/include/sys/types.h" 3 4 +extern "C" { + + + + + +typedef __u_char u_char; +typedef __u_short u_short; +typedef __u_int u_int; +typedef __u_long u_long; +typedef __quad_t quad_t; +typedef __u_quad_t u_quad_t; +typedef __fsid_t fsid_t; + + +typedef __loff_t loff_t; + + + + +typedef __ino_t ino_t; + + + + + + +typedef __ino64_t ino64_t; + + + + +typedef __dev_t dev_t; + + + + +typedef __gid_t gid_t; + + + + +typedef __mode_t mode_t; + + + + +typedef __nlink_t nlink_t; + + + + +typedef __uid_t uid_t; + + + + + +typedef __off_t off_t; + + + + + + +typedef __off64_t off64_t; + + + + +typedef __pid_t pid_t; + + + + + +typedef __id_t id_t; + + + + +typedef __ssize_t ssize_t; + + + + + +typedef __daddr_t daddr_t; +typedef __caddr_t caddr_t; + + + + + +typedef __key_t key_t; + + + + +# 1 "/usr/include/bits/types/clock_t.h" 1 3 4 + + + + + + +typedef __clock_t clock_t; +# 127 "/usr/include/sys/types.h" 2 3 4 + +# 1 "/usr/include/bits/types/clockid_t.h" 1 3 4 + + + + + + +typedef __clockid_t clockid_t; +# 129 "/usr/include/sys/types.h" 2 3 4 +# 1 "/usr/include/bits/types/time_t.h" 1 3 4 +# 10 "/usr/include/bits/types/time_t.h" 3 4 +typedef __time_t time_t; +# 130 "/usr/include/sys/types.h" 2 3 4 +# 1 "/usr/include/bits/types/timer_t.h" 1 3 4 + + + + + + +typedef __timer_t timer_t; +# 131 "/usr/include/sys/types.h" 2 3 4 + + + +typedef __useconds_t useconds_t; + + + +typedef __suseconds_t suseconds_t; + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 145 "/usr/include/sys/types.h" 2 3 4 + + + +typedef unsigned long int ulong; +typedef unsigned short int ushort; +typedef unsigned int uint; + + + + +# 1 "/usr/include/bits/stdint-intn.h" 1 3 4 +# 24 "/usr/include/bits/stdint-intn.h" 3 4 +typedef __int8_t int8_t; +typedef __int16_t int16_t; +typedef __int32_t int32_t; +typedef __int64_t int64_t; +# 156 "/usr/include/sys/types.h" 2 3 4 + + +typedef __uint8_t u_int8_t; +typedef __uint16_t u_int16_t; +typedef __uint32_t u_int32_t; +typedef __uint64_t u_int64_t; + + +typedef int register_t __attribute__ ((__mode__ (__word__))); +# 176 "/usr/include/sys/types.h" 3 4 +# 1 "/usr/include/endian.h" 1 3 4 +# 35 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/bits/byteswap.h" 1 3 4 +# 33 "/usr/include/bits/byteswap.h" 3 4 +static __inline __uint16_t +__bswap_16 (__uint16_t __bsx) +{ + + return __builtin_bswap16 (__bsx); + + + +} + + + + + + +static __inline __uint32_t +__bswap_32 (__uint32_t __bsx) +{ + + return __builtin_bswap32 (__bsx); + + + +} +# 69 "/usr/include/bits/byteswap.h" 3 4 +__extension__ static __inline __uint64_t +__bswap_64 (__uint64_t __bsx) +{ + + return __builtin_bswap64 (__bsx); + + + +} +# 36 "/usr/include/endian.h" 2 3 4 +# 1 "/usr/include/bits/uintn-identity.h" 1 3 4 +# 32 "/usr/include/bits/uintn-identity.h" 3 4 +static __inline __uint16_t +__uint16_identity (__uint16_t __x) +{ + return __x; +} + +static __inline __uint32_t +__uint32_identity (__uint32_t __x) +{ + return __x; +} + +static __inline __uint64_t +__uint64_identity (__uint64_t __x) +{ + return __x; +} +# 37 "/usr/include/endian.h" 2 3 4 +# 177 "/usr/include/sys/types.h" 2 3 4 + + +# 1 "/usr/include/sys/select.h" 1 3 4 +# 30 "/usr/include/sys/select.h" 3 4 +# 1 "/usr/include/bits/select.h" 1 3 4 +# 31 "/usr/include/sys/select.h" 2 3 4 + + +# 1 "/usr/include/bits/types/sigset_t.h" 1 3 4 + + + +# 1 "/usr/include/bits/types/__sigset_t.h" 1 3 4 + + + + +typedef struct +{ + unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; +} __sigset_t; +# 5 "/usr/include/bits/types/sigset_t.h" 2 3 4 + + +typedef __sigset_t sigset_t; +# 34 "/usr/include/sys/select.h" 2 3 4 + + + +# 1 "/usr/include/bits/types/struct_timeval.h" 1 3 4 + + + + + + + +struct timeval +{ + + + + + __time_t tv_sec; + __suseconds_t tv_usec; + +}; +# 38 "/usr/include/sys/select.h" 2 3 4 + +# 1 "/usr/include/bits/types/struct_timespec.h" 1 3 4 +# 11 "/usr/include/bits/types/struct_timespec.h" 3 4 +struct timespec +{ + + + + __time_t tv_sec; + + + + + __syscall_slong_t tv_nsec; +# 31 "/usr/include/bits/types/struct_timespec.h" 3 4 +}; +# 40 "/usr/include/sys/select.h" 2 3 4 +# 49 "/usr/include/sys/select.h" 3 4 +typedef long int __fd_mask; +# 59 "/usr/include/sys/select.h" 3 4 +typedef struct + { + + + + __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; + + + + + + } fd_set; + + + + + + +typedef __fd_mask fd_mask; +# 91 "/usr/include/sys/select.h" 3 4 +extern "C" { +# 102 "/usr/include/sys/select.h" 3 4 +extern int select (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + struct timeval *__restrict __timeout); +# 127 "/usr/include/sys/select.h" 3 4 +extern int pselect (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + const struct timespec *__restrict __timeout, + const __sigset_t *__restrict __sigmask); +# 153 "/usr/include/sys/select.h" 3 4 +} +# 180 "/usr/include/sys/types.h" 2 3 4 + + + + + +typedef __blksize_t blksize_t; + + + + + + +typedef __blkcnt_t blkcnt_t; + + + +typedef __fsblkcnt_t fsblkcnt_t; + + + +typedef __fsfilcnt_t fsfilcnt_t; +# 219 "/usr/include/sys/types.h" 3 4 +typedef __blkcnt64_t blkcnt64_t; +typedef __fsblkcnt64_t fsblkcnt64_t; +typedef __fsfilcnt64_t fsfilcnt64_t; + + + + + +# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4 +# 23 "/usr/include/bits/pthreadtypes.h" 3 4 +# 1 "/usr/include/bits/thread-shared-types.h" 1 3 4 +# 44 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/pthreadtypes-arch.h" 1 3 4 +# 21 "/usr/include/bits/pthreadtypes-arch.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 22 "/usr/include/bits/pthreadtypes-arch.h" 2 3 4 +# 45 "/usr/include/bits/thread-shared-types.h" 2 3 4 + +# 1 "/usr/include/bits/atomic_wide_counter.h" 1 3 4 +# 25 "/usr/include/bits/atomic_wide_counter.h" 3 4 +typedef union +{ + __extension__ unsigned long long int __value64; + struct + { + unsigned int __low; + unsigned int __high; + } __value32; +} __atomic_wide_counter; +# 47 "/usr/include/bits/thread-shared-types.h" 2 3 4 + + + + +typedef struct __pthread_internal_list +{ + struct __pthread_internal_list *__prev; + struct __pthread_internal_list *__next; +} __pthread_list_t; + +typedef struct __pthread_internal_slist +{ + struct __pthread_internal_slist *__next; +} __pthread_slist_t; +# 76 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/struct_mutex.h" 1 3 4 +# 22 "/usr/include/bits/struct_mutex.h" 3 4 +struct __pthread_mutex_s +{ + int __lock; + unsigned int __count; + int __owner; + + unsigned int __nusers; + + + + int __kind; + + short __spins; + short __elision; + __pthread_list_t __list; +# 53 "/usr/include/bits/struct_mutex.h" 3 4 +}; +# 77 "/usr/include/bits/thread-shared-types.h" 2 3 4 +# 89 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/struct_rwlock.h" 1 3 4 +# 23 "/usr/include/bits/struct_rwlock.h" 3 4 +struct __pthread_rwlock_arch_t +{ + unsigned int __readers; + unsigned int __writers; + unsigned int __wrphase_futex; + unsigned int __writers_futex; + unsigned int __pad3; + unsigned int __pad4; + + int __cur_writer; + int __shared; + signed char __rwelision; + + + + + unsigned char __pad1[7]; + + + unsigned long int __pad2; + + + unsigned int __flags; +# 55 "/usr/include/bits/struct_rwlock.h" 3 4 +}; +# 90 "/usr/include/bits/thread-shared-types.h" 2 3 4 + + + + +struct __pthread_cond_s +{ + __atomic_wide_counter __wseq; + __atomic_wide_counter __g1_start; + unsigned int __g_size[2] ; + unsigned int __g1_orig_size; + unsigned int __wrefs; + unsigned int __g_signals[2]; + unsigned int __unused_initialized_1; + unsigned int __unused_initialized_2; +}; + +typedef unsigned int __tss_t; +typedef unsigned long int __thrd_t; + +typedef struct +{ + int __data ; +} __once_flag; +# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4 + + + +typedef unsigned long int pthread_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_mutexattr_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_condattr_t; + + + +typedef unsigned int pthread_key_t; + + + +typedef int pthread_once_t; + + +union pthread_attr_t +{ + char __size[56]; + long int __align; +}; + +typedef union pthread_attr_t pthread_attr_t; + + + + +typedef union +{ + struct __pthread_mutex_s __data; + char __size[40]; + long int __align; +} pthread_mutex_t; + + +typedef union +{ + struct __pthread_cond_s __data; + char __size[48]; + __extension__ long long int __align; +} pthread_cond_t; + + + + + +typedef union +{ + struct __pthread_rwlock_arch_t __data; + char __size[56]; + long int __align; +} pthread_rwlock_t; + +typedef union +{ + char __size[8]; + long int __align; +} pthread_rwlockattr_t; + + + + + +typedef volatile int pthread_spinlock_t; + + + + +typedef union +{ + char __size[32]; + long int __align; +} pthread_barrier_t; + +typedef union +{ + char __size[4]; + int __align; +} pthread_barrierattr_t; +# 228 "/usr/include/sys/types.h" 2 3 4 + + +} +# 515 "/usr/include/stdlib.h" 2 3 4 + + + + + + +extern long int random (void) noexcept (true); + + +extern void srandom (unsigned int __seed) noexcept (true); + + + + + +extern char *initstate (unsigned int __seed, char *__statebuf, + size_t __statelen) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern char *setstate (char *__statebuf) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + + +struct random_data + { + int32_t *fptr; + int32_t *rptr; + int32_t *state; + int rand_type; + int rand_deg; + int rand_sep; + int32_t *end_ptr; + }; + +extern int random_r (struct random_data *__restrict __buf, + int32_t *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern int srandom_r (unsigned int __seed, struct random_data *__buf) + noexcept (true) __attribute__ ((__nonnull__ (2))); + +extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, + size_t __statelen, + struct random_data *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (2, 4))); + +extern int setstate_r (char *__restrict __statebuf, + struct random_data *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern int rand (void) noexcept (true); + +extern void srand (unsigned int __seed) noexcept (true); + + + +extern int rand_r (unsigned int *__seed) noexcept (true); + + + + + + + +extern double drand48 (void) noexcept (true); +extern double erand48 (unsigned short int __xsubi[3]) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int lrand48 (void) noexcept (true); +extern long int nrand48 (unsigned short int __xsubi[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int mrand48 (void) noexcept (true); +extern long int jrand48 (unsigned short int __xsubi[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void srand48 (long int __seedval) noexcept (true); +extern unsigned short int *seed48 (unsigned short int __seed16v[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); +extern void lcong48 (unsigned short int __param[7]) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +struct drand48_data + { + unsigned short int __x[3]; + unsigned short int __old_x[3]; + unsigned short int __c; + unsigned short int __init; + __extension__ unsigned long long int __a; + + }; + + +extern int drand48_r (struct drand48_data *__restrict __buffer, + double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int erand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int lrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int nrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int mrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int jrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int srand48_r (long int __seedval, struct drand48_data *__buffer) + noexcept (true) __attribute__ ((__nonnull__ (2))); + +extern int seed48_r (unsigned short int __seed16v[3], + struct drand48_data *__buffer) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern int lcong48_r (unsigned short int __param[7], + struct drand48_data *__buffer) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern __uint32_t arc4random (void) + noexcept (true) ; + + +extern void arc4random_buf (void *__buf, size_t __size) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern __uint32_t arc4random_uniform (__uint32_t __upper_bound) + noexcept (true) ; + + + + +extern void *malloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) + __attribute__ ((__alloc_size__ (1))) ; + +extern void *calloc (size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) ; + + + + + + +extern void *realloc (void *__ptr, size_t __size) + noexcept (true) __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2))); + + +extern void free (void *__ptr) noexcept (true); + + + + + + + +extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__warn_unused_result__)) + __attribute__ ((__alloc_size__ (2, 3))) + __attribute__ ((__malloc__ (__builtin_free, 1))); + + +extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__malloc__ (reallocarray, 1))); + + + +# 1 "/usr/include/alloca.h" 1 3 4 +# 24 "/usr/include/alloca.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 25 "/usr/include/alloca.h" 2 3 4 + +extern "C" { + + + + + +extern void *alloca (size_t __size) noexcept (true); + + + + + +} +# 707 "/usr/include/stdlib.h" 2 3 4 + + + + + +extern void *valloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) + __attribute__ ((__alloc_size__ (1))) ; + + + + +extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) + noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + +extern void *aligned_alloc (size_t __alignment, size_t __size) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_align__ (1))) + __attribute__ ((__alloc_size__ (2))) ; + + + +extern void abort (void) noexcept (true) __attribute__ ((__noreturn__)) __attribute__ ((__cold__)); + + + +extern int atexit (void (*__func) (void)) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern "C++" int at_quick_exit (void (*__func) (void)) + noexcept (true) __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1))); +# 749 "/usr/include/stdlib.h" 3 4 +extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern void exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + + +extern void quick_exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + + +extern void _Exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + +extern char *getenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + +extern char *secure_getenv (const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + + + +extern int putenv (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern int setenv (const char *__name, const char *__value, int __replace) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + +extern int unsetenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern int clearenv (void) noexcept (true); +# 814 "/usr/include/stdlib.h" 3 4 +extern char *mktemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))); +# 827 "/usr/include/stdlib.h" 3 4 +extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 837 "/usr/include/stdlib.h" 3 4 +extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 849 "/usr/include/stdlib.h" 3 4 +extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; +# 859 "/usr/include/stdlib.h" 3 4 +extern int mkstemps64 (char *__template, int __suffixlen) + __attribute__ ((__nonnull__ (1))) ; +# 870 "/usr/include/stdlib.h" 3 4 +extern char *mkdtemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))) ; +# 881 "/usr/include/stdlib.h" 3 4 +extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 891 "/usr/include/stdlib.h" 3 4 +extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 901 "/usr/include/stdlib.h" 3 4 +extern int mkostemps (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 913 "/usr/include/stdlib.h" 3 4 +extern int mkostemps64 (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 923 "/usr/include/stdlib.h" 3 4 +extern int system (const char *__command) ; + + + + + +extern char *canonicalize_file_name (const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__malloc__)) + __attribute__ ((__malloc__ (__builtin_free, 1))) ; +# 940 "/usr/include/stdlib.h" 3 4 +extern char *realpath (const char *__restrict __name, + char *__restrict __resolved) noexcept (true) ; + + + + + + +typedef int (*__compar_fn_t) (const void *, const void *); + + +typedef __compar_fn_t comparison_fn_t; + + + +typedef int (*__compar_d_fn_t) (const void *, const void *, void *); + + + + +extern void *bsearch (const void *__key, const void *__base, + size_t __nmemb, size_t __size, __compar_fn_t __compar) + __attribute__ ((__nonnull__ (1, 2, 5))) ; + + + + + + + +extern void qsort (void *__base, size_t __nmemb, size_t __size, + __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4))); + +extern void qsort_r (void *__base, size_t __nmemb, size_t __size, + __compar_d_fn_t __compar, void *__arg) + __attribute__ ((__nonnull__ (1, 4))); + + + + +extern int abs (int __x) noexcept (true) __attribute__ ((__const__)) ; +extern long int labs (long int __x) noexcept (true) __attribute__ ((__const__)) ; + + +__extension__ extern long long int llabs (long long int __x) + noexcept (true) __attribute__ ((__const__)) ; + + + + + + +extern div_t div (int __numer, int __denom) + noexcept (true) __attribute__ ((__const__)) ; +extern ldiv_t ldiv (long int __numer, long int __denom) + noexcept (true) __attribute__ ((__const__)) ; + + +__extension__ extern lldiv_t lldiv (long long int __numer, + long long int __denom) + noexcept (true) __attribute__ ((__const__)) ; +# 1012 "/usr/include/stdlib.h" 3 4 +extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *gcvt (double __value, int __ndigit, char *__buf) + noexcept (true) __attribute__ ((__nonnull__ (3))) ; + + + + +extern char *qecvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qfcvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qgcvt (long double __value, int __ndigit, char *__buf) + noexcept (true) __attribute__ ((__nonnull__ (3))) ; + + + + +extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); +extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); + +extern int qecvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); +extern int qfcvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); + + + + + +extern int mblen (const char *__s, size_t __n) noexcept (true); + + +extern int mbtowc (wchar_t *__restrict __pwc, + const char *__restrict __s, size_t __n) noexcept (true); + + +extern int wctomb (char *__s, wchar_t __wchar) noexcept (true); + + + +extern size_t mbstowcs (wchar_t *__restrict __pwcs, + const char *__restrict __s, size_t __n) noexcept (true) + __attribute__ ((__access__ (__read_only__, 2))); + +extern size_t wcstombs (char *__restrict __s, + const wchar_t *__restrict __pwcs, size_t __n) + noexcept (true) + __attribute__ ((__access__ (__write_only__, 1, 3))) + __attribute__ ((__access__ (__read_only__, 2))); + + + + + + +extern int rpmatch (const char *__response) noexcept (true) __attribute__ ((__nonnull__ (1))) ; +# 1099 "/usr/include/stdlib.h" 3 4 +extern int getsubopt (char **__restrict __optionp, + char *const *__restrict __tokens, + char **__restrict __valuep) + noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))) ; + + + + + + + +extern int posix_openpt (int __oflag) ; + + + + + + + +extern int grantpt (int __fd) noexcept (true); + + + +extern int unlockpt (int __fd) noexcept (true); + + + + +extern char *ptsname (int __fd) noexcept (true) ; + + + + + + +extern int ptsname_r (int __fd, char *__buf, size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3))); + + +extern int getpt (void); + + + + + + +extern int getloadavg (double __loadavg[], int __nelem) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 1155 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/stdlib-float.h" 1 3 4 +# 1156 "/usr/include/stdlib.h" 2 3 4 +# 1167 "/usr/include/stdlib.h" 3 4 +} +# 80 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 2 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 +# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::abs; + + + inline long + abs(long __i) { return __builtin_labs(__i); } + + + + inline long long + abs(long long __x) { return __builtin_llabs (__x); } +# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 + inline constexpr double + abs(double __x) + { return __builtin_fabs(__x); } + + inline constexpr float + abs(float __x) + { return __builtin_fabsf(__x); } + + inline constexpr long double + abs(long double __x) + { return __builtin_fabsl(__x); } + + + + __extension__ inline constexpr __int128 + abs(__int128 __x) { return __x >= 0 ? __x : -__x; } +# 135 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 + __extension__ inline constexpr + __float128 + abs(__float128 __x) + { + + + + return __builtin_fabsf128(__x); + + + + + } + + + +} +} +# 82 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 2 3 +# 125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::div_t; + using ::ldiv_t; + + using ::abort; + + using ::aligned_alloc; + + using ::atexit; + + + using ::at_quick_exit; + + + using ::atof; + using ::atoi; + using ::atol; + using ::bsearch; + using ::calloc; + using ::div; + using ::exit; + using ::free; + using ::getenv; + using ::labs; + using ::ldiv; + using ::malloc; + + using ::mblen; + using ::mbstowcs; + using ::mbtowc; + + using ::qsort; + + + using ::quick_exit; + + + using ::rand; + using ::realloc; + using ::srand; + using ::strtod; + using ::strtol; + using ::strtoul; + using ::system; + + using ::wcstombs; + using ::wctomb; + + + + inline ldiv_t + div(long __i, long __j) noexcept { return ldiv(__i, __j); } + + + + +} +# 199 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + using ::lldiv_t; + + + + + + using ::_Exit; + + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wlong-long" + using ::llabs; + + inline lldiv_t + div(long long __n, long long __d) + { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; } + + using ::lldiv; +#pragma GCC diagnostic pop +# 234 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 + using ::atoll; + using ::strtoll; + using ::strtoull; + + using ::strtof; + using ::strtold; + + +} + +namespace std +{ + + using ::__gnu_cxx::lldiv_t; + + using ::__gnu_cxx::_Exit; + + using ::__gnu_cxx::llabs; + using ::__gnu_cxx::div; + using ::__gnu_cxx::lldiv; + + using ::__gnu_cxx::atoll; + using ::__gnu_cxx::strtof; + using ::__gnu_cxx::strtoll; + using ::__gnu_cxx::strtoull; + using ::__gnu_cxx::strtold; +} +# 278 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +} +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h" 2 3 + +using std::abort; +using std::atexit; +using std::exit; + + + using std::at_quick_exit; + + + using std::quick_exit; + + + using std::_Exit; + + + + +using std::div_t; +using std::ldiv_t; + +using std::abs; +using std::atof; +using std::atoi; +using std::atol; +using std::bsearch; +using std::calloc; +using std::div; +using std::free; +using std::getenv; +using std::labs; +using std::ldiv; +using std::malloc; + +using std::mblen; +using std::mbstowcs; +using std::mbtowc; + +using std::qsort; +using std::rand; +using std::realloc; +using std::srand; +using std::strtod; +using std::strtol; +using std::strtoul; +using std::system; + +using std::wcstombs; +using std::wctomb; +# 55 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" 2 +# 173 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 174 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" 2 +# 184 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" + +# 184 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern "C" +{ + + + + + +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaDeviceSynchronizeDeprecationAvoidance(void); +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2DeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2DeviceGetLimit(size_t *pValue, enum cudaLimit limit); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2DeviceGetCacheConfig(enum cudaFuncCache *pCacheConfig); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2DeviceGetSharedMemConfig(enum cudaSharedMemConfig *pConfig); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2GetLastError(void); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2PeekAtLastError(void); +extern __attribute__((device)) __attribute__((cudart_builtin)) const char* __cudaCDP2GetErrorString(cudaError_t error); +extern __attribute__((device)) __attribute__((cudart_builtin)) const char* __cudaCDP2GetErrorName(cudaError_t error); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2GetDeviceCount(int *count); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2GetDevice(int *device); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2StreamCreateWithFlags(cudaStream_t *pStream, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2StreamDestroy(cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2StreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2StreamWaitEvent_ptsz(cudaStream_t stream, cudaEvent_t event, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventCreateWithFlags(cudaEvent_t *event, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventRecord(cudaEvent_t event, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventRecord_ptsz(cudaEvent_t event, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventRecordWithFlags_ptsz(cudaEvent_t event, cudaStream_t stream, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventDestroy(cudaEvent_t event); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2FuncGetAttributes(struct cudaFuncAttributes *attr, const void *func); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Free(void *devPtr); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Malloc(void **devPtr, size_t size); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2MemcpyAsync(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2MemcpyAsync_ptsz(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memcpy2DAsync(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memcpy2DAsync_ptsz(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memcpy3DAsync(const struct cudaMemcpy3DParms *p, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memcpy3DAsync_ptsz(const struct cudaMemcpy3DParms *p, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2MemsetAsync(void *devPtr, int value, size_t count, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2MemsetAsync_ptsz(void *devPtr, int value, size_t count, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memset2DAsync(void *devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memset2DAsync_ptsz(void *devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memset3DAsync(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memset3DAsync_ptsz(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2RuntimeGetVersion(int *runtimeVersion); +extern __attribute__((device)) __attribute__((cudart_builtin)) void * __cudaCDP2GetParameterBuffer(size_t alignment, size_t size); +extern __attribute__((device)) __attribute__((cudart_builtin)) void * __cudaCDP2GetParameterBufferV2(void *func, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2LaunchDevice_ptsz(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2LaunchDeviceV2_ptsz(void *parameterBuffer, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2LaunchDevice(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2LaunchDeviceV2(void *parameterBuffer, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func, int blockSize, size_t dynamicSmemSize); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *func, int blockSize, size_t dynamicSmemSize, unsigned int flags); + + +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream); +# 311 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static inline __attribute__((device)) __attribute__((cudart_builtin)) cudaGraphExec_t cudaGetCurrentGraphExec(void) +{ + unsigned long long current_graph_exec; + asm ("mov.u64 %0, %%current_graph_exec;" : "=l"(current_graph_exec)); + return (cudaGraphExec_t)current_graph_exec; +} +# 346 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetParam(cudaGraphDeviceNode_t node, size_t offset, const void *value , size_t size); +# 374 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetEnabled(cudaGraphDeviceNode_t node, bool enable); +# 401 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetGridDim(cudaGraphDeviceNode_t node, dim3 gridDim); +# 430 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeUpdatesApply(const cudaGraphKernelNodeUpdate *updates, size_t updateCount); +# 448 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static inline __attribute__((device)) __attribute__((cudart_builtin)) void cudaTriggerProgrammaticLaunchCompletion(void) +{ + asm volatile("griddepcontrol.launch_dependents;":::); +} +# 464 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static inline __attribute__((device)) __attribute__((cudart_builtin)) void cudaGridDependencySynchronize(void) +{ + asm volatile("griddepcontrol.wait;":::"memory"); +} +# 479 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) void cudaGraphSetConditional(cudaGraphConditionalHandle handle, unsigned int value); + + +extern __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long cudaCGGetIntrinsicHandle(enum cudaCGScope scope); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaCGSynchronize(unsigned long long handle, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaCGSynchronizeGrid(unsigned long long handle, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaCGGetSize(unsigned int *numThreads, unsigned int *numGrids, unsigned long long handle); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaCGGetRank(unsigned int *threadRank, unsigned int *gridRank, unsigned long long handle); +# 714 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) void * cudaGetParameterBuffer(size_t alignment, size_t size) +{ + return __cudaCDP2GetParameterBuffer(alignment, size); +} + + + + + + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) void * cudaGetParameterBufferV2(void *func, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize) +{ + return __cudaCDP2GetParameterBufferV2(func, gridDimension, blockDimension, sharedMemSize); +} + + + + + + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDevice_ptsz(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream) +{ + return __cudaCDP2LaunchDevice_ptsz(func, parameterBuffer, gridDimension, blockDimension, sharedMemSize, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDeviceV2_ptsz(void *parameterBuffer, cudaStream_t stream) +{ + return __cudaCDP2LaunchDeviceV2_ptsz(parameterBuffer, stream); +} +# 800 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" + static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDevice(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream) + { + return __cudaCDP2LaunchDevice(func, parameterBuffer, gridDimension, blockDimension, sharedMemSize, stream); + } + + static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDeviceV2(void *parameterBuffer, cudaStream_t stream) + { + return __cudaCDP2LaunchDeviceV2(parameterBuffer, stream); + } +# 862 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +} + + + + + +template static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMalloc(T **devPtr, size_t size); +template static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetAttributes(struct cudaFuncAttributes *attr, T *entry); +template static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, T func, int blockSize, size_t dynamicSmemSize); +template static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, T func, int blockSize, size_t dynamicSmemSize, unsigned int flags); +# 901 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +template +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetParam(cudaGraphDeviceNode_t node, size_t offset, const T &value) +{ + return cudaGraphKernelNodeSetParam(node, offset, &value, sizeof(T)); +} +# 154 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 2 +# 287 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern "C" { +# 334 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceReset(void); +# 356 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceSynchronize(void); +# 442 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetLimit(enum cudaLimit limit, size_t value); +# 478 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetLimit(size_t *pValue, enum cudaLimit limit); +# 501 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t *maxWidthInElements, const struct cudaChannelFormatDesc *fmtDesc, int device); +# 535 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetCacheConfig(enum cudaFuncCache *pCacheConfig); +# 572 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority); +# 616 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetCacheConfig(enum cudaFuncCache cacheConfig); +# 643 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetByPCIBusId(int *device, const char *pciBusId); +# 673 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetPCIBusId(char *pciBusId, int len, int device); +# 724 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t *handle, cudaEvent_t event); +# 768 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcOpenEventHandle(cudaEvent_t *event, cudaIpcEventHandle_t handle); +# 813 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t *handle, void *devPtr); +# 880 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcOpenMemHandle(void **devPtr, cudaIpcMemHandle_t handle, unsigned int flags); +# 919 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcCloseMemHandle(void *devPtr); +# 951 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(enum cudaFlushGPUDirectRDMAWritesTarget target, enum cudaFlushGPUDirectRDMAWritesScope scope); +# 989 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback); +# 1012 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback); +# 1059 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetSharedMemConfig(enum cudaSharedMemConfig *pConfig); +# 1105 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaDeviceSetSharedMemConfig(enum cudaSharedMemConfig config); +# 1146 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadExit(void); +# 1172 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSynchronize(void); +# 1221 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSetLimit(enum cudaLimit limit, size_t value); +# 1254 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadGetLimit(size_t *pValue, enum cudaLimit limit); +# 1290 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadGetCacheConfig(enum cudaFuncCache *pCacheConfig); +# 1337 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSetCacheConfig(enum cudaFuncCache cacheConfig); +# 1402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetLastError(void); +# 1453 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaPeekAtLastError(void); +# 1469 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) const char* cudaGetErrorName(cudaError_t error); +# 1485 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) const char* cudaGetErrorString(cudaError_t error); +# 1514 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceCount(int *count); +# 1818 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceProperties_v2(struct cudaDeviceProp *prop, int device); +# 2024 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device); +# 2042 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t *memPool, int device); +# 2066 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool); +# 2086 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetMemPool(cudaMemPool_t *memPool, int device); +# 2148 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetNvSciSyncAttributes(void *nvSciSyncAttrList, int device, int flags); +# 2188 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetP2PAttribute(int *value, enum cudaDeviceP2PAttr attr, int srcDevice, int dstDevice); +# 2210 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaChooseDevice(int *device, const struct cudaDeviceProp *prop); +# 2239 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags); +# 2285 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetDevice(int device); +# 2307 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDevice(int *device); +# 2338 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetValidDevices(int *device_arr, int len); +# 2408 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetDeviceFlags( unsigned int flags ); +# 2453 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetDeviceFlags( unsigned int *flags ); +# 2497 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamCreate(cudaStream_t *pStream); +# 2533 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithFlags(cudaStream_t *pStream, unsigned int flags); +# 2585 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithPriority(cudaStream_t *pStream, unsigned int flags, int priority); +# 2613 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int *priority); +# 2639 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int *flags); +# 2676 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetId(cudaStream_t hStream, unsigned long long *streamId); +# 2702 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetDevice(cudaStream_t hStream, int *device); +# 2717 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaCtxResetPersistingL2Cache(void); +# 2737 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src); +# 2758 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetAttribute( + cudaStream_t hStream, cudaLaunchAttributeID attr, + cudaLaunchAttributeValue *value_out); +# 2782 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamSetAttribute( + cudaStream_t hStream, cudaLaunchAttributeID attr, + const cudaLaunchAttributeValue *value); +# 2816 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamDestroy(cudaStream_t stream); +# 2847 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags = 0); + + + + + + + +typedef void ( *cudaStreamCallback_t)(cudaStream_t stream, cudaError_t status, void *userData); +# 2922 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamAddCallback(cudaStream_t stream, + cudaStreamCallback_t callback, void *userData, unsigned int flags); +# 2946 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamSynchronize(cudaStream_t stream); +# 2971 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamQuery(cudaStream_t stream); +# 3055 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamAttachMemAsync(cudaStream_t stream, void *devPtr, size_t length = 0, unsigned int flags = 0x04); +# 3094 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamBeginCapture(cudaStream_t stream, enum cudaStreamCaptureMode mode); +# 3135 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t *dependencies, const cudaGraphEdgeData *dependencyData, size_t numDependencies, enum cudaStreamCaptureMode mode); +# 3186 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaThreadExchangeStreamCaptureMode(enum cudaStreamCaptureMode *mode); +# 3215 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t *pGraph); +# 3253 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamIsCapturing(cudaStream_t stream, enum cudaStreamCaptureStatus *pCaptureStatus); +# 3303 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamGetCaptureInfo_v2(cudaStream_t stream, enum cudaStreamCaptureStatus *captureStatus_out, unsigned long long *id_out = 0, cudaGraph_t *graph_out = 0, const cudaGraphNode_t **dependencies_out = 0, size_t *numDependencies_out = 0); +# 3362 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamGetCaptureInfo_v3(cudaStream_t stream, + enum cudaStreamCaptureStatus *captureStatus_out, unsigned long long *id_out = 0, + cudaGraph_t *graph_out = 0, const cudaGraphNode_t **dependencies_out = 0, + const cudaGraphEdgeData **edgeData_out = 0, size_t *numDependencies_out = 0); +# 3402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t *dependencies, size_t numDependencies, unsigned int flags = 0); +# 3437 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamUpdateCaptureDependencies_v2(cudaStream_t stream, cudaGraphNode_t *dependencies, const cudaGraphEdgeData *dependencyData, size_t numDependencies, unsigned int flags = 0); +# 3474 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventCreate(cudaEvent_t *event); +# 3511 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventCreateWithFlags(cudaEvent_t *event, unsigned int flags); +# 3552 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream = 0); +# 3600 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream = 0, unsigned int flags = 0); +# 3633 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventQuery(cudaEvent_t event); +# 3664 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventSynchronize(cudaEvent_t event); +# 3694 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventDestroy(cudaEvent_t event); +# 3739 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventElapsedTime(float *ms, cudaEvent_t start, cudaEvent_t end); +# 3787 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventElapsedTime_v2(float *ms, cudaEvent_t start, cudaEvent_t end); +# 3968 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaImportExternalMemory(cudaExternalMemory_t *extMem_out, const struct cudaExternalMemoryHandleDesc *memHandleDesc); +# 4023 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaExternalMemoryGetMappedBuffer(void **devPtr, cudaExternalMemory_t extMem, const struct cudaExternalMemoryBufferDesc *bufferDesc); +# 4083 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t *mipmap, cudaExternalMemory_t extMem, const struct cudaExternalMemoryMipmappedArrayDesc *mipmapDesc); +# 4107 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem); +# 4261 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t *extSem_out, const struct cudaExternalSemaphoreHandleDesc *semHandleDesc); +# 4344 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSignalExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t *extSemArray, const struct cudaExternalSemaphoreSignalParams *paramsArray, unsigned int numExtSems, cudaStream_t stream = 0); +# 4420 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaWaitExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t *extSemArray, const struct cudaExternalSemaphoreWaitParams *paramsArray, unsigned int numExtSems, cudaStream_t stream = 0); +# 4443 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem); +# 4511 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchKernel(const void *func, dim3 gridDim, dim3 blockDim, void **args, size_t sharedMem, cudaStream_t stream); +# 4574 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchKernelExC(const cudaLaunchConfig_t *config, const void *func, void **args); +# 4632 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchCooperativeKernel(const void *func, dim3 gridDim, dim3 blockDim, void **args, size_t sharedMem, cudaStream_t stream); +# 4733 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaLaunchCooperativeKernelMultiDevice(struct cudaLaunchParams *launchParamsList, unsigned int numDevices, unsigned int flags = 0); +# 4783 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFuncSetCacheConfig(const void *func, enum cudaFuncCache cacheConfig); +# 4818 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetAttributes(struct cudaFuncAttributes *attr, const void *func); +# 4877 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncSetAttribute(const void *func, enum cudaFuncAttribute attr, int value); +# 4903 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetName(const char **name, const void *func); +# 4926 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetParamInfo(const void *func, size_t paramIndex, size_t *paramOffset, size_t *paramSize); +# 4950 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaSetDoubleForDevice(double *d); +# 4974 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaSetDoubleForHost(double *d); +# 5040 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void *userData); +# 5114 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaFuncSetSharedMemConfig(const void *func, enum cudaSharedMemConfig config); +# 5171 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func, int blockSize, size_t dynamicSMemSize); +# 5201 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t *dynamicSmemSize, const void *func, int numBlocks, int blockSize); +# 5247 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *func, int blockSize, size_t dynamicSMemSize, unsigned int flags); +# 5283 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxPotentialClusterSize(int *clusterSize, const void *func, const cudaLaunchConfig_t *launchConfig); +# 5323 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveClusters(int *numClusters, const void *func, const cudaLaunchConfig_t *launchConfig); +# 5443 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMallocManaged(void **devPtr, size_t size, unsigned int flags = 0x01); +# 5476 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMalloc(void **devPtr, size_t size); +# 5513 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocHost(void **ptr, size_t size); +# 5556 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocPitch(void **devPtr, size_t *pitch, size_t width, size_t height); +# 5608 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocArray(cudaArray_t *array, const struct cudaChannelFormatDesc *desc, size_t width, size_t height = 0, unsigned int flags = 0); +# 5647 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFree(void *devPtr); +# 5670 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeHost(void *ptr); +# 5693 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeArray(cudaArray_t array); +# 5716 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray); +# 5782 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostAlloc(void **pHost, size_t size, unsigned int flags); +# 5879 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostRegister(void *ptr, size_t size, unsigned int flags); +# 5902 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostUnregister(void *ptr); +# 5947 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostGetDevicePointer(void **pDevice, void *pHost, unsigned int flags); +# 5969 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostGetFlags(unsigned int *pFlags, void *pHost); +# 6008 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMalloc3D(struct cudaPitchedPtr* pitchedDevPtr, struct cudaExtent extent); +# 6153 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMalloc3DArray(cudaArray_t *array, const struct cudaChannelFormatDesc* desc, struct cudaExtent extent, unsigned int flags = 0); +# 6298 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocMipmappedArray(cudaMipmappedArray_t *mipmappedArray, const struct cudaChannelFormatDesc* desc, struct cudaExtent extent, unsigned int numLevels, unsigned int flags = 0); +# 6331 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t *levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level); +# 6436 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3D(const struct cudaMemcpy3DParms *p); +# 6468 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3DPeer(const struct cudaMemcpy3DPeerParms *p); +# 6586 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy3DAsync(const struct cudaMemcpy3DParms *p, cudaStream_t stream = 0); +# 6613 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3DPeerAsync(const struct cudaMemcpy3DPeerParms *p, cudaStream_t stream = 0); +# 6647 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemGetInfo(size_t *free, size_t *total); +# 6673 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetInfo(struct cudaChannelFormatDesc *desc, struct cudaExtent *extent, unsigned int *flags, cudaArray_t array); +# 6702 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetPlane(cudaArray_t *pPlaneArray, cudaArray_t hArray, unsigned int planeIdx); +# 6725 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetMemoryRequirements(struct cudaArrayMemoryRequirements *memoryRequirements, cudaArray_t array, int device); +# 6749 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMipmappedArrayGetMemoryRequirements(struct cudaArrayMemoryRequirements *memoryRequirements, cudaMipmappedArray_t mipmap, int device); +# 6777 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaArrayGetSparseProperties(struct cudaArraySparseProperties *sparseProperties, cudaArray_t array); +# 6807 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaMipmappedArrayGetSparseProperties(struct cudaArraySparseProperties *sparseProperties, cudaMipmappedArray_t mipmap); +# 6852 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind); +# 6887 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyPeer(void *dst, int dstDevice, const void *src, int srcDevice, size_t count); +# 6936 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2D(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind); +# 6986 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind); +# 7036 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DFromArray(void *dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind); +# 7083 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, enum cudaMemcpyKind kind = cudaMemcpyDeviceToDevice); +# 7126 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyToSymbol(const void *symbol, const void *src, size_t count, size_t offset = 0, enum cudaMemcpyKind kind = cudaMemcpyHostToDevice); +# 7170 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyFromSymbol(void *dst, const void *symbol, size_t count, size_t offset = 0, enum cudaMemcpyKind kind = cudaMemcpyDeviceToHost); +# 7227 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpyAsync(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7262 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyPeerAsync(void *dst, int dstDevice, const void *src, int srcDevice, size_t count, cudaStream_t stream = 0); +# 7334 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyBatchAsync(void **dsts, void **srcs, size_t *sizes, size_t count, struct cudaMemcpyAttributes *attrs, size_t *attrsIdxs, size_t numAttrs, size_t *failIdx, cudaStream_t stream); +# 7402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3DBatchAsync(size_t numOps, struct cudaMemcpy3DBatchOp *opList, size_t *failIdx, unsigned long long flags, cudaStream_t stream); +# 7465 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy2DAsync(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7523 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7580 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DFromArrayAsync(void *dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7631 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyToSymbolAsync(const void *symbol, const void *src, size_t count, size_t offset, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7682 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyFromSymbolAsync(void *dst, const void *symbol, size_t count, size_t offset, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7711 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset(void *devPtr, int value, size_t count); +# 7745 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset2D(void *devPtr, size_t pitch, int value, size_t width, size_t height); +# 7791 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset3D(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent); +# 7827 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemsetAsync(void *devPtr, int value, size_t count, cudaStream_t stream = 0); +# 7868 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemset2DAsync(void *devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream = 0); +# 7921 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemset3DAsync(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream = 0); +# 7949 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSymbolAddress(void **devPtr, const void *symbol); +# 7976 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSymbolSize(size_t *size, const void *symbol); +# 8048 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPrefetchAsync(const void *devPtr, size_t count, int dstDevice, cudaStream_t stream = 0); +# 8129 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPrefetchAsync_v2(const void *devPtr, size_t count, struct cudaMemLocation location, unsigned int flags, cudaStream_t stream = 0); +# 8243 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemAdvise(const void *devPtr, size_t count, enum cudaMemoryAdvise advice, int device); +# 8366 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemAdvise_v2(const void *devPtr, size_t count, enum cudaMemoryAdvise advice, struct cudaMemLocation location); +# 8448 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemRangeGetAttribute(void *data, size_t dataSize, enum cudaMemRangeAttribute attribute, const void *devPtr, size_t count); +# 8491 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemRangeGetAttributes(void **data, size_t *dataSizes, enum cudaMemRangeAttribute *attributes, size_t numAttributes, const void *devPtr, size_t count); +# 8551 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t count, enum cudaMemcpyKind kind); +# 8593 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyFromArray(void *dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, enum cudaMemcpyKind kind); +# 8636 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, enum cudaMemcpyKind kind = cudaMemcpyDeviceToDevice); +# 8687 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 8737 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyFromArrayAsync(void *dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 8806 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocAsync(void **devPtr, size_t size, cudaStream_t hStream); +# 8832 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeAsync(void *devPtr, cudaStream_t hStream); +# 8857 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep); +# 8901 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, enum cudaMemPoolAttr attr, void *value ); +# 8949 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, enum cudaMemPoolAttr attr, void *value ); +# 8964 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const struct cudaMemAccessDesc *descList, size_t count); +# 8977 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolGetAccess(enum cudaMemAccessFlags *flags, cudaMemPool_t memPool, struct cudaMemLocation *location); +# 9021 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolCreate(cudaMemPool_t *memPool, const struct cudaMemPoolProps *poolProps); +# 9043 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool); +# 9079 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocFromPoolAsync(void **ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream); +# 9104 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolExportToShareableHandle( + void *shareableHandle, + cudaMemPool_t memPool, + enum cudaMemAllocationHandleType handleType, + unsigned int flags); +# 9131 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolImportFromShareableHandle( + cudaMemPool_t *memPool, + void *shareableHandle, + enum cudaMemAllocationHandleType handleType, + unsigned int flags); +# 9154 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolExportPointer(struct cudaMemPoolPtrExportData *exportData, void *ptr); +# 9183 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolImportPointer(void **ptr, cudaMemPool_t memPool, struct cudaMemPoolPtrExportData *exportData); +# 9336 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaPointerGetAttributes(struct cudaPointerAttributes *attributes, const void *ptr); +# 9377 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceCanAccessPeer(int *canAccessPeer, int device, int peerDevice); +# 9419 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags); +# 9441 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceDisablePeerAccess(int peerDevice); +# 9505 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource); +# 9540 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags); +# 9579 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t *resources, cudaStream_t stream = 0); +# 9614 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t *resources, cudaStream_t stream = 0); +# 9646 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceGetMappedPointer(void **devPtr, size_t *size, cudaGraphicsResource_t resource); +# 9684 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t *array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel); +# 9713 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t *mipmappedArray, cudaGraphicsResource_t resource); +# 9748 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetChannelDesc(struct cudaChannelFormatDesc *desc, cudaArray_const_t array); +# 9778 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) struct cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, enum cudaChannelFormatKind f); +# 10003 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaCreateTextureObject(cudaTextureObject_t *pTexObject, const struct cudaResourceDesc *pResDesc, const struct cudaTextureDesc *pTexDesc, const struct cudaResourceViewDesc *pResViewDesc); +# 10023 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject); +# 10043 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectResourceDesc(struct cudaResourceDesc *pResDesc, cudaTextureObject_t texObject); +# 10063 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectTextureDesc(struct cudaTextureDesc *pTexDesc, cudaTextureObject_t texObject); +# 10084 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectResourceViewDesc(struct cudaResourceViewDesc *pResViewDesc, cudaTextureObject_t texObject); +# 10129 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t *pSurfObject, const struct cudaResourceDesc *pResDesc); +# 10149 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject); +# 10168 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSurfaceObjectResourceDesc(struct cudaResourceDesc *pResDesc, cudaSurfaceObject_t surfObject); +# 10202 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDriverGetVersion(int *driverVersion); +# 10231 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaRuntimeGetVersion(int *runtimeVersion); +# 10278 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphCreate(cudaGraph_t *pGraph, unsigned int flags); +# 10377 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddKernelNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaKernelNodeParams *pNodeParams); +# 10410 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, struct cudaKernelNodeParams *pNodeParams); +# 10437 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const struct cudaKernelNodeParams *pNodeParams); +# 10457 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeCopyAttributes( + cudaGraphNode_t hSrc, + cudaGraphNode_t hDst); +# 10480 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeGetAttribute( + cudaGraphNode_t hNode, + cudaLaunchAttributeID attr, + cudaLaunchAttributeValue *value_out); +# 10504 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeSetAttribute( + cudaGraphNode_t hNode, + cudaLaunchAttributeID attr, + const cudaLaunchAttributeValue *value); +# 10555 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaMemcpy3DParms *pCopyParams); +# 10614 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNodeToSymbol( + cudaGraphNode_t *pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t *pDependencies, + size_t numDependencies, + const void* symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 10683 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNodeFromSymbol( + cudaGraphNode_t* pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t* pDependencies, + size_t numDependencies, + void* dst, + const void* symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 10751 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNode1D( + cudaGraphNode_t *pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t *pDependencies, + size_t numDependencies, + void* dst, + const void* src, + size_t count, + enum cudaMemcpyKind kind); +# 10783 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, struct cudaMemcpy3DParms *pNodeParams); +# 10810 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const struct cudaMemcpy3DParms *pNodeParams); +# 10849 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParamsToSymbol( + cudaGraphNode_t node, + const void* symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 10895 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParamsFromSymbol( + cudaGraphNode_t node, + void* dst, + const void* symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 10941 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParams1D( + cudaGraphNode_t node, + void* dst, + const void* src, + size_t count, + enum cudaMemcpyKind kind); +# 10989 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddMemsetNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaMemsetParams *pMemsetParams); +# 11012 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, struct cudaMemsetParams *pNodeParams); +# 11036 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const struct cudaMemsetParams *pNodeParams); +# 11078 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddHostNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaHostNodeParams *pNodeParams); +# 11101 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, struct cudaHostNodeParams *pNodeParams); +# 11125 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const struct cudaHostNodeParams *pNodeParams); +# 11166 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddChildGraphNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, cudaGraph_t childGraph); +# 11193 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t *pGraph); +# 11231 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies); +# 11275 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddEventRecordNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, cudaEvent_t event); +# 11302 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t *event_out); +# 11330 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event); +# 11377 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddEventWaitNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, cudaEvent_t event); +# 11404 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t *event_out); +# 11432 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event); +# 11482 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaExternalSemaphoreSignalNodeParams *nodeParams); +# 11515 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, struct cudaExternalSemaphoreSignalNodeParams *params_out); +# 11543 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const struct cudaExternalSemaphoreSignalNodeParams *nodeParams); +# 11593 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaExternalSemaphoreWaitNodeParams *nodeParams); +# 11626 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, struct cudaExternalSemaphoreWaitNodeParams *params_out); +# 11654 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const struct cudaExternalSemaphoreWaitNodeParams *nodeParams); +# 11732 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddMemAllocNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, struct cudaMemAllocNodeParams *nodeParams); +# 11759 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, struct cudaMemAllocNodeParams *params_out); +# 11820 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddMemFreeNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, void *dptr); +# 11844 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void *dptr_out); +# 11872 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGraphMemTrim(int device); +# 11909 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetGraphMemAttribute(int device, enum cudaGraphMemAttributeType attr, void* value); +# 11943 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetGraphMemAttribute(int device, enum cudaGraphMemAttributeType attr, void* value); +# 11971 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphClone(cudaGraph_t *pGraphClone, cudaGraph_t originalGraph); +# 11999 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t *pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph); +# 12030 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, enum cudaGraphNodeType *pType); +# 12061 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t *nodes, size_t *numNodes); +# 12092 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t *pRootNodes, size_t *pNumRootNodes); +# 12126 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t *from, cudaGraphNode_t *to, size_t *numEdges); +# 12166 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetEdges_v2(cudaGraph_t graph, cudaGraphNode_t *from, cudaGraphNode_t *to, cudaGraphEdgeData *edgeData, size_t *numEdges); +# 12197 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t *pDependencies, size_t *pNumDependencies); +# 12234 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependencies_v2(cudaGraphNode_t node, cudaGraphNode_t *pDependencies, cudaGraphEdgeData *edgeData, size_t *pNumDependencies); +# 12266 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t *pDependentNodes, size_t *pNumDependentNodes); +# 12304 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependentNodes_v2(cudaGraphNode_t node, cudaGraphNode_t *pDependentNodes, cudaGraphEdgeData *edgeData, size_t *pNumDependentNodes); +# 12335 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, size_t numDependencies); +# 12367 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, const cudaGraphEdgeData *edgeData, size_t numDependencies); +# 12398 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, size_t numDependencies); +# 12433 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphRemoveDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, const cudaGraphEdgeData *edgeData, size_t numDependencies); +# 12463 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node); +# 12534 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiate(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, unsigned long long flags = 0); +# 12607 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, unsigned long long flags = 0); +# 12714 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiateWithParams(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams *instantiateParams); +# 12739 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long *flags); +# 12799 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaKernelNodeParams *pNodeParams); +# 12850 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaMemcpy3DParms *pNodeParams); +# 12905 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParamsToSymbol( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + const void* symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 12968 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParamsFromSymbol( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + void* dst, + const void* symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 13029 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParams1D( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + void* dst, + const void* src, + size_t count, + enum cudaMemcpyKind kind); +# 13088 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaMemsetParams *pNodeParams); +# 13128 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaHostNodeParams *pNodeParams); +# 13175 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph); +# 13220 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event); +# 13265 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event); +# 13313 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const struct cudaExternalSemaphoreSignalNodeParams *nodeParams); +# 13361 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const struct cudaExternalSemaphoreWaitNodeParams *nodeParams); +# 13401 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled); +# 13435 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int *isEnabled); +# 13529 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo *resultInfo); +# 13554 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream); +# 13585 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream); +# 13608 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec); +# 13629 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDestroy(cudaGraph_t graph); +# 13648 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char *path, unsigned int flags); +# 13684 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaUserObjectCreate(cudaUserObject_t *object_out, void *ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags); +# 13708 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned int count = 1); +# 13736 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned int count = 1); +# 13764 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count = 1, unsigned int flags = 0); +# 13789 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count = 1); +# 13831 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, struct cudaGraphNodeParams *nodeParams); +# 13875 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddNode_v2(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, const cudaGraphEdgeData *dependencyData, size_t numDependencies, struct cudaGraphNodeParams *nodeParams); +# 13904 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeSetParams(cudaGraphNode_t node, struct cudaGraphNodeParams *nodeParams); +# 13953 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, struct cudaGraphNodeParams *nodeParams); +# 13980 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle *pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue = 0, unsigned int flags = 0); +# 14061 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetDriverEntryPoint(const char *symbol, void **funcPtr, unsigned long long flags, enum cudaDriverEntryPointQueryResult *driverStatus = +# 14061 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 3 4 + __null +# 14061 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + ); +# 14137 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetDriverEntryPointByVersion(const char *symbol, void **funcPtr, unsigned int cudaVersion, unsigned long long flags, enum cudaDriverEntryPointQueryResult *driverStatus = +# 14137 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 3 4 + __null +# 14137 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + ); +# 14212 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryLoadData(cudaLibrary_t *library, const void *code, + enum cudaJitOption *jitOptions, void **jitOptionsValues, unsigned int numJitOptions, + enum cudaLibraryOption *libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions); +# 14272 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryLoadFromFile(cudaLibrary_t *library, const char *fileName, + enum cudaJitOption *jitOptions, void **jitOptionsValues, unsigned int numJitOptions, + enum cudaLibraryOption *libraryOptions, void **libraryOptionValues, unsigned int numLibraryOptions); +# 14293 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryUnload(cudaLibrary_t library); +# 14318 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryGetKernel(cudaKernel_t *pKernel, cudaLibrary_t library, const char *name); +# 14352 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryGetGlobal(void **dptr, size_t *bytes, cudaLibrary_t library, const char *name); +# 14385 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryGetManaged(void **dptr, size_t *bytes, cudaLibrary_t library, const char *name); +# 14412 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryGetUnifiedFunction(void **fptr, cudaLibrary_t library, const char *symbol); +# 14434 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryGetKernelCount(unsigned int *count, cudaLibrary_t lib); +# 14456 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLibraryEnumerateKernels(cudaKernel_t *kernels, unsigned int numKernels, cudaLibrary_t lib); +# 14525 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaKernelSetAttributeForDevice(cudaKernel_t kernel, enum cudaFuncAttribute attr, int value, int device); + + + + +extern __attribute__((host)) cudaError_t cudaGetExportTable(const void **ppExportTable, const cudaUUID_t *pExportTableId); +# 14716 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetFuncBySymbol(cudaFunction_t* functionPtr, const void* symbolPtr); +# 14740 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetKernel(cudaKernel_t *kernelPtr, const void *entryFuncAddr); +# 14918 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +} +# 62 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" 2 +# 120 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" +template __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(0, 0, 0, 0, cudaChannelFormatKindNone); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescHalf(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescHalf1(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescHalf2(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindFloat); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescHalf4(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindFloat); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(char) * 8; + + + + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); + +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(signed char) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned char) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(signed char) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned char) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(signed char) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned char) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(signed char) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned char) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(short) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(short) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(int) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned int) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(int) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned int) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(int) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned int) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(int) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned int) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +} +# 392 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(float) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(float) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(float) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindFloat); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(float) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindFloat); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescNV12(void) +{ + int e = (int)sizeof(char) * 8; + + return cudaCreateChannelDesc(e, e, e, 0, cudaChannelFormatKindNV12); +} + +template __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(0, 0, 0, 0, cudaChannelFormatKindNone); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindSignedNormalized8X1); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindSignedNormalized8X2); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindSignedNormalized8X4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindUnsignedNormalized8X1); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindUnsignedNormalized8X2); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedNormalized8X4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 0, 0, 0, cudaChannelFormatKindSignedNormalized16X1); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 0, 0, cudaChannelFormatKindSignedNormalized16X2); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 16, 16, cudaChannelFormatKindSignedNormalized16X4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 0, 0, 0, cudaChannelFormatKindUnsignedNormalized16X1); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 0, 0, cudaChannelFormatKindUnsignedNormalized16X2); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 16, 16, cudaChannelFormatKindUnsignedNormalized16X4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 0, cudaChannelFormatKindNV12); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(10, 10, 10, 2, cudaChannelFormatKindUnsignedNormalized1010102); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed1); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed1SRGB); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed2); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed2SRGB); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed3); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed3SRGB); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindUnsignedBlockCompressed4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindSignedBlockCompressed4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindUnsignedBlockCompressed5); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindSignedBlockCompressed5); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 16, 0, cudaChannelFormatKindUnsignedBlockCompressed6H); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 16, 0, cudaChannelFormatKindSignedBlockCompressed6H); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed7); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed7SRGB); +} +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" 1 +# 53 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 54 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 55 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" 2 +# 79 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static __inline__ __attribute__((host)) struct cudaPitchedPtr make_cudaPitchedPtr(void *d, size_t p, size_t xsz, size_t ysz) +{ + struct cudaPitchedPtr s; + + s.ptr = d; + s.pitch = p; + s.xsize = xsz; + s.ysize = ysz; + + return s; +} +# 106 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static __inline__ __attribute__((host)) struct cudaPos make_cudaPos(size_t x, size_t y, size_t z) +{ + struct cudaPos p; + + p.x = x; + p.y = y; + p.z = z; + + return p; +} +# 132 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static __inline__ __attribute__((host)) struct cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) +{ + struct cudaExtent e; + + e.width = w; + e.height = h; + e.depth = d; + + return e; +} +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 100 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + + + + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.h" 1 +# 77 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.h" +static __inline__ __attribute__((host)) __attribute__((device)) char1 make_char1(signed char x); + +static __inline__ __attribute__((host)) __attribute__((device)) uchar1 make_uchar1(unsigned char x); + +static __inline__ __attribute__((host)) __attribute__((device)) char2 make_char2(signed char x, signed char y); + +static __inline__ __attribute__((host)) __attribute__((device)) uchar2 make_uchar2(unsigned char x, unsigned char y); + +static __inline__ __attribute__((host)) __attribute__((device)) char3 make_char3(signed char x, signed char y, signed char z); + +static __inline__ __attribute__((host)) __attribute__((device)) uchar3 make_uchar3(unsigned char x, unsigned char y, unsigned char z); + +static __inline__ __attribute__((host)) __attribute__((device)) char4 make_char4(signed char x, signed char y, signed char z, signed char w); + +static __inline__ __attribute__((host)) __attribute__((device)) uchar4 make_uchar4(unsigned char x, unsigned char y, unsigned char z, unsigned char w); + +static __inline__ __attribute__((host)) __attribute__((device)) short1 make_short1(short x); + +static __inline__ __attribute__((host)) __attribute__((device)) ushort1 make_ushort1(unsigned short x); + +static __inline__ __attribute__((host)) __attribute__((device)) short2 make_short2(short x, short y); + +static __inline__ __attribute__((host)) __attribute__((device)) ushort2 make_ushort2(unsigned short x, unsigned short y); + +static __inline__ __attribute__((host)) __attribute__((device)) short3 make_short3(short x,short y, short z); + +static __inline__ __attribute__((host)) __attribute__((device)) ushort3 make_ushort3(unsigned short x, unsigned short y, unsigned short z); + +static __inline__ __attribute__((host)) __attribute__((device)) short4 make_short4(short x, short y, short z, short w); + +static __inline__ __attribute__((host)) __attribute__((device)) ushort4 make_ushort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w); + +static __inline__ __attribute__((host)) __attribute__((device)) int1 make_int1(int x); + +static __inline__ __attribute__((host)) __attribute__((device)) uint1 make_uint1(unsigned int x); + +static __inline__ __attribute__((host)) __attribute__((device)) int2 make_int2(int x, int y); + +static __inline__ __attribute__((host)) __attribute__((device)) uint2 make_uint2(unsigned int x, unsigned int y); + +static __inline__ __attribute__((host)) __attribute__((device)) int3 make_int3(int x, int y, int z); + +static __inline__ __attribute__((host)) __attribute__((device)) uint3 make_uint3(unsigned int x, unsigned int y, unsigned int z); + +static __inline__ __attribute__((host)) __attribute__((device)) int4 make_int4(int x, int y, int z, int w); + +static __inline__ __attribute__((host)) __attribute__((device)) uint4 make_uint4(unsigned int x, unsigned int y, unsigned int z, unsigned int w); + +static __inline__ __attribute__((host)) __attribute__((device)) long1 make_long1(long int x); + +static __inline__ __attribute__((host)) __attribute__((device)) ulong1 make_ulong1(unsigned long int x); + +static __inline__ __attribute__((host)) __attribute__((device)) long2 make_long2(long int x, long int y); + +static __inline__ __attribute__((host)) __attribute__((device)) ulong2 make_ulong2(unsigned long int x, unsigned long int y); + +static __inline__ __attribute__((host)) __attribute__((device)) long3 make_long3(long int x, long int y, long int z); + +static __inline__ __attribute__((host)) __attribute__((device)) ulong3 make_ulong3(unsigned long int x, unsigned long int y, unsigned long int z); + +static __inline__ __attribute__((host)) __attribute__((device)) long4 make_long4(long int x, long int y, long int z, long int w); + +static __inline__ __attribute__((host)) __attribute__((device)) ulong4 make_ulong4(unsigned long int x, unsigned long int y, unsigned long int z, unsigned long int w); + +static __inline__ __attribute__((host)) __attribute__((device)) float1 make_float1(float x); + +static __inline__ __attribute__((host)) __attribute__((device)) float2 make_float2(float x, float y); + +static __inline__ __attribute__((host)) __attribute__((device)) float3 make_float3(float x, float y, float z); + +static __inline__ __attribute__((host)) __attribute__((device)) float4 make_float4(float x, float y, float z, float w); + +static __inline__ __attribute__((host)) __attribute__((device)) longlong1 make_longlong1(long long int x); + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong1 make_ulonglong1(unsigned long long int x); + +static __inline__ __attribute__((host)) __attribute__((device)) longlong2 make_longlong2(long long int x, long long int y); + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong2 make_ulonglong2(unsigned long long int x, unsigned long long int y); + +static __inline__ __attribute__((host)) __attribute__((device)) longlong3 make_longlong3(long long int x, long long int y, long long int z); + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong3 make_ulonglong3(unsigned long long int x, unsigned long long int y, unsigned long long int z); + +static __inline__ __attribute__((host)) __attribute__((device)) longlong4 make_longlong4(long long int x, long long int y, long long int z, long long int w); + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong4 make_ulonglong4(unsigned long long int x, unsigned long long int y, unsigned long long int z, unsigned long long int w); + +static __inline__ __attribute__((host)) __attribute__((device)) double1 make_double1(double x); + +static __inline__ __attribute__((host)) __attribute__((device)) double2 make_double2(double x, double y); + +static __inline__ __attribute__((host)) __attribute__((device)) double3 make_double3(double x, double y, double z); + +static __inline__ __attribute__((host)) __attribute__((device)) double4 make_double4(double x, double y, double z, double w); + + + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.hpp" 1 +# 73 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.hpp" +static __inline__ __attribute__((host)) __attribute__((device)) char1 make_char1(signed char x) +{ + char1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uchar1 make_uchar1(unsigned char x) +{ + uchar1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) char2 make_char2(signed char x, signed char y) +{ + char2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uchar2 make_uchar2(unsigned char x, unsigned char y) +{ + uchar2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) char3 make_char3(signed char x, signed char y, signed char z) +{ + char3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uchar3 make_uchar3(unsigned char x, unsigned char y, unsigned char z) +{ + uchar3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) char4 make_char4(signed char x, signed char y, signed char z, signed char w) +{ + char4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uchar4 make_uchar4(unsigned char x, unsigned char y, unsigned char z, unsigned char w) +{ + uchar4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) short1 make_short1(short x) +{ + short1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ushort1 make_ushort1(unsigned short x) +{ + ushort1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) short2 make_short2(short x, short y) +{ + short2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ushort2 make_ushort2(unsigned short x, unsigned short y) +{ + ushort2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) short3 make_short3(short x,short y, short z) +{ + short3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ushort3 make_ushort3(unsigned short x, unsigned short y, unsigned short z) +{ + ushort3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) short4 make_short4(short x, short y, short z, short w) +{ + short4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ushort4 make_ushort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w) +{ + ushort4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) int1 make_int1(int x) +{ + int1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uint1 make_uint1(unsigned int x) +{ + uint1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) int2 make_int2(int x, int y) +{ + int2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uint2 make_uint2(unsigned int x, unsigned int y) +{ + uint2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) int3 make_int3(int x, int y, int z) +{ + int3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uint3 make_uint3(unsigned int x, unsigned int y, unsigned int z) +{ + uint3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) int4 make_int4(int x, int y, int z, int w) +{ + int4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uint4 make_uint4(unsigned int x, unsigned int y, unsigned int z, unsigned int w) +{ + uint4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) long1 make_long1(long int x) +{ + long1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulong1 make_ulong1(unsigned long int x) +{ + ulong1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) long2 make_long2(long int x, long int y) +{ + long2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulong2 make_ulong2(unsigned long int x, unsigned long int y) +{ + ulong2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) long3 make_long3(long int x, long int y, long int z) +{ + long3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulong3 make_ulong3(unsigned long int x, unsigned long int y, unsigned long int z) +{ + ulong3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) long4 make_long4(long int x, long int y, long int z, long int w) +{ + long4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulong4 make_ulong4(unsigned long int x, unsigned long int y, unsigned long int z, unsigned long int w) +{ + ulong4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) float1 make_float1(float x) +{ + float1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) float2 make_float2(float x, float y) +{ + float2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) float3 make_float3(float x, float y, float z) +{ + float3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) float4 make_float4(float x, float y, float z, float w) +{ + float4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) longlong1 make_longlong1(long long int x) +{ + longlong1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong1 make_ulonglong1(unsigned long long int x) +{ + ulonglong1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) longlong2 make_longlong2(long long int x, long long int y) +{ + longlong2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong2 make_ulonglong2(unsigned long long int x, unsigned long long int y) +{ + ulonglong2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) longlong3 make_longlong3(long long int x, long long int y, long long int z) +{ + longlong3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong3 make_ulonglong3(unsigned long long int x, unsigned long long int y, unsigned long long int z) +{ + ulonglong3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) longlong4 make_longlong4(long long int x, long long int y, long long int z, long long int w) +{ + longlong4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong4 make_ulonglong4(unsigned long long int x, unsigned long long int y, unsigned long long int z, unsigned long long int w) +{ + ulonglong4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) double1 make_double1(double x) +{ + double1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) double2 make_double2(double x, double y) +{ + double2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) double3 make_double3(double x, double y, double z) +{ + double3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) double4 make_double4(double x, double y, double z, double w) +{ + double4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} +# 177 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.h" 2 +# 106 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 117 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 1 +# 71 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 72 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 73 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 85 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +# 1 "/usr/include/string.h" 1 3 4 +# 26 "/usr/include/string.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/string.h" 2 3 4 + + +# 28 "/usr/include/string.h" 3 4 +extern "C" { + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 34 "/usr/include/string.h" 2 3 4 +# 43 "/usr/include/string.h" 3 4 +extern void *memcpy (void *__restrict __dest, const void *__restrict __src, + size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern void *memmove (void *__dest, const void *__src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern void *memccpy (void *__restrict __dest, const void *__restrict __src, + int __c, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__write_only__, 1, 4))); + + + + +extern void *memset (void *__s, int __c, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int memcmp (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 80 "/usr/include/string.h" 3 4 +extern int __memcmpeq (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + +extern "C++" +{ +extern void *memchr (void *__s, int __c, size_t __n) + noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const void *memchr (const void *__s, int __c, size_t __n) + noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 105 "/usr/include/string.h" 3 4 +} +# 115 "/usr/include/string.h" 3 4 +extern "C++" void *rawmemchr (void *__s, int __c) + noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const void *rawmemchr (const void *__s, int __c) + noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + + + +extern "C++" void *memrchr (void *__s, int __c, size_t __n) + noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__read_only__, 1, 3))); +extern "C++" const void *memrchr (const void *__s, int __c, size_t __n) + noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__read_only__, 1, 3))); +# 141 "/usr/include/string.h" 3 4 +extern char *strcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strcat (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncat (char *__restrict __dest, const char *__restrict __src, + size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern int strncmp (const char *__s1, const char *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcoll (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern size_t strxfrm (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 1, 3))); + + + + + + +extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + + +extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n, + locale_t __l) noexcept (true) __attribute__ ((__nonnull__ (2, 4))) + __attribute__ ((__access__ (__write_only__, 1, 3))); + + + + + +extern char *strdup (const char *__s) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); + + + + + + +extern char *strndup (const char *__string, size_t __n) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); +# 224 "/usr/include/string.h" 3 4 +extern "C++" +{ +extern char *strchr (char *__s, int __c) + noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *strchr (const char *__s, int __c) + noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 244 "/usr/include/string.h" 3 4 +} + + + + + + +extern "C++" +{ +extern char *strrchr (char *__s, int __c) + noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *strrchr (const char *__s, int __c) + noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 271 "/usr/include/string.h" 3 4 +} +# 281 "/usr/include/string.h" 3 4 +extern "C++" char *strchrnul (char *__s, int __c) + noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const char *strchrnul (const char *__s, int __c) + noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 293 "/usr/include/string.h" 3 4 +extern size_t strcspn (const char *__s, const char *__reject) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern size_t strspn (const char *__s, const char *__accept) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern "C++" +{ +extern char *strpbrk (char *__s, const char *__accept) + noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern const char *strpbrk (const char *__s, const char *__accept) + noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 321 "/usr/include/string.h" 3 4 +} + + + + + + +extern "C++" +{ +extern char *strstr (char *__haystack, const char *__needle) + noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern const char *strstr (const char *__haystack, const char *__needle) + noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 348 "/usr/include/string.h" 3 4 +} + + + + + + + +extern char *strtok (char *__restrict __s, const char *__restrict __delim) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern char *__strtok_r (char *__restrict __s, + const char *__restrict __delim, + char **__restrict __save_ptr) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + +extern char *strtok_r (char *__restrict __s, const char *__restrict __delim, + char **__restrict __save_ptr) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + + + + + +extern "C++" char *strcasestr (char *__haystack, const char *__needle) + noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern "C++" const char *strcasestr (const char *__haystack, + const char *__needle) + noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 389 "/usr/include/string.h" 3 4 +extern void *memmem (const void *__haystack, size_t __haystacklen, + const void *__needle, size_t __needlelen) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3))) + __attribute__ ((__access__ (__read_only__, 1, 2))) + __attribute__ ((__access__ (__read_only__, 3, 4))); + + + +extern void *__mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern void *mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern size_t strlen (const char *__s) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + +extern size_t strnlen (const char *__string, size_t __maxlen) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + +extern char *strerror (int __errnum) noexcept (true); +# 444 "/usr/include/string.h" 3 4 +extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3))); + + + + +extern const char *strerrordesc_np (int __err) noexcept (true); + +extern const char *strerrorname_np (int __err) noexcept (true); + + + + + +extern char *strerror_l (int __errnum, locale_t __l) noexcept (true); + + + +# 1 "/usr/include/strings.h" 1 3 4 +# 23 "/usr/include/strings.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 24 "/usr/include/strings.h" 2 3 4 + + + + + + +extern "C" { + + + +extern int bcmp (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern void bcopy (const void *__src, void *__dest, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern void bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern "C++" +{ +extern char *index (char *__s, int __c) + noexcept (true) __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *index (const char *__s, int __c) + noexcept (true) __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 66 "/usr/include/strings.h" 3 4 +} + + + + + + + +extern "C++" +{ +extern char *rindex (char *__s, int __c) + noexcept (true) __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *rindex (const char *__s, int __c) + noexcept (true) __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 94 "/usr/include/strings.h" 3 4 +} +# 104 "/usr/include/strings.h" 3 4 +extern int ffs (int __i) noexcept (true) __attribute__ ((__const__)); + + + + + +extern int ffsl (long int __l) noexcept (true) __attribute__ ((__const__)); +__extension__ extern int ffsll (long long int __ll) + noexcept (true) __attribute__ ((__const__)); + + + +extern int strcasecmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strncasecmp (const char *__s1, const char *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + + + + +extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + + + +extern int strncasecmp_l (const char *__s1, const char *__s2, + size_t __n, locale_t __loc) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4))); + + +} +# 463 "/usr/include/string.h" 2 3 4 + + + +extern void explicit_bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__write_only__, 1, 2))); + + + +extern char *strsep (char **__restrict __stringp, + const char *__restrict __delim) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern char *strsignal (int __sig) noexcept (true); + + + +extern const char *sigabbrev_np (int __sig) noexcept (true); + + +extern const char *sigdescr_np (int __sig) noexcept (true); + + + +extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern char *stpcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern char *__stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern char *stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern size_t strlcpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__write_only__, 1, 3))); + + + +extern size_t strlcat (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__read_write__, 1, 3))); + + + + +extern int strverscmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strfry (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void *memfrob (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__read_write__, 1, 2))); + + + + + + + +extern "C++" char *basename (char *__filename) + noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); +extern "C++" const char *basename (const char *__filename) + noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); +# 552 "/usr/include/string.h" 3 4 +} +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 1 "/usr/include/time.h" 1 3 4 +# 29 "/usr/include/time.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 1 3 4 +# 30 "/usr/include/time.h" 2 3 4 + + + +# 1 "/usr/include/bits/time.h" 1 3 4 +# 73 "/usr/include/bits/time.h" 3 4 +# 1 "/usr/include/bits/timex.h" 1 3 4 +# 26 "/usr/include/bits/timex.h" 3 4 +struct timex +{ +# 58 "/usr/include/bits/timex.h" 3 4 + unsigned int modes; + __syscall_slong_t offset; + __syscall_slong_t freq; + __syscall_slong_t maxerror; + __syscall_slong_t esterror; + int status; + __syscall_slong_t constant; + __syscall_slong_t precision; + __syscall_slong_t tolerance; + struct timeval time; + __syscall_slong_t tick; + __syscall_slong_t ppsfreq; + __syscall_slong_t jitter; + int shift; + __syscall_slong_t stabil; + __syscall_slong_t jitcnt; + __syscall_slong_t calcnt; + __syscall_slong_t errcnt; + __syscall_slong_t stbcnt; + + int tai; + + + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; + +}; +# 74 "/usr/include/bits/time.h" 2 3 4 + +extern "C" { + + +extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) noexcept (true) __attribute__ ((__nonnull__ (2))); +# 90 "/usr/include/bits/time.h" 3 4 +} +# 34 "/usr/include/time.h" 2 3 4 + + + + + +# 1 "/usr/include/bits/types/struct_tm.h" 1 3 4 + + + + + + +struct tm +{ + int tm_sec; + int tm_min; + int tm_hour; + int tm_mday; + int tm_mon; + int tm_year; + int tm_wday; + int tm_yday; + int tm_isdst; + + + long int tm_gmtoff; + const char *tm_zone; + + + + +}; +# 40 "/usr/include/time.h" 2 3 4 +# 48 "/usr/include/time.h" 3 4 +# 1 "/usr/include/bits/types/struct_itimerspec.h" 1 3 4 + + + + + + + +struct itimerspec + { + struct timespec it_interval; + struct timespec it_value; + }; +# 49 "/usr/include/time.h" 2 3 4 +struct sigevent; +# 68 "/usr/include/time.h" 3 4 +extern "C" { + + + +extern clock_t clock (void) noexcept (true); + + + +extern time_t time (time_t *__timer) noexcept (true); + + +extern double difftime (time_t __time1, time_t __time0); + + +extern time_t mktime (struct tm *__tp) noexcept (true); +# 99 "/usr/include/time.h" 3 4 +extern size_t strftime (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp) + noexcept (true) __attribute__ ((__nonnull__ (1, 3, 4))); + + + + +extern char *strptime (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp) + noexcept (true); + + + + + + +extern size_t strftime_l (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp, + locale_t __loc) noexcept (true); + + + +extern char *strptime_l (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp, + locale_t __loc) noexcept (true); + + + + + + +extern struct tm *gmtime (const time_t *__timer) noexcept (true); + + + +extern struct tm *localtime (const time_t *__timer) noexcept (true); +# 154 "/usr/include/time.h" 3 4 +extern struct tm *gmtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) noexcept (true); + + + +extern struct tm *localtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) noexcept (true); +# 179 "/usr/include/time.h" 3 4 +extern char *asctime (const struct tm *__tp) noexcept (true); + + + +extern char *ctime (const time_t *__timer) noexcept (true); +# 197 "/usr/include/time.h" 3 4 +extern char *asctime_r (const struct tm *__restrict __tp, + char *__restrict __buf) noexcept (true); + + + +extern char *ctime_r (const time_t *__restrict __timer, + char *__restrict __buf) noexcept (true); +# 217 "/usr/include/time.h" 3 4 +extern char *__tzname[2]; +extern int __daylight; +extern long int __timezone; + + + + +extern char *tzname[2]; + + + +extern void tzset (void) noexcept (true); + + + +extern int daylight; +extern long int timezone; +# 246 "/usr/include/time.h" 3 4 +extern time_t timegm (struct tm *__tp) noexcept (true); +# 263 "/usr/include/time.h" 3 4 +extern time_t timelocal (struct tm *__tp) noexcept (true); + + + + + + + +extern int dysize (int __year) noexcept (true) __attribute__ ((__const__)); +# 281 "/usr/include/time.h" 3 4 +extern int nanosleep (const struct timespec *__requested_time, + struct timespec *__remaining); + + +extern int clock_getres (clockid_t __clock_id, struct timespec *__res) noexcept (true); + + +extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + +extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp) + noexcept (true) __attribute__ ((__nonnull__ (2))); +# 323 "/usr/include/time.h" 3 4 +extern int clock_nanosleep (clockid_t __clock_id, int __flags, + const struct timespec *__req, + struct timespec *__rem); +# 338 "/usr/include/time.h" 3 4 +extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) noexcept (true); + + + + +extern int timer_create (clockid_t __clock_id, + struct sigevent *__restrict __evp, + timer_t *__restrict __timerid) noexcept (true); + + +extern int timer_delete (timer_t __timerid) noexcept (true); + + + +extern int timer_settime (timer_t __timerid, int __flags, + const struct itimerspec *__restrict __value, + struct itimerspec *__restrict __ovalue) noexcept (true); + + +extern int timer_gettime (timer_t __timerid, struct itimerspec *__value) + noexcept (true); +# 376 "/usr/include/time.h" 3 4 +extern int timer_getoverrun (timer_t __timerid) noexcept (true); + + + + + + +extern int timespec_get (struct timespec *__ts, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 399 "/usr/include/time.h" 3 4 +extern int timespec_getres (struct timespec *__ts, int __base) + noexcept (true); +# 425 "/usr/include/time.h" 3 4 +extern int getdate_err; +# 434 "/usr/include/time.h" 3 4 +extern struct tm *getdate (const char *__string); +# 448 "/usr/include/time.h" 3 4 +extern int getdate_r (const char *__restrict __string, + struct tm *__restrict __resbufp); + + +} +# 87 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 + + +# 88 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern "C" +{ + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) clock_t clock(void) + + + + +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 +noexcept (true) +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void* memset(void*, int, size_t) +# 96 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 + noexcept (true) +# 96 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void* memcpy(void*, const void*, size_t) +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 + noexcept (true) +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; + +} +# 303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 1 +# 114 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 115 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 116 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 126 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern "C" +{ +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) int abs(int a) +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) long int labs(long int a) +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 255 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) long long int llabs(long long int a) +# 255 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 255 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fabs(double x) +# 283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 306 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fabsf(float x) +# 306 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 306 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 317 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int min(const int a, const int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned int umin(const unsigned int a, const unsigned int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llmin(const long long int a, const long long int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned long long int ullmin(const unsigned long long int a, const unsigned long long int b); +# 359 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fminf(float x, float y) +# 359 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 359 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 379 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmin(double x, double y) +# 379 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 379 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 392 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int max(const int a, const int b); + + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned int umax(const unsigned int a, const unsigned int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llmax(const long long int a, const long long int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned long long int ullmax(const unsigned long long int a, const unsigned long long int b); +# 435 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmaxf(float x, float y) +# 435 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 435 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 455 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmax(double, double) +# 455 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 455 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sin(double x) +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 495 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cos(double x) +# 495 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 495 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 511 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincos(double x, double *sptr, double *cptr) +# 511 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 511 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 524 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincosf(float x, float *sptr, float *cptr) +# 524 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 524 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 547 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tan(double x) +# 547 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 547 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 571 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sqrt(double x) +# 571 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 571 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 597 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rsqrt(double x); +# 621 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rsqrtf(float x); +# 648 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log2(double x) +# 648 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 648 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 677 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp2(double x) +# 677 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 677 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 706 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float exp2f(float x) +# 706 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 706 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 737 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp10(double x) +# 737 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 737 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 764 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float exp10f(float x) +# 764 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 764 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 798 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double expm1(double x) +# 798 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 798 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 831 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float expm1f(float x) +# 831 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 831 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 858 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log2f(float x) +# 858 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 858 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 883 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log10(double x) +# 883 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 883 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 909 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log(double x) +# 909 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 909 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 936 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log1p(double x) +# 936 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 936 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 966 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log1pf(float x) +# 966 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 966 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 992 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double floor(double x) +# 992 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 992 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1021 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp(double x) +# 1021 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1021 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1040 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cosh(double x) +# 1040 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1040 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sinh(double x) +# 1060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1080 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tanh(double x) +# 1080 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1080 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double acosh(double x) +# 1104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1131 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float acoshf(float x) +# 1131 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1131 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1155 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double asinh(double x) +# 1155 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1155 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1179 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float asinhf(float x) +# 1179 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1179 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atanh(double x) +# 1204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1229 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atanhf(float x) +# 1229 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1229 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1247 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double ldexp(double x, int exp) +# 1247 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1247 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1262 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ldexpf(float x, int exp) +# 1262 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1262 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double logb(double x) +# 1283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1307 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float logbf(float x) +# 1307 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1307 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1331 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int ilogb(double x) +# 1331 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1331 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1355 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int ilogbf(float x) +# 1355 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1355 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1383 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double scalbn(double x, int n) +# 1383 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1383 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float scalbnf(float x, int n) +# 1411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1439 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double scalbln(double x, long int n) +# 1439 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1439 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1467 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float scalblnf(float x, long int n) +# 1467 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1467 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1499 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double frexp(double x, int *nptr) +# 1499 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1499 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1528 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float frexpf(float x, int *nptr) +# 1528 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1528 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1551 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double round(double x) +# 1551 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1551 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1577 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float roundf(float x) +# 1577 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1577 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1595 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lround(double x) +# 1595 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1595 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1613 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lroundf(float x) +# 1613 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1613 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1631 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llround(double x) +# 1631 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1631 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1649 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llroundf(float x) +# 1649 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1649 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1719 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rintf(float x) +# 1719 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1719 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1736 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lrint(double x) +# 1736 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1736 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1753 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lrintf(float x) +# 1753 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1753 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1770 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llrint(double x) +# 1770 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1770 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1787 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llrintf(float x) +# 1787 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1787 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nearbyint(double x) +# 1811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1835 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nearbyintf(float x) +# 1835 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1835 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1859 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double ceil(double x) +# 1859 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1859 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1882 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double trunc(double x) +# 1882 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1882 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float truncf(float x) +# 1908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1930 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fdim(double x, double y) +# 1930 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1930 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1951 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fdimf(float x, float y) +# 1951 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1951 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atan2(double y, double x) +# 2034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atan(double x) +# 2060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double acos(double x) +# 2077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2099 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double asin(double x) +# 2099 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2099 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2130 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double hypot(double x, double y) +# 2130 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2130 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2156 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rhypot(double x, double y) +# 2156 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2156 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2187 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float hypotf(float x, float y) +# 2187 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2187 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2213 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rhypotf(float x, float y) +# 2213 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2213 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2231 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double norm3d(double a, double b, double c) +# 2231 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2231 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2249 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm3d(double a, double b, double c) +# 2249 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2249 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double norm4d(double a, double b, double c, double d) +# 2267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm4d(double a, double b, double c, double d) +# 2285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +__attribute__((device)) __attribute__((device_builtin)) double norm(int dim, double const * p) +# 2303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2321 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm(int dim, double const * p) +# 2321 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2321 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnormf(int dim, float const * p) +# 2340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2358 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +__attribute__((device)) __attribute__((device_builtin)) float normf(int dim, float const * p) +# 2358 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2358 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2377 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float norm3df(float a, float b, float c) +# 2377 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2377 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2395 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnorm3df(float a, float b, float c) +# 2395 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2395 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2413 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float norm4df(float a, float b, float c, float d) +# 2413 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2413 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2431 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnorm4df(float a, float b, float c, float d) +# 2431 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2431 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2459 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cbrt(double x) +# 2459 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2459 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2486 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cbrtf(float x) +# 2486 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2486 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2512 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rcbrt(double x); +# 2533 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rcbrtf(float x); +# 2556 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sinpi(double x) noexcept (true); +# 2579 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinpif(float x) noexcept (true); +# 2601 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cospi(double x) noexcept (true); +# 2623 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cospif(float x) noexcept (true); +# 2636 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincospi(double x, double *sptr, double *cptr); +# 2649 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincospif(float x, float *sptr, float *cptr); +# 2735 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double pow(double x, double y) +# 2735 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2735 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2759 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double modf(double x, double *iptr) +# 2759 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2759 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2786 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmod(double x, double y) +# 2786 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2786 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2816 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double remainder(double x, double y) +# 2816 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2816 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2849 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float remainderf(float x, float y) +# 2849 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2849 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2887 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double remquo(double x, double y, int *quo) +# 2887 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2887 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2925 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float remquof(float x, float y, int *quo) +# 2925 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2925 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2946 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double j0(double x) +# 2946 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2946 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2968 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float j0f(float x) +# 2968 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2968 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2995 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double j1(double x) +# 2995 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2995 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3022 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float j1f(float x) +# 3022 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3022 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3045 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double jn(int n, double x) +# 3045 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3045 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3068 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float jnf(int n, float x) +# 3068 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3068 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3095 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double y0(double x) +# 3095 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3095 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3122 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float y0f(float x) +# 3122 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3122 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3149 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double y1(double x) +# 3149 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3149 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3176 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float y1f(float x) +# 3176 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3176 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double yn(int n, double x) +# 3204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3232 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ynf(int n, float x) +# 3232 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3232 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3250 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double cyl_bessel_i0(double x) +# 3250 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3250 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float cyl_bessel_i0f(float x) +# 3267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3267 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double cyl_bessel_i1(double x) +# 3285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3285 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3302 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float cyl_bessel_i1f(float x) +# 3302 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3302 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erf(double x) +# 3328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erff(float x) +# 3353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3383 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfinv(double x); +# 3406 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfinvf(float x); +# 3430 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfc(double x) +# 3430 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3430 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3453 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcf(float x) +# 3453 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3453 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3485 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double lgamma(double x) +# 3485 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3485 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3513 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfcinv(double x); +# 3534 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcinvf(float x); +# 3556 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double normcdfinv(double x); +# 3578 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normcdfinvf(float x); +# 3597 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double normcdf(double x); +# 3616 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normcdff(float x); +# 3636 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfcx(double x); +# 3656 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcxf(float x); +# 3689 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float lgammaf(float x) +# 3689 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3689 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3718 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tgamma(double x) +# 3718 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3718 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3747 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tgammaf(float x) +# 3747 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3747 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3761 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double copysign(double x, double y) +# 3761 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3761 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3775 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float copysignf(float x, float y) +# 3775 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3775 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3794 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nextafter(double x, double y) +# 3794 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3794 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3813 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nextafterf(float x, float y) +# 3813 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3813 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3829 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nan(const char *tagp) +# 3829 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3829 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3845 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nanf(const char *tagp) +# 3845 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3845 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinff(float) +# 3852 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3852 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnanf(float) +# 3853 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3853 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3863 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finite(double) +# 3863 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3863 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finitef(float) +# 3864 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3864 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbit(double) +# 3865 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3865 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnan(double) +# 3866 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3866 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinf(double) +# 3867 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3867 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitf(float) +# 3870 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3870 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3921 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fma(double x, double y, double z) +# 3921 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3921 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmaf(float x, float y, float z) +# 3971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3982 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitl(long double) +# 3982 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3982 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finitel(long double) +# 3988 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3988 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinfl(long double) +# 3989 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3989 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnanl(long double) +# 3990 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3990 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float acosf(float x) +# 4034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4056 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float asinf(float x) +# 4056 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4056 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4083 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atanf(float x) +# 4083 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4083 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4163 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atan2f(float y, float x) +# 4163 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4163 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4182 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cosf(float x) +# 4182 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4182 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4202 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinf(float x) +# 4202 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4202 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4222 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tanf(float x) +# 4222 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4222 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4241 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float coshf(float x) +# 4241 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4241 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4261 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinhf(float x) +# 4261 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4261 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4281 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tanhf(float x) +# 4281 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4281 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4304 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float logf(float x) +# 4304 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4304 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4334 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float expf(float x) +# 4334 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4334 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4357 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log10f(float x) +# 4357 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4357 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4380 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float modff(float x, float *iptr) +# 4380 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4380 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4463 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float powf(float x, float y) +# 4463 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4463 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4487 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sqrtf(float x) +# 4487 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4487 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4510 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ceilf(float x) +# 4510 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4510 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4533 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float floorf(float x) +# 4533 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4533 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4559 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmodf(float x, float y) +# 4559 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4559 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4574 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +} + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/math.h" 1 3 +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/math.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/requires_hosted.h" 1 3 +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 1 3 +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 2 3 +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + struct __true_type { }; + struct __false_type { }; + + template + struct __truth_type + { typedef __false_type __type; }; + + template<> + struct __truth_type + { typedef __true_type __type; }; + + + + template + struct __traitor + { + enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; + typedef typename __truth_type<__value>::__type __type; + }; + + + template + struct __are_same + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __are_same<_Tp, _Tp> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_void + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_void + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_integer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 185 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 273 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +__extension__ template<> struct __is_integer<__int128> { enum { __value = 1 }; typedef __true_type __type; }; __extension__ template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; +# 290 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + template + struct __is_floating + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 367 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + template + struct __is_pointer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __is_pointer<_Tp*> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_arithmetic + : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > + { }; + + + + + template + struct __is_scalar + : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > + { }; + + + + + template + struct __is_char + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_byte + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + enum class byte : unsigned char; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 471 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + template struct iterator_traits; + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = __is_trivially_copyable(_Tp) }; + }; + + + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = 0 }; + }; + + + template + struct __memcpyable + { + enum { __value = 0 }; + }; + + template + struct __memcpyable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcpyable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + template + struct __memcmpable + { + enum { __value = 0 }; + }; + + + template + struct __memcmpable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + + template::__value + + > + struct __is_memcmp_ordered + { + static const bool __value = _Tp(-1) > _Tp(1); + }; + + template + struct __is_memcmp_ordered<_Tp, false> + { + static const bool __value = false; + }; + + + template + struct __is_memcmp_ordered_with + { + static const bool __value = __is_memcmp_ordered<_Tp>::__value + && __is_memcmp_ordered<_Up>::__value; + }; + + template + struct __is_memcmp_ordered_with<_Tp, _Up, false> + { + static const bool __value = false; + }; +# 580 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 + template<> + struct __is_memcmp_ordered_with + { static constexpr bool __value = true; }; + + template + struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> + { static constexpr bool __value = false; }; + + template + struct __is_memcmp_ordered_with + { static constexpr bool __value = false; }; + + + + + + template + struct __is_move_iterator + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + template + + inline _Iterator + __miter_base(_Iterator __it) + { return __it; } + + +} +} +# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 + +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 + + + + +extern "C++" { + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct __enable_if + { }; + + template + struct __enable_if + { typedef _Tp __type; }; + + + + template + struct __conditional_type + { typedef _Iftrue __type; }; + + template + struct __conditional_type + { typedef _Iffalse __type; }; + + + + template + struct __add_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned short __type; }; + + template<> + struct __add_unsigned + { typedef unsigned int __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long long __type; }; + + + template<> + struct __add_unsigned; + + template<> + struct __add_unsigned; + + + + template + struct __remove_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef short __type; }; + + template<> + struct __remove_unsigned + { typedef int __type; }; + + template<> + struct __remove_unsigned + { typedef long __type; }; + + template<> + struct __remove_unsigned + { typedef long long __type; }; + + + template<> + struct __remove_unsigned; + + template<> + struct __remove_unsigned; + + + + template + constexpr + inline bool + __is_null_pointer(_Type* __ptr) + { return __ptr == 0; } + + template + constexpr + inline bool + __is_null_pointer(_Type) + { return false; } + + + constexpr bool + __is_null_pointer(std::nullptr_t) + { return true; } + + + + + template::__value> + struct __promote + { typedef double __type; }; + + + + + template + struct __promote<_Tp, false> + { }; + + template<> + struct __promote + { typedef long double __type; }; + + template<> + struct __promote + { typedef double __type; }; + + template<> + struct __promote + { typedef float __type; }; +# 225 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 + template + using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); + + + + template + using __promote_2 = __promote<__promoted_t<_Tp, _Up>>; + + template + using __promote_3 = __promote<__promoted_t<_Tp, _Up, _Vp>>; + + template + using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>; +# 269 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 + +} +} +# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 + +# 1 "/usr/include/math.h" 1 3 4 +# 27 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 28 "/usr/include/math.h" 2 3 4 + + + + + + +extern "C" { + + + + + +# 1 "/usr/include/bits/math-vector.h" 1 3 4 +# 25 "/usr/include/bits/math-vector.h" 3 4 +# 1 "/usr/include/bits/libm-simd-decl-stubs.h" 1 3 4 +# 26 "/usr/include/bits/math-vector.h" 2 3 4 +# 41 "/usr/include/math.h" 2 3 4 +# 156 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/flt-eval-method.h" 1 3 4 +# 157 "/usr/include/math.h" 2 3 4 +# 167 "/usr/include/math.h" 3 4 +typedef float float_t; +typedef double double_t; +# 208 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/fp-logb.h" 1 3 4 +# 209 "/usr/include/math.h" 2 3 4 +# 251 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/fp-fast.h" 1 3 4 +# 252 "/usr/include/math.h" 2 3 4 + + + +enum + { + FP_INT_UPWARD = + + 0, + FP_INT_DOWNWARD = + + 1, + FP_INT_TOWARDZERO = + + 2, + FP_INT_TONEARESTFROMZERO = + + 3, + FP_INT_TONEAREST = + + 4, + }; + + +# 1 "/usr/include/bits/mathcalls-macros.h" 1 3 4 +# 276 "/usr/include/math.h" 2 3 4 + + + + + +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassify (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbit (double __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinf (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finite (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnan (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsig (double __x, double __y) noexcept (true); + + +extern int __issignaling (double __value) noexcept (true) + __attribute__ ((__const__)); +# 282 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern double acos (double __x) noexcept (true); extern double __acos (double __x) noexcept (true); + + extern double asin (double __x) noexcept (true); extern double __asin (double __x) noexcept (true); + + extern double atan (double __x) noexcept (true); extern double __atan (double __x) noexcept (true); + + extern double atan2 (double __y, double __x) noexcept (true); extern double __atan2 (double __y, double __x) noexcept (true); + + + extern double cos (double __x) noexcept (true); extern double __cos (double __x) noexcept (true); + + extern double sin (double __x) noexcept (true); extern double __sin (double __x) noexcept (true); + + extern double tan (double __x) noexcept (true); extern double __tan (double __x) noexcept (true); + + + +extern double acospi (double __x) noexcept (true); extern double __acospi (double __x) noexcept (true); + +extern double asinpi (double __x) noexcept (true); extern double __asinpi (double __x) noexcept (true); + +extern double atanpi (double __x) noexcept (true); extern double __atanpi (double __x) noexcept (true); + +extern double atan2pi (double __y, double __x) noexcept (true); extern double __atan2pi (double __y, double __x) noexcept (true); + + + extern double cospi (double __x) noexcept (true); extern double __cospi (double __x) noexcept (true); + + extern double sinpi (double __x) noexcept (true); extern double __sinpi (double __x) noexcept (true); + + extern double tanpi (double __x) noexcept (true); extern double __tanpi (double __x) noexcept (true); + + + + + + extern double cosh (double __x) noexcept (true); extern double __cosh (double __x) noexcept (true); + + extern double sinh (double __x) noexcept (true); extern double __sinh (double __x) noexcept (true); + + extern double tanh (double __x) noexcept (true); extern double __tanh (double __x) noexcept (true); + + + + extern void sincos (double __x, double *__sinx, double *__cosx) noexcept (true); extern void __sincos (double __x, double *__sinx, double *__cosx) noexcept (true) + ; + + + + + extern double acosh (double __x) noexcept (true); extern double __acosh (double __x) noexcept (true); + + extern double asinh (double __x) noexcept (true); extern double __asinh (double __x) noexcept (true); + + extern double atanh (double __x) noexcept (true); extern double __atanh (double __x) noexcept (true); + + + + + + extern double exp (double __x) noexcept (true); extern double __exp (double __x) noexcept (true); + + +extern double frexp (double __x, int *__exponent) noexcept (true); extern double __frexp (double __x, int *__exponent) noexcept (true); + + +extern double ldexp (double __x, int __exponent) noexcept (true); extern double __ldexp (double __x, int __exponent) noexcept (true); + + + extern double log (double __x) noexcept (true); extern double __log (double __x) noexcept (true); + + + extern double log10 (double __x) noexcept (true); extern double __log10 (double __x) noexcept (true); + + +extern double modf (double __x, double *__iptr) noexcept (true); extern double __modf (double __x, double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern double exp10 (double __x) noexcept (true); extern double __exp10 (double __x) noexcept (true); + + +extern double exp2m1 (double __x) noexcept (true); extern double __exp2m1 (double __x) noexcept (true); + + +extern double exp10m1 (double __x) noexcept (true); extern double __exp10m1 (double __x) noexcept (true); + + +extern double log2p1 (double __x) noexcept (true); extern double __log2p1 (double __x) noexcept (true); + + +extern double log10p1 (double __x) noexcept (true); extern double __log10p1 (double __x) noexcept (true); + + + extern double logp1 (double __x) noexcept (true); extern double __logp1 (double __x) noexcept (true); + + + + + extern double expm1 (double __x) noexcept (true); extern double __expm1 (double __x) noexcept (true); + + + extern double log1p (double __x) noexcept (true); extern double __log1p (double __x) noexcept (true); + + +extern double logb (double __x) noexcept (true); extern double __logb (double __x) noexcept (true); + + + + + extern double exp2 (double __x) noexcept (true); extern double __exp2 (double __x) noexcept (true); + + + extern double log2 (double __x) noexcept (true); extern double __log2 (double __x) noexcept (true); + + + + + + + extern double pow (double __x, double __y) noexcept (true); extern double __pow (double __x, double __y) noexcept (true); + + +extern double sqrt (double __x) noexcept (true); extern double __sqrt (double __x) noexcept (true); + + + + extern double hypot (double __x, double __y) noexcept (true); extern double __hypot (double __x, double __y) noexcept (true); + + + + + extern double cbrt (double __x) noexcept (true); extern double __cbrt (double __x) noexcept (true); + + + + + + +extern double ceil (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double fabs (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double floor (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double fmod (double __x, double __y) noexcept (true); extern double __fmod (double __x, double __y) noexcept (true); +# 216 "/usr/include/bits/mathcalls.h" 3 4 +extern int finite (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern double drem (double __x, double __y) noexcept (true); extern double __drem (double __x, double __y) noexcept (true); + + + +extern double significand (double __x) noexcept (true); extern double __significand (double __x) noexcept (true); + + + + + + +extern double copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern double nan (const char *__tagb) noexcept (true); extern double __nan (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern double j0 (double) noexcept (true); extern double __j0 (double) noexcept (true); +extern double j1 (double) noexcept (true); extern double __j1 (double) noexcept (true); +extern double jn (int, double) noexcept (true); extern double __jn (int, double) noexcept (true); +extern double y0 (double) noexcept (true); extern double __y0 (double) noexcept (true); +extern double y1 (double) noexcept (true); extern double __y1 (double) noexcept (true); +extern double yn (int, double) noexcept (true); extern double __yn (int, double) noexcept (true); + + + + + + extern double erf (double) noexcept (true); extern double __erf (double) noexcept (true); + extern double erfc (double) noexcept (true); extern double __erfc (double) noexcept (true); +extern double lgamma (double) noexcept (true); extern double __lgamma (double) noexcept (true); + + + + +extern double tgamma (double) noexcept (true); extern double __tgamma (double) noexcept (true); + + + + + +extern double gamma (double) noexcept (true); extern double __gamma (double) noexcept (true); + + + + + + + +extern double lgamma_r (double, int *__signgamp) noexcept (true); extern double __lgamma_r (double, int *__signgamp) noexcept (true); + + + + + + +extern double rint (double __x) noexcept (true); extern double __rint (double __x) noexcept (true); + + +extern double nextafter (double __x, double __y) noexcept (true); extern double __nextafter (double __x, double __y) noexcept (true); + +extern double nexttoward (double __x, long double __y) noexcept (true); extern double __nexttoward (double __x, long double __y) noexcept (true); + + + + +extern double nextdown (double __x) noexcept (true); extern double __nextdown (double __x) noexcept (true); + +extern double nextup (double __x) noexcept (true); extern double __nextup (double __x) noexcept (true); + + + +extern double remainder (double __x, double __y) noexcept (true); extern double __remainder (double __x, double __y) noexcept (true); + + + +extern double scalbn (double __x, int __n) noexcept (true); extern double __scalbn (double __x, int __n) noexcept (true); + + + +extern int ilogb (double __x) noexcept (true); extern int __ilogb (double __x) noexcept (true); + + + + +extern long int llogb (double __x) noexcept (true); extern long int __llogb (double __x) noexcept (true); + + + + +extern double scalbln (double __x, long int __n) noexcept (true); extern double __scalbln (double __x, long int __n) noexcept (true); + + + +extern double nearbyint (double __x) noexcept (true); extern double __nearbyint (double __x) noexcept (true); + + + +extern double round (double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern double trunc (double __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern double remquo (double __x, double __y, int *__quo) noexcept (true); extern double __remquo (double __x, double __y, int *__quo) noexcept (true); + + + + + + +extern long int lrint (double __x) noexcept (true); extern long int __lrint (double __x) noexcept (true); +__extension__ +extern long long int llrint (double __x) noexcept (true); extern long long int __llrint (double __x) noexcept (true); + + + +extern long int lround (double __x) noexcept (true); extern long int __lround (double __x) noexcept (true); +__extension__ +extern long long int llround (double __x) noexcept (true); extern long long int __llround (double __x) noexcept (true); + + + +extern double fdim (double __x, double __y) noexcept (true); extern double __fdim (double __x, double __y) noexcept (true); + + + +extern double fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + +extern double fma (double __x, double __y, double __z) noexcept (true); extern double __fma (double __x, double __y, double __z) noexcept (true); + + + + +extern double roundeven (double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfp (double __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfp (double __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpx (double __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpx (double __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalize (double *__cx, const double *__x) noexcept (true); + + + + + + +extern double fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern double fmaximum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorder (const double *__x, const double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermag (const double *__x, const double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern double getpayload (const double *__x) noexcept (true); extern double __getpayload (const double *__x) noexcept (true); + + +extern int setpayload (double *__x, double __payload) noexcept (true); + + +extern int setpayloadsig (double *__x, double __payload) noexcept (true); + + + + + + + +extern double scalb (double __x, double __n) noexcept (true); extern double __scalb (double __x, double __n) noexcept (true); +# 283 "/usr/include/math.h" 2 3 4 +# 298 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyf (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitf (float __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinff (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitef (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanf (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigf (float __x, float __y) noexcept (true); + + +extern int __issignalingf (float __value) noexcept (true) + __attribute__ ((__const__)); +# 299 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern float acosf (float __x) noexcept (true); extern float __acosf (float __x) noexcept (true); + + extern float asinf (float __x) noexcept (true); extern float __asinf (float __x) noexcept (true); + + extern float atanf (float __x) noexcept (true); extern float __atanf (float __x) noexcept (true); + + extern float atan2f (float __y, float __x) noexcept (true); extern float __atan2f (float __y, float __x) noexcept (true); + + + extern float cosf (float __x) noexcept (true); extern float __cosf (float __x) noexcept (true); + + extern float sinf (float __x) noexcept (true); extern float __sinf (float __x) noexcept (true); + + extern float tanf (float __x) noexcept (true); extern float __tanf (float __x) noexcept (true); + + + +extern float acospif (float __x) noexcept (true); extern float __acospif (float __x) noexcept (true); + +extern float asinpif (float __x) noexcept (true); extern float __asinpif (float __x) noexcept (true); + +extern float atanpif (float __x) noexcept (true); extern float __atanpif (float __x) noexcept (true); + +extern float atan2pif (float __y, float __x) noexcept (true); extern float __atan2pif (float __y, float __x) noexcept (true); + + + extern float cospif (float __x) noexcept (true); extern float __cospif (float __x) noexcept (true); + + extern float sinpif (float __x) noexcept (true); extern float __sinpif (float __x) noexcept (true); + + extern float tanpif (float __x) noexcept (true); extern float __tanpif (float __x) noexcept (true); + + + + + + extern float coshf (float __x) noexcept (true); extern float __coshf (float __x) noexcept (true); + + extern float sinhf (float __x) noexcept (true); extern float __sinhf (float __x) noexcept (true); + + extern float tanhf (float __x) noexcept (true); extern float __tanhf (float __x) noexcept (true); + + + + extern void sincosf (float __x, float *__sinx, float *__cosx) noexcept (true); extern void __sincosf (float __x, float *__sinx, float *__cosx) noexcept (true) + ; + + + + + extern float acoshf (float __x) noexcept (true); extern float __acoshf (float __x) noexcept (true); + + extern float asinhf (float __x) noexcept (true); extern float __asinhf (float __x) noexcept (true); + + extern float atanhf (float __x) noexcept (true); extern float __atanhf (float __x) noexcept (true); + + + + + + extern float expf (float __x) noexcept (true); extern float __expf (float __x) noexcept (true); + + +extern float frexpf (float __x, int *__exponent) noexcept (true); extern float __frexpf (float __x, int *__exponent) noexcept (true); + + +extern float ldexpf (float __x, int __exponent) noexcept (true); extern float __ldexpf (float __x, int __exponent) noexcept (true); + + + extern float logf (float __x) noexcept (true); extern float __logf (float __x) noexcept (true); + + + extern float log10f (float __x) noexcept (true); extern float __log10f (float __x) noexcept (true); + + +extern float modff (float __x, float *__iptr) noexcept (true); extern float __modff (float __x, float *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern float exp10f (float __x) noexcept (true); extern float __exp10f (float __x) noexcept (true); + + +extern float exp2m1f (float __x) noexcept (true); extern float __exp2m1f (float __x) noexcept (true); + + +extern float exp10m1f (float __x) noexcept (true); extern float __exp10m1f (float __x) noexcept (true); + + +extern float log2p1f (float __x) noexcept (true); extern float __log2p1f (float __x) noexcept (true); + + +extern float log10p1f (float __x) noexcept (true); extern float __log10p1f (float __x) noexcept (true); + + + extern float logp1f (float __x) noexcept (true); extern float __logp1f (float __x) noexcept (true); + + + + + extern float expm1f (float __x) noexcept (true); extern float __expm1f (float __x) noexcept (true); + + + extern float log1pf (float __x) noexcept (true); extern float __log1pf (float __x) noexcept (true); + + +extern float logbf (float __x) noexcept (true); extern float __logbf (float __x) noexcept (true); + + + + + extern float exp2f (float __x) noexcept (true); extern float __exp2f (float __x) noexcept (true); + + + extern float log2f (float __x) noexcept (true); extern float __log2f (float __x) noexcept (true); + + + + + + + extern float powf (float __x, float __y) noexcept (true); extern float __powf (float __x, float __y) noexcept (true); + + +extern float sqrtf (float __x) noexcept (true); extern float __sqrtf (float __x) noexcept (true); + + + + extern float hypotf (float __x, float __y) noexcept (true); extern float __hypotf (float __x, float __y) noexcept (true); + + + + + extern float cbrtf (float __x) noexcept (true); extern float __cbrtf (float __x) noexcept (true); + + + + + + +extern float ceilf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float fabsf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float floorf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float fmodf (float __x, float __y) noexcept (true); extern float __fmodf (float __x, float __y) noexcept (true); +# 210 "/usr/include/bits/mathcalls.h" 3 4 +extern int isinff (float __value) noexcept (true) + __attribute__ ((__const__)); + + + + +extern int finitef (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern float dremf (float __x, float __y) noexcept (true); extern float __dremf (float __x, float __y) noexcept (true); + + + +extern float significandf (float __x) noexcept (true); extern float __significandf (float __x) noexcept (true); + + + + + + +extern float copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern float nanf (const char *__tagb) noexcept (true); extern float __nanf (const char *__tagb) noexcept (true); +# 246 "/usr/include/bits/mathcalls.h" 3 4 +extern int isnanf (float __value) noexcept (true) + __attribute__ ((__const__)); + + + + + +extern float j0f (float) noexcept (true); extern float __j0f (float) noexcept (true); +extern float j1f (float) noexcept (true); extern float __j1f (float) noexcept (true); +extern float jnf (int, float) noexcept (true); extern float __jnf (int, float) noexcept (true); +extern float y0f (float) noexcept (true); extern float __y0f (float) noexcept (true); +extern float y1f (float) noexcept (true); extern float __y1f (float) noexcept (true); +extern float ynf (int, float) noexcept (true); extern float __ynf (int, float) noexcept (true); + + + + + + extern float erff (float) noexcept (true); extern float __erff (float) noexcept (true); + extern float erfcf (float) noexcept (true); extern float __erfcf (float) noexcept (true); +extern float lgammaf (float) noexcept (true); extern float __lgammaf (float) noexcept (true); + + + + +extern float tgammaf (float) noexcept (true); extern float __tgammaf (float) noexcept (true); + + + + + +extern float gammaf (float) noexcept (true); extern float __gammaf (float) noexcept (true); + + + + + + + +extern float lgammaf_r (float, int *__signgamp) noexcept (true); extern float __lgammaf_r (float, int *__signgamp) noexcept (true); + + + + + + +extern float rintf (float __x) noexcept (true); extern float __rintf (float __x) noexcept (true); + + +extern float nextafterf (float __x, float __y) noexcept (true); extern float __nextafterf (float __x, float __y) noexcept (true); + +extern float nexttowardf (float __x, long double __y) noexcept (true); extern float __nexttowardf (float __x, long double __y) noexcept (true); + + + + +extern float nextdownf (float __x) noexcept (true); extern float __nextdownf (float __x) noexcept (true); + +extern float nextupf (float __x) noexcept (true); extern float __nextupf (float __x) noexcept (true); + + + +extern float remainderf (float __x, float __y) noexcept (true); extern float __remainderf (float __x, float __y) noexcept (true); + + + +extern float scalbnf (float __x, int __n) noexcept (true); extern float __scalbnf (float __x, int __n) noexcept (true); + + + +extern int ilogbf (float __x) noexcept (true); extern int __ilogbf (float __x) noexcept (true); + + + + +extern long int llogbf (float __x) noexcept (true); extern long int __llogbf (float __x) noexcept (true); + + + + +extern float scalblnf (float __x, long int __n) noexcept (true); extern float __scalblnf (float __x, long int __n) noexcept (true); + + + +extern float nearbyintf (float __x) noexcept (true); extern float __nearbyintf (float __x) noexcept (true); + + + +extern float roundf (float __x) noexcept (true) __attribute__ ((__const__)); + + + +extern float truncf (float __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern float remquof (float __x, float __y, int *__quo) noexcept (true); extern float __remquof (float __x, float __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf (float __x) noexcept (true); extern long int __lrintf (float __x) noexcept (true); +__extension__ +extern long long int llrintf (float __x) noexcept (true); extern long long int __llrintf (float __x) noexcept (true); + + + +extern long int lroundf (float __x) noexcept (true); extern long int __lroundf (float __x) noexcept (true); +__extension__ +extern long long int llroundf (float __x) noexcept (true); extern long long int __llroundf (float __x) noexcept (true); + + + +extern float fdimf (float __x, float __y) noexcept (true); extern float __fdimf (float __x, float __y) noexcept (true); + + + +extern float fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + +extern float fmaf (float __x, float __y, float __z) noexcept (true); extern float __fmaf (float __x, float __y, float __z) noexcept (true); + + + + +extern float roundevenf (float __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf (float __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf (float __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf (float __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef (float *__cx, const float *__x) noexcept (true); + + + + + + +extern float fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern float fmaximumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf (const float *__x, const float *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf (const float *__x, const float *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern float getpayloadf (const float *__x) noexcept (true); extern float __getpayloadf (const float *__x) noexcept (true); + + +extern int setpayloadf (float *__x, float __payload) noexcept (true); + + +extern int setpayloadsigf (float *__x, float __payload) noexcept (true); + + + + + + + +extern float scalbf (float __x, float __n) noexcept (true); extern float __scalbf (float __x, float __n) noexcept (true); +# 300 "/usr/include/math.h" 2 3 4 +# 367 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinfl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitel (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigl (long double __x, long double __y) noexcept (true); + + +extern int __issignalingl (long double __value) noexcept (true) + __attribute__ ((__const__)); +# 368 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern long double acosl (long double __x) noexcept (true); extern long double __acosl (long double __x) noexcept (true); + + extern long double asinl (long double __x) noexcept (true); extern long double __asinl (long double __x) noexcept (true); + + extern long double atanl (long double __x) noexcept (true); extern long double __atanl (long double __x) noexcept (true); + + extern long double atan2l (long double __y, long double __x) noexcept (true); extern long double __atan2l (long double __y, long double __x) noexcept (true); + + + extern long double cosl (long double __x) noexcept (true); extern long double __cosl (long double __x) noexcept (true); + + extern long double sinl (long double __x) noexcept (true); extern long double __sinl (long double __x) noexcept (true); + + extern long double tanl (long double __x) noexcept (true); extern long double __tanl (long double __x) noexcept (true); + + + +extern long double acospil (long double __x) noexcept (true); extern long double __acospil (long double __x) noexcept (true); + +extern long double asinpil (long double __x) noexcept (true); extern long double __asinpil (long double __x) noexcept (true); + +extern long double atanpil (long double __x) noexcept (true); extern long double __atanpil (long double __x) noexcept (true); + +extern long double atan2pil (long double __y, long double __x) noexcept (true); extern long double __atan2pil (long double __y, long double __x) noexcept (true); + + + extern long double cospil (long double __x) noexcept (true); extern long double __cospil (long double __x) noexcept (true); + + extern long double sinpil (long double __x) noexcept (true); extern long double __sinpil (long double __x) noexcept (true); + + extern long double tanpil (long double __x) noexcept (true); extern long double __tanpil (long double __x) noexcept (true); + + + + + + extern long double coshl (long double __x) noexcept (true); extern long double __coshl (long double __x) noexcept (true); + + extern long double sinhl (long double __x) noexcept (true); extern long double __sinhl (long double __x) noexcept (true); + + extern long double tanhl (long double __x) noexcept (true); extern long double __tanhl (long double __x) noexcept (true); + + + + extern void sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true) + ; + + + + + extern long double acoshl (long double __x) noexcept (true); extern long double __acoshl (long double __x) noexcept (true); + + extern long double asinhl (long double __x) noexcept (true); extern long double __asinhl (long double __x) noexcept (true); + + extern long double atanhl (long double __x) noexcept (true); extern long double __atanhl (long double __x) noexcept (true); + + + + + + extern long double expl (long double __x) noexcept (true); extern long double __expl (long double __x) noexcept (true); + + +extern long double frexpl (long double __x, int *__exponent) noexcept (true); extern long double __frexpl (long double __x, int *__exponent) noexcept (true); + + +extern long double ldexpl (long double __x, int __exponent) noexcept (true); extern long double __ldexpl (long double __x, int __exponent) noexcept (true); + + + extern long double logl (long double __x) noexcept (true); extern long double __logl (long double __x) noexcept (true); + + + extern long double log10l (long double __x) noexcept (true); extern long double __log10l (long double __x) noexcept (true); + + +extern long double modfl (long double __x, long double *__iptr) noexcept (true); extern long double __modfl (long double __x, long double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern long double exp10l (long double __x) noexcept (true); extern long double __exp10l (long double __x) noexcept (true); + + +extern long double exp2m1l (long double __x) noexcept (true); extern long double __exp2m1l (long double __x) noexcept (true); + + +extern long double exp10m1l (long double __x) noexcept (true); extern long double __exp10m1l (long double __x) noexcept (true); + + +extern long double log2p1l (long double __x) noexcept (true); extern long double __log2p1l (long double __x) noexcept (true); + + +extern long double log10p1l (long double __x) noexcept (true); extern long double __log10p1l (long double __x) noexcept (true); + + + extern long double logp1l (long double __x) noexcept (true); extern long double __logp1l (long double __x) noexcept (true); + + + + + extern long double expm1l (long double __x) noexcept (true); extern long double __expm1l (long double __x) noexcept (true); + + + extern long double log1pl (long double __x) noexcept (true); extern long double __log1pl (long double __x) noexcept (true); + + +extern long double logbl (long double __x) noexcept (true); extern long double __logbl (long double __x) noexcept (true); + + + + + extern long double exp2l (long double __x) noexcept (true); extern long double __exp2l (long double __x) noexcept (true); + + + extern long double log2l (long double __x) noexcept (true); extern long double __log2l (long double __x) noexcept (true); + + + + + + + extern long double powl (long double __x, long double __y) noexcept (true); extern long double __powl (long double __x, long double __y) noexcept (true); + + +extern long double sqrtl (long double __x) noexcept (true); extern long double __sqrtl (long double __x) noexcept (true); + + + + extern long double hypotl (long double __x, long double __y) noexcept (true); extern long double __hypotl (long double __x, long double __y) noexcept (true); + + + + + extern long double cbrtl (long double __x) noexcept (true); extern long double __cbrtl (long double __x) noexcept (true); + + + + + + +extern long double ceill (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double floorl (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmodl (long double __x, long double __y) noexcept (true); extern long double __fmodl (long double __x, long double __y) noexcept (true); +# 210 "/usr/include/bits/mathcalls.h" 3 4 +extern int isinfl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + + +extern int finitel (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern long double dreml (long double __x, long double __y) noexcept (true); extern long double __dreml (long double __x, long double __y) noexcept (true); + + + +extern long double significandl (long double __x) noexcept (true); extern long double __significandl (long double __x) noexcept (true); + + + + + + +extern long double copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double nanl (const char *__tagb) noexcept (true); extern long double __nanl (const char *__tagb) noexcept (true); +# 246 "/usr/include/bits/mathcalls.h" 3 4 +extern int isnanl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + + + +extern long double j0l (long double) noexcept (true); extern long double __j0l (long double) noexcept (true); +extern long double j1l (long double) noexcept (true); extern long double __j1l (long double) noexcept (true); +extern long double jnl (int, long double) noexcept (true); extern long double __jnl (int, long double) noexcept (true); +extern long double y0l (long double) noexcept (true); extern long double __y0l (long double) noexcept (true); +extern long double y1l (long double) noexcept (true); extern long double __y1l (long double) noexcept (true); +extern long double ynl (int, long double) noexcept (true); extern long double __ynl (int, long double) noexcept (true); + + + + + + extern long double erfl (long double) noexcept (true); extern long double __erfl (long double) noexcept (true); + extern long double erfcl (long double) noexcept (true); extern long double __erfcl (long double) noexcept (true); +extern long double lgammal (long double) noexcept (true); extern long double __lgammal (long double) noexcept (true); + + + + +extern long double tgammal (long double) noexcept (true); extern long double __tgammal (long double) noexcept (true); + + + + + +extern long double gammal (long double) noexcept (true); extern long double __gammal (long double) noexcept (true); + + + + + + + +extern long double lgammal_r (long double, int *__signgamp) noexcept (true); extern long double __lgammal_r (long double, int *__signgamp) noexcept (true); + + + + + + +extern long double rintl (long double __x) noexcept (true); extern long double __rintl (long double __x) noexcept (true); + + +extern long double nextafterl (long double __x, long double __y) noexcept (true); extern long double __nextafterl (long double __x, long double __y) noexcept (true); + +extern long double nexttowardl (long double __x, long double __y) noexcept (true); extern long double __nexttowardl (long double __x, long double __y) noexcept (true); + + + + +extern long double nextdownl (long double __x) noexcept (true); extern long double __nextdownl (long double __x) noexcept (true); + +extern long double nextupl (long double __x) noexcept (true); extern long double __nextupl (long double __x) noexcept (true); + + + +extern long double remainderl (long double __x, long double __y) noexcept (true); extern long double __remainderl (long double __x, long double __y) noexcept (true); + + + +extern long double scalbnl (long double __x, int __n) noexcept (true); extern long double __scalbnl (long double __x, int __n) noexcept (true); + + + +extern int ilogbl (long double __x) noexcept (true); extern int __ilogbl (long double __x) noexcept (true); + + + + +extern long int llogbl (long double __x) noexcept (true); extern long int __llogbl (long double __x) noexcept (true); + + + + +extern long double scalblnl (long double __x, long int __n) noexcept (true); extern long double __scalblnl (long double __x, long int __n) noexcept (true); + + + +extern long double nearbyintl (long double __x) noexcept (true); extern long double __nearbyintl (long double __x) noexcept (true); + + + +extern long double roundl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern long double truncl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double remquol (long double __x, long double __y, int *__quo) noexcept (true); extern long double __remquol (long double __x, long double __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintl (long double __x) noexcept (true); extern long int __lrintl (long double __x) noexcept (true); +__extension__ +extern long long int llrintl (long double __x) noexcept (true); extern long long int __llrintl (long double __x) noexcept (true); + + + +extern long int lroundl (long double __x) noexcept (true); extern long int __lroundl (long double __x) noexcept (true); +__extension__ +extern long long int llroundl (long double __x) noexcept (true); extern long long int __llroundl (long double __x) noexcept (true); + + + +extern long double fdiml (long double __x, long double __y) noexcept (true); extern long double __fdiml (long double __x, long double __y) noexcept (true); + + + +extern long double fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + +extern long double fmal (long double __x, long double __y, long double __z) noexcept (true); extern long double __fmal (long double __x, long double __y, long double __z) noexcept (true); + + + + +extern long double roundevenl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpl (long double __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizel (long double *__cx, const long double *__x) noexcept (true); + + + + + + +extern long double fmaxmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double fmaximuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderl (const long double *__x, const long double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagl (const long double *__x, const long double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern long double getpayloadl (const long double *__x) noexcept (true); extern long double __getpayloadl (const long double *__x) noexcept (true); + + +extern int setpayloadl (long double *__x, long double __payload) noexcept (true); + + +extern int setpayloadsigl (long double *__x, long double __payload) noexcept (true); + + + + + + + +extern long double scalbl (long double __x, long double __n) noexcept (true); extern long double __scalbl (long double __x, long double __n) noexcept (true); +# 369 "/usr/include/math.h" 2 3 4 +# 419 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float32 acosf32 (_Float32 __x) noexcept (true); extern _Float32 __acosf32 (_Float32 __x) noexcept (true); + + extern _Float32 asinf32 (_Float32 __x) noexcept (true); extern _Float32 __asinf32 (_Float32 __x) noexcept (true); + + extern _Float32 atanf32 (_Float32 __x) noexcept (true); extern _Float32 __atanf32 (_Float32 __x) noexcept (true); + + extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); + + + extern _Float32 cosf32 (_Float32 __x) noexcept (true); extern _Float32 __cosf32 (_Float32 __x) noexcept (true); + + extern _Float32 sinf32 (_Float32 __x) noexcept (true); extern _Float32 __sinf32 (_Float32 __x) noexcept (true); + + extern _Float32 tanf32 (_Float32 __x) noexcept (true); extern _Float32 __tanf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 acospif32 (_Float32 __x) noexcept (true); extern _Float32 __acospif32 (_Float32 __x) noexcept (true); + +extern _Float32 asinpif32 (_Float32 __x) noexcept (true); extern _Float32 __asinpif32 (_Float32 __x) noexcept (true); + +extern _Float32 atanpif32 (_Float32 __x) noexcept (true); extern _Float32 __atanpif32 (_Float32 __x) noexcept (true); + +extern _Float32 atan2pif32 (_Float32 __y, _Float32 __x) noexcept (true); extern _Float32 __atan2pif32 (_Float32 __y, _Float32 __x) noexcept (true); + + + extern _Float32 cospif32 (_Float32 __x) noexcept (true); extern _Float32 __cospif32 (_Float32 __x) noexcept (true); + + extern _Float32 sinpif32 (_Float32 __x) noexcept (true); extern _Float32 __sinpif32 (_Float32 __x) noexcept (true); + + extern _Float32 tanpif32 (_Float32 __x) noexcept (true); extern _Float32 __tanpif32 (_Float32 __x) noexcept (true); + + + + + + extern _Float32 coshf32 (_Float32 __x) noexcept (true); extern _Float32 __coshf32 (_Float32 __x) noexcept (true); + + extern _Float32 sinhf32 (_Float32 __x) noexcept (true); extern _Float32 __sinhf32 (_Float32 __x) noexcept (true); + + extern _Float32 tanhf32 (_Float32 __x) noexcept (true); extern _Float32 __tanhf32 (_Float32 __x) noexcept (true); + + + + extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true) + ; + + + + + extern _Float32 acoshf32 (_Float32 __x) noexcept (true); extern _Float32 __acoshf32 (_Float32 __x) noexcept (true); + + extern _Float32 asinhf32 (_Float32 __x) noexcept (true); extern _Float32 __asinhf32 (_Float32 __x) noexcept (true); + + extern _Float32 atanhf32 (_Float32 __x) noexcept (true); extern _Float32 __atanhf32 (_Float32 __x) noexcept (true); + + + + + + extern _Float32 expf32 (_Float32 __x) noexcept (true); extern _Float32 __expf32 (_Float32 __x) noexcept (true); + + +extern _Float32 frexpf32 (_Float32 __x, int *__exponent) noexcept (true); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) noexcept (true); + + +extern _Float32 ldexpf32 (_Float32 __x, int __exponent) noexcept (true); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) noexcept (true); + + + extern _Float32 logf32 (_Float32 __x) noexcept (true); extern _Float32 __logf32 (_Float32 __x) noexcept (true); + + + extern _Float32 log10f32 (_Float32 __x) noexcept (true); extern _Float32 __log10f32 (_Float32 __x) noexcept (true); + + +extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true); extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float32 exp10f32 (_Float32 __x) noexcept (true); extern _Float32 __exp10f32 (_Float32 __x) noexcept (true); + + +extern _Float32 exp2m1f32 (_Float32 __x) noexcept (true); extern _Float32 __exp2m1f32 (_Float32 __x) noexcept (true); + + +extern _Float32 exp10m1f32 (_Float32 __x) noexcept (true); extern _Float32 __exp10m1f32 (_Float32 __x) noexcept (true); + + +extern _Float32 log2p1f32 (_Float32 __x) noexcept (true); extern _Float32 __log2p1f32 (_Float32 __x) noexcept (true); + + +extern _Float32 log10p1f32 (_Float32 __x) noexcept (true); extern _Float32 __log10p1f32 (_Float32 __x) noexcept (true); + + + extern _Float32 logp1f32 (_Float32 __x) noexcept (true); extern _Float32 __logp1f32 (_Float32 __x) noexcept (true); + + + + + extern _Float32 expm1f32 (_Float32 __x) noexcept (true); extern _Float32 __expm1f32 (_Float32 __x) noexcept (true); + + + extern _Float32 log1pf32 (_Float32 __x) noexcept (true); extern _Float32 __log1pf32 (_Float32 __x) noexcept (true); + + +extern _Float32 logbf32 (_Float32 __x) noexcept (true); extern _Float32 __logbf32 (_Float32 __x) noexcept (true); + + + + + extern _Float32 exp2f32 (_Float32 __x) noexcept (true); extern _Float32 __exp2f32 (_Float32 __x) noexcept (true); + + + extern _Float32 log2f32 (_Float32 __x) noexcept (true); extern _Float32 __log2f32 (_Float32 __x) noexcept (true); + + + + + + + extern _Float32 powf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) noexcept (true); + + +extern _Float32 sqrtf32 (_Float32 __x) noexcept (true); extern _Float32 __sqrtf32 (_Float32 __x) noexcept (true); + + + + extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + + + extern _Float32 cbrtf32 (_Float32 __x) noexcept (true); extern _Float32 __cbrtf32 (_Float32 __x) noexcept (true); + + + + + + +extern _Float32 ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); +# 231 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 nanf32 (const char *__tagb) noexcept (true); extern _Float32 __nanf32 (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32 j0f32 (_Float32) noexcept (true); extern _Float32 __j0f32 (_Float32) noexcept (true); +extern _Float32 j1f32 (_Float32) noexcept (true); extern _Float32 __j1f32 (_Float32) noexcept (true); +extern _Float32 jnf32 (int, _Float32) noexcept (true); extern _Float32 __jnf32 (int, _Float32) noexcept (true); +extern _Float32 y0f32 (_Float32) noexcept (true); extern _Float32 __y0f32 (_Float32) noexcept (true); +extern _Float32 y1f32 (_Float32) noexcept (true); extern _Float32 __y1f32 (_Float32) noexcept (true); +extern _Float32 ynf32 (int, _Float32) noexcept (true); extern _Float32 __ynf32 (int, _Float32) noexcept (true); + + + + + + extern _Float32 erff32 (_Float32) noexcept (true); extern _Float32 __erff32 (_Float32) noexcept (true); + extern _Float32 erfcf32 (_Float32) noexcept (true); extern _Float32 __erfcf32 (_Float32) noexcept (true); +extern _Float32 lgammaf32 (_Float32) noexcept (true); extern _Float32 __lgammaf32 (_Float32) noexcept (true); + + + + +extern _Float32 tgammaf32 (_Float32) noexcept (true); extern _Float32 __tgammaf32 (_Float32) noexcept (true); +# 285 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32 lgammaf32_r (_Float32, int *__signgamp) noexcept (true); extern _Float32 __lgammaf32_r (_Float32, int *__signgamp) noexcept (true); + + + + + + +extern _Float32 rintf32 (_Float32 __x) noexcept (true); extern _Float32 __rintf32 (_Float32 __x) noexcept (true); + + +extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + + + + +extern _Float32 nextdownf32 (_Float32 __x) noexcept (true); extern _Float32 __nextdownf32 (_Float32 __x) noexcept (true); + +extern _Float32 nextupf32 (_Float32 __x) noexcept (true); extern _Float32 __nextupf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + +extern _Float32 scalbnf32 (_Float32 __x, int __n) noexcept (true); extern _Float32 __scalbnf32 (_Float32 __x, int __n) noexcept (true); + + + +extern int ilogbf32 (_Float32 __x) noexcept (true); extern int __ilogbf32 (_Float32 __x) noexcept (true); + + + + +extern long int llogbf32 (_Float32 __x) noexcept (true); extern long int __llogbf32 (_Float32 __x) noexcept (true); + + + + +extern _Float32 scalblnf32 (_Float32 __x, long int __n) noexcept (true); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) noexcept (true); + + + +extern _Float32 nearbyintf32 (_Float32 __x) noexcept (true); extern _Float32 __nearbyintf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32 truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf32 (_Float32 __x) noexcept (true); extern long int __lrintf32 (_Float32 __x) noexcept (true); +__extension__ +extern long long int llrintf32 (_Float32 __x) noexcept (true); extern long long int __llrintf32 (_Float32 __x) noexcept (true); + + + +extern long int lroundf32 (_Float32 __x) noexcept (true); extern long int __lroundf32 (_Float32 __x) noexcept (true); +__extension__ +extern long long int llroundf32 (_Float32 __x) noexcept (true); extern long long int __llroundf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + +extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); + + + + +extern _Float32 roundevenf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) noexcept (true); + + + + + + +extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 fmaximumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float32 getpayloadf32 (const _Float32 *__x) noexcept (true); extern _Float32 __getpayloadf32 (const _Float32 *__x) noexcept (true); + + +extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) noexcept (true); + + +extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) noexcept (true); +# 420 "/usr/include/math.h" 2 3 4 +# 436 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float64 acosf64 (_Float64 __x) noexcept (true); extern _Float64 __acosf64 (_Float64 __x) noexcept (true); + + extern _Float64 asinf64 (_Float64 __x) noexcept (true); extern _Float64 __asinf64 (_Float64 __x) noexcept (true); + + extern _Float64 atanf64 (_Float64 __x) noexcept (true); extern _Float64 __atanf64 (_Float64 __x) noexcept (true); + + extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); extern _Float64 __atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); + + + extern _Float64 cosf64 (_Float64 __x) noexcept (true); extern _Float64 __cosf64 (_Float64 __x) noexcept (true); + + extern _Float64 sinf64 (_Float64 __x) noexcept (true); extern _Float64 __sinf64 (_Float64 __x) noexcept (true); + + extern _Float64 tanf64 (_Float64 __x) noexcept (true); extern _Float64 __tanf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 acospif64 (_Float64 __x) noexcept (true); extern _Float64 __acospif64 (_Float64 __x) noexcept (true); + +extern _Float64 asinpif64 (_Float64 __x) noexcept (true); extern _Float64 __asinpif64 (_Float64 __x) noexcept (true); + +extern _Float64 atanpif64 (_Float64 __x) noexcept (true); extern _Float64 __atanpif64 (_Float64 __x) noexcept (true); + +extern _Float64 atan2pif64 (_Float64 __y, _Float64 __x) noexcept (true); extern _Float64 __atan2pif64 (_Float64 __y, _Float64 __x) noexcept (true); + + + extern _Float64 cospif64 (_Float64 __x) noexcept (true); extern _Float64 __cospif64 (_Float64 __x) noexcept (true); + + extern _Float64 sinpif64 (_Float64 __x) noexcept (true); extern _Float64 __sinpif64 (_Float64 __x) noexcept (true); + + extern _Float64 tanpif64 (_Float64 __x) noexcept (true); extern _Float64 __tanpif64 (_Float64 __x) noexcept (true); + + + + + + extern _Float64 coshf64 (_Float64 __x) noexcept (true); extern _Float64 __coshf64 (_Float64 __x) noexcept (true); + + extern _Float64 sinhf64 (_Float64 __x) noexcept (true); extern _Float64 __sinhf64 (_Float64 __x) noexcept (true); + + extern _Float64 tanhf64 (_Float64 __x) noexcept (true); extern _Float64 __tanhf64 (_Float64 __x) noexcept (true); + + + + extern void sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) noexcept (true); extern void __sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) noexcept (true) + ; + + + + + extern _Float64 acoshf64 (_Float64 __x) noexcept (true); extern _Float64 __acoshf64 (_Float64 __x) noexcept (true); + + extern _Float64 asinhf64 (_Float64 __x) noexcept (true); extern _Float64 __asinhf64 (_Float64 __x) noexcept (true); + + extern _Float64 atanhf64 (_Float64 __x) noexcept (true); extern _Float64 __atanhf64 (_Float64 __x) noexcept (true); + + + + + + extern _Float64 expf64 (_Float64 __x) noexcept (true); extern _Float64 __expf64 (_Float64 __x) noexcept (true); + + +extern _Float64 frexpf64 (_Float64 __x, int *__exponent) noexcept (true); extern _Float64 __frexpf64 (_Float64 __x, int *__exponent) noexcept (true); + + +extern _Float64 ldexpf64 (_Float64 __x, int __exponent) noexcept (true); extern _Float64 __ldexpf64 (_Float64 __x, int __exponent) noexcept (true); + + + extern _Float64 logf64 (_Float64 __x) noexcept (true); extern _Float64 __logf64 (_Float64 __x) noexcept (true); + + + extern _Float64 log10f64 (_Float64 __x) noexcept (true); extern _Float64 __log10f64 (_Float64 __x) noexcept (true); + + +extern _Float64 modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true); extern _Float64 __modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float64 exp10f64 (_Float64 __x) noexcept (true); extern _Float64 __exp10f64 (_Float64 __x) noexcept (true); + + +extern _Float64 exp2m1f64 (_Float64 __x) noexcept (true); extern _Float64 __exp2m1f64 (_Float64 __x) noexcept (true); + + +extern _Float64 exp10m1f64 (_Float64 __x) noexcept (true); extern _Float64 __exp10m1f64 (_Float64 __x) noexcept (true); + + +extern _Float64 log2p1f64 (_Float64 __x) noexcept (true); extern _Float64 __log2p1f64 (_Float64 __x) noexcept (true); + + +extern _Float64 log10p1f64 (_Float64 __x) noexcept (true); extern _Float64 __log10p1f64 (_Float64 __x) noexcept (true); + + + extern _Float64 logp1f64 (_Float64 __x) noexcept (true); extern _Float64 __logp1f64 (_Float64 __x) noexcept (true); + + + + + extern _Float64 expm1f64 (_Float64 __x) noexcept (true); extern _Float64 __expm1f64 (_Float64 __x) noexcept (true); + + + extern _Float64 log1pf64 (_Float64 __x) noexcept (true); extern _Float64 __log1pf64 (_Float64 __x) noexcept (true); + + +extern _Float64 logbf64 (_Float64 __x) noexcept (true); extern _Float64 __logbf64 (_Float64 __x) noexcept (true); + + + + + extern _Float64 exp2f64 (_Float64 __x) noexcept (true); extern _Float64 __exp2f64 (_Float64 __x) noexcept (true); + + + extern _Float64 log2f64 (_Float64 __x) noexcept (true); extern _Float64 __log2f64 (_Float64 __x) noexcept (true); + + + + + + + extern _Float64 powf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __powf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float64 sqrtf64 (_Float64 __x) noexcept (true); extern _Float64 __sqrtf64 (_Float64 __x) noexcept (true); + + + + extern _Float64 hypotf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __hypotf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + + + extern _Float64 cbrtf64 (_Float64 __x) noexcept (true); extern _Float64 __cbrtf64 (_Float64 __x) noexcept (true); + + + + + + +extern _Float64 ceilf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fabsf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 floorf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmodf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __fmodf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 231 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64 nanf64 (const char *__tagb) noexcept (true); extern _Float64 __nanf64 (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64 j0f64 (_Float64) noexcept (true); extern _Float64 __j0f64 (_Float64) noexcept (true); +extern _Float64 j1f64 (_Float64) noexcept (true); extern _Float64 __j1f64 (_Float64) noexcept (true); +extern _Float64 jnf64 (int, _Float64) noexcept (true); extern _Float64 __jnf64 (int, _Float64) noexcept (true); +extern _Float64 y0f64 (_Float64) noexcept (true); extern _Float64 __y0f64 (_Float64) noexcept (true); +extern _Float64 y1f64 (_Float64) noexcept (true); extern _Float64 __y1f64 (_Float64) noexcept (true); +extern _Float64 ynf64 (int, _Float64) noexcept (true); extern _Float64 __ynf64 (int, _Float64) noexcept (true); + + + + + + extern _Float64 erff64 (_Float64) noexcept (true); extern _Float64 __erff64 (_Float64) noexcept (true); + extern _Float64 erfcf64 (_Float64) noexcept (true); extern _Float64 __erfcf64 (_Float64) noexcept (true); +extern _Float64 lgammaf64 (_Float64) noexcept (true); extern _Float64 __lgammaf64 (_Float64) noexcept (true); + + + + +extern _Float64 tgammaf64 (_Float64) noexcept (true); extern _Float64 __tgammaf64 (_Float64) noexcept (true); +# 285 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64 lgammaf64_r (_Float64, int *__signgamp) noexcept (true); extern _Float64 __lgammaf64_r (_Float64, int *__signgamp) noexcept (true); + + + + + + +extern _Float64 rintf64 (_Float64 __x) noexcept (true); extern _Float64 __rintf64 (_Float64 __x) noexcept (true); + + +extern _Float64 nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + + + + +extern _Float64 nextdownf64 (_Float64 __x) noexcept (true); extern _Float64 __nextdownf64 (_Float64 __x) noexcept (true); + +extern _Float64 nextupf64 (_Float64 __x) noexcept (true); extern _Float64 __nextupf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 remainderf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __remainderf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + +extern _Float64 scalbnf64 (_Float64 __x, int __n) noexcept (true); extern _Float64 __scalbnf64 (_Float64 __x, int __n) noexcept (true); + + + +extern int ilogbf64 (_Float64 __x) noexcept (true); extern int __ilogbf64 (_Float64 __x) noexcept (true); + + + + +extern long int llogbf64 (_Float64 __x) noexcept (true); extern long int __llogbf64 (_Float64 __x) noexcept (true); + + + + +extern _Float64 scalblnf64 (_Float64 __x, long int __n) noexcept (true); extern _Float64 __scalblnf64 (_Float64 __x, long int __n) noexcept (true); + + + +extern _Float64 nearbyintf64 (_Float64 __x) noexcept (true); extern _Float64 __nearbyintf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 roundf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64 truncf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64 remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcept (true); extern _Float64 __remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf64 (_Float64 __x) noexcept (true); extern long int __lrintf64 (_Float64 __x) noexcept (true); +__extension__ +extern long long int llrintf64 (_Float64 __x) noexcept (true); extern long long int __llrintf64 (_Float64 __x) noexcept (true); + + + +extern long int lroundf64 (_Float64 __x) noexcept (true); extern long int __lroundf64 (_Float64 __x) noexcept (true); +__extension__ +extern long long int llroundf64 (_Float64 __x) noexcept (true); extern long long int __llroundf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 fdimf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __fdimf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + +extern _Float64 fmaxf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64 fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); extern _Float64 __fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); + + + + +extern _Float64 roundevenf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef64 (_Float64 *__cx, const _Float64 *__x) noexcept (true); + + + + + + +extern _Float64 fmaxmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64 fmaximumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf64 (const _Float64 *__x, const _Float64 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf64 (const _Float64 *__x, const _Float64 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float64 getpayloadf64 (const _Float64 *__x) noexcept (true); extern _Float64 __getpayloadf64 (const _Float64 *__x) noexcept (true); + + +extern int setpayloadf64 (_Float64 *__x, _Float64 __payload) noexcept (true); + + +extern int setpayloadsigf64 (_Float64 *__x, _Float64 __payload) noexcept (true); +# 437 "/usr/include/math.h" 2 3 4 +# 450 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyf128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitf128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinff128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitef128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanf128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern int __issignalingf128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); +# 451 "/usr/include/math.h" 2 3 4 + + +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float128 acosf128 (_Float128 __x) noexcept (true); extern _Float128 __acosf128 (_Float128 __x) noexcept (true); + + extern _Float128 asinf128 (_Float128 __x) noexcept (true); extern _Float128 __asinf128 (_Float128 __x) noexcept (true); + + extern _Float128 atanf128 (_Float128 __x) noexcept (true); extern _Float128 __atanf128 (_Float128 __x) noexcept (true); + + extern _Float128 atan2f128 (_Float128 __y, _Float128 __x) noexcept (true); extern _Float128 __atan2f128 (_Float128 __y, _Float128 __x) noexcept (true); + + + extern _Float128 cosf128 (_Float128 __x) noexcept (true); extern _Float128 __cosf128 (_Float128 __x) noexcept (true); + + extern _Float128 sinf128 (_Float128 __x) noexcept (true); extern _Float128 __sinf128 (_Float128 __x) noexcept (true); + + extern _Float128 tanf128 (_Float128 __x) noexcept (true); extern _Float128 __tanf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 acospif128 (_Float128 __x) noexcept (true); extern _Float128 __acospif128 (_Float128 __x) noexcept (true); + +extern _Float128 asinpif128 (_Float128 __x) noexcept (true); extern _Float128 __asinpif128 (_Float128 __x) noexcept (true); + +extern _Float128 atanpif128 (_Float128 __x) noexcept (true); extern _Float128 __atanpif128 (_Float128 __x) noexcept (true); + +extern _Float128 atan2pif128 (_Float128 __y, _Float128 __x) noexcept (true); extern _Float128 __atan2pif128 (_Float128 __y, _Float128 __x) noexcept (true); + + + extern _Float128 cospif128 (_Float128 __x) noexcept (true); extern _Float128 __cospif128 (_Float128 __x) noexcept (true); + + extern _Float128 sinpif128 (_Float128 __x) noexcept (true); extern _Float128 __sinpif128 (_Float128 __x) noexcept (true); + + extern _Float128 tanpif128 (_Float128 __x) noexcept (true); extern _Float128 __tanpif128 (_Float128 __x) noexcept (true); + + + + + + extern _Float128 coshf128 (_Float128 __x) noexcept (true); extern _Float128 __coshf128 (_Float128 __x) noexcept (true); + + extern _Float128 sinhf128 (_Float128 __x) noexcept (true); extern _Float128 __sinhf128 (_Float128 __x) noexcept (true); + + extern _Float128 tanhf128 (_Float128 __x) noexcept (true); extern _Float128 __tanhf128 (_Float128 __x) noexcept (true); + + + + extern void sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) noexcept (true); extern void __sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) noexcept (true) + ; + + + + + extern _Float128 acoshf128 (_Float128 __x) noexcept (true); extern _Float128 __acoshf128 (_Float128 __x) noexcept (true); + + extern _Float128 asinhf128 (_Float128 __x) noexcept (true); extern _Float128 __asinhf128 (_Float128 __x) noexcept (true); + + extern _Float128 atanhf128 (_Float128 __x) noexcept (true); extern _Float128 __atanhf128 (_Float128 __x) noexcept (true); + + + + + + extern _Float128 expf128 (_Float128 __x) noexcept (true); extern _Float128 __expf128 (_Float128 __x) noexcept (true); + + +extern _Float128 frexpf128 (_Float128 __x, int *__exponent) noexcept (true); extern _Float128 __frexpf128 (_Float128 __x, int *__exponent) noexcept (true); + + +extern _Float128 ldexpf128 (_Float128 __x, int __exponent) noexcept (true); extern _Float128 __ldexpf128 (_Float128 __x, int __exponent) noexcept (true); + + + extern _Float128 logf128 (_Float128 __x) noexcept (true); extern _Float128 __logf128 (_Float128 __x) noexcept (true); + + + extern _Float128 log10f128 (_Float128 __x) noexcept (true); extern _Float128 __log10f128 (_Float128 __x) noexcept (true); + + +extern _Float128 modff128 (_Float128 __x, _Float128 *__iptr) noexcept (true); extern _Float128 __modff128 (_Float128 __x, _Float128 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float128 exp10f128 (_Float128 __x) noexcept (true); extern _Float128 __exp10f128 (_Float128 __x) noexcept (true); + + +extern _Float128 exp2m1f128 (_Float128 __x) noexcept (true); extern _Float128 __exp2m1f128 (_Float128 __x) noexcept (true); + + +extern _Float128 exp10m1f128 (_Float128 __x) noexcept (true); extern _Float128 __exp10m1f128 (_Float128 __x) noexcept (true); + + +extern _Float128 log2p1f128 (_Float128 __x) noexcept (true); extern _Float128 __log2p1f128 (_Float128 __x) noexcept (true); + + +extern _Float128 log10p1f128 (_Float128 __x) noexcept (true); extern _Float128 __log10p1f128 (_Float128 __x) noexcept (true); + + + extern _Float128 logp1f128 (_Float128 __x) noexcept (true); extern _Float128 __logp1f128 (_Float128 __x) noexcept (true); + + + + + extern _Float128 expm1f128 (_Float128 __x) noexcept (true); extern _Float128 __expm1f128 (_Float128 __x) noexcept (true); + + + extern _Float128 log1pf128 (_Float128 __x) noexcept (true); extern _Float128 __log1pf128 (_Float128 __x) noexcept (true); + + +extern _Float128 logbf128 (_Float128 __x) noexcept (true); extern _Float128 __logbf128 (_Float128 __x) noexcept (true); + + + + + extern _Float128 exp2f128 (_Float128 __x) noexcept (true); extern _Float128 __exp2f128 (_Float128 __x) noexcept (true); + + + extern _Float128 log2f128 (_Float128 __x) noexcept (true); extern _Float128 __log2f128 (_Float128 __x) noexcept (true); + + + + + + + extern _Float128 powf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __powf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float128 sqrtf128 (_Float128 __x) noexcept (true); extern _Float128 __sqrtf128 (_Float128 __x) noexcept (true); + + + + extern _Float128 hypotf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __hypotf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + + + extern _Float128 cbrtf128 (_Float128 __x) noexcept (true); extern _Float128 __cbrtf128 (_Float128 __x) noexcept (true); + + + + + + +extern _Float128 ceilf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fabsf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 floorf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmodf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __fmodf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 231 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float128 copysignf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 nanf128 (const char *__tagb) noexcept (true); extern _Float128 __nanf128 (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float128 j0f128 (_Float128) noexcept (true); extern _Float128 __j0f128 (_Float128) noexcept (true); +extern _Float128 j1f128 (_Float128) noexcept (true); extern _Float128 __j1f128 (_Float128) noexcept (true); +extern _Float128 jnf128 (int, _Float128) noexcept (true); extern _Float128 __jnf128 (int, _Float128) noexcept (true); +extern _Float128 y0f128 (_Float128) noexcept (true); extern _Float128 __y0f128 (_Float128) noexcept (true); +extern _Float128 y1f128 (_Float128) noexcept (true); extern _Float128 __y1f128 (_Float128) noexcept (true); +extern _Float128 ynf128 (int, _Float128) noexcept (true); extern _Float128 __ynf128 (int, _Float128) noexcept (true); + + + + + + extern _Float128 erff128 (_Float128) noexcept (true); extern _Float128 __erff128 (_Float128) noexcept (true); + extern _Float128 erfcf128 (_Float128) noexcept (true); extern _Float128 __erfcf128 (_Float128) noexcept (true); +extern _Float128 lgammaf128 (_Float128) noexcept (true); extern _Float128 __lgammaf128 (_Float128) noexcept (true); + + + + +extern _Float128 tgammaf128 (_Float128) noexcept (true); extern _Float128 __tgammaf128 (_Float128) noexcept (true); +# 285 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float128 lgammaf128_r (_Float128, int *__signgamp) noexcept (true); extern _Float128 __lgammaf128_r (_Float128, int *__signgamp) noexcept (true); + + + + + + +extern _Float128 rintf128 (_Float128 __x) noexcept (true); extern _Float128 __rintf128 (_Float128 __x) noexcept (true); + + +extern _Float128 nextafterf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __nextafterf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + + + + +extern _Float128 nextdownf128 (_Float128 __x) noexcept (true); extern _Float128 __nextdownf128 (_Float128 __x) noexcept (true); + +extern _Float128 nextupf128 (_Float128 __x) noexcept (true); extern _Float128 __nextupf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 remainderf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __remainderf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + +extern _Float128 scalbnf128 (_Float128 __x, int __n) noexcept (true); extern _Float128 __scalbnf128 (_Float128 __x, int __n) noexcept (true); + + + +extern int ilogbf128 (_Float128 __x) noexcept (true); extern int __ilogbf128 (_Float128 __x) noexcept (true); + + + + +extern long int llogbf128 (_Float128 __x) noexcept (true); extern long int __llogbf128 (_Float128 __x) noexcept (true); + + + + +extern _Float128 scalblnf128 (_Float128 __x, long int __n) noexcept (true); extern _Float128 __scalblnf128 (_Float128 __x, long int __n) noexcept (true); + + + +extern _Float128 nearbyintf128 (_Float128 __x) noexcept (true); extern _Float128 __nearbyintf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 roundf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float128 truncf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 remquof128 (_Float128 __x, _Float128 __y, int *__quo) noexcept (true); extern _Float128 __remquof128 (_Float128 __x, _Float128 __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf128 (_Float128 __x) noexcept (true); extern long int __lrintf128 (_Float128 __x) noexcept (true); +__extension__ +extern long long int llrintf128 (_Float128 __x) noexcept (true); extern long long int __llrintf128 (_Float128 __x) noexcept (true); + + + +extern long int lroundf128 (_Float128 __x) noexcept (true); extern long int __lroundf128 (_Float128 __x) noexcept (true); +__extension__ +extern long long int llroundf128 (_Float128 __x) noexcept (true); extern long long int __llroundf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 fdimf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __fdimf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + +extern _Float128 fmaxf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float128 fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); extern _Float128 __fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + + + +extern _Float128 roundevenf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef128 (_Float128 *__cx, const _Float128 *__x) noexcept (true); + + + + + + +extern _Float128 fmaxmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 fmaximumf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimumf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmaximum_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmaximum_magf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_magf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmaximum_mag_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_mag_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf128 (const _Float128 *__x, const _Float128 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf128 (const _Float128 *__x, const _Float128 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float128 getpayloadf128 (const _Float128 *__x) noexcept (true); extern _Float128 __getpayloadf128 (const _Float128 *__x) noexcept (true); + + +extern int setpayloadf128 (_Float128 *__x, _Float128 __payload) noexcept (true); + + +extern int setpayloadsigf128 (_Float128 *__x, _Float128 __payload) noexcept (true); +# 454 "/usr/include/math.h" 2 3 4 +# 470 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float32x acosf32x (_Float32x __x) noexcept (true); extern _Float32x __acosf32x (_Float32x __x) noexcept (true); + + extern _Float32x asinf32x (_Float32x __x) noexcept (true); extern _Float32x __asinf32x (_Float32x __x) noexcept (true); + + extern _Float32x atanf32x (_Float32x __x) noexcept (true); extern _Float32x __atanf32x (_Float32x __x) noexcept (true); + + extern _Float32x atan2f32x (_Float32x __y, _Float32x __x) noexcept (true); extern _Float32x __atan2f32x (_Float32x __y, _Float32x __x) noexcept (true); + + + extern _Float32x cosf32x (_Float32x __x) noexcept (true); extern _Float32x __cosf32x (_Float32x __x) noexcept (true); + + extern _Float32x sinf32x (_Float32x __x) noexcept (true); extern _Float32x __sinf32x (_Float32x __x) noexcept (true); + + extern _Float32x tanf32x (_Float32x __x) noexcept (true); extern _Float32x __tanf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x acospif32x (_Float32x __x) noexcept (true); extern _Float32x __acospif32x (_Float32x __x) noexcept (true); + +extern _Float32x asinpif32x (_Float32x __x) noexcept (true); extern _Float32x __asinpif32x (_Float32x __x) noexcept (true); + +extern _Float32x atanpif32x (_Float32x __x) noexcept (true); extern _Float32x __atanpif32x (_Float32x __x) noexcept (true); + +extern _Float32x atan2pif32x (_Float32x __y, _Float32x __x) noexcept (true); extern _Float32x __atan2pif32x (_Float32x __y, _Float32x __x) noexcept (true); + + + extern _Float32x cospif32x (_Float32x __x) noexcept (true); extern _Float32x __cospif32x (_Float32x __x) noexcept (true); + + extern _Float32x sinpif32x (_Float32x __x) noexcept (true); extern _Float32x __sinpif32x (_Float32x __x) noexcept (true); + + extern _Float32x tanpif32x (_Float32x __x) noexcept (true); extern _Float32x __tanpif32x (_Float32x __x) noexcept (true); + + + + + + extern _Float32x coshf32x (_Float32x __x) noexcept (true); extern _Float32x __coshf32x (_Float32x __x) noexcept (true); + + extern _Float32x sinhf32x (_Float32x __x) noexcept (true); extern _Float32x __sinhf32x (_Float32x __x) noexcept (true); + + extern _Float32x tanhf32x (_Float32x __x) noexcept (true); extern _Float32x __tanhf32x (_Float32x __x) noexcept (true); + + + + extern void sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) noexcept (true); extern void __sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) noexcept (true) + ; + + + + + extern _Float32x acoshf32x (_Float32x __x) noexcept (true); extern _Float32x __acoshf32x (_Float32x __x) noexcept (true); + + extern _Float32x asinhf32x (_Float32x __x) noexcept (true); extern _Float32x __asinhf32x (_Float32x __x) noexcept (true); + + extern _Float32x atanhf32x (_Float32x __x) noexcept (true); extern _Float32x __atanhf32x (_Float32x __x) noexcept (true); + + + + + + extern _Float32x expf32x (_Float32x __x) noexcept (true); extern _Float32x __expf32x (_Float32x __x) noexcept (true); + + +extern _Float32x frexpf32x (_Float32x __x, int *__exponent) noexcept (true); extern _Float32x __frexpf32x (_Float32x __x, int *__exponent) noexcept (true); + + +extern _Float32x ldexpf32x (_Float32x __x, int __exponent) noexcept (true); extern _Float32x __ldexpf32x (_Float32x __x, int __exponent) noexcept (true); + + + extern _Float32x logf32x (_Float32x __x) noexcept (true); extern _Float32x __logf32x (_Float32x __x) noexcept (true); + + + extern _Float32x log10f32x (_Float32x __x) noexcept (true); extern _Float32x __log10f32x (_Float32x __x) noexcept (true); + + +extern _Float32x modff32x (_Float32x __x, _Float32x *__iptr) noexcept (true); extern _Float32x __modff32x (_Float32x __x, _Float32x *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float32x exp10f32x (_Float32x __x) noexcept (true); extern _Float32x __exp10f32x (_Float32x __x) noexcept (true); + + +extern _Float32x exp2m1f32x (_Float32x __x) noexcept (true); extern _Float32x __exp2m1f32x (_Float32x __x) noexcept (true); + + +extern _Float32x exp10m1f32x (_Float32x __x) noexcept (true); extern _Float32x __exp10m1f32x (_Float32x __x) noexcept (true); + + +extern _Float32x log2p1f32x (_Float32x __x) noexcept (true); extern _Float32x __log2p1f32x (_Float32x __x) noexcept (true); + + +extern _Float32x log10p1f32x (_Float32x __x) noexcept (true); extern _Float32x __log10p1f32x (_Float32x __x) noexcept (true); + + + extern _Float32x logp1f32x (_Float32x __x) noexcept (true); extern _Float32x __logp1f32x (_Float32x __x) noexcept (true); + + + + + extern _Float32x expm1f32x (_Float32x __x) noexcept (true); extern _Float32x __expm1f32x (_Float32x __x) noexcept (true); + + + extern _Float32x log1pf32x (_Float32x __x) noexcept (true); extern _Float32x __log1pf32x (_Float32x __x) noexcept (true); + + +extern _Float32x logbf32x (_Float32x __x) noexcept (true); extern _Float32x __logbf32x (_Float32x __x) noexcept (true); + + + + + extern _Float32x exp2f32x (_Float32x __x) noexcept (true); extern _Float32x __exp2f32x (_Float32x __x) noexcept (true); + + + extern _Float32x log2f32x (_Float32x __x) noexcept (true); extern _Float32x __log2f32x (_Float32x __x) noexcept (true); + + + + + + + extern _Float32x powf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __powf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32x sqrtf32x (_Float32x __x) noexcept (true); extern _Float32x __sqrtf32x (_Float32x __x) noexcept (true); + + + + extern _Float32x hypotf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __hypotf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + + + extern _Float32x cbrtf32x (_Float32x __x) noexcept (true); extern _Float32x __cbrtf32x (_Float32x __x) noexcept (true); + + + + + + +extern _Float32x ceilf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x floorf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); +# 231 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x nanf32x (const char *__tagb) noexcept (true); extern _Float32x __nanf32x (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32x j0f32x (_Float32x) noexcept (true); extern _Float32x __j0f32x (_Float32x) noexcept (true); +extern _Float32x j1f32x (_Float32x) noexcept (true); extern _Float32x __j1f32x (_Float32x) noexcept (true); +extern _Float32x jnf32x (int, _Float32x) noexcept (true); extern _Float32x __jnf32x (int, _Float32x) noexcept (true); +extern _Float32x y0f32x (_Float32x) noexcept (true); extern _Float32x __y0f32x (_Float32x) noexcept (true); +extern _Float32x y1f32x (_Float32x) noexcept (true); extern _Float32x __y1f32x (_Float32x) noexcept (true); +extern _Float32x ynf32x (int, _Float32x) noexcept (true); extern _Float32x __ynf32x (int, _Float32x) noexcept (true); + + + + + + extern _Float32x erff32x (_Float32x) noexcept (true); extern _Float32x __erff32x (_Float32x) noexcept (true); + extern _Float32x erfcf32x (_Float32x) noexcept (true); extern _Float32x __erfcf32x (_Float32x) noexcept (true); +extern _Float32x lgammaf32x (_Float32x) noexcept (true); extern _Float32x __lgammaf32x (_Float32x) noexcept (true); + + + + +extern _Float32x tgammaf32x (_Float32x) noexcept (true); extern _Float32x __tgammaf32x (_Float32x) noexcept (true); +# 285 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32x lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true); extern _Float32x __lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true); + + + + + + +extern _Float32x rintf32x (_Float32x __x) noexcept (true); extern _Float32x __rintf32x (_Float32x __x) noexcept (true); + + +extern _Float32x nextafterf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __nextafterf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + + + + +extern _Float32x nextdownf32x (_Float32x __x) noexcept (true); extern _Float32x __nextdownf32x (_Float32x __x) noexcept (true); + +extern _Float32x nextupf32x (_Float32x __x) noexcept (true); extern _Float32x __nextupf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x remainderf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __remainderf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + +extern _Float32x scalbnf32x (_Float32x __x, int __n) noexcept (true); extern _Float32x __scalbnf32x (_Float32x __x, int __n) noexcept (true); + + + +extern int ilogbf32x (_Float32x __x) noexcept (true); extern int __ilogbf32x (_Float32x __x) noexcept (true); + + + + +extern long int llogbf32x (_Float32x __x) noexcept (true); extern long int __llogbf32x (_Float32x __x) noexcept (true); + + + + +extern _Float32x scalblnf32x (_Float32x __x, long int __n) noexcept (true); extern _Float32x __scalblnf32x (_Float32x __x, long int __n) noexcept (true); + + + +extern _Float32x nearbyintf32x (_Float32x __x) noexcept (true); extern _Float32x __nearbyintf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x roundf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32x truncf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) noexcept (true); extern _Float32x __remquof32x (_Float32x __x, _Float32x __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf32x (_Float32x __x) noexcept (true); extern long int __lrintf32x (_Float32x __x) noexcept (true); +__extension__ +extern long long int llrintf32x (_Float32x __x) noexcept (true); extern long long int __llrintf32x (_Float32x __x) noexcept (true); + + + +extern long int lroundf32x (_Float32x __x) noexcept (true); extern long int __lroundf32x (_Float32x __x) noexcept (true); +__extension__ +extern long long int llroundf32x (_Float32x __x) noexcept (true); extern long long int __llroundf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x fdimf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fdimf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + +extern _Float32x fmaxf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32x fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); extern _Float32x __fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); + + + + +extern _Float32x roundevenf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef32x (_Float32x *__cx, const _Float32x *__x) noexcept (true); + + + + + + +extern _Float32x fmaxmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x fmaximumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf32x (const _Float32x *__x, const _Float32x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf32x (const _Float32x *__x, const _Float32x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float32x getpayloadf32x (const _Float32x *__x) noexcept (true); extern _Float32x __getpayloadf32x (const _Float32x *__x) noexcept (true); + + +extern int setpayloadf32x (_Float32x *__x, _Float32x __payload) noexcept (true); + + +extern int setpayloadsigf32x (_Float32x *__x, _Float32x __payload) noexcept (true); +# 471 "/usr/include/math.h" 2 3 4 +# 487 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float64x acosf64x (_Float64x __x) noexcept (true); extern _Float64x __acosf64x (_Float64x __x) noexcept (true); + + extern _Float64x asinf64x (_Float64x __x) noexcept (true); extern _Float64x __asinf64x (_Float64x __x) noexcept (true); + + extern _Float64x atanf64x (_Float64x __x) noexcept (true); extern _Float64x __atanf64x (_Float64x __x) noexcept (true); + + extern _Float64x atan2f64x (_Float64x __y, _Float64x __x) noexcept (true); extern _Float64x __atan2f64x (_Float64x __y, _Float64x __x) noexcept (true); + + + extern _Float64x cosf64x (_Float64x __x) noexcept (true); extern _Float64x __cosf64x (_Float64x __x) noexcept (true); + + extern _Float64x sinf64x (_Float64x __x) noexcept (true); extern _Float64x __sinf64x (_Float64x __x) noexcept (true); + + extern _Float64x tanf64x (_Float64x __x) noexcept (true); extern _Float64x __tanf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x acospif64x (_Float64x __x) noexcept (true); extern _Float64x __acospif64x (_Float64x __x) noexcept (true); + +extern _Float64x asinpif64x (_Float64x __x) noexcept (true); extern _Float64x __asinpif64x (_Float64x __x) noexcept (true); + +extern _Float64x atanpif64x (_Float64x __x) noexcept (true); extern _Float64x __atanpif64x (_Float64x __x) noexcept (true); + +extern _Float64x atan2pif64x (_Float64x __y, _Float64x __x) noexcept (true); extern _Float64x __atan2pif64x (_Float64x __y, _Float64x __x) noexcept (true); + + + extern _Float64x cospif64x (_Float64x __x) noexcept (true); extern _Float64x __cospif64x (_Float64x __x) noexcept (true); + + extern _Float64x sinpif64x (_Float64x __x) noexcept (true); extern _Float64x __sinpif64x (_Float64x __x) noexcept (true); + + extern _Float64x tanpif64x (_Float64x __x) noexcept (true); extern _Float64x __tanpif64x (_Float64x __x) noexcept (true); + + + + + + extern _Float64x coshf64x (_Float64x __x) noexcept (true); extern _Float64x __coshf64x (_Float64x __x) noexcept (true); + + extern _Float64x sinhf64x (_Float64x __x) noexcept (true); extern _Float64x __sinhf64x (_Float64x __x) noexcept (true); + + extern _Float64x tanhf64x (_Float64x __x) noexcept (true); extern _Float64x __tanhf64x (_Float64x __x) noexcept (true); + + + + extern void sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) noexcept (true); extern void __sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) noexcept (true) + ; + + + + + extern _Float64x acoshf64x (_Float64x __x) noexcept (true); extern _Float64x __acoshf64x (_Float64x __x) noexcept (true); + + extern _Float64x asinhf64x (_Float64x __x) noexcept (true); extern _Float64x __asinhf64x (_Float64x __x) noexcept (true); + + extern _Float64x atanhf64x (_Float64x __x) noexcept (true); extern _Float64x __atanhf64x (_Float64x __x) noexcept (true); + + + + + + extern _Float64x expf64x (_Float64x __x) noexcept (true); extern _Float64x __expf64x (_Float64x __x) noexcept (true); + + +extern _Float64x frexpf64x (_Float64x __x, int *__exponent) noexcept (true); extern _Float64x __frexpf64x (_Float64x __x, int *__exponent) noexcept (true); + + +extern _Float64x ldexpf64x (_Float64x __x, int __exponent) noexcept (true); extern _Float64x __ldexpf64x (_Float64x __x, int __exponent) noexcept (true); + + + extern _Float64x logf64x (_Float64x __x) noexcept (true); extern _Float64x __logf64x (_Float64x __x) noexcept (true); + + + extern _Float64x log10f64x (_Float64x __x) noexcept (true); extern _Float64x __log10f64x (_Float64x __x) noexcept (true); + + +extern _Float64x modff64x (_Float64x __x, _Float64x *__iptr) noexcept (true); extern _Float64x __modff64x (_Float64x __x, _Float64x *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float64x exp10f64x (_Float64x __x) noexcept (true); extern _Float64x __exp10f64x (_Float64x __x) noexcept (true); + + +extern _Float64x exp2m1f64x (_Float64x __x) noexcept (true); extern _Float64x __exp2m1f64x (_Float64x __x) noexcept (true); + + +extern _Float64x exp10m1f64x (_Float64x __x) noexcept (true); extern _Float64x __exp10m1f64x (_Float64x __x) noexcept (true); + + +extern _Float64x log2p1f64x (_Float64x __x) noexcept (true); extern _Float64x __log2p1f64x (_Float64x __x) noexcept (true); + + +extern _Float64x log10p1f64x (_Float64x __x) noexcept (true); extern _Float64x __log10p1f64x (_Float64x __x) noexcept (true); + + + extern _Float64x logp1f64x (_Float64x __x) noexcept (true); extern _Float64x __logp1f64x (_Float64x __x) noexcept (true); + + + + + extern _Float64x expm1f64x (_Float64x __x) noexcept (true); extern _Float64x __expm1f64x (_Float64x __x) noexcept (true); + + + extern _Float64x log1pf64x (_Float64x __x) noexcept (true); extern _Float64x __log1pf64x (_Float64x __x) noexcept (true); + + +extern _Float64x logbf64x (_Float64x __x) noexcept (true); extern _Float64x __logbf64x (_Float64x __x) noexcept (true); + + + + + extern _Float64x exp2f64x (_Float64x __x) noexcept (true); extern _Float64x __exp2f64x (_Float64x __x) noexcept (true); + + + extern _Float64x log2f64x (_Float64x __x) noexcept (true); extern _Float64x __log2f64x (_Float64x __x) noexcept (true); + + + + + + + extern _Float64x powf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __powf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64x sqrtf64x (_Float64x __x) noexcept (true); extern _Float64x __sqrtf64x (_Float64x __x) noexcept (true); + + + + extern _Float64x hypotf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __hypotf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + + + extern _Float64x cbrtf64x (_Float64x __x) noexcept (true); extern _Float64x __cbrtf64x (_Float64x __x) noexcept (true); + + + + + + +extern _Float64x ceilf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x floorf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 231 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x nanf64x (const char *__tagb) noexcept (true); extern _Float64x __nanf64x (const char *__tagb) noexcept (true); +# 253 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64x j0f64x (_Float64x) noexcept (true); extern _Float64x __j0f64x (_Float64x) noexcept (true); +extern _Float64x j1f64x (_Float64x) noexcept (true); extern _Float64x __j1f64x (_Float64x) noexcept (true); +extern _Float64x jnf64x (int, _Float64x) noexcept (true); extern _Float64x __jnf64x (int, _Float64x) noexcept (true); +extern _Float64x y0f64x (_Float64x) noexcept (true); extern _Float64x __y0f64x (_Float64x) noexcept (true); +extern _Float64x y1f64x (_Float64x) noexcept (true); extern _Float64x __y1f64x (_Float64x) noexcept (true); +extern _Float64x ynf64x (int, _Float64x) noexcept (true); extern _Float64x __ynf64x (int, _Float64x) noexcept (true); + + + + + + extern _Float64x erff64x (_Float64x) noexcept (true); extern _Float64x __erff64x (_Float64x) noexcept (true); + extern _Float64x erfcf64x (_Float64x) noexcept (true); extern _Float64x __erfcf64x (_Float64x) noexcept (true); +extern _Float64x lgammaf64x (_Float64x) noexcept (true); extern _Float64x __lgammaf64x (_Float64x) noexcept (true); + + + + +extern _Float64x tgammaf64x (_Float64x) noexcept (true); extern _Float64x __tgammaf64x (_Float64x) noexcept (true); +# 285 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64x lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true); extern _Float64x __lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true); + + + + + + +extern _Float64x rintf64x (_Float64x __x) noexcept (true); extern _Float64x __rintf64x (_Float64x __x) noexcept (true); + + +extern _Float64x nextafterf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __nextafterf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + + + + +extern _Float64x nextdownf64x (_Float64x __x) noexcept (true); extern _Float64x __nextdownf64x (_Float64x __x) noexcept (true); + +extern _Float64x nextupf64x (_Float64x __x) noexcept (true); extern _Float64x __nextupf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x remainderf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __remainderf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + +extern _Float64x scalbnf64x (_Float64x __x, int __n) noexcept (true); extern _Float64x __scalbnf64x (_Float64x __x, int __n) noexcept (true); + + + +extern int ilogbf64x (_Float64x __x) noexcept (true); extern int __ilogbf64x (_Float64x __x) noexcept (true); + + + + +extern long int llogbf64x (_Float64x __x) noexcept (true); extern long int __llogbf64x (_Float64x __x) noexcept (true); + + + + +extern _Float64x scalblnf64x (_Float64x __x, long int __n) noexcept (true); extern _Float64x __scalblnf64x (_Float64x __x, long int __n) noexcept (true); + + + +extern _Float64x nearbyintf64x (_Float64x __x) noexcept (true); extern _Float64x __nearbyintf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x roundf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64x truncf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) noexcept (true); extern _Float64x __remquof64x (_Float64x __x, _Float64x __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf64x (_Float64x __x) noexcept (true); extern long int __lrintf64x (_Float64x __x) noexcept (true); +__extension__ +extern long long int llrintf64x (_Float64x __x) noexcept (true); extern long long int __llrintf64x (_Float64x __x) noexcept (true); + + + +extern long int lroundf64x (_Float64x __x) noexcept (true); extern long int __lroundf64x (_Float64x __x) noexcept (true); +__extension__ +extern long long int llroundf64x (_Float64x __x) noexcept (true); extern long long int __llroundf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x fdimf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fdimf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + +extern _Float64x fmaxf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64x fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); extern _Float64x __fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + + + +extern _Float64x roundevenf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef64x (_Float64x *__cx, const _Float64x *__x) noexcept (true); + + + + + + +extern _Float64x fmaxmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x fmaximumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf64x (const _Float64x *__x, const _Float64x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf64x (const _Float64x *__x, const _Float64x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float64x getpayloadf64x (const _Float64x *__x) noexcept (true); extern _Float64x __getpayloadf64x (const _Float64x *__x) noexcept (true); + + +extern int setpayloadf64x (_Float64x *__x, _Float64x __payload) noexcept (true); + + +extern int setpayloadsigf64x (_Float64x *__x, _Float64x __payload) noexcept (true); +# 488 "/usr/include/math.h" 2 3 4 +# 535 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern float fadd (double __x, double __y) noexcept (true); + + +extern float fdiv (double __x, double __y) noexcept (true); + + +extern float ffma (double __x, double __y, double __z) noexcept (true); + + +extern float fmul (double __x, double __y) noexcept (true); + + +extern float fsqrt (double __x) noexcept (true); + + +extern float fsub (double __x, double __y) noexcept (true); +# 536 "/usr/include/math.h" 2 3 4 +# 556 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern float faddl (long double __x, long double __y) noexcept (true); + + +extern float fdivl (long double __x, long double __y) noexcept (true); + + +extern float ffmal (long double __x, long double __y, long double __z) noexcept (true); + + +extern float fmull (long double __x, long double __y) noexcept (true); + + +extern float fsqrtl (long double __x) noexcept (true); + + +extern float fsubl (long double __x, long double __y) noexcept (true); +# 557 "/usr/include/math.h" 2 3 4 +# 585 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern double daddl (long double __x, long double __y) noexcept (true); + + +extern double ddivl (long double __x, long double __y) noexcept (true); + + +extern double dfmal (long double __x, long double __y, long double __z) noexcept (true); + + +extern double dmull (long double __x, long double __y) noexcept (true); + + +extern double dsqrtl (long double __x) noexcept (true); + + +extern double dsubl (long double __x, long double __y) noexcept (true); +# 586 "/usr/include/math.h" 2 3 4 +# 666 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32divf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); + + +extern _Float32 f32mulf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32sqrtf32x (_Float32x __x) noexcept (true); + + +extern _Float32 f32subf32x (_Float32x __x, _Float32x __y) noexcept (true); +# 667 "/usr/include/math.h" 2 3 4 +# 676 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32divf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); + + +extern _Float32 f32mulf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32sqrtf64 (_Float64 __x) noexcept (true); + + +extern _Float32 f32subf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 677 "/usr/include/math.h" 2 3 4 +# 686 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32divf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + +extern _Float32 f32mulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32sqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float32 f32subf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 687 "/usr/include/math.h" 2 3 4 +# 696 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32divf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float32 f32mulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32sqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float32 f32subf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 697 "/usr/include/math.h" 2 3 4 +# 716 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xdivf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xfmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); + + +extern _Float32x f32xmulf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xsqrtf64 (_Float64 __x) noexcept (true); + + +extern _Float32x f32xsubf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 717 "/usr/include/math.h" 2 3 4 +# 726 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xdivf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xfmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + +extern _Float32x f32xmulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xsqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float32x f32xsubf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 727 "/usr/include/math.h" 2 3 4 +# 736 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xdivf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xfmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float32x f32xmulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xsqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float32x f32xsubf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 737 "/usr/include/math.h" 2 3 4 +# 756 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float64 f64addf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64divf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + +extern _Float64 f64mulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64sqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float64 f64subf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 757 "/usr/include/math.h" 2 3 4 +# 766 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float64 f64addf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64divf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float64 f64mulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64sqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float64 f64subf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 767 "/usr/include/math.h" 2 3 4 +# 786 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float64x f64xaddf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xdivf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xfmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float64x f64xmulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xsqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float64x f64xsubf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 787 "/usr/include/math.h" 2 3 4 +# 823 "/usr/include/math.h" 3 4 +extern int signgam; +# 903 "/usr/include/math.h" 3 4 +enum + { + FP_NAN = + + 0, + FP_INFINITE = + + 1, + FP_ZERO = + + 2, + FP_SUBNORMAL = + + 3, + FP_NORMAL = + + 4 + }; +# 1024 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/iscanonical.h" 1 3 4 +# 23 "/usr/include/bits/iscanonical.h" 3 4 +extern int __iscanonicall (long double __x) + noexcept (true) __attribute__ ((__const__)); +# 46 "/usr/include/bits/iscanonical.h" 3 4 +extern "C++" { +inline int iscanonical (float __val) { return ((void) (__typeof (__val)) (__val), 1); } +inline int iscanonical (double __val) { return ((void) (__typeof (__val)) (__val), 1); } +inline int iscanonical (long double __val) { return __iscanonicall (__val); } + +inline int iscanonical (_Float128 __val) { return ((void) (__typeof (__val)) (__val), 1); } + +} +# 1025 "/usr/include/math.h" 2 3 4 +# 1036 "/usr/include/math.h" 3 4 +extern "C++" { +inline int issignaling (float __val) { return __issignalingf (__val); } +inline int issignaling (double __val) { return __issignaling (__val); } +inline int +issignaling (long double __val) +{ + + + + return __issignalingl (__val); + +} + + + +inline int issignaling (_Float128 __val) { return __issignalingf128 (__val); } + +} +# 1067 "/usr/include/math.h" 3 4 +extern "C++" { +# 1098 "/usr/include/math.h" 3 4 +template inline bool +iszero (__T __val) +{ + return __val == 0; +} + +} +# 1333 "/usr/include/math.h" 3 4 +extern "C++" { +template struct __iseqsig_type; + +template<> struct __iseqsig_type +{ + static int __call (float __x, float __y) throw () + { + return __iseqsigf (__x, __y); + } +}; + +template<> struct __iseqsig_type +{ + static int __call (double __x, double __y) throw () + { + return __iseqsig (__x, __y); + } +}; + +template<> struct __iseqsig_type +{ + static int __call (long double __x, long double __y) throw () + { + + return __iseqsigl (__x, __y); + + + + } +}; + + +template<> struct __iseqsig_type<_Float32> +{ + static int __call (_Float32 __x, _Float32 __y) throw () + { + return __iseqsigf (__x, __y); + } +}; + + + +template<> struct __iseqsig_type<_Float64> +{ + static int __call (_Float64 __x, _Float64 __y) throw () + { + return __iseqsig (__x, __y); + } +}; + + + + + +template<> struct __iseqsig_type<_Float128> +{ + static int __call (_Float128 __x, _Float128 __y) throw () + { + + return __iseqsigf128 (__x, __y); + + + + } +}; + + + +template<> struct __iseqsig_type<_Float32x> +{ + static int __call (_Float32x __x, _Float32x __y) throw () + { + return __iseqsig (__x, __y); + } +}; + + + +template<> struct __iseqsig_type<_Float64x> +{ + static int __call (_Float64x __x, _Float64x __y) throw () + { + + return __iseqsigl (__x, __y); + + + + } +}; + + +template +inline int +iseqsig (_T1 __x, _T2 __y) throw () +{ + + typedef decltype (((__x) + (__y) + 0.0f)) _T3; + + + + return __iseqsig_type<_T3>::__call (__x, __y); +} + +} + + + + +} +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 +# 56 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 +# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::acos; + + + inline constexpr float + acos(float __x) + { return __builtin_acosf(__x); } + + inline constexpr long double + acos(long double __x) + { return __builtin_acosl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acos(_Tp __x) + { return __builtin_acos(__x); } + + using ::asin; + + + inline constexpr float + asin(float __x) + { return __builtin_asinf(__x); } + + inline constexpr long double + asin(long double __x) + { return __builtin_asinl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asin(_Tp __x) + { return __builtin_asin(__x); } + + using ::atan; + + + inline constexpr float + atan(float __x) + { return __builtin_atanf(__x); } + + inline constexpr long double + atan(long double __x) + { return __builtin_atanl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atan(_Tp __x) + { return __builtin_atan(__x); } + + using ::atan2; + + + inline constexpr float + atan2(float __y, float __x) + { return __builtin_atan2f(__y, __x); } + + inline constexpr long double + atan2(long double __y, long double __x) + { return __builtin_atan2l(__y, __x); } + + + using ::ceil; + + + inline constexpr float + ceil(float __x) + { return __builtin_ceilf(__x); } + + inline constexpr long double + ceil(long double __x) + { return __builtin_ceill(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ceil(_Tp __x) + { return __builtin_ceil(__x); } + + using ::cos; + + + inline constexpr float + cos(float __x) + { return __builtin_cosf(__x); } + + inline constexpr long double + cos(long double __x) + { return __builtin_cosl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cos(_Tp __x) + { return __builtin_cos(__x); } + + using ::cosh; + + + inline constexpr float + cosh(float __x) + { return __builtin_coshf(__x); } + + inline constexpr long double + cosh(long double __x) + { return __builtin_coshl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cosh(_Tp __x) + { return __builtin_cosh(__x); } + + using ::exp; + + + inline constexpr float + exp(float __x) + { return __builtin_expf(__x); } + + inline constexpr long double + exp(long double __x) + { return __builtin_expl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp(_Tp __x) + { return __builtin_exp(__x); } + + using ::fabs; + + + inline constexpr float + fabs(float __x) + { return __builtin_fabsf(__x); } + + inline constexpr long double + fabs(long double __x) + { return __builtin_fabsl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + fabs(_Tp __x) + { return __builtin_fabs(__x); } + + using ::floor; + + + inline constexpr float + floor(float __x) + { return __builtin_floorf(__x); } + + inline constexpr long double + floor(long double __x) + { return __builtin_floorl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + floor(_Tp __x) + { return __builtin_floor(__x); } + + using ::fmod; + + + inline constexpr float + fmod(float __x, float __y) + { return __builtin_fmodf(__x, __y); } + + inline constexpr long double + fmod(long double __x, long double __y) + { return __builtin_fmodl(__x, __y); } + + + using ::frexp; + + + inline float + frexp(float __x, int* __exp) + { return __builtin_frexpf(__x, __exp); } + + inline long double + frexp(long double __x, int* __exp) + { return __builtin_frexpl(__x, __exp); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + frexp(_Tp __x, int* __exp) + { return __builtin_frexp(__x, __exp); } + + using ::ldexp; + + + inline constexpr float + ldexp(float __x, int __exp) + { return __builtin_ldexpf(__x, __exp); } + + inline constexpr long double + ldexp(long double __x, int __exp) + { return __builtin_ldexpl(__x, __exp); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ldexp(_Tp __x, int __exp) + { return __builtin_ldexp(__x, __exp); } + + using ::log; + + + inline constexpr float + log(float __x) + { return __builtin_logf(__x); } + + inline constexpr long double + log(long double __x) + { return __builtin_logl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log(_Tp __x) + { return __builtin_log(__x); } + + using ::log10; + + + inline constexpr float + log10(float __x) + { return __builtin_log10f(__x); } + + inline constexpr long double + log10(long double __x) + { return __builtin_log10l(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log10(_Tp __x) + { return __builtin_log10(__x); } + + using ::modf; + + + inline float + modf(float __x, float* __iptr) + { return __builtin_modff(__x, __iptr); } + + inline long double + modf(long double __x, long double* __iptr) + { return __builtin_modfl(__x, __iptr); } + + + using ::pow; + + + inline constexpr float + pow(float __x, float __y) + { return __builtin_powf(__x, __y); } + + inline constexpr long double + pow(long double __x, long double __y) + { return __builtin_powl(__x, __y); } +# 400 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + using ::sin; + + + inline constexpr float + sin(float __x) + { return __builtin_sinf(__x); } + + inline constexpr long double + sin(long double __x) + { return __builtin_sinl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sin(_Tp __x) + { return __builtin_sin(__x); } + + using ::sinh; + + + inline constexpr float + sinh(float __x) + { return __builtin_sinhf(__x); } + + inline constexpr long double + sinh(long double __x) + { return __builtin_sinhl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sinh(_Tp __x) + { return __builtin_sinh(__x); } + + using ::sqrt; + + + inline constexpr float + sqrt(float __x) + { return __builtin_sqrtf(__x); } + + inline constexpr long double + sqrt(long double __x) + { return __builtin_sqrtl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sqrt(_Tp __x) + { return __builtin_sqrt(__x); } + + using ::tan; + + + inline constexpr float + tan(float __x) + { return __builtin_tanf(__x); } + + inline constexpr long double + tan(long double __x) + { return __builtin_tanl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tan(_Tp __x) + { return __builtin_tan(__x); } + + using ::tanh; + + + inline constexpr float + tanh(float __x) + { return __builtin_tanhf(__x); } + + inline constexpr long double + tanh(long double __x) + { return __builtin_tanhl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tanh(_Tp __x) + { return __builtin_tanh(__x); } +# 1053 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + atan2(_Tp __y, _Up __x) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return atan2(__type(__y), __type(__x)); + } + + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmod(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmod(__type(__x), __type(__y)); + } + + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + pow(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return pow(__type(__x), __type(__y)); + } +# 1100 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + constexpr int + fpclassify(float __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + constexpr int + fpclassify(double __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + constexpr int + fpclassify(long double __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + int>::__type + fpclassify(_Tp __x) + { return __x != 0 ? 4 : 2; } + + + + constexpr bool + isfinite(float __x) + { return __builtin_isfinite(__x); } + + constexpr bool + isfinite(double __x) + { return __builtin_isfinite(__x); } + + constexpr bool + isfinite(long double __x) + { return __builtin_isfinite(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isfinite(_Tp) + { return true; } + + + + constexpr bool + isinf(float __x) + { return __builtin_isinf(__x); } + + + + + + constexpr bool + isinf(double __x) + { return __builtin_isinf(__x); } + + + constexpr bool + isinf(long double __x) + { return __builtin_isinf(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isinf(_Tp) + { return false; } + + + + constexpr bool + isnan(float __x) + { return __builtin_isnan(__x); } + + + + + + constexpr bool + isnan(double __x) + { return __builtin_isnan(__x); } + + + constexpr bool + isnan(long double __x) + { return __builtin_isnan(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isnan(_Tp) + { return false; } + + + + constexpr bool + isnormal(float __x) + { return __builtin_isnormal(__x); } + + constexpr bool + isnormal(double __x) + { return __builtin_isnormal(__x); } + + constexpr bool + isnormal(long double __x) + { return __builtin_isnormal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isnormal(_Tp __x) + { return __x != 0 ? true : false; } + + + + + constexpr bool + signbit(float __x) + { return __builtin_signbit(__x); } + + constexpr bool + signbit(double __x) + { return __builtin_signbit(__x); } + + constexpr bool + signbit(long double __x) + { return __builtin_signbit(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + signbit(_Tp __x) + { return __x < 0 ? true : false; } + + + + constexpr bool + isgreater(float __x, float __y) + { return __builtin_isgreater(__x, __y); } + + constexpr bool + isgreater(double __x, double __y) + { return __builtin_isgreater(__x, __y); } + + constexpr bool + isgreater(long double __x, long double __y) + { return __builtin_isgreater(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isgreater(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isgreater(__type(__x), __type(__y)); + } + + + + constexpr bool + isgreaterequal(float __x, float __y) + { return __builtin_isgreaterequal(__x, __y); } + + constexpr bool + isgreaterequal(double __x, double __y) + { return __builtin_isgreaterequal(__x, __y); } + + constexpr bool + isgreaterequal(long double __x, long double __y) + { return __builtin_isgreaterequal(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isgreaterequal(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isgreaterequal(__type(__x), __type(__y)); + } + + + + constexpr bool + isless(float __x, float __y) + { return __builtin_isless(__x, __y); } + + constexpr bool + isless(double __x, double __y) + { return __builtin_isless(__x, __y); } + + constexpr bool + isless(long double __x, long double __y) + { return __builtin_isless(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isless(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isless(__type(__x), __type(__y)); + } + + + + constexpr bool + islessequal(float __x, float __y) + { return __builtin_islessequal(__x, __y); } + + constexpr bool + islessequal(double __x, double __y) + { return __builtin_islessequal(__x, __y); } + + constexpr bool + islessequal(long double __x, long double __y) + { return __builtin_islessequal(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + islessequal(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_islessequal(__type(__x), __type(__y)); + } + + + + constexpr bool + islessgreater(float __x, float __y) + { return __builtin_islessgreater(__x, __y); } + + constexpr bool + islessgreater(double __x, double __y) + { return __builtin_islessgreater(__x, __y); } + + constexpr bool + islessgreater(long double __x, long double __y) + { return __builtin_islessgreater(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + islessgreater(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_islessgreater(__type(__x), __type(__y)); + } + + + + constexpr bool + isunordered(float __x, float __y) + { return __builtin_isunordered(__x, __y); } + + constexpr bool + isunordered(double __x, double __y) + { return __builtin_isunordered(__x, __y); } + + constexpr bool + isunordered(long double __x, long double __y) + { return __builtin_isunordered(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isunordered(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isunordered(__type(__x), __type(__y)); + } +# 1820 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + using ::acosf; + + + using ::acosl; + + + + using ::asinf; + + + using ::asinl; + + + + using ::atanf; + + + using ::atanl; + + + + using ::atan2f; + + + using ::atan2l; + + + + using ::ceilf; + + + using ::ceill; + + + + using ::cosf; + + + using ::cosl; + + + + using ::coshf; + + + using ::coshl; + + + + using ::expf; + + + using ::expl; + + + + using ::fabsf; + + + using ::fabsl; + + + + using ::floorf; + + + using ::floorl; + + + + using ::fmodf; + + + using ::fmodl; + + + + using ::frexpf; + + + using ::frexpl; + + + + using ::ldexpf; + + + using ::ldexpl; + + + + using ::logf; + + + using ::logl; + + + + using ::log10f; + + + using ::log10l; + + + + using ::modff; + + + using ::modfl; + + + + using ::powf; + + + using ::powl; + + + + using ::sinf; + + + using ::sinl; + + + + using ::sinhf; + + + using ::sinhl; + + + + using ::sqrtf; + + + using ::sqrtl; + + + + using ::tanf; + + + using ::tanl; + + + + using ::tanhf; + + + using ::tanhl; +# 2085 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + using ::double_t; + using ::float_t; + + + + using ::acosh; + using ::acoshf; + using ::acoshl; + + using ::asinh; + using ::asinhf; + using ::asinhl; + + using ::atanh; + using ::atanhf; + using ::atanhl; + + using ::cbrt; + using ::cbrtf; + using ::cbrtl; + + using ::copysign; + using ::copysignf; + using ::copysignl; + + using ::erf; + using ::erff; + using ::erfl; + + using ::erfc; + using ::erfcf; + using ::erfcl; + + using ::exp2; + using ::exp2f; + using ::exp2l; + + using ::expm1; + using ::expm1f; + using ::expm1l; + + using ::fdim; + using ::fdimf; + using ::fdiml; + + using ::fma; + using ::fmaf; + using ::fmal; + + using ::fmax; + using ::fmaxf; + using ::fmaxl; + + using ::fmin; + using ::fminf; + using ::fminl; + + using ::hypot; + using ::hypotf; + using ::hypotl; + + using ::ilogb; + using ::ilogbf; + using ::ilogbl; + + using ::lgamma; + using ::lgammaf; + using ::lgammal; + + + using ::llrint; + using ::llrintf; + using ::llrintl; + + using ::llround; + using ::llroundf; + using ::llroundl; + + + using ::log1p; + using ::log1pf; + using ::log1pl; + + using ::log2; + using ::log2f; + using ::log2l; + + using ::logb; + using ::logbf; + using ::logbl; + + using ::lrint; + using ::lrintf; + using ::lrintl; + + using ::lround; + using ::lroundf; + using ::lroundl; + + using ::nan; + using ::nanf; + using ::nanl; + + using ::nearbyint; + using ::nearbyintf; + using ::nearbyintl; + + using ::nextafter; + using ::nextafterf; + using ::nextafterl; + + using ::nexttoward; + using ::nexttowardf; + using ::nexttowardl; + + using ::remainder; + using ::remainderf; + using ::remainderl; + + using ::remquo; + using ::remquof; + using ::remquol; + + using ::rint; + using ::rintf; + using ::rintl; + + using ::round; + using ::roundf; + using ::roundl; + + using ::scalbln; + using ::scalblnf; + using ::scalblnl; + + using ::scalbn; + using ::scalbnf; + using ::scalbnl; + + using ::tgamma; + using ::tgammaf; + using ::tgammal; + + using ::trunc; + using ::truncf; + using ::truncl; + + + + constexpr float + acosh(float __x) + { return __builtin_acoshf(__x); } + + constexpr long double + acosh(long double __x) + { return __builtin_acoshl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acosh(_Tp __x) + { return __builtin_acosh(__x); } + + + + constexpr float + asinh(float __x) + { return __builtin_asinhf(__x); } + + constexpr long double + asinh(long double __x) + { return __builtin_asinhl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asinh(_Tp __x) + { return __builtin_asinh(__x); } + + + + constexpr float + atanh(float __x) + { return __builtin_atanhf(__x); } + + constexpr long double + atanh(long double __x) + { return __builtin_atanhl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atanh(_Tp __x) + { return __builtin_atanh(__x); } + + + + constexpr float + cbrt(float __x) + { return __builtin_cbrtf(__x); } + + constexpr long double + cbrt(long double __x) + { return __builtin_cbrtl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cbrt(_Tp __x) + { return __builtin_cbrt(__x); } + + + + constexpr float + copysign(float __x, float __y) + { return __builtin_copysignf(__x, __y); } + + constexpr long double + copysign(long double __x, long double __y) + { return __builtin_copysignl(__x, __y); } + + + + constexpr float + erf(float __x) + { return __builtin_erff(__x); } + + constexpr long double + erf(long double __x) + { return __builtin_erfl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erf(_Tp __x) + { return __builtin_erf(__x); } + + + + constexpr float + erfc(float __x) + { return __builtin_erfcf(__x); } + + constexpr long double + erfc(long double __x) + { return __builtin_erfcl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erfc(_Tp __x) + { return __builtin_erfc(__x); } + + + + constexpr float + exp2(float __x) + { return __builtin_exp2f(__x); } + + constexpr long double + exp2(long double __x) + { return __builtin_exp2l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp2(_Tp __x) + { return __builtin_exp2(__x); } + + + + constexpr float + expm1(float __x) + { return __builtin_expm1f(__x); } + + constexpr long double + expm1(long double __x) + { return __builtin_expm1l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + expm1(_Tp __x) + { return __builtin_expm1(__x); } + + + + constexpr float + fdim(float __x, float __y) + { return __builtin_fdimf(__x, __y); } + + constexpr long double + fdim(long double __x, long double __y) + { return __builtin_fdiml(__x, __y); } + + + + constexpr float + fma(float __x, float __y, float __z) + { return __builtin_fmaf(__x, __y, __z); } + + constexpr long double + fma(long double __x, long double __y, long double __z) + { return __builtin_fmal(__x, __y, __z); } + + + + constexpr float + fmax(float __x, float __y) + { return __builtin_fmaxf(__x, __y); } + + constexpr long double + fmax(long double __x, long double __y) + { return __builtin_fmaxl(__x, __y); } + + + + constexpr float + fmin(float __x, float __y) + { return __builtin_fminf(__x, __y); } + + constexpr long double + fmin(long double __x, long double __y) + { return __builtin_fminl(__x, __y); } + + + + constexpr float + hypot(float __x, float __y) + { return __builtin_hypotf(__x, __y); } + + constexpr long double + hypot(long double __x, long double __y) + { return __builtin_hypotl(__x, __y); } + + + + constexpr int + ilogb(float __x) + { return __builtin_ilogbf(__x); } + + constexpr int + ilogb(long double __x) + { return __builtin_ilogbl(__x); } + + + + template + constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + int>::__type + ilogb(_Tp __x) + { return __builtin_ilogb(__x); } + + + + constexpr float + lgamma(float __x) + { return __builtin_lgammaf(__x); } + + constexpr long double + lgamma(long double __x) + { return __builtin_lgammal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + lgamma(_Tp __x) + { return __builtin_lgamma(__x); } + + + + constexpr long long + llrint(float __x) + { return __builtin_llrintf(__x); } + + constexpr long long + llrint(long double __x) + { return __builtin_llrintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llrint(_Tp __x) + { return __builtin_llrint(__x); } + + + + constexpr long long + llround(float __x) + { return __builtin_llroundf(__x); } + + constexpr long long + llround(long double __x) + { return __builtin_llroundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llround(_Tp __x) + { return __builtin_llround(__x); } + + + + constexpr float + log1p(float __x) + { return __builtin_log1pf(__x); } + + constexpr long double + log1p(long double __x) + { return __builtin_log1pl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log1p(_Tp __x) + { return __builtin_log1p(__x); } + + + + + constexpr float + log2(float __x) + { return __builtin_log2f(__x); } + + constexpr long double + log2(long double __x) + { return __builtin_log2l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log2(_Tp __x) + { return __builtin_log2(__x); } + + + + constexpr float + logb(float __x) + { return __builtin_logbf(__x); } + + constexpr long double + logb(long double __x) + { return __builtin_logbl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + logb(_Tp __x) + { return __builtin_logb(__x); } + + + + constexpr long + lrint(float __x) + { return __builtin_lrintf(__x); } + + constexpr long + lrint(long double __x) + { return __builtin_lrintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lrint(_Tp __x) + { return __builtin_lrint(__x); } + + + + constexpr long + lround(float __x) + { return __builtin_lroundf(__x); } + + constexpr long + lround(long double __x) + { return __builtin_lroundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lround(_Tp __x) + { return __builtin_lround(__x); } + + + + constexpr float + nearbyint(float __x) + { return __builtin_nearbyintf(__x); } + + constexpr long double + nearbyint(long double __x) + { return __builtin_nearbyintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nearbyint(_Tp __x) + { return __builtin_nearbyint(__x); } + + + + constexpr float + nextafter(float __x, float __y) + { return __builtin_nextafterf(__x, __y); } + + constexpr long double + nextafter(long double __x, long double __y) + { return __builtin_nextafterl(__x, __y); } + + + + constexpr float + nexttoward(float __x, long double __y) + { return __builtin_nexttowardf(__x, __y); } + + constexpr long double + nexttoward(long double __x, long double __y) + { return __builtin_nexttowardl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nexttoward(_Tp __x, long double __y) + { return __builtin_nexttoward(__x, __y); } + + + + constexpr float + remainder(float __x, float __y) + { return __builtin_remainderf(__x, __y); } + + constexpr long double + remainder(long double __x, long double __y) + { return __builtin_remainderl(__x, __y); } + + + + inline float + remquo(float __x, float __y, int* __pquo) + { return __builtin_remquof(__x, __y, __pquo); } + + inline long double + remquo(long double __x, long double __y, int* __pquo) + { return __builtin_remquol(__x, __y, __pquo); } + + + + constexpr float + rint(float __x) + { return __builtin_rintf(__x); } + + constexpr long double + rint(long double __x) + { return __builtin_rintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + rint(_Tp __x) + { return __builtin_rint(__x); } + + + + constexpr float + round(float __x) + { return __builtin_roundf(__x); } + + constexpr long double + round(long double __x) + { return __builtin_roundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + round(_Tp __x) + { return __builtin_round(__x); } + + + + constexpr float + scalbln(float __x, long __ex) + { return __builtin_scalblnf(__x, __ex); } + + constexpr long double + scalbln(long double __x, long __ex) + { return __builtin_scalblnl(__x, __ex); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbln(_Tp __x, long __ex) + { return __builtin_scalbln(__x, __ex); } + + + + constexpr float + scalbn(float __x, int __ex) + { return __builtin_scalbnf(__x, __ex); } + + constexpr long double + scalbn(long double __x, int __ex) + { return __builtin_scalbnl(__x, __ex); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbn(_Tp __x, int __ex) + { return __builtin_scalbn(__x, __ex); } + + + + constexpr float + tgamma(float __x) + { return __builtin_tgammaf(__x); } + + constexpr long double + tgamma(long double __x) + { return __builtin_tgammal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tgamma(_Tp __x) + { return __builtin_tgamma(__x); } + + + + constexpr float + trunc(float __x) + { return __builtin_truncf(__x); } + + constexpr long double + trunc(long double __x) + { return __builtin_truncl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + trunc(_Tp __x) + { return __builtin_trunc(__x); } +# 3682 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + copysign(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return copysign(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fdim(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fdim(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmax(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmax(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmin(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmin(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + hypot(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return hypot(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + nextafter(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return nextafter(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remainder(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remainder(__type(__x), __type(__y)); + } + + template + inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remquo(_Tp __x, _Up __y, int* __pquo) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remquo(__type(__x), __type(__y), __pquo); + } + + template + constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type + fma(_Tp __x, _Up __y, _Vp __z) + { + typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; + return fma(__type(__x), __type(__y), __type(__z)); + } + + + + + + + + template + inline _Tp + __hypot3(_Tp __x, _Tp __y, _Tp __z) + { + __x = std::abs(__x); + __y = std::abs(__y); + __z = std::abs(__z); + if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x) + return __a * std::sqrt((__x / __a) * (__x / __a) + + (__y / __a) * (__y / __a) + + (__z / __a) * (__z / __a)); + else + return {}; + } + + inline float + hypot(float __x, float __y, float __z) + { return std::__hypot3(__x, __y, __z); } + + inline double + hypot(double __x, double __y, double __z) + { return std::__hypot3(__x, __y, __z); } + + inline long double + hypot(long double __x, long double __y, long double __z) + { return std::__hypot3(__x, __y, __z); } + + template + __gnu_cxx::__promoted_t<_Tp, _Up, _Vp> + hypot(_Tp __x, _Up __y, _Vp __z) + { + using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>; + return std::__hypot3<__type>(__x, __y, __z); + } +# 3902 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + +} + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 1 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 1 3 +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h" 1 3 +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/exception_defines.h" 1 3 +# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + void + __throw_bad_exception(void) __attribute__((__noreturn__)); + + + void + __throw_bad_alloc(void) __attribute__((__noreturn__)); + + void + __throw_bad_array_new_length(void) __attribute__((__noreturn__)); + + + void + __throw_bad_cast(void) __attribute__((__noreturn__,__cold__)); + + void + __throw_bad_typeid(void) __attribute__((__noreturn__,__cold__)); + + + void + __throw_logic_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_domain_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_invalid_argument(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_length_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_out_of_range(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__,__cold__)) + __attribute__((__format__(__gnu_printf__, 1, 2))); + + void + __throw_runtime_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_range_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_overflow_error(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_underflow_error(const char*) __attribute__((__noreturn__,__cold__)); + + + void + __throw_ios_failure(const char*) __attribute__((__noreturn__,__cold__)); + + void + __throw_ios_failure(const char*, int) __attribute__((__noreturn__,__cold__)); + + + void + __throw_system_error(int) __attribute__((__noreturn__,__cold__)); + + + void + __throw_future_error(int) __attribute__((__noreturn__,__cold__)); + + + void + __throw_bad_function_call() __attribute__((__noreturn__,__cold__)); +# 140 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h" 3 + +} +# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + template + struct __is_integer_nonstrict + : public std::__is_integer<_Tp> + { + using std::__is_integer<_Tp>::__value; + + + enum { __width = __value ? sizeof(_Tp) * 8 : 0 }; + }; + + template + struct __numeric_traits_integer + { + + static_assert(__is_integer_nonstrict<_Value>::__value, + "invalid specialization"); + + + + + static const bool __is_signed = (_Value)(-1) < 0; + static const int __digits + = __is_integer_nonstrict<_Value>::__width - __is_signed; + + + static const _Value __max = __is_signed + ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1) + : ~(_Value)0; + static const _Value __min = __is_signed ? -__max - 1 : (_Value)0; + }; + + template + const _Value __numeric_traits_integer<_Value>::__min; + + template + const _Value __numeric_traits_integer<_Value>::__max; + + template + const bool __numeric_traits_integer<_Value>::__is_signed; + + template + const int __numeric_traits_integer<_Value>::__digits; +# 137 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + template + using __int_traits = __numeric_traits_integer<_Tp>; +# 157 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + template + struct __numeric_traits_floating + { + + static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136); + + + static const bool __is_signed = true; + static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18); + static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932); + }; + + template + const int __numeric_traits_floating<_Value>::__max_digits10; + + template + const bool __numeric_traits_floating<_Value>::__is_signed; + + template + const int __numeric_traits_floating<_Value>::__digits10; + + template + const int __numeric_traits_floating<_Value>::__max_exponent10; + + + + + + + template + struct __numeric_traits + : public __numeric_traits_integer<_Value> + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; +# 238 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 + +} +# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 1 3 +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + class reference_wrapper; +# 86 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct integral_constant + { + static constexpr _Tp value = __v; + using value_type = _Tp; + using type = integral_constant<_Tp, __v>; + constexpr operator value_type() const noexcept { return value; } + + + constexpr value_type operator()() const noexcept { return value; } + + }; +# 106 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + using __bool_constant = integral_constant; + + + + using true_type = __bool_constant; + + + using false_type = __bool_constant; + + + + + template + using bool_constant = __bool_constant<__v>; + + + + + + + template + struct enable_if + { }; + + + template + struct enable_if + { using type = _Tp; }; + + + template + using __enable_if_t = typename enable_if<_Cond, _Tp>::type; + + template + struct __conditional + { + template + using type = _Tp; + }; + + template<> + struct __conditional + { + template + using type = _Up; + }; + + + template + using __conditional_t + = typename __conditional<_Cond>::template type<_If, _Else>; + + + template + struct __type_identity + { using type = _Type; }; + + template + using __type_identity_t = typename __type_identity<_Tp>::type; + + namespace __detail + { + + template + using __first_t = _Tp; + + + template + auto __or_fn(int) -> __first_t...>; + + template + auto __or_fn(...) -> true_type; + + template + auto __and_fn(int) -> __first_t...>; + + template + auto __and_fn(...) -> false_type; + } + + + + + template + struct __or_ + : decltype(__detail::__or_fn<_Bn...>(0)) + { }; + + template + struct __and_ + : decltype(__detail::__and_fn<_Bn...>(0)) + { }; + + template + struct __not_ + : __bool_constant + { }; + + + + + + template + inline constexpr bool __or_v = __or_<_Bn...>::value; + template + inline constexpr bool __and_v = __and_<_Bn...>::value; + + namespace __detail + { + template + struct __disjunction_impl + { using type = _B1; }; + + template + struct __disjunction_impl<__enable_if_t, _B1, _B2, _Bn...> + { using type = typename __disjunction_impl::type; }; + + template + struct __conjunction_impl + { using type = _B1; }; + + template + struct __conjunction_impl<__enable_if_t, _B1, _B2, _Bn...> + { using type = typename __conjunction_impl::type; }; + } + + + template + struct conjunction + : __detail::__conjunction_impl::type + { }; + + template<> + struct conjunction<> + : true_type + { }; + + template + struct disjunction + : __detail::__disjunction_impl::type + { }; + + template<> + struct disjunction<> + : false_type + { }; + + template + struct negation + : __not_<_Pp>::type + { }; + + + + + template + inline constexpr bool conjunction_v = conjunction<_Bn...>::value; + + template + inline constexpr bool disjunction_v = disjunction<_Bn...>::value; + + template + inline constexpr bool negation_v = negation<_Pp>::value; + + + + + + template + struct is_reference; + template + struct is_function; + template + struct is_void; + template + struct remove_cv; + template + struct is_const; + + + template + struct __is_array_unknown_bounds; + + + + + template + constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>) + { return {}; } + + template + constexpr typename __or_< + is_reference<_NestedType>, + is_function<_NestedType>, + is_void<_NestedType>, + __is_array_unknown_bounds<_NestedType> + >::type __is_complete_or_unbounded(_TypeIdentity) + { return {}; } + + + template + using __remove_cv_t = typename remove_cv<_Tp>::type; + + + + + + template + struct is_void + : public false_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + + template + struct __is_integral_helper + : public false_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + + + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + __extension__ + template<> + struct __is_integral_helper<__int128> + : public true_type { }; + + __extension__ + template<> + struct __is_integral_helper + : public true_type { }; +# 460 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_integral + : public __is_integral_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct __is_floating_point_helper + : public false_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; +# 513 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template<> + struct __is_floating_point_helper<__float128> + : public true_type { }; + + + + + template + struct is_floating_point + : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type + { }; + + + + template + struct is_array + : public __bool_constant<__is_array(_Tp)> + { }; +# 545 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct __is_pointer_helper + : public false_type { }; + + template + struct __is_pointer_helper<_Tp*> + : public true_type { }; + + + template + struct is_pointer + : public __is_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_lvalue_reference + : public false_type { }; + + template + struct is_lvalue_reference<_Tp&> + : public true_type { }; + + + template + struct is_rvalue_reference + : public false_type { }; + + template + struct is_rvalue_reference<_Tp&&> + : public true_type { }; + + + + template + struct is_member_object_pointer + : public __bool_constant<__is_member_object_pointer(_Tp)> + { }; +# 601 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_member_function_pointer + : public __bool_constant<__is_member_function_pointer(_Tp)> + { }; +# 622 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_enum + : public __bool_constant<__is_enum(_Tp)> + { }; + + + template + struct is_union + : public __bool_constant<__is_union(_Tp)> + { }; + + + template + struct is_class + : public __bool_constant<__is_class(_Tp)> + { }; + + + + template + struct is_function + : public __bool_constant<__is_function(_Tp)> + { }; +# 661 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_null_pointer + : public false_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + + + template + struct __is_nullptr_t + : public is_null_pointer<_Tp> + { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead"))); + + + + + + + template + struct is_reference + : public __bool_constant<__is_reference(_Tp)> + { }; +# 715 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_arithmetic + : public __or_, is_floating_point<_Tp>>::type + { }; + + + template + struct is_fundamental + : public __or_, is_void<_Tp>, + is_null_pointer<_Tp>>::type + { }; + + + + template + struct is_object + : public __bool_constant<__is_object(_Tp)> + { }; +# 741 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_member_pointer; + + + template + struct is_scalar + : public __or_, is_enum<_Tp>, is_pointer<_Tp>, + is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type + { }; + + + template + struct is_compound + : public __bool_constant::value> { }; + + + + template + struct is_member_pointer + : public __bool_constant<__is_member_pointer(_Tp)> + { }; +# 779 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_same; + + + template + using __is_one_of = __or_...>; + + + __extension__ + template + using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, + signed char, signed short, signed int, signed long, + signed long long + + , signed __int128 +# 804 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + >; + + + __extension__ + template + using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>, + unsigned char, unsigned short, unsigned int, unsigned long, + unsigned long long + + , unsigned __int128 +# 824 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + >; + + + template + using __is_standard_integer + = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>; + + + template using __void_t = void; + + + + + + template + struct is_const + : public false_type { }; + + template + struct is_const<_Tp const> + : public true_type { }; + + + template + struct is_volatile + : public false_type { }; + + template + struct is_volatile<_Tp volatile> + : public true_type { }; + + + template + struct is_trivial + : public __bool_constant<__is_trivial(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copyable + : public __bool_constant<__is_trivially_copyable(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_standard_layout + : public __bool_constant<__is_standard_layout(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + template + struct + + is_pod + : public __bool_constant<__is_pod(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct + [[__deprecated__]] + is_literal_type + : public __bool_constant<__is_literal_type(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_empty + : public __bool_constant<__is_empty(_Tp)> + { }; + + + template + struct is_polymorphic + : public __bool_constant<__is_polymorphic(_Tp)> + { }; + + + + + template + struct is_final + : public __bool_constant<__is_final(_Tp)> + { }; + + + + template + struct is_abstract + : public __bool_constant<__is_abstract(_Tp)> + { }; + + + template::value> + struct __is_signed_helper + : public false_type { }; + + template + struct __is_signed_helper<_Tp, true> + : public __bool_constant<_Tp(-1) < _Tp(0)> + { }; + + + + template + struct is_signed + : public __is_signed_helper<_Tp>::type + { }; + + + template + struct is_unsigned + : public __and_, __not_>>::type + { }; + + + template + _Up + __declval(int); + + template + _Tp + __declval(long); + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)); + + template + struct remove_all_extents; + + + template + struct __is_array_known_bounds + : public false_type + { }; + + template + struct __is_array_known_bounds<_Tp[_Size]> + : public true_type + { }; + + template + struct __is_array_unknown_bounds + : public false_type + { }; + + template + struct __is_array_unknown_bounds<_Tp[]> + : public true_type + { }; +# 1006 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + struct __do_is_destructible_impl + { + template().~_Tp())> + static true_type __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_destructible_impl + : public __do_is_destructible_impl + { + using type = decltype(__test<_Tp>(0)); + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_destructible_safe; + + template + struct __is_destructible_safe<_Tp, false, false> + : public __is_destructible_impl::type>::type + { }; + + template + struct __is_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_destructible + : public __is_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + + struct __do_is_nt_destructible_impl + { + template + static __bool_constant().~_Tp())> + __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_nt_destructible_impl + : public __do_is_nt_destructible_impl + { + using type = decltype(__test<_Tp>(0)); + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_nt_destructible_safe; + + template + struct __is_nt_destructible_safe<_Tp, false, false> + : public __is_nt_destructible_impl::type>::type + { }; + + template + struct __is_nt_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_nt_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_nothrow_destructible + : public __is_nt_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_constructible_impl + = __bool_constant<__is_constructible(_Tp, _Args...)>; + + + + template + struct is_constructible + : public __is_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_default_constructible + : public __is_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct __add_lvalue_reference_helper + { using type = _Tp; }; + + template + struct __add_lvalue_reference_helper<_Tp, __void_t<_Tp&>> + { using type = _Tp&; }; + + template + using __add_lval_ref_t = typename __add_lvalue_reference_helper<_Tp>::type; + + + + template + struct is_copy_constructible + : public __is_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct __add_rvalue_reference_helper + { using type = _Tp; }; + + template + struct __add_rvalue_reference_helper<_Tp, __void_t<_Tp&&>> + { using type = _Tp&&; }; + + template + using __add_rval_ref_t = typename __add_rvalue_reference_helper<_Tp>::type; + + + + template + struct is_move_constructible + : public __is_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_constructible_impl + = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>; + + + + template + struct is_nothrow_constructible + : public __is_nothrow_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_default_constructible + : public __is_nothrow_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_copy_constructible + : public __is_nothrow_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_move_constructible + : public __is_nothrow_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_assignable_impl = __bool_constant<__is_assignable(_Tp, _Up)>; + + + + template + struct is_assignable + : public __is_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_copy_assignable + : public __is_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_move_assignable + : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_assignable_impl + = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>; + + + + template + struct is_nothrow_assignable + : public __is_nothrow_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_copy_assignable + : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_move_assignable + : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_trivially_constructible_impl + = __bool_constant<__is_trivially_constructible(_Tp, _Args...)>; + + + + template + struct is_trivially_constructible + : public __is_trivially_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_default_constructible + : public __is_trivially_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; +# 1319 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + struct __do_is_implicitly_default_constructible_impl + { + template + static void __helper(const _Tp&); + + template + static true_type __test(const _Tp&, + decltype(__helper({}))* = 0); + + static false_type __test(...); + }; + + template + struct __is_implicitly_default_constructible_impl + : public __do_is_implicitly_default_constructible_impl + { + using type = decltype(__test(declval<_Tp>())); + }; + + template + struct __is_implicitly_default_constructible_safe + : public __is_implicitly_default_constructible_impl<_Tp>::type + { }; + + template + struct __is_implicitly_default_constructible + : public __and_<__is_constructible_impl<_Tp>, + __is_implicitly_default_constructible_safe<_Tp>>::type + { }; + + + + template + struct is_trivially_copy_constructible + : public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_move_constructible + : public __is_trivially_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_trivially_assignable_impl + = __bool_constant<__is_trivially_assignable(_Tp, _Up)>; + + + + template + struct is_trivially_assignable + : public __is_trivially_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copy_assignable + : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_move_assignable + : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_destructible + : public __and_<__is_destructible_safe<_Tp>, + __bool_constant<__has_trivial_destructor(_Tp)>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + struct has_virtual_destructor + : public __bool_constant<__has_virtual_destructor(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct alignment_of + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct rank + : public integral_constant { }; + + template + struct rank<_Tp[_Size]> + : public integral_constant::value> { }; + + template + struct rank<_Tp[]> + : public integral_constant::value> { }; + + + template + struct extent + : public integral_constant { }; + + template + struct extent<_Tp[_Size], 0> + : public integral_constant { }; + + template + struct extent<_Tp[_Size], _Uint> + : public extent<_Tp, _Uint - 1>::type { }; + + template + struct extent<_Tp[], 0> + : public integral_constant { }; + + template + struct extent<_Tp[], _Uint> + : public extent<_Tp, _Uint - 1>::type { }; + + + + + + + template + struct is_same + : public __bool_constant<__is_same(_Tp, _Up)> + { }; +# 1491 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct is_base_of + : public __bool_constant<__is_base_of(_Base, _Derived)> + { }; + + + template + struct is_convertible + : public __bool_constant<__is_convertible(_From, _To)> + { }; +# 1540 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + using __is_array_convertible + = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; +# 1600 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++14-extensions" + template + struct __is_nothrow_new_constructible_impl + : __bool_constant< + noexcept(::new(std::declval()) _Tp(std::declval<_Args>()...)) + > + { }; + + template + inline constexpr bool __is_nothrow_new_constructible + = __and_, + __is_nothrow_new_constructible_impl<_Tp, _Args...>>::value; +#pragma GCC diagnostic pop + + + + + template + struct remove_const + { using type = _Tp; }; + + template + struct remove_const<_Tp const> + { using type = _Tp; }; + + + template + struct remove_volatile + { using type = _Tp; }; + + template + struct remove_volatile<_Tp volatile> + { using type = _Tp; }; + + + + template + struct remove_cv + { using type = __remove_cv(_Tp); }; +# 1659 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct add_const + { using type = _Tp const; }; + + + template + struct add_volatile + { using type = _Tp volatile; }; + + + template + struct add_cv + { using type = _Tp const volatile; }; + + + + template + using remove_const_t = typename remove_const<_Tp>::type; + + + template + using remove_volatile_t = typename remove_volatile<_Tp>::type; + + + template + using remove_cv_t = typename remove_cv<_Tp>::type; + + + template + using add_const_t = typename add_const<_Tp>::type; + + + template + using add_volatile_t = typename add_volatile<_Tp>::type; + + + template + using add_cv_t = typename add_cv<_Tp>::type; + + + + + + + template + struct remove_reference + { using type = __remove_reference(_Tp); }; +# 1721 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct add_lvalue_reference + { using type = __add_lval_ref_t<_Tp>; }; + + + template + struct add_rvalue_reference + { using type = __add_rval_ref_t<_Tp>; }; + + + + template + using remove_reference_t = typename remove_reference<_Tp>::type; + + + template + using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; + + + template + using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; + + + + + + + + template + struct __cv_selector; + + template + struct __cv_selector<_Unqualified, false, false> + { using __type = _Unqualified; }; + + template + struct __cv_selector<_Unqualified, false, true> + { using __type = volatile _Unqualified; }; + + template + struct __cv_selector<_Unqualified, true, false> + { using __type = const _Unqualified; }; + + template + struct __cv_selector<_Unqualified, true, true> + { using __type = const volatile _Unqualified; }; + + template::value, + bool _IsVol = is_volatile<_Qualified>::value> + class __match_cv_qualifiers + { + using __match = __cv_selector<_Unqualified, _IsConst, _IsVol>; + + public: + using __type = typename __match::__type; + }; + + + template + struct __make_unsigned + { using __type = _Tp; }; + + template<> + struct __make_unsigned + { using __type = unsigned char; }; + + template<> + struct __make_unsigned + { using __type = unsigned char; }; + + template<> + struct __make_unsigned + { using __type = unsigned short; }; + + template<> + struct __make_unsigned + { using __type = unsigned int; }; + + template<> + struct __make_unsigned + { using __type = unsigned long; }; + + template<> + struct __make_unsigned + { using __type = unsigned long long; }; + + + __extension__ + template<> + struct __make_unsigned<__int128> + { using __type = unsigned __int128; }; +# 1834 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template::value, + bool _IsEnum = __is_enum(_Tp)> + class __make_unsigned_selector; + + template + class __make_unsigned_selector<_Tp, true, false> + { + using __unsigned_type + = typename __make_unsigned<__remove_cv_t<_Tp>>::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + class __make_unsigned_selector_base + { + protected: + template struct _List { }; + + template + struct _List<_Tp, _Up...> : _List<_Up...> + { static constexpr size_t __size = sizeof(_Tp); }; + + template + struct __select; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, true> + { using __type = _Uint; }; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, false> + : __select<_Sz, _List<_UInts...>> + { }; + }; + + + template + class __make_unsigned_selector<_Tp, false, true> + : __make_unsigned_selector_base + { + + using _UInts = _List; + + using __unsigned_type = typename __select::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + + + + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; +# 1908 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + + + + + + template + struct make_unsigned + { using type = typename __make_unsigned_selector<_Tp>::__type; }; + + + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + + + + + template + struct __make_signed + { using __type = _Tp; }; + + template<> + struct __make_signed + { using __type = signed char; }; + + template<> + struct __make_signed + { using __type = signed char; }; + + template<> + struct __make_signed + { using __type = signed short; }; + + template<> + struct __make_signed + { using __type = signed int; }; + + template<> + struct __make_signed + { using __type = signed long; }; + + template<> + struct __make_signed + { using __type = signed long long; }; + + + __extension__ + template<> + struct __make_signed + { using __type = __int128; }; +# 1994 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template::value, + bool _IsEnum = __is_enum(_Tp)> + class __make_signed_selector; + + template + class __make_signed_selector<_Tp, true, false> + { + using __signed_type + = typename __make_signed<__remove_cv_t<_Tp>>::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __signed_type>::__type; + }; + + + template + class __make_signed_selector<_Tp, false, true> + { + using __unsigned_type = typename __make_unsigned_selector<_Tp>::__type; + + public: + using __type = typename __make_signed_selector<__unsigned_type>::__type; + }; + + + + + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; +# 2040 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + + + + + + template + struct make_signed + { using type = typename __make_signed_selector<_Tp>::__type; }; + + + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + + + + template + using make_signed_t = typename make_signed<_Tp>::type; + + + template + using make_unsigned_t = typename make_unsigned<_Tp>::type; + + + + + + template + struct remove_extent + { using type = _Tp; }; + + template + struct remove_extent<_Tp[_Size]> + { using type = _Tp; }; + + template + struct remove_extent<_Tp[]> + { using type = _Tp; }; + + + template + struct remove_all_extents + { using type = _Tp; }; + + template + struct remove_all_extents<_Tp[_Size]> + { using type = typename remove_all_extents<_Tp>::type; }; + + template + struct remove_all_extents<_Tp[]> + { using type = typename remove_all_extents<_Tp>::type; }; + + + + template + using remove_extent_t = typename remove_extent<_Tp>::type; + + + template + using remove_all_extents_t = typename remove_all_extents<_Tp>::type; + + + + + + + template + struct remove_pointer + { using type = __remove_pointer(_Tp); }; +# 2139 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct __add_pointer_helper + { using type = _Tp; }; + + template + struct __add_pointer_helper<_Tp, __void_t<_Tp*>> + { using type = _Tp*; }; + + + template + struct add_pointer + : public __add_pointer_helper<_Tp> + { }; + + template + struct add_pointer<_Tp&> + { using type = _Tp*; }; + + template + struct add_pointer<_Tp&&> + { using type = _Tp*; }; + + + + template + using remove_pointer_t = typename remove_pointer<_Tp>::type; + + + template + using add_pointer_t = typename add_pointer<_Tp>::type; + + + template + struct __aligned_storage_msa + { + union __type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__)) { } __align; + }; + }; +# 2194 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template::__type)> + struct + + aligned_storage + { + union type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__((_Align)))) { } __align; + }; + }; + + template + struct __strictest_alignment + { + static const size_t _S_alignment = 0; + static const size_t _S_size = 0; + }; + + template + struct __strictest_alignment<_Tp, _Types...> + { + static const size_t _S_alignment = + alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment + ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; + static const size_t _S_size = + sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size + ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 2240 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct + + aligned_union + { + private: + static_assert(sizeof...(_Types) != 0, "At least one type is required"); + + using __strictest = __strictest_alignment<_Types...>; + static const size_t _S_len = _Len > __strictest::_S_size + ? _Len : __strictest::_S_size; + public: + + static const size_t alignment_value = __strictest::_S_alignment; + + using type = typename aligned_storage<_S_len, alignment_value>::type; + }; + + template + const size_t aligned_union<_Len, _Types...>::alignment_value; +#pragma GCC diagnostic pop + + + + + + template + struct __decay_selector + : __conditional_t::value, + remove_cv<_Up>, + add_pointer<_Up>> + { }; + + template + struct __decay_selector<_Up[_Nm]> + { using type = _Up*; }; + + template + struct __decay_selector<_Up[]> + { using type = _Up*; }; + + + + + template + struct decay + { using type = typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&> + { using type = typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&&> + { using type = typename __decay_selector<_Tp>::type; }; + + + + + template + struct __strip_reference_wrapper + { + using __type = _Tp; + }; + + template + struct __strip_reference_wrapper > + { + using __type = _Tp&; + }; + + + template + using __decay_t = typename decay<_Tp>::type; + + template + using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; + + + + + + template + using _Require = __enable_if_t<__and_<_Cond...>::value>; + + + template + using __remove_cvref_t + = typename remove_cv::type>::type; + + + + + template + struct conditional + { using type = _Iftrue; }; + + + template + struct conditional + { using type = _Iffalse; }; + + + template + struct common_type; +# 2355 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct __success_type + { using type = _Tp; }; + + struct __failure_type + { }; + + struct __do_common_type_impl + { + template + using __cond_t + = decltype(true ? std::declval<_Tp>() : std::declval<_Up>()); + + + + template + static __success_type<__decay_t<__cond_t<_Tp, _Up>>> + _S_test(int); +# 2382 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + static __failure_type + _S_test_2(...); + + template + static decltype(_S_test_2<_Tp, _Up>(0)) + _S_test(...); + }; + + + template<> + struct common_type<> + { }; + + + template + struct common_type<_Tp0> + : public common_type<_Tp0, _Tp0> + { }; + + + template, typename _Dp2 = __decay_t<_Tp2>> + struct __common_type_impl + { + + + using type = common_type<_Dp1, _Dp2>; + }; + + template + struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> + : private __do_common_type_impl + { + + + using type = decltype(_S_test<_Tp1, _Tp2>(0)); + }; + + + template + struct common_type<_Tp1, _Tp2> + : public __common_type_impl<_Tp1, _Tp2>::type + { }; + + template + struct __common_type_pack + { }; + + template + struct __common_type_fold; + + + template + struct common_type<_Tp1, _Tp2, _Rp...> + : public __common_type_fold, + __common_type_pack<_Rp...>> + { }; + + + + + template + struct __common_type_fold<_CTp, __common_type_pack<_Rp...>, + __void_t> + : public common_type + { }; + + + template + struct __common_type_fold<_CTp, _Rp, void> + { }; + + template + struct __underlying_type_impl + { + using type = __underlying_type(_Tp); + }; + + template + struct __underlying_type_impl<_Tp, false> + { }; + + + + template + struct underlying_type + : public __underlying_type_impl<_Tp> + { }; + + + template + struct __declval_protector + { + static const bool __stop = false; + }; + + + + + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)) + { + static_assert(__declval_protector<_Tp>::__stop, + "declval() must not be used!"); + return __declval<_Tp>(0); + } + + + template + struct result_of; + + + + + struct __invoke_memfun_ref { }; + struct __invoke_memfun_deref { }; + struct __invoke_memobj_ref { }; + struct __invoke_memobj_deref { }; + struct __invoke_other { }; + + + template + struct __result_of_success : __success_type<_Tp> + { using __invoke_type = _Tag; }; + + + struct __result_of_memfun_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_ref + : private __result_of_memfun_ref_impl + { + using type = decltype(_S_test<_MemPtr, _Arg, _Args...>(0)); + }; + + + struct __result_of_memfun_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_deref + : private __result_of_memfun_deref_impl + { + using type = decltype(_S_test<_MemPtr, _Arg, _Args...>(0)); + }; + + + struct __result_of_memobj_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>() + ), __invoke_memobj_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_ref + : private __result_of_memobj_ref_impl + { + using type = decltype(_S_test<_MemPtr, _Arg>(0)); + }; + + + struct __result_of_memobj_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>() + ), __invoke_memobj_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_deref + : private __result_of_memobj_deref_impl + { + using type = decltype(_S_test<_MemPtr, _Arg>(0)); + }; + + template + struct __result_of_memobj; + + template + struct __result_of_memobj<_Res _Class::*, _Arg> + { + using _Argval = __remove_cvref_t<_Arg>; + using _MemPtr = _Res _Class::*; + using type = typename __conditional_t<__or_, + is_base_of<_Class, _Argval>>::value, + __result_of_memobj_ref<_MemPtr, _Arg>, + __result_of_memobj_deref<_MemPtr, _Arg> + >::type; + }; + + template + struct __result_of_memfun; + + template + struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> + { + using _Argval = typename remove_reference<_Arg>::type; + using _MemPtr = _Res _Class::*; + using type = typename __conditional_t::value, + __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, + __result_of_memfun_deref<_MemPtr, _Arg, _Args...> + >::type; + }; + + + + + + + template> + struct __inv_unwrap + { + using type = _Tp; + }; + + template + struct __inv_unwrap<_Tp, reference_wrapper<_Up>> + { + using type = _Up&; + }; + + template + struct __result_of_impl + { + using type = __failure_type; + }; + + template + struct __result_of_impl + : public __result_of_memobj<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type> + { }; + + template + struct __result_of_impl + : public __result_of_memfun<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type, _Args...> + { }; + + + struct __result_of_other_impl + { + template + static __result_of_success()(std::declval<_Args>()...) + ), __invoke_other> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_impl + : private __result_of_other_impl + { + using type = decltype(_S_test<_Functor, _ArgTypes...>(0)); + }; + + + template + struct __invoke_result + : public __result_of_impl< + is_member_object_pointer< + typename remove_reference<_Functor>::type + >::value, + is_member_function_pointer< + typename remove_reference<_Functor>::type + >::value, + _Functor, _ArgTypes... + >::type + { }; + + + template + using __invoke_result_t = typename __invoke_result<_Fn, _Args...>::type; + + + template + struct result_of<_Functor(_ArgTypes...)> + : public __invoke_result<_Functor, _ArgTypes...> + { } __attribute__ ((__deprecated__ ("use '" "std::invoke_result" "' instead"))); + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + template::__type)> + using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; + + template + using aligned_union_t = typename aligned_union<_Len, _Types...>::type; +#pragma GCC diagnostic pop + + + template + using decay_t = typename decay<_Tp>::type; + + + template + using enable_if_t = typename enable_if<_Cond, _Tp>::type; + + + template + using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; + + + template + using common_type_t = typename common_type<_Tp...>::type; + + + template + using underlying_type_t = typename underlying_type<_Tp>::type; + + + template + using result_of_t = typename result_of<_Tp>::type; + + + + + template using void_t = void; +# 2759 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template class _Op, typename... _Args> + struct __detector + { + using type = _Default; + using __is_detected = false_type; + }; + + + template class _Op, + typename... _Args> + struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> + { + using type = _Op<_Args...>; + using __is_detected = true_type; + }; + + template class _Op, + typename... _Args> + using __detected_or = __detector<_Default, void, _Op, _Args...>; + + + + template class _Op, + typename... _Args> + using __detected_or_t + = typename __detected_or<_Default, _Op, _Args...>::type; +# 2801 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template + struct __is_swappable; + + template + struct __is_nothrow_swappable; + + template + struct __is_tuple_like_impl : false_type + { }; + + + template + struct __is_tuple_like + : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type + { }; + + + template + + inline + _Require<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>> + swap(_Tp&, _Tp&) + noexcept(__and_, + is_nothrow_move_assignable<_Tp>>::value); + + template + + inline + __enable_if_t<__is_swappable<_Tp>::value> + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value); + + + namespace __swappable_details { + using std::swap; + + struct __do_is_swappable_impl + { + template(), std::declval<_Tp&>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_impl + : public __swappable_details::__do_is_swappable_impl + { + using type = decltype(__test<_Tp>(0)); + }; + + template + struct __is_nothrow_swappable_impl + : public __swappable_details::__do_is_nothrow_swappable_impl + { + using type = decltype(__test<_Tp>(0)); + }; + + template + struct __is_swappable + : public __is_swappable_impl<_Tp>::type + { }; + + template + struct __is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { }; + + + + + + + template + struct is_swappable + : public __is_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_v = + is_swappable<_Tp>::value; + + + template + inline constexpr bool is_nothrow_swappable_v = + is_nothrow_swappable<_Tp>::value; + + + + namespace __swappable_with_details { + using std::swap; + + struct __do_is_swappable_with_impl + { + template(), std::declval<_Up>())), + typename + = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_with_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) + && + noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_with_impl + : public __swappable_with_details::__do_is_swappable_with_impl + { + using type = decltype(__test<_Tp, _Up>(0)); + }; + + + template + struct __is_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_swappable_impl + { + using type = decltype(__test<_Tp&>(0)); + }; + + template + struct __is_nothrow_swappable_with_impl + : public __swappable_with_details::__do_is_nothrow_swappable_with_impl + { + using type = decltype(__test<_Tp, _Up>(0)); + }; + + + template + struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_nothrow_swappable_impl + { + using type = decltype(__test<_Tp&>(0)); + }; + + + + template + struct is_swappable_with + : public __is_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable_with + : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_with_v = + is_swappable_with<_Tp, _Up>::value; + + + template + inline constexpr bool is_nothrow_swappable_with_v = + is_nothrow_swappable_with<_Tp, _Up>::value; +# 3023 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + template::value, typename = void> + struct __is_invocable_impl + : false_type + { + using __nothrow_conv = false_type; + }; + + + template + struct __is_invocable_impl<_Result, _Ret, + true, + __void_t> + : true_type + { + using __nothrow_conv = true_type; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + + template + struct __is_invocable_impl<_Result, _Ret, + false, + __void_t> + { + private: + + using _Res_t = typename _Result::type; + + + + static _Res_t _S_get() noexcept; + + + template + static void _S_conv(__type_identity_t<_Tp>) noexcept; + + + template(_S_get())), + typename = decltype(_S_conv<_Tp>(_S_get())), + + bool _Dangle = __reference_converts_from_temporary(_Tp, _Res_t) + + + + > + static __bool_constant<_Nothrow && !_Dangle> + _S_test(int); + + template + static false_type + _S_test(...); + + public: + + using type = decltype(_S_test<_Ret, true>(1)); + + + using __nothrow_conv = decltype(_S_test<_Ret>(1)); + }; +#pragma GCC diagnostic pop + + template + struct __is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { }; + + template + constexpr bool __call_is_nt(__invoke_memfun_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept((std::declval<_Up>().*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memfun_deref) + { + return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept(std::declval<_Up>().*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_deref) + { + return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_other) + { + return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); + } + + template + struct __call_is_nothrow + : __bool_constant< + std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) + > + { }; + + template + using __call_is_nothrow_ + = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; + + + template + struct __is_nothrow_invocable + : __and_<__is_invocable<_Fn, _Args...>, + __call_is_nothrow_<_Fn, _Args...>>::type + { }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + struct __nonesuchbase {}; + struct __nonesuch : private __nonesuchbase { + ~__nonesuch() = delete; + __nonesuch(__nonesuch const&) = delete; + void operator=(__nonesuch const&) = delete; + }; +#pragma GCC diagnostic pop + + + + + template + struct invoke_result + : public __invoke_result<_Functor, _ArgTypes...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}), + "_Functor must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; + + + template + struct is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + struct is_invocable_r + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_invocable + : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + + + + template + using __is_nt_invocable_impl + = typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv; + + + + template + struct is_nothrow_invocable_r + : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; +# 3251 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template + inline constexpr bool is_void_v = is_void<_Tp>::value; +template + inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; +template + inline constexpr bool is_integral_v = is_integral<_Tp>::value; +template + inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; + + +template + inline constexpr bool is_array_v = __is_array(_Tp); +# 3272 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template + inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; +template + inline constexpr bool is_lvalue_reference_v = false; +template + inline constexpr bool is_lvalue_reference_v<_Tp&> = true; +template + inline constexpr bool is_rvalue_reference_v = false; +template + inline constexpr bool is_rvalue_reference_v<_Tp&&> = true; + + +template + inline constexpr bool is_member_object_pointer_v = + __is_member_object_pointer(_Tp); + + + + + + + +template + inline constexpr bool is_member_function_pointer_v = + __is_member_function_pointer(_Tp); + + + + + + +template + inline constexpr bool is_enum_v = __is_enum(_Tp); +template + inline constexpr bool is_union_v = __is_union(_Tp); +template + inline constexpr bool is_class_v = __is_class(_Tp); + + + +template + inline constexpr bool is_reference_v = __is_reference(_Tp); +# 3323 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template + inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; +template + inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; + + +template + inline constexpr bool is_object_v = __is_object(_Tp); + + + + + +template + inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; +template + inline constexpr bool is_compound_v = !is_fundamental_v<_Tp>; + + +template + inline constexpr bool is_member_pointer_v = __is_member_pointer(_Tp); + + + + + +template + inline constexpr bool is_const_v = false; +template + inline constexpr bool is_const_v = true; + + +template + inline constexpr bool is_function_v = __is_function(_Tp); +# 3366 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template + inline constexpr bool is_volatile_v = false; +template + inline constexpr bool is_volatile_v = true; + +template + inline constexpr bool is_trivial_v = __is_trivial(_Tp); +template + inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp); +template + inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp); +template + + inline constexpr bool is_pod_v = __is_pod(_Tp); +template + [[__deprecated__]] + inline constexpr bool is_literal_type_v = __is_literal_type(_Tp); +template + inline constexpr bool is_empty_v = __is_empty(_Tp); +template + inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp); +template + inline constexpr bool is_abstract_v = __is_abstract(_Tp); +template + inline constexpr bool is_final_v = __is_final(_Tp); + +template + inline constexpr bool is_signed_v = is_signed<_Tp>::value; +template + inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; + +template + inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...); +template + inline constexpr bool is_default_constructible_v = __is_constructible(_Tp); +template + inline constexpr bool is_copy_constructible_v + = __is_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_move_constructible_v + = __is_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Up); +template + inline constexpr bool is_copy_assignable_v + = __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t); +template + inline constexpr bool is_move_assignable_v + = __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; + +template + inline constexpr bool is_trivially_constructible_v + = __is_trivially_constructible(_Tp, _Args...); +template + inline constexpr bool is_trivially_default_constructible_v + = __is_trivially_constructible(_Tp); +template + inline constexpr bool is_trivially_copy_constructible_v + = __is_trivially_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_constructible_v + = __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_trivially_assignable_v + = __is_trivially_assignable(_Tp, _Up); +template + inline constexpr bool is_trivially_copy_assignable_v + = __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_assignable_v + = __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>); +# 3461 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template + inline constexpr bool is_trivially_destructible_v = + is_trivially_destructible<_Tp>::value; + + +template + inline constexpr bool is_nothrow_constructible_v + = __is_nothrow_constructible(_Tp, _Args...); +template + inline constexpr bool is_nothrow_default_constructible_v + = __is_nothrow_constructible(_Tp); +template + inline constexpr bool is_nothrow_copy_constructible_v + = __is_nothrow_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_constructible_v + = __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_assignable_v + = __is_nothrow_assignable(_Tp, _Up); +template + inline constexpr bool is_nothrow_copy_assignable_v + = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_assignable_v + = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_destructible_v = + is_nothrow_destructible<_Tp>::value; + +template + inline constexpr bool has_virtual_destructor_v + = __has_virtual_destructor(_Tp); + +template + inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; + +template + inline constexpr size_t rank_v = 0; +template + inline constexpr size_t rank_v<_Tp[_Size]> = 1 + rank_v<_Tp>; +template + inline constexpr size_t rank_v<_Tp[]> = 1 + rank_v<_Tp>; + +template + inline constexpr size_t extent_v = 0; +template + inline constexpr size_t extent_v<_Tp[_Size], 0> = _Size; +template + inline constexpr size_t extent_v<_Tp[_Size], _Idx> = extent_v<_Tp, _Idx - 1>; +template + inline constexpr size_t extent_v<_Tp[], 0> = 0; +template + inline constexpr size_t extent_v<_Tp[], _Idx> = extent_v<_Tp, _Idx - 1>; + + +template + inline constexpr bool is_same_v = __is_same(_Tp, _Up); + + + + + + +template + inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived); + +template + inline constexpr bool is_convertible_v = __is_convertible(_From, _To); + + + + +template + inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_v + = is_nothrow_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_invocable_r_v + = is_invocable_r<_Ret, _Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_r_v + = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; + + + + + + + template + struct has_unique_object_representations + : bool_constant<__has_unique_object_representations( + remove_cv_t> + )> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool has_unique_object_representations_v + = has_unique_object_representations<_Tp>::value; + + + + + + + template + struct is_aggregate + : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> + { }; + + + + + + + template + inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>); +# 4017 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 + +} +# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 1 3 +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + inline constexpr _Tp* + __addressof(_Tp& __r) noexcept + { return __builtin_addressof(__r); } +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Tp&&>(__t); } +# 81 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type&& __t) noexcept + { + static_assert(!std::is_lvalue_reference<_Tp>::value, + "std::forward must not be used to convert an rvalue to an lvalue"); + return static_cast<_Tp&&>(__t); + } +# 134 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr typename std::remove_reference<_Tp>::type&& + move(_Tp&& __t) noexcept + { return static_cast::type&&>(__t); } + + + template + struct __move_if_noexcept_cond + : public __and_<__not_>, + is_copy_constructible<_Tp>>::type { }; +# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr + __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&> + move_if_noexcept(_Tp& __x) noexcept + { return std::move(__x); } +# 172 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + [[__nodiscard__]] + inline constexpr _Tp* + addressof(_Tp& __r) noexcept + { return std::__addressof(__r); } + + + + template + const _Tp* addressof(const _Tp&&) = delete; + + + template + + inline _Tp + __exchange(_Tp& __obj, _Up&& __new_val) + { + _Tp __old_val = std::move(__obj); + __obj = std::forward<_Up>(__new_val); + return __old_val; + } +# 216 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 + template + + inline + + typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>>::value>::type + + + + swap(_Tp& __a, _Tp& __b) + noexcept(__and_, is_nothrow_move_assignable<_Tp>>::value) + + { + + + + + _Tp __tmp = std::move(__a); + __a = std::move(__b); + __b = std::move(__tmp); + } + + + + + template + + inline + + typename enable_if<__is_swappable<_Tp>::value>::type + + + + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value) + { + for (size_t __n = 0; __n < _Nm; ++__n) + swap(__a[__n], __b[__n]); + } + + + +} +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 1 3 +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 + +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct tuple_size; + + + + + + template::type, + typename = typename enable_if::value>::type, + size_t = tuple_size<_Tp>::value> + using __enable_if_has_tuple_size = _Tp; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + + template + inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value; + + + + template + struct tuple_element; + + + template + using __tuple_element_t = typename tuple_element<__i, _Tp>::type; + + template + struct tuple_element<__i, const _Tp> + { + using type = const __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, volatile _Tp> + { + using type = volatile __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, const volatile _Tp> + { + using type = const volatile __tuple_element_t<__i, _Tp>; + }; + + + + + + template + constexpr size_t + __find_uniq_type_in_pack() + { + constexpr size_t __sz = sizeof...(_Types); + constexpr bool __found[__sz] = { __is_same(_Tp, _Types) ... }; + size_t __n = __sz; + for (size_t __i = 0; __i < __sz; ++__i) + { + if (__found[__i]) + { + if (__n < __sz) + return __sz; + __n = __i; + } + } + return __n; + } +# 134 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 + template + using tuple_element_t = typename tuple_element<__i, _Tp>::type; + + + + + template struct _Index_tuple { }; + + + template + struct _Build_index_tuple + { +# 154 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 + using __type = _Index_tuple<__integer_pack(_Num)...>; + + }; + + + + + template + struct integer_sequence + { + + + + typedef _Tp value_type; + static constexpr size_t size() noexcept { return sizeof...(_Idx); } + }; + + + template + using make_integer_sequence + + + + = integer_sequence<_Tp, __integer_pack(_Num)...>; + + + + template + using index_sequence = integer_sequence; + + + template + using make_index_sequence = make_integer_sequence; + + + template + using index_sequence_for = make_index_sequence; + + + + + struct in_place_t { + explicit in_place_t() = default; + }; + + inline constexpr in_place_t in_place{}; + + template struct in_place_type_t + { + explicit in_place_type_t() = default; + }; + + template + inline constexpr in_place_type_t<_Tp> in_place_type{}; + + template struct in_place_index_t + { + explicit in_place_index_t() = default; + }; + + template + inline constexpr in_place_index_t<_Idx> in_place_index{}; + + template + inline constexpr bool __is_in_place_type_v = false; + + template + inline constexpr bool __is_in_place_type_v> = true; + + template + using __is_in_place_type = bool_constant<__is_in_place_type_v<_Tp>>; + + template + inline constexpr bool __is_in_place_index_v = false; + + template + inline constexpr bool __is_in_place_index_v> = true; + + + + + template + struct _Nth_type + { using type = __type_pack_element<_Np, _Types...>; }; +# 283 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 + +} +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + struct piecewise_construct_t { explicit piecewise_construct_t() = default; }; + + + inline constexpr piecewise_construct_t piecewise_construct = + piecewise_construct_t(); + + + + + template + struct pair; + + template + class tuple; + + + + + + template + struct array; + + template + struct _Index_tuple; + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(pair<_Tp1, _Tp2>& __in) noexcept; + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(pair<_Tp1, _Tp2>&& __in) noexcept; + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(const pair<_Tp1, _Tp2>& __in) noexcept; + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(const pair<_Tp1, _Tp2>&& __in) noexcept; + + template + constexpr __tuple_element_t<__i, tuple<_Elements...>>& + get(tuple<_Elements...>& __t) noexcept; + + template + constexpr const __tuple_element_t<__i, tuple<_Elements...>>& + get(const tuple<_Elements...>& __t) noexcept; + + template + constexpr __tuple_element_t<__i, tuple<_Elements...>>&& + get(tuple<_Elements...>&& __t) noexcept; + + template + constexpr const __tuple_element_t<__i, tuple<_Elements...>>&& + get(const tuple<_Elements...>&& __t) noexcept; + + template + constexpr _Tp& + get(array<_Tp, _Nm>&) noexcept; + + template + constexpr _Tp&& + get(array<_Tp, _Nm>&&) noexcept; + + template + constexpr const _Tp& + get(const array<_Tp, _Nm>&) noexcept; + + template + constexpr const _Tp&& + get(const array<_Tp, _Nm>&&) noexcept; + + + + + + + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return __and_, + is_constructible<_T2, const _U2&>>::value; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return __and_, + is_convertible>::value; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return __and_, + is_constructible<_T2, _U2&&>>::value; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return __and_, + is_convertible<_U2&&, _T2>>::value; + } + }; + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return false; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return false; + } + }; +# 260 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template class __pair_base + { + + template friend struct pair; + __pair_base() = default; + ~__pair_base() = default; + __pair_base(const __pair_base&) = default; + __pair_base& operator=(const __pair_base&) = delete; + + }; +# 283 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + struct pair + : public __pair_base<_T1, _T2> + { + typedef _T1 first_type; + typedef _T2 second_type; + + _T1 first; + _T2 second; + + + constexpr pair(const pair&) = default; + constexpr pair(pair&&) = default; + + template + + pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); + + + void + swap(pair& __p) + noexcept(__and_<__is_nothrow_swappable<_T1>, + __is_nothrow_swappable<_T2>>::value) + { + using std::swap; + swap(first, __p.first); + swap(second, __p.second); + } +# 331 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + private: + template + + pair(tuple<_Args1...>&, tuple<_Args2...>&, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); + public: +# 719 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template , + __is_implicitly_default_constructible<_U2>> + ::value, bool>::type = true> + constexpr pair() + : first(), second() { } + + template , + is_default_constructible<_U2>, + __not_< + __and_<__is_implicitly_default_constructible<_U1>, + __is_implicitly_default_constructible<_U2>>>> + ::value, bool>::type = false> + explicit constexpr pair() + : first(), second() { } + + + + using _PCCP = _PCC; + + + + template() + && _PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + template() + && !_PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + + template + using _PCCFP = _PCC::value + || !is_same<_T2, _U2>::value, + _T1, _T2>; + + + template::template + _ConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) + { ; } + + template::template + _ConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) + { ; } +# 803 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + private: + + + + struct __zero_as_null_pointer_constant + { + __zero_as_null_pointer_constant(int __zero_as_null_pointer_constant::*) + { } + template::value>> + __zero_as_null_pointer_constant(_Tp) = delete; + }; + + public: + + + + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + is_convertible<_U1, _T1>>::value, + bool> = true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + constexpr + pair(_U1&& __x, __zero_as_null_pointer_constant, ...) + : first(std::forward<_U1>(__x)), second(nullptr) + { ; } + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + __not_>>::value, + bool> = false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + explicit constexpr + pair(_U1&& __x, __zero_as_null_pointer_constant, ...) + : first(std::forward<_U1>(__x)), second(nullptr) + { ; } + + template, + __not_>, + is_constructible<_T2, _U2>, + __not_>, + is_convertible<_U2, _T2>>::value, + bool> = true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + constexpr + pair(__zero_as_null_pointer_constant, _U2&& __y, ...) + : first(nullptr), second(std::forward<_U2>(__y)) + { ; } + + template, + __not_>, + is_constructible<_T2, _U2>, + __not_>, + __not_>>::value, + bool> = false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + explicit constexpr + pair(__zero_as_null_pointer_constant, _U2&& __y, ...) + : first(nullptr), second(std::forward<_U2>(__y)) + { ; } + + + + template() + && _PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) + { ; } + + template() + && !_PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) + { ; } + + + template::template + _MoveConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) + { ; } + + template::template + _MoveConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) + { ; } + + + + pair& + operator=(__conditional_t<__and_, + is_copy_assignable<_T2>>::value, + const pair&, const __nonesuch&> __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + pair& + operator=(__conditional_t<__and_, + is_move_assignable<_T2>>::value, + pair&&, __nonesuch&&> __p) + noexcept(__and_, + is_nothrow_move_assignable<_T2>>::value) + { + first = std::forward(__p.first); + second = std::forward(__p.second); + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, const _U2&>>::value, + pair&>::type + operator=(const pair<_U1, _U2>& __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, _U2&&>>::value, + pair&>::type + operator=(pair<_U1, _U2>&& __p) + { + first = std::forward<_U1>(__p.first); + second = std::forward<_U2>(__p.second); + return *this; + } +# 995 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + }; + + + + + template pair(_T1, _T2) -> pair<_T1, _T2>; +# 1031 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + inline constexpr bool + operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first == __y.first && __x.second == __y.second; } +# 1043 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + inline constexpr bool + operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first < __y.first + || (!(__y.first < __x.first) && __x.second < __y.second); } + + + template + inline constexpr bool + operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x == __y); } + + + template + inline constexpr bool + operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __y < __x; } + + + template + inline constexpr bool + operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__y < __x); } + + + template + inline constexpr bool + operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x < __y); } +# 1080 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + inline + + + typename enable_if<__and_<__is_swappable<_T1>, + __is_swappable<_T2>>::value>::type + + + + swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } +# 1103 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + typename enable_if, + __is_swappable<_T2>>::value>::type + swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete; +# 1129 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + constexpr pair::__type, + typename __decay_and_strip<_T2>::__type> + make_pair(_T1&& __x, _T2&& __y) + { + typedef typename __decay_and_strip<_T1>::__type __ds_type1; + typedef typename __decay_and_strip<_T2>::__type __ds_type2; + typedef pair<__ds_type1, __ds_type2> __pair_type; + return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y)); + } +# 1152 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + template + struct __is_tuple_like_impl> : true_type + { }; + + + + template + struct tuple_size> + : public integral_constant { }; + + + template + struct tuple_element<0, pair<_Tp1, _Tp2>> + { typedef _Tp1 type; }; + + + template + struct tuple_element<1, pair<_Tp1, _Tp2>> + { typedef _Tp2 type; }; + + + + template + struct tuple_element<__i, tuple<_Types...>>; + + + template + inline constexpr size_t tuple_size_v> = 2; + + template + inline constexpr size_t tuple_size_v> = 2; + + template + inline constexpr bool __is_pair = false; + + template + inline constexpr bool __is_pair> = true; + + + + template + struct __pair_get; + + template<> + struct __pair_get<0> + { + template + static constexpr _Tp1& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr _Tp1&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp1>(__pair.first); } + + template + static constexpr const _Tp1& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr const _Tp1&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.first); } + }; + + template<> + struct __pair_get<1> + { + template + static constexpr _Tp2& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr _Tp2&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp2>(__pair.second); } + + template + static constexpr const _Tp2& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr const _Tp2&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.second); } + }; + + + + + + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__get(__in); } + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__move_get(std::move(__in)); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(const pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__const_get(__in); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(const pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__const_move_get(std::move(__in)); } + + + + template + constexpr _Tp& + get(pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr const _Tp& + get(const pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr _Tp&& + get(pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr const _Tp&& + get(const pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr _Tp& + get(pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr const _Tp& + get(const pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr _Tp&& + get(pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } + + template + constexpr const _Tp&& + get(const pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } +# 1332 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 + +} +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 1 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 + +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 +# 74 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 93 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 + struct input_iterator_tag { }; + + + struct output_iterator_tag { }; + + + struct forward_iterator_tag : public input_iterator_tag { }; + + + + struct bidirectional_iterator_tag : public forward_iterator_tag { }; + + + + struct random_access_iterator_tag : public bidirectional_iterator_tag { }; +# 125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 + template + struct [[__deprecated__]] iterator + { + + typedef _Category iterator_category; + + typedef _Tp value_type; + + typedef _Distance difference_type; + + typedef _Pointer pointer; + + typedef _Reference reference; + }; +# 149 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits; + + + + + template> + struct __iterator_traits { }; + + + + template + struct __iterator_traits<_Iterator, + __void_t> + { + typedef typename _Iterator::iterator_category iterator_category; + typedef typename _Iterator::value_type value_type; + typedef typename _Iterator::difference_type difference_type; + typedef typename _Iterator::pointer pointer; + typedef typename _Iterator::reference reference; + }; + + + template + struct iterator_traits + : public __iterator_traits<_Iterator> { }; +# 209 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits<_Tp*> + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef _Tp* pointer; + typedef _Tp& reference; + }; + + + template + struct iterator_traits + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef const _Tp* pointer; + typedef const _Tp& reference; + }; + + + + + + + template + __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_Iter>::iterator_category + __iterator_category(const _Iter&) + { return typename iterator_traits<_Iter>::iterator_category(); } + + + + + template + using __iter_category_t + = typename iterator_traits<_Iter>::iterator_category; + + template + using _RequireInputIter = + __enable_if_t, + input_iterator_tag>::value>; + + template> + struct __is_random_access_iter + : is_base_of + { + typedef is_base_of _Base; + enum { __value = _Base::value }; + }; + + + + + + + + +} +# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 1 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 + +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/concept_check.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/concept_check.h" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/concept_check.h" 3 +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/debug/assertions.h" 1 3 +# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template struct _List_iterator; + template struct _List_const_iterator; + + + template + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + __distance(_InputIterator __first, _InputIterator __last, + input_iterator_tag) + { + + + + typename iterator_traits<_InputIterator>::difference_type __n = 0; + while (__first != __last) + { + ++__first; + ++__n; + } + return __n; + } + + template + __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_RandomAccessIterator>::difference_type + __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, + random_access_iterator_tag) + { + + + + return __last - __first; + } + + + + template + ptrdiff_t + __distance(std::_List_iterator<_Tp>, + std::_List_iterator<_Tp>, + input_iterator_tag); + + template + ptrdiff_t + __distance(std::_List_const_iterator<_Tp>, + std::_List_const_iterator<_Tp>, + input_iterator_tag); + + + + + template + void + __distance(_OutputIterator, _OutputIterator, output_iterator_tag) = delete; +# 144 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 + template + [[__nodiscard__]] __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + distance(_InputIterator __first, _InputIterator __last) + { + + return std::__distance(__first, __last, + std::__iterator_category(__first)); + } + + template + inline constexpr void + __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) + { + + + do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) std::__glibcxx_assert_fail(); } while (false); + while (__n--) + ++__i; + } + + template + inline constexpr void + __advance(_BidirectionalIterator& __i, _Distance __n, + bidirectional_iterator_tag) + { + + + + if (__n > 0) + while (__n--) + ++__i; + else + while (__n++) + --__i; + } + + template + inline constexpr void + __advance(_RandomAccessIterator& __i, _Distance __n, + random_access_iterator_tag) + { + + + + if (__builtin_constant_p(__n) && __n == 1) + ++__i; + else if (__builtin_constant_p(__n) && __n == -1) + --__i; + else + __i += __n; + } + + + + template + void + __advance(_OutputIterator&, _Distance, output_iterator_tag) = delete; +# 217 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 + template + __attribute__((__always_inline__)) + inline constexpr void + advance(_InputIterator& __i, _Distance __n) + { + + typename iterator_traits<_InputIterator>::difference_type __d = __n; + std::__advance(__i, __d, std::__iterator_category(__i)); + } + + + + template + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _InputIterator + next(_InputIterator __x, typename + iterator_traits<_InputIterator>::difference_type __n = 1) + { + + + std::advance(__x, __n); + return __x; + } + + template + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _BidirectionalIterator + prev(_BidirectionalIterator __x, typename + iterator_traits<_BidirectionalIterator>::difference_type __n = 1) + { + + + + std::advance(__x, -__n); + return __x; + } + + + + +} +# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 1 3 +# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/ptr_traits.h" 1 3 +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/ptr_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + class __undefined; + + + + template + struct __get_first_arg + { using type = __undefined; }; + + template class _SomeTemplate, typename _Tp, + typename... _Types> + struct __get_first_arg<_SomeTemplate<_Tp, _Types...>> + { using type = _Tp; }; + + + + template + struct __replace_first_arg + { }; + + template class _SomeTemplate, typename _Up, + typename _Tp, typename... _Types> + struct __replace_first_arg<_SomeTemplate<_Tp, _Types...>, _Up> + { using type = _SomeTemplate<_Up, _Types...>; }; + + + template + struct __ptr_traits_elem : __get_first_arg<_Ptr> + { }; + + + + + + + + template + struct __ptr_traits_elem<_Ptr, __void_t> + { using type = typename _Ptr::element_type; }; + + + template + using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type; + + + + + template::value> + struct __ptr_traits_ptr_to + { + using pointer = _Ptr; + using element_type = _Elt; + + + + + + + + static pointer + pointer_to(element_type& __r) + + + + + + { return pointer::pointer_to(__r); } + }; + + + template + struct __ptr_traits_ptr_to<_Ptr, _Elt, true> + { }; + + + template + struct __ptr_traits_ptr_to<_Tp*, _Tp, false> + { + using pointer = _Tp*; + using element_type = _Tp; + + + + + + + static pointer + pointer_to(element_type& __r) noexcept + { return std::addressof(__r); } + }; + + template + struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt> + { + private: + template + using __diff_t = typename _Tp::difference_type; + + template + using __rebind = __type_identity>; + + public: + + using pointer = _Ptr; + + + using element_type = _Elt; + + + using difference_type = __detected_or_t; + + + template + using rebind = typename __detected_or_t<__replace_first_arg<_Ptr, _Up>, + __rebind, _Ptr, _Up>::type; + }; + + + + template + struct __ptr_traits_impl<_Ptr, __undefined> + { }; + + + + + + + + template + struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>> + { }; + + + + + + + + template + struct pointer_traits<_Tp*> : __ptr_traits_ptr_to<_Tp*, _Tp> + { + + typedef _Tp* pointer; + + typedef _Tp element_type; + + typedef ptrdiff_t difference_type; + + template using rebind = _Up*; + }; + + + template + using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>; + + template + constexpr _Tp* + __to_address(_Tp* __ptr) noexcept + { + static_assert(!std::is_function<_Tp>::value, "not a function pointer"); + return __ptr; + } + + + template + constexpr typename std::pointer_traits<_Ptr>::element_type* + __to_address(const _Ptr& __ptr) + { return std::__to_address(__ptr.operator->()); } +# 257 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/ptr_traits.h" 3 + +} +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 2 3 +# 85 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 106 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + +# 106 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 128 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class reverse_iterator + : public iterator::iterator_category, + typename iterator_traits<_Iterator>::value_type, + typename iterator_traits<_Iterator>::difference_type, + typename iterator_traits<_Iterator>::pointer, + typename iterator_traits<_Iterator>::reference> + { + template + friend class reverse_iterator; +# 147 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + protected: + _Iterator current; + + typedef iterator_traits<_Iterator> __traits_type; + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::pointer pointer; + + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; +# 178 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + constexpr + reverse_iterator() + noexcept(noexcept(_Iterator())) + : current() + { } + + + + + explicit constexpr + reverse_iterator(iterator_type __x) + noexcept(noexcept(_Iterator(__x))) + : current(__x) + { } + + + + + constexpr + reverse_iterator(const reverse_iterator& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + reverse_iterator& operator=(const reverse_iterator&) = default; + + + + + + + template + + + + constexpr + reverse_iterator(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + template + + + + + constexpr + reverse_iterator& + operator=(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(current = __x.current)) + { + current = __x.current; + return *this; + } + + + + + + [[__nodiscard__]] + constexpr iterator_type + base() const + noexcept(noexcept(_Iterator(current))) + { return current; } +# 255 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + { + _Iterator __tmp = current; + return *--__tmp; + } + + + + + + + [[__nodiscard__]] + constexpr pointer + operator->() const + + + + + { + + + _Iterator __tmp = current; + --__tmp; + return _S_to_pointer(__tmp); + } + + + + + + + constexpr reverse_iterator& + operator++() + { + --current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator++(int) + { + reverse_iterator __tmp = *this; + --current; + return __tmp; + } + + + + + + + constexpr reverse_iterator& + operator--() + { + ++current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator--(int) + { + reverse_iterator __tmp = *this; + ++current; + return __tmp; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator+(difference_type __n) const + { return reverse_iterator(current - __n); } + + + + + + + + constexpr reverse_iterator& + operator+=(difference_type __n) + { + current -= __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator-(difference_type __n) const + { return reverse_iterator(current + __n); } + + + + + + + + constexpr reverse_iterator& + operator-=(difference_type __n) + { + current += __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + { return *(*this + __n); } +# 415 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + private: + template + static constexpr _Tp* + _S_to_pointer(_Tp* __p) + { return __p; } + + template + static constexpr pointer + _S_to_pointer(_Tp __t) + { return __t.operator->(); } + }; +# 438 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator==(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y.base() < __x.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() == __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() > __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() != __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() < __y.base(); } + + template + inline constexpr bool + operator<=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() >= __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() <= __y.base(); } +# 615 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr auto + operator-(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + -> decltype(__y.base() - __x.base()) + { return __y.base() - __x.base(); } + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Iterator> + operator+(typename reverse_iterator<_Iterator>::difference_type __n, + const reverse_iterator<_Iterator>& __x) + { return reverse_iterator<_Iterator>(__x.base() - __n); } + + + + template + inline constexpr reverse_iterator<_Iterator> + __make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Iterator> + make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } +# 657 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + + auto + __niter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__niter_base(__it.base()))) + { return __make_reverse_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + : __is_move_iterator<_Iterator> + { }; + + template + + auto + __miter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__miter_base(__it.base()))) + { return __make_reverse_iterator(__miter_base(__it.base())); } +# 688 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class back_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + explicit + back_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 726 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + + back_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_back(__value); + return *this; + } + + + back_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_back(std::move(__value)); + return *this; + } + + + + [[__nodiscard__]] + back_insert_iterator& + operator*() + { return *this; } + + + + back_insert_iterator& + operator++() + { return *this; } + + + + back_insert_iterator + operator++(int) + { return *this; } + }; +# 773 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline back_insert_iterator<_Container> + back_inserter(_Container& __x) + { return back_insert_iterator<_Container>(__x); } +# 789 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class front_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + explicit + front_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 827 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + + front_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_front(__value); + return *this; + } + + + front_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_front(std::move(__value)); + return *this; + } + + + + [[__nodiscard__]] + front_insert_iterator& + operator*() + { return *this; } + + + + front_insert_iterator& + operator++() + { return *this; } + + + + front_insert_iterator + operator++(int) + { return *this; } + }; +# 874 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline front_insert_iterator<_Container> + front_inserter(_Container& __x) + { return front_insert_iterator<_Container>(__x); } +# 894 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class insert_iterator + : public iterator + { + + + + typedef typename _Container::iterator _Iter; + + protected: + _Container* container; + _Iter iter; + + public: + + typedef _Container container_type; +# 919 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + + insert_iterator(_Container& __x, _Iter __i) + : container(std::__addressof(__x)), iter(__i) {} +# 955 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + + insert_iterator& + operator=(const typename _Container::value_type& __value) + { + iter = container->insert(iter, __value); + ++iter; + return *this; + } + + + insert_iterator& + operator=(typename _Container::value_type&& __value) + { + iter = container->insert(iter, std::move(__value)); + ++iter; + return *this; + } + + + + [[__nodiscard__]] + insert_iterator& + operator*() + { return *this; } + + + + insert_iterator& + operator++() + { return *this; } + + + + insert_iterator& + operator++(int) + { return *this; } + }; + +#pragma GCC diagnostic pop +# 1014 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline insert_iterator<_Container> + inserter(_Container& __x, typename _Container::iterator __i) + { return insert_iterator<_Container>(__x, __i); } + + + + + +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 1037 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class __normal_iterator + { + protected: + _Iterator _M_current; + + typedef std::iterator_traits<_Iterator> __traits_type; + + + template + using __convertible_from + = std::__enable_if_t::value>; + + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; + typedef typename __traits_type::pointer pointer; + + + + + + constexpr __normal_iterator() noexcept + : _M_current(_Iterator()) { } + + explicit + __normal_iterator(const _Iterator& __i) noexcept + : _M_current(__i) { } + + + + template> + + __normal_iterator(const __normal_iterator<_Iter, _Container>& __i) + noexcept +# 1085 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + : _M_current(__i.base()) { } + + + + reference + operator*() const noexcept + { return *_M_current; } + + + pointer + operator->() const noexcept + { return _M_current; } + + + __normal_iterator& + operator++() noexcept + { + ++_M_current; + return *this; + } + + + __normal_iterator + operator++(int) noexcept + { return __normal_iterator(_M_current++); } + + + + __normal_iterator& + operator--() noexcept + { + --_M_current; + return *this; + } + + + __normal_iterator + operator--(int) noexcept + { return __normal_iterator(_M_current--); } + + + + reference + operator[](difference_type __n) const noexcept + { return _M_current[__n]; } + + + __normal_iterator& + operator+=(difference_type __n) noexcept + { _M_current += __n; return *this; } + + + __normal_iterator + operator+(difference_type __n) const noexcept + { return __normal_iterator(_M_current + __n); } + + + __normal_iterator& + operator-=(difference_type __n) noexcept + { _M_current -= __n; return *this; } + + + __normal_iterator + operator-(difference_type __n) const noexcept + { return __normal_iterator(_M_current - __n); } + + + const _Iterator& + base() const noexcept + { return _M_current; } + }; +# 1205 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline bool + operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator==(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + + + + + + template + + + [[__nodiscard__]] + inline auto + operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept + -> decltype(__lhs.base() - __rhs.base()) + + + + + + { return __lhs.base() - __rhs.base(); } + + template + [[__nodiscard__]] + inline typename __normal_iterator<_Iterator, _Container>::difference_type + operator-(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() - __rhs.base(); } + + template + [[__nodiscard__]] + inline __normal_iterator<_Iterator, _Container> + operator+(typename __normal_iterator<_Iterator, _Container>::difference_type + __n, const __normal_iterator<_Iterator, _Container>& __i) + noexcept + { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } + + +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + + _Iterator + __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it.base(); } + + + + + + + template + constexpr auto + __to_address(const __gnu_cxx::__normal_iterator<_Iterator, + _Container>& __it) noexcept + -> decltype(std::__to_address(__it.base())) + { return std::__to_address(__it.base()); } +# 1412 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + namespace __detail + { +# 1428 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + } +# 1439 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + class move_iterator + + + + { + _Iterator _M_current; + + using __traits_type = iterator_traits<_Iterator>; + + using __base_ref = typename __traits_type::reference; + + + template + friend class move_iterator; +# 1478 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + public: + using iterator_type = _Iterator; +# 1490 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + + typedef _Iterator pointer; + + + using reference + = __conditional_t::value, + typename remove_reference<__base_ref>::type&&, + __base_ref>; + + + constexpr + move_iterator() + : _M_current() { } + + explicit constexpr + move_iterator(iterator_type __i) + : _M_current(std::move(__i)) { } + + template + + + + constexpr + move_iterator(const move_iterator<_Iter>& __i) + : _M_current(__i._M_current) { } + + template + + + + + constexpr + move_iterator& operator=(const move_iterator<_Iter>& __i) + { + _M_current = __i._M_current; + return *this; + } + + + [[__nodiscard__]] + constexpr iterator_type + base() const + { return _M_current; } +# 1548 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + + + + { return static_cast(*_M_current); } + + + [[__nodiscard__]] + constexpr pointer + operator->() const + { return _M_current; } + + constexpr move_iterator& + operator++() + { + ++_M_current; + return *this; + } + + constexpr move_iterator + operator++(int) + { + move_iterator __tmp = *this; + ++_M_current; + return __tmp; + } + + + + + + + + constexpr move_iterator& + operator--() + { + --_M_current; + return *this; + } + + constexpr move_iterator + operator--(int) + { + move_iterator __tmp = *this; + --_M_current; + return __tmp; + } + + [[__nodiscard__]] + constexpr move_iterator + operator+(difference_type __n) const + { return move_iterator(_M_current + __n); } + + constexpr move_iterator& + operator+=(difference_type __n) + { + _M_current += __n; + return *this; + } + + [[__nodiscard__]] + constexpr move_iterator + operator-(difference_type __n) const + { return move_iterator(_M_current - __n); } + + constexpr move_iterator& + operator-=(difference_type __n) + { + _M_current -= __n; + return *this; + } + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + + + + { return std::move(_M_current[__n]); } +# 1662 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + }; + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() == __y.base(); } +# 1683 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return !(__x == __y); } + + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() < __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + + { return __x.base() == __y.base(); } +# 1750 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() < __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + template + [[__nodiscard__]] + inline constexpr auto + operator-(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + -> decltype(__x.base() - __y.base()) + { return __x.base() - __y.base(); } + + template + [[__nodiscard__]] + inline constexpr move_iterator<_Iterator> + operator+(typename move_iterator<_Iterator>::difference_type __n, + const move_iterator<_Iterator>& __x) + + + + { return __x + __n; } + + template + [[__nodiscard__]] + inline constexpr move_iterator<_Iterator> + make_move_iterator(_Iterator __i) + { return move_iterator<_Iterator>(std::move(__i)); } + + template::value_type>::value, + _Iterator, move_iterator<_Iterator>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Iterator __i) + { return _ReturnType(__i); } + + + + template::value, + const _Tp*, move_iterator<_Tp*>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Tp* __i) + { return _ReturnType(__i); } +# 2964 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + + auto + __niter_base(move_iterator<_Iterator> __it) + -> decltype(make_move_iterator(__niter_base(__it.base()))) + { return make_move_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template + + auto + __miter_base(move_iterator<_Iterator> __it) + -> decltype(__miter_base(__it.base())) + { return __miter_base(__it.base()); } +# 2996 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 + template + using __iter_key_t = remove_const_t< + + + + typename iterator_traits<_InputIterator>::value_type::first_type>; + + + template + using __iter_val_t + + + + = typename iterator_traits<_InputIterator>::value_type::second_type; + + + template + struct pair; + + template + using __iter_to_alloc_t + = pair, __iter_val_t<_InputIterator>>; + + + +} +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/debug/debug.h" 1 3 +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/debug/debug.h" 3 +namespace std +{ + namespace __debug { } +} + + + + +namespace __gnu_debug +{ + using namespace std::__debug; + + template + struct _Safe_iterator; +} +# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/predefined_ops.h" 1 3 +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/predefined_ops.h" 3 +namespace __gnu_cxx +{ +namespace __ops +{ + struct _Iter_less_iter + { + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 < *__it2; } + }; + + constexpr + inline _Iter_less_iter + __iter_less_iter() + { return _Iter_less_iter(); } + + struct _Iter_less_val + { + + constexpr _Iter_less_val() = default; + + + + + + explicit + _Iter_less_val(_Iter_less_iter) { } + + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it < __val; } + }; + + + inline _Iter_less_val + __iter_less_val() + { return _Iter_less_val(); } + + + inline _Iter_less_val + __iter_comp_val(_Iter_less_iter) + { return _Iter_less_val(); } + + struct _Val_less_iter + { + + constexpr _Val_less_iter() = default; + + + + + + explicit + _Val_less_iter(_Iter_less_iter) { } + + template + + bool + operator()(_Value& __val, _Iterator __it) const + { return __val < *__it; } + }; + + + inline _Val_less_iter + __val_less_iter() + { return _Val_less_iter(); } + + + inline _Val_less_iter + __val_comp_iter(_Iter_less_iter) + { return _Val_less_iter(); } + + struct _Iter_equal_to_iter + { + template + + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 == *__it2; } + }; + + + inline _Iter_equal_to_iter + __iter_equal_to_iter() + { return _Iter_equal_to_iter(); } + + struct _Iter_equal_to_val + { + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it == __val; } + }; + + + inline _Iter_equal_to_val + __iter_equal_to_val() + { return _Iter_equal_to_val(); } + + + inline _Iter_equal_to_val + __iter_comp_val(_Iter_equal_to_iter) + { return _Iter_equal_to_val(); } + + template + struct _Iter_comp_iter + { + _Compare _M_comp; + + explicit constexpr + _Iter_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) + { return bool(_M_comp(*__it1, *__it2)); } + }; + + template + constexpr + inline _Iter_comp_iter<_Compare> + __iter_comp_iter(_Compare __comp) + { return _Iter_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_comp_val + { + _Compare _M_comp; + + + explicit + _Iter_comp_val(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Iterator __it, _Value& __val) + { return bool(_M_comp(*__it, __val)); } + }; + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Compare __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Iter_comp_iter<_Compare> __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + struct _Val_comp_iter + { + _Compare _M_comp; + + + explicit + _Val_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Value& __val, _Iterator __it) + { return bool(_M_comp(__val, *__it)); } + }; + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Compare __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Iter_comp_iter<_Compare> __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_equals_val + { + _Value& _M_value; + + + explicit + _Iter_equals_val(_Value& __value) + : _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return *__it == _M_value; } + }; + + template + + inline _Iter_equals_val<_Value> + __iter_equals_val(_Value& __val) + { return _Iter_equals_val<_Value>(__val); } + + template + struct _Iter_equals_iter + { + _Iterator1 _M_it1; + + + explicit + _Iter_equals_iter(_Iterator1 __it1) + : _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return *__it2 == *_M_it1; } + }; + + template + + inline _Iter_equals_iter<_Iterator> + __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) + { return _Iter_equals_iter<_Iterator>(__it); } + + template + struct _Iter_pred + { + _Predicate _M_pred; + + + explicit + _Iter_pred(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_pred<_Predicate> + __pred_iter(_Predicate __pred) + { return _Iter_pred<_Predicate>(std::move(__pred)); } + + template + struct _Iter_comp_to_val + { + _Compare _M_comp; + _Value& _M_value; + + + _Iter_comp_to_val(_Compare __comp, _Value& __value) + : _M_comp(std::move(__comp)), _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_comp(*__it, _M_value)); } + }; + + template + _Iter_comp_to_val<_Compare, _Value> + + __iter_comp_val(_Compare __comp, _Value &__val) + { + return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val); + } + + template + struct _Iter_comp_to_iter + { + _Compare _M_comp; + _Iterator1 _M_it1; + + + _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) + : _M_comp(std::move(__comp)), _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return bool(_M_comp(*__it2, *_M_it1)); } + }; + + template + + inline _Iter_comp_to_iter<_Compare, _Iterator> + __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) + { + return _Iter_comp_to_iter<_Compare, _Iterator>( + std::move(__comp._M_comp), __it); + } + + template + struct _Iter_negate + { + _Predicate _M_pred; + + + explicit + _Iter_negate(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return !bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_negate<_Predicate> + __negate(_Iter_pred<_Predicate> __pred) + { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } + +} +} +# 72 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 + +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/concepts" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/concepts" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/concepts" 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/concepts" 2 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 2 3 +# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 + template + constexpr _Tp + __rotl(_Tp __x, int __s) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) == 0) + { + + + constexpr unsigned __uNd = _Nd; + const unsigned __r = __s; + return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd)); + } + const int __r = __s % _Nd; + if (__r == 0) + return __x; + else if (__r > 0) + return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); + else + return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); + } + + template + constexpr _Tp + __rotr(_Tp __x, int __s) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) == 0) + { + + + constexpr unsigned __uNd = _Nd; + const unsigned __r = __s; + return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd)); + } + const int __r = __s % _Nd; + if (__r == 0) + return __x; + else if (__r > 0) + return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); + else + return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); + } + + template + constexpr int + __countl_zero(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + if (__x == 0) + return _Nd; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + { + constexpr int __diff = _Nd_u - _Nd; + return __builtin_clz(__x) - __diff; + } + else if constexpr (_Nd <= _Nd_ul) + { + constexpr int __diff = _Nd_ul - _Nd; + return __builtin_clzl(__x) - __diff; + } + else if constexpr (_Nd <= _Nd_ull) + { + constexpr int __diff = _Nd_ull - _Nd; + return __builtin_clzll(__x) - __diff; + } + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + unsigned long long __high = __x >> _Nd_ull; + if (__high != 0) + { + constexpr int __diff = (2 * _Nd_ull) - _Nd; + return __builtin_clzll(__high) - __diff; + } + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + return (_Nd - _Nd_ull) + __builtin_clzll(__low); + } + } + + template + constexpr int + __countl_one(_Tp __x) noexcept + { + return std::__countl_zero<_Tp>((_Tp)~__x); + } + + template + constexpr int + __countr_zero(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + if (__x == 0) + return _Nd; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + return __builtin_ctz(__x); + else if constexpr (_Nd <= _Nd_ul) + return __builtin_ctzl(__x); + else if constexpr (_Nd <= _Nd_ull) + return __builtin_ctzll(__x); + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + if (__low != 0) + return __builtin_ctzll(__low); + unsigned long long __high = __x >> _Nd_ull; + return __builtin_ctzll(__high) + _Nd_ull; + } + } + + template + constexpr int + __countr_one(_Tp __x) noexcept + { + return std::__countr_zero((_Tp)~__x); + } + + template + constexpr int + __popcount(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + return __builtin_popcount(__x); + else if constexpr (_Nd <= _Nd_ul) + return __builtin_popcountl(__x); + else if constexpr (_Nd <= _Nd_ull) + return __builtin_popcountll(__x); + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + unsigned long long __high = __x >> _Nd_ull; + return __builtin_popcountll(__low) + __builtin_popcountll(__high); + } + } + + template + constexpr bool + __has_single_bit(_Tp __x) noexcept + { return std::__popcount(__x) == 1; } + + template + constexpr _Tp + __bit_ceil(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + if (__x == 0 || __x == 1) + return 1; + auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u)); + + + + + if (!std::__is_constant_evaluated()) + { + do { if (std::__is_constant_evaluated() && !bool(__shift_exponent != __int_traits<_Tp>::__digits)) std::__glibcxx_assert_fail(); } while (false); + } + + using __promoted_type = decltype(__x << 1); + if constexpr (!is_same<__promoted_type, _Tp>::value) + { + + + + + + const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; + __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; + } + return (_Tp)1u << __shift_exponent; + } + + template + constexpr _Tp + __bit_floor(_Tp __x) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if (__x == 0) + return 0; + return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1))); + } + + template + constexpr int + __bit_width(_Tp __x) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + return _Nd - std::__countl_zero(__x); + } +# 482 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 + +} +# 77 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + template + constexpr + inline int + __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num) + { + + static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp"); +# 108 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); + } +# 152 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline void + iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) + { + + + + +# 185 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + swap(*__a, *__b); + + } +# 201 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + _ForwardIterator2 + swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + std::iter_swap(__first1, __first2); + return __first2; + } +# 230 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b) + { + + + + if (__b < __a) + return __b; + return __a; + } +# 254 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b) + { + + + + if (__a < __b) + return __b; + return __a; + } +# 278 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__b, __a)) + return __b; + return __a; + } +# 300 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__a, __b)) + return __b; + return __a; + } + + + + template + + inline _Iterator + __niter_base(_Iterator __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it; } +# 332 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + decltype(std::__niter_base(std::declval<_Ite>())) + __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, + std::random_access_iterator_tag>&) + noexcept(std::is_nothrow_copy_constructible<_Ite>::value); + + + + + + template + + inline _From + __niter_wrap(_From __from, _To __res) + { return __from + (std::__niter_base(__res) - std::__niter_base(__from)); } + + + template + + inline _Iterator + __niter_wrap(const _Iterator&, _Iterator __res) + { return __res; } + + + + + + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = *__first; + return __result; + } + }; + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = std::move(*__first); + return __result; + } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = *__first; + ++__first; + ++__result; + } + return __result; + } + + template + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to = *__from; } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = std::move(*__first); + ++__first; + ++__result; + } + return __result; + } + + template + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to = std::move(*__from); } + }; + + + template + struct __copy_move<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_m(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num = __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); + else if (_Num == 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result, __first); + return __result + _Num; + } + }; + + + + template + struct _Deque_iterator; + + struct _Bit_iterator; + + + + + + + template + struct char_traits; + + template + class istreambuf_iterator; + + template + class ostreambuf_iterator; + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(_CharT*, _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(const _CharT*, const _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + _CharT*>::__type + __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_move_a2( + istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>); + + + template + + inline _OI + __copy_move_a2(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::iterator_category _Category; + + + + + + return std::__copy_move<_IsMove, __memcpyable<_OI, _II>::__value, + _Category>::__copy_m(__first, __last, __result); + } + + template + _OI + __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + std::_Deque_iterator<_OTp, _OTp&, _OTp*> + __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_OTp, _OTp&, _OTp*>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, + std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + + inline _OI + __copy_move_a1(_II __first, _II __last, _OI __result) + { return std::__copy_move_a2<_IsMove>(__first, __last, __result); } + + template + + inline _OI + __copy_move_a(_II __first, _II __last, _OI __result) + { + return std::__niter_wrap(__result, + std::__copy_move_a1<_IsMove>(std::__niter_base(__first), + std::__niter_base(__last), + std::__niter_base(__result))); + } + + template + + _OI + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + + ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); + + template + + _OutputIterator + __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, + bool) + { + if (__n > 0) + { + while (true) + { + *__result = *__first; + ++__result; + if (--__n > 0) + ++__first; + else + break; + } + } + return __result; + } + + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, _CharT*>::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, + _Size, _CharT*, bool); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, _Size, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>, + bool); +# 639 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _OI + copy(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a<__is_move_iterator<_II>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 672 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _OI + move(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a(std::__miter_base(__first), + std::__miter_base(__last), __result); + } + + + + + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = *--__last; + return __result; + } + }; + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n = __last - __first; + for (; __n > 0; --__n) + *--__result = *--__last; + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n = __last - __first; + for (; __n > 0; --__n) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template + struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_move_b(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num = __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); + else if (_Num == 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result - 1, __first); + return __result - _Num; + } + }; + + template + + inline _BI2 + __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) + { + typedef typename iterator_traits<_BI1>::iterator_category _Category; + + + + + + return std::__copy_move_backward<_IsMove, + __memcpyable<_BI2, _BI1>::__value, + _Category>::__copy_move_b(__first, + __last, + __result); + } + + template + + inline _BI2 + __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) + { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); } + + template + _OI + __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + std::_Deque_iterator<_OTp, _OTp&, _OTp*> + __copy_move_backward_a1( + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_OTp, _OTp&, _OTp*>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, + std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __copy_move_backward_a1(_II, _II, + std::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + + inline _OI + __copy_move_backward_a(_II __first, _II __last, _OI __result) + { + return std::__niter_wrap(__result, + std::__copy_move_backward_a1<_IsMove> + (std::__niter_base(__first), std::__niter_base(__last), + std::__niter_base(__result))); + } + + template + + _OI + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_backward_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + + ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); +# 875 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _BI2 + copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + ; + + return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 910 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _BI2 + move_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + ; + + return std::__copy_move_backward_a(std::__miter_base(__first), + std::__miter_base(__last), + __result); + } + + + + + + + template + + inline typename + __gnu_cxx::__enable_if::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + for (; __first != __last; ++__first) + *__first = __value; + } + + template + + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __first != __last; ++__first) + *__first = __tmp; + } + + + template + + inline typename + __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type + __fill_a1(_Tp* __first, _Tp* __last, const _Tp& __c) + { + const _Tp __tmp = __c; +# 971 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + if (const size_t __len = __last - __first) + __builtin_memset(__first, static_cast(__tmp), __len); + } + + template + + inline void + __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first, + ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last, + const _Tp& __value) + { std::__fill_a1(__first.base(), __last.base(), __value); } + + template + void + __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const _VTp&); + + + void + __fill_a1(std::_Bit_iterator, std::_Bit_iterator, + const bool&); + + template + + inline void + __fill_a(_FIte __first, _FIte __last, const _Tp& __value) + { std::__fill_a1(__first, __last, __value); } + + template + + void + __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const _Tp&); +# 1019 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline void + fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) + { + + + + ; + + std::__fill_a(__first, __last, __value); + } + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wlong-long" + + inline constexpr int + __size_to_integer(int __n) { return __n; } + inline constexpr unsigned + __size_to_integer(unsigned __n) { return __n; } + inline constexpr long + __size_to_integer(long __n) { return __n; } + inline constexpr unsigned long + __size_to_integer(unsigned long __n) { return __n; } + inline constexpr long long + __size_to_integer(long long __n) { return __n; } + inline constexpr unsigned long long + __size_to_integer(unsigned long long __n) { return __n; } + + + __extension__ inline constexpr __int128 + __size_to_integer(__int128 __n) { return __n; } + __extension__ inline constexpr unsigned __int128 + __size_to_integer(unsigned __int128 __n) { return __n; } +# 1073 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + inline constexpr long long + __size_to_integer(float __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(double __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(long double __n) { return (long long)__n; } + + __extension__ inline constexpr long long + __size_to_integer(__float128 __n) { return (long long)__n; } + +#pragma GCC diagnostic pop + + template + + inline typename + __gnu_cxx::__enable_if::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + for (; __n > 0; --__n, (void) ++__first) + *__first = __value; + return __first; + } + + template + + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __n > 0; --__n, (void) ++__first) + *__first = __tmp; + return __first; + } + + template + + ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first, + _Size __n, const _Tp& __value, + std::input_iterator_tag); + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::output_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + return __fill_n_a1(__first, __n, __value); + } + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::input_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + return __fill_n_a1(__first, __n, __value); + } + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::random_access_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + if (__n <= 0) + return __first; + + ; + + std::__fill_a(__first, __first + __n, __value); + return __first + __n; + } +# 1175 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _OI + fill_n(_OI __first, _Size __n, const _Tp& __value) + { + + + + return std::__fill_n_a(__first, std::__size_to_integer(__n), __value, + std::__iterator_category(__first)); + } + + template + struct __equal + { + template + + static bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + for (; __first1 != __last1; ++__first1, (void) ++__first2) + if (!(*__first1 == *__first2)) + return false; + return true; + } + }; + + template<> + struct __equal + { + template + + static bool + equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) + { + if (const size_t __len = (__last1 - __first1)) + return !std::__memcmp(__first1, __first2, __len); + return true; + } + }; + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _II); + + template + bool + __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(_II, _II, + std::_Deque_iterator<_Tp, _Ref, _Ptr>); + + template + + inline bool + __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + const bool __simple = ((__is_integer<_ValueType1>::__value + || __is_pointer<_ValueType1>::__value) + && __memcmpable<_II1, _II2>::__value); + return std::__equal<__simple>::equal(__first1, __last1, __first2); + } + + template + + inline bool + __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) + { + return std::__equal_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2)); + } + + template + + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + _II2); + + template + + bool + __equal_aux(_II1, _II1, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + struct __lc_rai + { + template + + static _II1 + __newlast1(_II1, _II1 __last1, _II2, _II2) + { return __last1; } + + template + + static bool + __cnd2(_II __first, _II __last) + { return __first != __last; } + }; + + template<> + struct __lc_rai + { + template + + static _RAI1 + __newlast1(_RAI1 __first1, _RAI1 __last1, + _RAI2 __first2, _RAI2 __last2) + { + const typename iterator_traits<_RAI1>::difference_type + __diff1 = __last1 - __first1; + const typename iterator_traits<_RAI2>::difference_type + __diff2 = __last2 - __first2; + return __diff2 < __diff1 ? __first1 + __diff2 : __last1; + } + + template + static bool + __cnd2(_RAI, _RAI) + { return true; } + }; + + template + + bool + __lexicographical_compare_impl(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, + _Compare __comp) + { + typedef typename iterator_traits<_II1>::iterator_category _Category1; + typedef typename iterator_traits<_II2>::iterator_category _Category2; + typedef std::__lc_rai<_Category1, _Category2> __rai_type; + + __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); + for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); + ++__first1, (void)++__first2) + { + if (__comp(__first1, __first2)) + return true; + if (__comp(__first2, __first1)) + return false; + } + return __first1 == __last1 && __first2 != __last2; + } + + template + struct __lexicographical_compare + { + template + + static bool + __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using __gnu_cxx::__ops::__iter_less_iter; + return std::__lexicographical_compare_impl(__first1, __last1, + __first2, __last2, + __iter_less_iter()); + } + + template + + static int + __3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + while (__first1 != __last1) + { + if (__first2 == __last2) + return +1; + if (*__first1 < *__first2) + return -1; + if (*__first2 < *__first1) + return +1; + ++__first1; + ++__first2; + } + return int(__first2 == __last2) - 1; + } + }; + + template<> + struct __lexicographical_compare + { + template + + static bool + __lc(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { return __3way(__first1, __last1, __first2, __last2) < 0; } + + template + + static ptrdiff_t + __3way(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { + const size_t __len1 = __last1 - __first1; + const size_t __len2 = __last2 - __first2; + if (const size_t __len = std::min(__len1, __len2)) + if (int __result = std::__memcmp(__first1, __first2, __len)) + return __result; + return ptrdiff_t(__len1 - __len2); + } + }; + + template + + inline bool + __lexicographical_compare_aux1(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + typedef typename iterator_traits<_II2>::value_type _ValueType2; + const bool __simple = + (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value + && __is_pointer<_II1>::__value + && __is_pointer<_II2>::__value + + + + + + + + ); + + return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, + __first2, __last2); + } + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + _Tp2*, _Tp2*); + + template + bool + __lexicographical_compare_aux1(_Tp1*, _Tp1*, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + + inline bool + __lexicographical_compare_aux(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + return std::__lexicographical_compare_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2), + std::__niter_base(__last2)); + } + + template + + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + _II2, _II2); + + template + + bool + __lexicographical_compare_aux( + _II1, _II1, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + + _ForwardIterator + __lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len = std::distance(__first, __last); + + while (__len > 0) + { + _DistanceType __half = __len >> 1; + _ForwardIterator __middle = __first; + std::advance(__middle, __half); + if (__comp(__middle, __val)) + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + else + __len = __half; + } + return __first; + } +# 1527 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline _ForwardIterator + lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + + + + + ; + + return std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val()); + } + + + + template + inline constexpr _Tp + __lg(_Tp __n) + { + + return std::__bit_width(make_unsigned_t<_Tp>(__n)) - 1; +# 1563 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + } + + +# 1579 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + + + + + + + ; + + return std::__equal_aux(__first1, __last1, __first2); + } +# 1610 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return true; + } + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++17-extensions" + + + template + + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if constexpr (_RAIters::value) + { + if ((__last1 - __first1) != (__last2 - __first2)) + return false; + return std::equal(__first1, __last1, __first2); + } + else + { + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!(*__first1 == *__first2)) + return false; + return __first1 == __last1 && __first2 == __last2; + } + } + + + template + + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, + _BinaryPredicate __binary_pred) + { + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if constexpr (_RAIters::value) + { + if ((__last1 - __first1) != (__last2 - __first2)) + return false; + return std::equal(__first1, __last1, __first2, + __binary_pred); + } + else + { + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return __first1 == __last1 && __first2 == __last2; + } + } +#pragma GCC diagnostic pop +# 1701 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + + + + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2); + } +# 1734 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2, + __binary_pred); + } +# 1766 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + + + + + + + + + + ; + ; + + return std::__lexicographical_compare_aux(__first1, __last1, + __first2, __last2); + } +# 1801 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, _Compare __comp) + { + + + + ; + ; + + return std::__lexicographical_compare_impl + (__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 1916 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 1944 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2) + { + + + + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 1978 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + template + + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __first2 != __last2 + && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 2026 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2) + { + + + + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 2062 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + [[__nodiscard__]] + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + + + template + + inline _InputIterator + __find_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred, input_iterator_tag) + { + while (__first != __last && !__pred(__first)) + ++__first; + return __first; + } + + + template + + _RandomAccessIterator + __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Predicate __pred, random_access_iterator_tag) + { + typename iterator_traits<_RandomAccessIterator>::difference_type + __trip_count = (__last - __first) >> 2; + + for (; __trip_count > 0; --__trip_count) + { + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + } + + switch (__last - __first) + { + case 3: + if (__pred(__first)) + return __first; + ++__first; + + case 2: + if (__pred(__first)) + return __first; + ++__first; + + case 1: + if (__pred(__first)) + return __first; + ++__first; + + case 0: + default: + return __last; + } + } + + template + + inline _Iterator + __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) + { + return __find_if(__first, __last, __pred, + std::__iterator_category(__first)); + } + + template + + typename iterator_traits<_InputIterator>::difference_type + __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { + typename iterator_traits<_InputIterator>::difference_type __n = 0; + for (; __first != __last; ++__first) + if (__pred(__first)) + ++__n; + return __n; + } + + template + + _ForwardIterator + __remove_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + __first = std::__find_if(__first, __last, __pred); + if (__first == __last) + return __first; + _ForwardIterator __result = __first; + ++__first; + for (; __first != __last; ++__first) + if (!__pred(__first)) + { + *__result = std::move(*__first); + ++__result; + } + return __result; + } + + template + + _ForwardIterator1 + __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __predicate) + { + + if (__first1 == __last1 || __first2 == __last2) + return __first1; + + + _ForwardIterator2 __p1(__first2); + if (++__p1 == __last2) + return std::__find_if(__first1, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); + + + _ForwardIterator1 __current = __first1; + + for (;;) + { + __first1 = + std::__find_if(__first1, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); + + if (__first1 == __last1) + return __last1; + + _ForwardIterator2 __p = __p1; + __current = __first1; + if (++__current == __last1) + return __last1; + + while (__predicate(__current, __p)) + { + if (++__p == __last2) + return __first1; + if (++__current == __last1) + return __last1; + } + ++__first1; + } + return __first1; + } + + + template + + bool + __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _BinaryPredicate __pred) + { + + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!__pred(__first1, __first2)) + break; + + if (__first1 == __last1) + return true; + + + + _ForwardIterator2 __last2 = __first2; + std::advance(__last2, std::distance(__first1, __last1)); + for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) + { + if (__scan != std::__find_if(__first1, __scan, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) + continue; + + auto __matches + = std::__count_if(__first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); + if (0 == __matches || + std::__count_if(__scan, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) + != __matches) + return false; + } + return true; + } +# 2286 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + + ; + + return std::__is_permutation(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } + + + +# 2328 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 + template + + inline _ForwardIterator1 + search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __predicate) + { + + + + + + + ; + ; + + return std::__search(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__predicate)); + } + + + +} +# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 1 3 +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + +# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +# 158 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + enum float_round_style + { + round_indeterminate = -1, + round_toward_zero = 0, + round_to_nearest = 1, + round_toward_infinity = 2, + round_toward_neg_infinity = 3 + }; + + + + + + + + enum float_denorm_style + { + + denorm_indeterminate = -1, + + denorm_absent = 0, + + denorm_present = 1 + }; +# 202 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + struct __numeric_limits_base + { + + + static constexpr bool is_specialized = false; + + + + + static constexpr int digits = 0; + + + static constexpr int digits10 = 0; + + + + + static constexpr int max_digits10 = 0; + + + + static constexpr bool is_signed = false; + + + static constexpr bool is_integer = false; + + + + + static constexpr bool is_exact = false; + + + + static constexpr int radix = 0; + + + + static constexpr int min_exponent = 0; + + + + static constexpr int min_exponent10 = 0; + + + + + static constexpr int max_exponent = 0; + + + + static constexpr int max_exponent10 = 0; + + + static constexpr bool has_infinity = false; + + + + static constexpr bool has_quiet_NaN = false; + + + + static constexpr bool has_signaling_NaN = false; + + + static constexpr float_denorm_style has_denorm = denorm_absent; + + + + static constexpr bool has_denorm_loss = false; + + + + static constexpr bool is_iec559 = false; + + + + + static constexpr bool is_bounded = false; +# 288 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + static constexpr bool is_modulo = false; + + + static constexpr bool traps = false; + + + static constexpr bool tinyness_before = false; + + + + + static constexpr float_round_style round_style = + round_toward_zero; + }; +# 311 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + template + struct numeric_limits : public __numeric_limits_base + { + + + static constexpr _Tp + min() noexcept { return _Tp(); } + + + static constexpr _Tp + max() noexcept { return _Tp(); } + + + + + static constexpr _Tp + lowest() noexcept { return _Tp(); } + + + + + static constexpr _Tp + epsilon() noexcept { return _Tp(); } + + + static constexpr _Tp + round_error() noexcept { return _Tp(); } + + + static constexpr _Tp + infinity() noexcept { return _Tp(); } + + + + static constexpr _Tp + quiet_NaN() noexcept { return _Tp(); } + + + + static constexpr _Tp + signaling_NaN() noexcept { return _Tp(); } + + + + + static constexpr _Tp + denorm_min() noexcept { return _Tp(); } + }; + + + + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; +# 383 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr bool + min() noexcept { return false; } + + static constexpr bool + max() noexcept { return true; } + + + static constexpr bool + lowest() noexcept { return min(); } + + static constexpr int digits = 1; + static constexpr int digits10 = 0; + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr bool + epsilon() noexcept { return false; } + + static constexpr bool + round_error() noexcept { return false; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr bool + infinity() noexcept { return false; } + + static constexpr bool + quiet_NaN() noexcept { return false; } + + static constexpr bool + signaling_NaN() noexcept { return false; } + + static constexpr bool + denorm_min() noexcept { return false; } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + + + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char + min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); } + + static constexpr char + max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); } + + + static constexpr char + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = ((char)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char + epsilon() noexcept { return 0; } + + static constexpr char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr + char infinity() noexcept { return char(); } + + static constexpr char + quiet_NaN() noexcept { return char(); } + + static constexpr char + signaling_NaN() noexcept { return char(); } + + static constexpr char + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr signed char + min() noexcept { return -0x7f - 1; } + + static constexpr signed char + max() noexcept { return 0x7f; } + + + static constexpr signed char + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr signed char + epsilon() noexcept { return 0; } + + static constexpr signed char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr signed char + infinity() noexcept { return static_cast(0); } + + static constexpr signed char + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr signed char + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr signed char + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned char + min() noexcept { return 0; } + + static constexpr unsigned char + max() noexcept { return 0x7f * 2U + 1; } + + + static constexpr unsigned char + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned char + epsilon() noexcept { return 0; } + + static constexpr unsigned char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned char + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned char + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned char + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned char + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr wchar_t + min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); } + + static constexpr wchar_t + max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); } + + + static constexpr wchar_t + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = ((wchar_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr wchar_t + epsilon() noexcept { return 0; } + + static constexpr wchar_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr wchar_t + infinity() noexcept { return wchar_t(); } + + static constexpr wchar_t + quiet_NaN() noexcept { return wchar_t(); } + + static constexpr wchar_t + signaling_NaN() noexcept { return wchar_t(); } + + static constexpr wchar_t + denorm_min() noexcept { return wchar_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; +# 796 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char16_t + min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); } + + static constexpr char16_t + max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); } + + static constexpr char16_t + lowest() noexcept { return min(); } + + static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136); + static constexpr int max_digits10 = 0; + static constexpr bool is_signed = ((char16_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char16_t + epsilon() noexcept { return 0; } + + static constexpr char16_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr char16_t + infinity() noexcept { return char16_t(); } + + static constexpr char16_t + quiet_NaN() noexcept { return char16_t(); } + + static constexpr char16_t + signaling_NaN() noexcept { return char16_t(); } + + static constexpr char16_t + denorm_min() noexcept { return char16_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char32_t + min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); } + + static constexpr char32_t + max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); } + + static constexpr char32_t + lowest() noexcept { return min(); } + + static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136); + static constexpr int max_digits10 = 0; + static constexpr bool is_signed = ((char32_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char32_t + epsilon() noexcept { return 0; } + + static constexpr char32_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr char32_t + infinity() noexcept { return char32_t(); } + + static constexpr char32_t + quiet_NaN() noexcept { return char32_t(); } + + static constexpr char32_t + signaling_NaN() noexcept { return char32_t(); } + + static constexpr char32_t + denorm_min() noexcept { return char32_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style = round_toward_zero; + }; + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr short + min() noexcept { return -0x7fff - 1; } + + static constexpr short + max() noexcept { return 0x7fff; } + + + static constexpr short + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0)); + static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr short + epsilon() noexcept { return 0; } + + static constexpr short + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr short + infinity() noexcept { return short(); } + + static constexpr short + quiet_NaN() noexcept { return short(); } + + static constexpr short + signaling_NaN() noexcept { return short(); } + + static constexpr short + denorm_min() noexcept { return short(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned short + min() noexcept { return 0; } + + static constexpr unsigned short + max() noexcept { return 0x7fff * 2U + 1; } + + + static constexpr unsigned short + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned short + epsilon() noexcept { return 0; } + + static constexpr unsigned short + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned short + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned short + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned short + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned short + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr int + min() noexcept { return -0x7fffffff - 1; } + + static constexpr int + max() noexcept { return 0x7fffffff; } + + + static constexpr int + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0)); + static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr int + epsilon() noexcept { return 0; } + + static constexpr int + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr int + infinity() noexcept { return static_cast(0); } + + static constexpr int + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr int + signaling_NaN() noexcept { return static_cast(0); } + + static constexpr int + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned int + min() noexcept { return 0; } + + static constexpr unsigned int + max() noexcept { return 0x7fffffff * 2U + 1; } + + + static constexpr unsigned int + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned int + epsilon() noexcept { return 0; } + + static constexpr unsigned int + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned int + infinity() noexcept { return static_cast(0); } + + static constexpr unsigned int + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned int + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned int + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr long + min() noexcept { return -0x7fffffffffffffffL - 1; } + + static constexpr long + max() noexcept { return 0x7fffffffffffffffL; } + + + static constexpr long + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0)); + static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr long + epsilon() noexcept { return 0; } + + static constexpr long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr long + infinity() noexcept { return static_cast(0); } + + static constexpr long + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr long + signaling_NaN() noexcept { return static_cast(0); } + + static constexpr long + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned long + min() noexcept { return 0; } + + static constexpr unsigned long + max() noexcept { return 0x7fffffffffffffffL * 2UL + 1; } + + + static constexpr unsigned long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned long + epsilon() noexcept { return 0; } + + static constexpr unsigned long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned long + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned long + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr long long + min() noexcept { return -0x7fffffffffffffffLL - 1; } + + static constexpr long long + max() noexcept { return 0x7fffffffffffffffLL; } + + + static constexpr long long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(long long) * 8 - ((long long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr long long + epsilon() noexcept { return 0; } + + static constexpr long long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr long long + infinity() noexcept { return static_cast(0); } + + static constexpr long long + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr long long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr long long + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned long long + min() noexcept { return 0; } + + static constexpr unsigned long long + max() noexcept { return 0x7fffffffffffffffLL * 2ULL + 1; } + + + static constexpr unsigned long long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned long long + epsilon() noexcept { return 0; } + + static constexpr unsigned long long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned long long + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; +# 1637 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + __extension__ template<> struct numeric_limits<__int128> { static constexpr bool is_specialized = true; static constexpr __int128 min() noexcept { return (((__int128)(-1) < 0) ? -(((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0) - 1 : (__int128)0); } static constexpr __int128 max() noexcept { return (((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0); } static constexpr int digits = 128 - 1; static constexpr int digits10 = (128 - 1) * 643L / 2136; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr __int128 epsilon() noexcept { return 0; } static constexpr __int128 round_error() noexcept { return 0; } static constexpr __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 0; static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr __int128 infinity() noexcept { return static_cast<__int128>(0); } static constexpr __int128 quiet_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 signaling_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 denorm_min() noexcept { return static_cast<__int128>(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; __extension__ template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr unsigned __int128 min() noexcept { return 0; } static constexpr unsigned __int128 max() noexcept { return (((unsigned __int128)(-1) < 0) ? (((((unsigned __int128)1 << ((128 - ((unsigned __int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(unsigned __int128)0); } static constexpr unsigned __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 0; static constexpr int digits = 128; static constexpr int digits10 = 128 * 643L / 2136; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr unsigned __int128 epsilon() noexcept { return 0; } static constexpr unsigned __int128 round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr unsigned __int128 infinity() noexcept { return static_cast(0); } static constexpr unsigned __int128 quiet_NaN() noexcept { return static_cast(0); } static constexpr unsigned __int128 signaling_NaN() noexcept { return static_cast(0); } static constexpr unsigned __int128 denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = true; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; +# 1669 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr float + min() noexcept { return 1.17549435082228750796873653722224568e-38F; } + + static constexpr float + max() noexcept { return 3.40282346638528859811704183484516925e+38F; } + + + static constexpr float + lowest() noexcept { return -3.40282346638528859811704183484516925e+38F; } + + + static constexpr int digits = 24; + static constexpr int digits10 = 6; + + static constexpr int max_digits10 + = (2 + (24) * 643L / 2136); + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr float + epsilon() noexcept { return 1.19209289550781250000000000000000000e-7F; } + + static constexpr float + round_error() noexcept { return 0.5F; } + + static constexpr int min_exponent = (-125); + static constexpr int min_exponent10 = (-37); + static constexpr int max_exponent = 128; + static constexpr int max_exponent10 = 38; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + static constexpr bool has_signaling_NaN = has_quiet_NaN; + static constexpr float_denorm_style has_denorm + = bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + = false; + + static constexpr float + infinity() noexcept { return __builtin_huge_valf(); } + + static constexpr float + quiet_NaN() noexcept { return __builtin_nanf(""); } + + static constexpr float + signaling_NaN() noexcept { return __builtin_nansf(""); } + + static constexpr float + denorm_min() noexcept { return 1.40129846432481707092372958328991613e-45F; } + + static constexpr bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before + = false; + static constexpr float_round_style round_style + = round_to_nearest; + }; + + + + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr double + min() noexcept { return double(2.22507385850720138309023271733240406e-308L); } + + static constexpr double + max() noexcept { return double(1.79769313486231570814527423731704357e+308L); } + + + static constexpr double + lowest() noexcept { return -double(1.79769313486231570814527423731704357e+308L); } + + + static constexpr int digits = 53; + static constexpr int digits10 = 15; + + static constexpr int max_digits10 + = (2 + (53) * 643L / 2136); + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr double + epsilon() noexcept { return double(2.22044604925031308084726333618164062e-16L); } + + static constexpr double + round_error() noexcept { return 0.5; } + + static constexpr int min_exponent = (-1021); + static constexpr int min_exponent10 = (-307); + static constexpr int max_exponent = 1024; + static constexpr int max_exponent10 = 308; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + static constexpr bool has_signaling_NaN = has_quiet_NaN; + static constexpr float_denorm_style has_denorm + = bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + = false; + + static constexpr double + infinity() noexcept { return __builtin_huge_val(); } + + static constexpr double + quiet_NaN() noexcept { return __builtin_nan(""); } + + static constexpr double + signaling_NaN() noexcept { return __builtin_nans(""); } + + static constexpr double + denorm_min() noexcept { return double(4.94065645841246544176568792868221372e-324L); } + + static constexpr bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before + = false; + static constexpr float_round_style round_style + = round_to_nearest; + }; + + + + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr long double + min() noexcept { return 3.36210314311209350626267781732175260e-4932L; } + + static constexpr long double + max() noexcept { return 1.18973149535723176502126385303097021e+4932L; } + + + static constexpr long double + lowest() noexcept { return -1.18973149535723176502126385303097021e+4932L; } + + + static constexpr int digits = 64; + static constexpr int digits10 = 18; + + static constexpr int max_digits10 + = (2 + (64) * 643L / 2136); + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr long double + epsilon() noexcept { return 1.08420217248550443400745280086994171e-19L; } + + static constexpr long double + round_error() noexcept { return 0.5L; } + + static constexpr int min_exponent = (-16381); + static constexpr int min_exponent10 = (-4931); + static constexpr int max_exponent = 16384; + static constexpr int max_exponent10 = 4932; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + static constexpr bool has_signaling_NaN = has_quiet_NaN; + static constexpr float_denorm_style has_denorm + = bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + = false; + + static constexpr long double + infinity() noexcept { return __builtin_huge_vall(); } + + static constexpr long double + quiet_NaN() noexcept { return __builtin_nanl(""); } + + static constexpr long double + signaling_NaN() noexcept { return __builtin_nansl(""); } + + static constexpr long double + denorm_min() noexcept { return 3.64519953188247460252840593361941982e-4951L; } + + static constexpr bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before = + false; + static constexpr float_round_style round_style = + round_to_nearest; + }; +# 1989 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +__extension__ template<> struct numeric_limits<_Float32> { static constexpr bool is_specialized = true; static constexpr _Float32 min() noexcept { return 1.17549435082228750796873653722224568e-38F32; } static constexpr _Float32 max() noexcept { return 3.40282346638528859811704183484516925e+38F32; } static constexpr _Float32 lowest() noexcept { return -3.40282346638528859811704183484516925e+38F32; } static constexpr int digits = 24; static constexpr int digits10 = 6; static constexpr int max_digits10 = (2 + (24) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr _Float32 epsilon() noexcept { return 1.19209289550781250000000000000000000e-7F32; } static constexpr _Float32 round_error() noexcept { return 0.5F32; } static constexpr int min_exponent = (-125); static constexpr int min_exponent10 = (-37); static constexpr int max_exponent = 128; static constexpr int max_exponent10 = 38; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr _Float32 infinity() noexcept { return __builtin_huge_valf32(); } static constexpr _Float32 quiet_NaN() noexcept { return __builtin_nanf32(""); } static constexpr _Float32 signaling_NaN() noexcept { return __builtin_nansf32(""); } static constexpr _Float32 denorm_min() noexcept { return 1.40129846432481707092372958328991613e-45F32; } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; + + +__extension__ template<> struct numeric_limits<_Float64> { static constexpr bool is_specialized = true; static constexpr _Float64 min() noexcept { return 2.22507385850720138309023271733240406e-308F64; } static constexpr _Float64 max() noexcept { return 1.79769313486231570814527423731704357e+308F64; } static constexpr _Float64 lowest() noexcept { return -1.79769313486231570814527423731704357e+308F64; } static constexpr int digits = 53; static constexpr int digits10 = 15; static constexpr int max_digits10 = (2 + (53) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr _Float64 epsilon() noexcept { return 2.22044604925031308084726333618164062e-16F64; } static constexpr _Float64 round_error() noexcept { return 0.5F64; } static constexpr int min_exponent = (-1021); static constexpr int min_exponent10 = (-307); static constexpr int max_exponent = 1024; static constexpr int max_exponent10 = 308; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr _Float64 infinity() noexcept { return __builtin_huge_valf64(); } static constexpr _Float64 quiet_NaN() noexcept { return __builtin_nanf64(""); } static constexpr _Float64 signaling_NaN() noexcept { return __builtin_nansf64(""); } static constexpr _Float64 denorm_min() noexcept { return 4.94065645841246544176568792868221372e-324F64; } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; + + +__extension__ template<> struct numeric_limits<_Float128> { static constexpr bool is_specialized = true; static constexpr _Float128 min() noexcept { return 3.36210314311209350626267781732175260e-4932F128; } static constexpr _Float128 max() noexcept { return 1.18973149535723176508575932662800702e+4932F128; } static constexpr _Float128 lowest() noexcept { return -1.18973149535723176508575932662800702e+4932F128; } static constexpr int digits = 113; static constexpr int digits10 = 33; static constexpr int max_digits10 = (2 + (113) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr _Float128 epsilon() noexcept { return 1.92592994438723585305597794258492732e-34F128; } static constexpr _Float128 round_error() noexcept { return 0.5F128; } static constexpr int min_exponent = (-16381); static constexpr int min_exponent10 = (-4931); static constexpr int max_exponent = 16384; static constexpr int max_exponent10 = 4932; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr _Float128 infinity() noexcept { return __builtin_huge_valf128(); } static constexpr _Float128 quiet_NaN() noexcept { return __builtin_nanf128(""); } static constexpr _Float128 signaling_NaN() noexcept { return __builtin_nansf128(""); } static constexpr _Float128 denorm_min() noexcept { return 6.47517511943802511092443895822764655e-4966F128; } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; +# 2087 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + __extension__ + template<> + struct numeric_limits<__float128> + { + static constexpr bool is_specialized = true; + + static constexpr __float128 + min() noexcept + { + + + + + return __extension__ 0x1.0p-16382Q; + + } + + static constexpr __float128 + max() noexcept + { + + + + + + + + return __extension__ 0x1.ffffffffffffffffffffffffffffp+16383Q; + + } + + static constexpr __float128 + lowest() noexcept + { return -max(); } + + static constexpr int digits = 113; + static constexpr int digits10 = 33; + + static constexpr int max_digits10 = 35; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr __float128 + epsilon() noexcept + { return double(1.9259299443872359e-34); } + + static constexpr __float128 + round_error() noexcept { return 0.5; } + + static constexpr int min_exponent = -16381; + static constexpr int min_exponent10 = -4931; + static constexpr int max_exponent = 16384; + static constexpr int max_exponent10 = 4932; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + + + static constexpr bool has_signaling_NaN = true; + + + + static constexpr float_denorm_style has_denorm + = denorm_present; + static constexpr bool has_denorm_loss = false; + + static constexpr __float128 + infinity() noexcept + { return __builtin_huge_val(); } + + static constexpr __float128 + quiet_NaN() noexcept + { return __builtin_nan(""); } + + static constexpr __float128 + signaling_NaN() noexcept + { + + return __builtin_nansq(""); + + + + + + } + + static constexpr __float128 + denorm_min() noexcept + { + + + + + return __extension__ 0x1.0p-16494Q; + + } + + static constexpr bool is_iec559 = has_signaling_NaN; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_to_nearest; +# 2218 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 + }; + + + + +} +# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 1 3 +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 + namespace __detail + { + + + + template + struct __floating_point_constant + { + static const _Tp __value; + }; + + + + template + struct __numeric_constants + { + + static _Tp __pi() throw() + { return static_cast<_Tp>(3.1415926535897932384626433832795029L); } + + static _Tp __pi_2() throw() + { return static_cast<_Tp>(1.5707963267948966192313216916397514L); } + + static _Tp __pi_3() throw() + { return static_cast<_Tp>(1.0471975511965977461542144610931676L); } + + static _Tp __pi_4() throw() + { return static_cast<_Tp>(0.7853981633974483096156608458198757L); } + + static _Tp __1_pi() throw() + { return static_cast<_Tp>(0.3183098861837906715377675267450287L); } + + static _Tp __2_sqrtpi() throw() + { return static_cast<_Tp>(1.1283791670955125738961589031215452L); } + + static _Tp __sqrt2() throw() + { return static_cast<_Tp>(1.4142135623730950488016887242096981L); } + + static _Tp __sqrt3() throw() + { return static_cast<_Tp>(1.7320508075688772935274463415058723L); } + + static _Tp __sqrtpio2() throw() + { return static_cast<_Tp>(1.2533141373155002512078826424055226L); } + + static _Tp __sqrt1_2() throw() + { return static_cast<_Tp>(0.7071067811865475244008443621048490L); } + + static _Tp __lnpi() throw() + { return static_cast<_Tp>(1.1447298858494001741434273513530587L); } + + static _Tp __gamma_e() throw() + { return static_cast<_Tp>(0.5772156649015328606065120900824024L); } + + static _Tp __euler() throw() + { return static_cast<_Tp>(2.7182818284590452353602874713526625L); } + }; +# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 + template + inline bool __isnan(_Tp __x) + { return std::isnan(__x); } +# 133 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 + } + + + + + +} +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + namespace __detail + { +# 76 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __bernoulli_series(unsigned int __n) + { + + static const _Tp __num[28] = { + _Tp(1UL), -_Tp(1UL) / _Tp(2UL), + _Tp(1UL) / _Tp(6UL), _Tp(0UL), + -_Tp(1UL) / _Tp(30UL), _Tp(0UL), + _Tp(1UL) / _Tp(42UL), _Tp(0UL), + -_Tp(1UL) / _Tp(30UL), _Tp(0UL), + _Tp(5UL) / _Tp(66UL), _Tp(0UL), + -_Tp(691UL) / _Tp(2730UL), _Tp(0UL), + _Tp(7UL) / _Tp(6UL), _Tp(0UL), + -_Tp(3617UL) / _Tp(510UL), _Tp(0UL), + _Tp(43867UL) / _Tp(798UL), _Tp(0UL), + -_Tp(174611) / _Tp(330UL), _Tp(0UL), + _Tp(854513UL) / _Tp(138UL), _Tp(0UL), + -_Tp(236364091UL) / _Tp(2730UL), _Tp(0UL), + _Tp(8553103UL) / _Tp(6UL), _Tp(0UL) + }; + + if (__n == 0) + return _Tp(1); + + if (__n == 1) + return -_Tp(1) / _Tp(2); + + + if (__n % 2 == 1) + return _Tp(0); + + + if (__n < 28) + return __num[__n]; + + + _Tp __fact = _Tp(1); + if ((__n / 2) % 2 == 0) + __fact *= _Tp(-1); + for (unsigned int __k = 1; __k <= __n; ++__k) + __fact *= __k / (_Tp(2) * __numeric_constants<_Tp>::__pi()); + __fact *= _Tp(2); + + _Tp __sum = _Tp(0); + for (unsigned int __i = 1; __i < 1000; ++__i) + { + _Tp __term = std::pow(_Tp(__i), -_Tp(__n)); + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + __sum += __term; + } + + return __fact * __sum; + } +# 139 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + inline _Tp + __bernoulli(int __n) + { return __bernoulli_series<_Tp>(__n); } +# 153 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma_bernoulli(_Tp __x) + { + _Tp __lg = (__x - _Tp(0.5L)) * std::log(__x) - __x + + _Tp(0.5L) * std::log(_Tp(2) + * __numeric_constants<_Tp>::__pi()); + + const _Tp __xx = __x * __x; + _Tp __help = _Tp(1) / __x; + for ( unsigned int __i = 1; __i < 20; ++__i ) + { + const _Tp __2i = _Tp(2 * __i); + __help /= __2i * (__2i - _Tp(1)) * __xx; + __lg += __bernoulli<_Tp>(2 * __i) * __help; + } + + return __lg; + } +# 181 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma_lanczos(_Tp __x) + { + const _Tp __xm1 = __x - _Tp(1); + + static const _Tp __lanczos_cheb_7[9] = { + _Tp( 0.99999999999980993227684700473478L), + _Tp( 676.520368121885098567009190444019L), + _Tp(-1259.13921672240287047156078755283L), + _Tp( 771.3234287776530788486528258894L), + _Tp(-176.61502916214059906584551354L), + _Tp( 12.507343278686904814458936853L), + _Tp(-0.13857109526572011689554707L), + _Tp( 9.984369578019570859563e-6L), + _Tp( 1.50563273514931155834e-7L) + }; + + static const _Tp __LOGROOT2PI + = _Tp(0.9189385332046727417803297364056176L); + + _Tp __sum = __lanczos_cheb_7[0]; + for(unsigned int __k = 1; __k < 9; ++__k) + __sum += __lanczos_cheb_7[__k] / (__xm1 + __k); + + const _Tp __term1 = (__xm1 + _Tp(0.5L)) + * std::log((__xm1 + _Tp(7.5L)) + / __numeric_constants<_Tp>::__euler()); + const _Tp __term2 = __LOGROOT2PI + std::log(__sum); + const _Tp __result = __term1 + (__term2 - _Tp(7)); + + return __result; + } +# 225 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma(_Tp __x) + { + if (__x > _Tp(0.5L)) + return __log_gamma_lanczos(__x); + else + { + const _Tp __sin_fact + = std::abs(std::sin(__numeric_constants<_Tp>::__pi() * __x)); + if (__sin_fact == _Tp(0)) + std::__throw_domain_error(("Argument is nonpositive integer " "in __log_gamma") + ); + return __numeric_constants<_Tp>::__lnpi() + - std::log(__sin_fact) + - __log_gamma_lanczos(_Tp(1) - __x); + } + } +# 252 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma_sign(_Tp __x) + { + if (__x > _Tp(0)) + return _Tp(1); + else + { + const _Tp __sin_fact + = std::sin(__numeric_constants<_Tp>::__pi() * __x); + if (__sin_fact > _Tp(0)) + return (1); + else if (__sin_fact < _Tp(0)) + return -_Tp(1); + else + return _Tp(0); + } + } +# 283 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __log_bincoef(unsigned int __n, unsigned int __k) + { + + static const _Tp __max_bincoeff + = std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + _Tp __coeff = ::std::lgamma(_Tp(1 + __n)) + - ::std::lgamma(_Tp(1 + __k)) + - ::std::lgamma(_Tp(1 + __n - __k)); + + + + + + } +# 314 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __bincoef(unsigned int __n, unsigned int __k) + { + + static const _Tp __max_bincoeff + = std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + const _Tp __log_coeff = __log_bincoef<_Tp>(__n, __k); + if (__log_coeff > __max_bincoeff) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return std::exp(__log_coeff); + } +# 337 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + inline _Tp + __gamma(_Tp __x) + { return std::exp(__log_gamma(__x)); } +# 356 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __psi_series(_Tp __x) + { + _Tp __sum = -__numeric_constants<_Tp>::__gamma_e() - _Tp(1) / __x; + const unsigned int __max_iter = 100000; + for (unsigned int __k = 1; __k < __max_iter; ++__k) + { + const _Tp __term = __x / (__k * (__k + __x)); + __sum += __term; + if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon()) + break; + } + return __sum; + } +# 386 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __psi_asymp(_Tp __x) + { + _Tp __sum = std::log(__x) - _Tp(0.5L) / __x; + const _Tp __xx = __x * __x; + _Tp __xp = __xx; + const unsigned int __max_iter = 100; + for (unsigned int __k = 1; __k < __max_iter; ++__k) + { + const _Tp __term = __bernoulli<_Tp>(2 * __k) / (2 * __k * __xp); + __sum -= __term; + if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon()) + break; + __xp *= __xx; + } + return __sum; + } +# 417 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __psi(_Tp __x) + { + const int __n = static_cast(__x + 0.5L); + const _Tp __eps = _Tp(4) * std::numeric_limits<_Tp>::epsilon(); + if (__n <= 0 && std::abs(__x - _Tp(__n)) < __eps) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x < _Tp(0)) + { + const _Tp __pi = __numeric_constants<_Tp>::__pi(); + return __psi(_Tp(1) - __x) + - __pi * std::cos(__pi * __x) / std::sin(__pi * __x); + } + else if (__x > _Tp(100)) + return __psi_asymp(__x); + else + return __psi_series(__x); + } +# 446 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 + template + _Tp + __psi(unsigned int __n, _Tp __x) + { + if (__x <= _Tp(0)) + std::__throw_domain_error(("Argument out of range " "in __psi") + ); + else if (__n == 0) + return __psi(__x); + else + { + const _Tp __hzeta = __hurwitz_zeta(_Tp(__n + 1), __x); + + const _Tp __ln_nfact = ::std::lgamma(_Tp(__n + 1)); + + + + _Tp __result = std::exp(__ln_nfact) * __hzeta; + if (__n % 2 == 1) + __result = -__result; + return __result; + } + } + } + + + + + + +} +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 1 3 +# 55 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 71 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + namespace __detail + { +# 98 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + void + __gamma_temme(_Tp __mu, + _Tp & __gam1, _Tp & __gam2, _Tp & __gampl, _Tp & __gammi) + { + + __gampl = _Tp(1) / ::std::tgamma(_Tp(1) + __mu); + __gammi = _Tp(1) / ::std::tgamma(_Tp(1) - __mu); + + + + + + if (std::abs(__mu) < std::numeric_limits<_Tp>::epsilon()) + __gam1 = -_Tp(__numeric_constants<_Tp>::__gamma_e()); + else + __gam1 = (__gammi - __gampl) / (_Tp(2) * __mu); + + __gam2 = (__gammi + __gampl) / (_Tp(2)); + + return; + } +# 136 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + void + __bessel_jn(_Tp __nu, _Tp __x, + _Tp & __Jnu, _Tp & __Nnu, _Tp & __Jpnu, _Tp & __Npnu) + { + if (__x == _Tp(0)) + { + if (__nu == _Tp(0)) + { + __Jnu = _Tp(1); + __Jpnu = _Tp(0); + } + else if (__nu == _Tp(1)) + { + __Jnu = _Tp(0); + __Jpnu = _Tp(0.5L); + } + else + { + __Jnu = _Tp(0); + __Jpnu = _Tp(0); + } + __Nnu = -std::numeric_limits<_Tp>::infinity(); + __Npnu = std::numeric_limits<_Tp>::infinity(); + return; + } + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + + + + const _Tp __fp_min = std::sqrt(std::numeric_limits<_Tp>::min()); + const int __max_iter = 15000; + const _Tp __x_min = _Tp(2); + + const int __nl = (__x < __x_min + ? static_cast(__nu + _Tp(0.5L)) + : std::max(0, static_cast(__nu - __x + _Tp(1.5L)))); + + const _Tp __mu = __nu - __nl; + const _Tp __mu2 = __mu * __mu; + const _Tp __xi = _Tp(1) / __x; + const _Tp __xi2 = _Tp(2) * __xi; + _Tp __w = __xi2 / __numeric_constants<_Tp>::__pi(); + int __isign = 1; + _Tp __h = __nu * __xi; + if (__h < __fp_min) + __h = __fp_min; + _Tp __b = __xi2 * __nu; + _Tp __d = _Tp(0); + _Tp __c = __h; + int __i; + for (__i = 1; __i <= __max_iter; ++__i) + { + __b += __xi2; + __d = __b - __d; + if (std::abs(__d) < __fp_min) + __d = __fp_min; + __c = __b - _Tp(1) / __c; + if (std::abs(__c) < __fp_min) + __c = __fp_min; + __d = _Tp(1) / __d; + const _Tp __del = __c * __d; + __h *= __del; + if (__d < _Tp(0)) + __isign = -__isign; + if (std::abs(__del - _Tp(1)) < __eps) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Argument x too large in __bessel_jn; " "try asymptotic expansion.") + ); + _Tp __Jnul = __isign * __fp_min; + _Tp __Jpnul = __h * __Jnul; + _Tp __Jnul1 = __Jnul; + _Tp __Jpnu1 = __Jpnul; + _Tp __fact = __nu * __xi; + for ( int __l = __nl; __l >= 1; --__l ) + { + const _Tp __Jnutemp = __fact * __Jnul + __Jpnul; + __fact -= __xi; + __Jpnul = __fact * __Jnutemp - __Jnul; + __Jnul = __Jnutemp; + } + if (__Jnul == _Tp(0)) + __Jnul = __eps; + _Tp __f= __Jpnul / __Jnul; + _Tp __Nmu, __Nnu1, __Npmu, __Jmu; + if (__x < __x_min) + { + const _Tp __x2 = __x / _Tp(2); + const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu; + _Tp __fact = (std::abs(__pimu) < __eps + ? _Tp(1) : __pimu / std::sin(__pimu)); + _Tp __d = -std::log(__x2); + _Tp __e = __mu * __d; + _Tp __fact2 = (std::abs(__e) < __eps + ? _Tp(1) : std::sinh(__e) / __e); + _Tp __gam1, __gam2, __gampl, __gammi; + __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi); + _Tp __ff = (_Tp(2) / __numeric_constants<_Tp>::__pi()) + * __fact * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d); + __e = std::exp(__e); + _Tp __p = __e / (__numeric_constants<_Tp>::__pi() * __gampl); + _Tp __q = _Tp(1) / (__e * __numeric_constants<_Tp>::__pi() * __gammi); + const _Tp __pimu2 = __pimu / _Tp(2); + _Tp __fact3 = (std::abs(__pimu2) < __eps + ? _Tp(1) : std::sin(__pimu2) / __pimu2 ); + _Tp __r = __numeric_constants<_Tp>::__pi() * __pimu2 * __fact3 * __fact3; + _Tp __c = _Tp(1); + __d = -__x2 * __x2; + _Tp __sum = __ff + __r * __q; + _Tp __sum1 = __p; + for (__i = 1; __i <= __max_iter; ++__i) + { + __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2); + __c *= __d / _Tp(__i); + __p /= _Tp(__i) - __mu; + __q /= _Tp(__i) + __mu; + const _Tp __del = __c * (__ff + __r * __q); + __sum += __del; + const _Tp __del1 = __c * __p - __i * __del; + __sum1 += __del1; + if ( std::abs(__del) < __eps * (_Tp(1) + std::abs(__sum)) ) + break; + } + if ( __i > __max_iter ) + std::__throw_runtime_error(("Bessel y series failed to converge " "in __bessel_jn.") + ); + __Nmu = -__sum; + __Nnu1 = -__sum1 * __xi2; + __Npmu = __mu * __xi * __Nmu - __Nnu1; + __Jmu = __w / (__Npmu - __f * __Nmu); + } + else + { + _Tp __a = _Tp(0.25L) - __mu2; + _Tp __q = _Tp(1); + _Tp __p = -__xi / _Tp(2); + _Tp __br = _Tp(2) * __x; + _Tp __bi = _Tp(2); + _Tp __fact = __a * __xi / (__p * __p + __q * __q); + _Tp __cr = __br + __q * __fact; + _Tp __ci = __bi + __p * __fact; + _Tp __den = __br * __br + __bi * __bi; + _Tp __dr = __br / __den; + _Tp __di = -__bi / __den; + _Tp __dlr = __cr * __dr - __ci * __di; + _Tp __dli = __cr * __di + __ci * __dr; + _Tp __temp = __p * __dlr - __q * __dli; + __q = __p * __dli + __q * __dlr; + __p = __temp; + int __i; + for (__i = 2; __i <= __max_iter; ++__i) + { + __a += _Tp(2 * (__i - 1)); + __bi += _Tp(2); + __dr = __a * __dr + __br; + __di = __a * __di + __bi; + if (std::abs(__dr) + std::abs(__di) < __fp_min) + __dr = __fp_min; + __fact = __a / (__cr * __cr + __ci * __ci); + __cr = __br + __cr * __fact; + __ci = __bi - __ci * __fact; + if (std::abs(__cr) + std::abs(__ci) < __fp_min) + __cr = __fp_min; + __den = __dr * __dr + __di * __di; + __dr /= __den; + __di /= -__den; + __dlr = __cr * __dr - __ci * __di; + __dli = __cr * __di + __ci * __dr; + __temp = __p * __dlr - __q * __dli; + __q = __p * __dli + __q * __dlr; + __p = __temp; + if (std::abs(__dlr - _Tp(1)) + std::abs(__dli) < __eps) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Lentz's method failed " "in __bessel_jn.") + ); + const _Tp __gam = (__p - __f) / __q; + __Jmu = std::sqrt(__w / ((__p - __f) * __gam + __q)); + + __Jmu = ::std::copysign(__Jmu, __Jnul); + + + + + __Nmu = __gam * __Jmu; + __Npmu = (__p + __q / __gam) * __Nmu; + __Nnu1 = __mu * __xi * __Nmu - __Npmu; + } + __fact = __Jmu / __Jnul; + __Jnu = __fact * __Jnul1; + __Jpnu = __fact * __Jpnu1; + for (__i = 1; __i <= __nl; ++__i) + { + const _Tp __Nnutemp = (__mu + __i) * __xi2 * __Nnu1 - __Nmu; + __Nmu = __Nnu1; + __Nnu1 = __Nnutemp; + } + __Nnu = __Nmu; + __Npnu = __nu * __xi * __Nmu - __Nnu1; + + return; + } +# 361 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + void + __cyl_bessel_jn_asymp(_Tp __nu, _Tp __x, _Tp & __Jnu, _Tp & __Nnu) + { + const _Tp __mu = _Tp(4) * __nu * __nu; + const _Tp __8x = _Tp(8) * __x; + + _Tp __P = _Tp(0); + _Tp __Q = _Tp(0); + + _Tp __k = _Tp(0); + _Tp __term = _Tp(1); + + int __epsP = 0; + int __epsQ = 0; + + _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + do + { + __term *= (__k == 0 + ? _Tp(1) + : -(__mu - (2 * __k - 1) * (2 * __k - 1)) / (__k * __8x)); + + __epsP = std::abs(__term) < __eps * std::abs(__P); + __P += __term; + + __k++; + + __term *= (__mu - (2 * __k - 1) * (2 * __k - 1)) / (__k * __8x); + __epsQ = std::abs(__term) < __eps * std::abs(__Q); + __Q += __term; + + if (__epsP && __epsQ && __k > (__nu / 2.)) + break; + + __k++; + } + while (__k < 1000); + + const _Tp __chi = __x - (__nu + _Tp(0.5L)) + * __numeric_constants<_Tp>::__pi_2(); + + const _Tp __c = std::cos(__chi); + const _Tp __s = std::sin(__chi); + + const _Tp __coef = std::sqrt(_Tp(2) + / (__numeric_constants<_Tp>::__pi() * __x)); + + __Jnu = __coef * (__c * __P - __s * __Q); + __Nnu = __coef * (__s * __P + __c * __Q); + + return; + } +# 444 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_bessel_ij_series(_Tp __nu, _Tp __x, _Tp __sgn, + unsigned int __max_iter) + { + if (__x == _Tp(0)) + return __nu == _Tp(0) ? _Tp(1) : _Tp(0); + + const _Tp __x2 = __x / _Tp(2); + _Tp __fact = __nu * std::log(__x2); + + __fact -= ::std::lgamma(__nu + _Tp(1)); + + + + __fact = std::exp(__fact); + const _Tp __xx4 = __sgn * __x2 * __x2; + _Tp __Jn = _Tp(1); + _Tp __term = _Tp(1); + + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + __term *= __xx4 / (_Tp(__i) * (__nu + _Tp(__i))); + __Jn += __term; + if (std::abs(__term / __Jn) < std::numeric_limits<_Tp>::epsilon()) + break; + } + + return __fact * __Jn; + } +# 490 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_bessel_j(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_j.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x * __x < _Tp(10) * (__nu + _Tp(1))) + return __cyl_bessel_ij_series(__nu, __x, -_Tp(1), 200); + else if (__x > _Tp(1000)) + { + _Tp __J_nu, __N_nu; + __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); + return __J_nu; + } + else + { + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + return __J_nu; + } + } +# 532 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_neumann_n(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_neumann_n.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x > _Tp(1000)) + { + _Tp __J_nu, __N_nu; + __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); + return __N_nu; + } + else + { + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + return __N_nu; + } + } +# 569 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + void + __sph_bessel_jn(unsigned int __n, _Tp __x, + _Tp & __j_n, _Tp & __n_n, _Tp & __jp_n, _Tp & __np_n) + { + const _Tp __nu = _Tp(__n) + _Tp(0.5L); + + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + + const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2() + / std::sqrt(__x); + + __j_n = __factor * __J_nu; + __n_n = __factor * __N_nu; + __jp_n = __factor * __Jp_nu - __j_n / (_Tp(2) * __x); + __np_n = __factor * __Np_nu - __n_n / (_Tp(2) * __x); + + return; + } +# 604 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + _Tp + __sph_bessel(unsigned int __n, _Tp __x) + { + if (__x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __sph_bessel.") + ); + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x == _Tp(0)) + { + if (__n == 0) + return _Tp(1); + else + return _Tp(0); + } + else + { + _Tp __j_n, __n_n, __jp_n, __np_n; + __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n); + return __j_n; + } + } +# 642 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 + template + _Tp + __sph_neumann(unsigned int __n, _Tp __x) + { + if (__x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __sph_neumann.") + ); + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x == _Tp(0)) + return -std::numeric_limits<_Tp>::infinity(); + else + { + _Tp __j_n, __n_n, __jp_n, __np_n; + __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n); + return __n_n; + } + } + } + + + + + + +} +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 1 3 +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + namespace __detail + { +# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + template + _Tp + __beta_gamma(_Tp __x, _Tp __y) + { + + _Tp __bet; + + if (__x > __y) + { + __bet = ::std::tgamma(__x) + / ::std::tgamma(__x + __y); + __bet *= ::std::tgamma(__y); + } + else + { + __bet = ::std::tgamma(__y) + / ::std::tgamma(__x + __y); + __bet *= ::std::tgamma(__x); + } +# 111 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + return __bet; + } +# 127 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + template + _Tp + __beta_lgamma(_Tp __x, _Tp __y) + { + + _Tp __bet = ::std::lgamma(__x) + + ::std::lgamma(__y) + - ::std::lgamma(__x + __y); + + + + + + __bet = std::exp(__bet); + return __bet; + } +# 158 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + template + _Tp + __beta_product(_Tp __x, _Tp __y) + { + + _Tp __bet = (__x + __y) / (__x * __y); + + unsigned int __max_iter = 1000000; + for (unsigned int __k = 1; __k < __max_iter; ++__k) + { + _Tp __term = (_Tp(1) + (__x + __y) / __k) + / ((_Tp(1) + __x / __k) * (_Tp(1) + __y / __k)); + __bet *= __term; + } + + return __bet; + } +# 189 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 + template + inline _Tp + __beta(_Tp __x, _Tp __y) + { + if (__isnan(__x) || __isnan(__y)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __beta_lgamma(__x, __y); + } + } + + + + + + +} +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 1 3 +# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + namespace __detail + { +# 76 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rf(_Tp __x, _Tp __y, _Tp __z) + { + const _Tp __min = std::numeric_limits<_Tp>::min(); + const _Tp __lolim = _Tp(5) * __min; + + if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0)) + std::__throw_domain_error(("Argument less than zero " "in __ellint_rf.") + ); + else if (__x + __y < __lolim || __x + __z < __lolim + || __y + __z < __lolim) + std::__throw_domain_error(("Argument too small in __ellint_rf")); + else + { + const _Tp __c0 = _Tp(1) / _Tp(4); + const _Tp __c1 = _Tp(1) / _Tp(24); + const _Tp __c2 = _Tp(1) / _Tp(10); + const _Tp __c3 = _Tp(3) / _Tp(44); + const _Tp __c4 = _Tp(1) / _Tp(14); + + _Tp __xn = __x; + _Tp __yn = __y; + _Tp __zn = __z; + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol = std::pow(__eps, _Tp(1) / _Tp(6)); + _Tp __mu; + _Tp __xndev, __yndev, __zndev; + + const unsigned int __max_iter = 100; + for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) + { + __mu = (__xn + __yn + __zn) / _Tp(3); + __xndev = 2 - (__mu + __xn) / __mu; + __yndev = 2 - (__mu + __yn) / __mu; + __zndev = 2 - (__mu + __zn) / __mu; + _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); + __epsilon = std::max(__epsilon, std::abs(__zndev)); + if (__epsilon < __errtol) + break; + const _Tp __xnroot = std::sqrt(__xn); + const _Tp __ynroot = std::sqrt(__yn); + const _Tp __znroot = std::sqrt(__zn); + const _Tp __lambda = __xnroot * (__ynroot + __znroot) + + __ynroot * __znroot; + __xn = __c0 * (__xn + __lambda); + __yn = __c0 * (__yn + __lambda); + __zn = __c0 * (__zn + __lambda); + } + + const _Tp __e2 = __xndev * __yndev - __zndev * __zndev; + const _Tp __e3 = __xndev * __yndev * __zndev; + const _Tp __s = _Tp(1) + (__c1 * __e2 - __c2 - __c3 * __e3) * __e2 + + __c4 * __e3; + + return __s / std::sqrt(__mu); + } + } +# 153 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_1_series(_Tp __k) + { + + const _Tp __kk = __k * __k; + + _Tp __term = __kk / _Tp(4); + _Tp __sum = _Tp(1) + __term; + + const unsigned int __max_iter = 1000; + for (unsigned int __i = 2; __i < __max_iter; ++__i) + { + __term *= (2 * __i - 1) * __kk / (2 * __i); + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + __sum += __term; + } + + return __numeric_constants<_Tp>::__pi_2() * __sum; + } +# 191 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_1(_Tp __k) + { + + if (__isnan(__k)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) >= _Tp(1)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __ellint_rf(_Tp(0), _Tp(1) - __k * __k, _Tp(1)); + } +# 219 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_1(_Tp __k, _Tp __phi) + { + + if (__isnan(__k) || __isnan(__phi)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __ellint_1.")); + else + { + + const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + + _Tp(0.5L)); + const _Tp __phi_red = __phi + - __n * __numeric_constants<_Tp>::__pi(); + + const _Tp __s = std::sin(__phi_red); + const _Tp __c = std::cos(__phi_red); + + const _Tp __F = __s + * __ellint_rf(__c * __c, + _Tp(1) - __k * __k * __s * __s, _Tp(1)); + + if (__n == 0) + return __F; + else + return __F + _Tp(2) * __n * __comp_ellint_1(__k); + } + } +# 266 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_2_series(_Tp __k) + { + + const _Tp __kk = __k * __k; + + _Tp __term = __kk; + _Tp __sum = __term; + + const unsigned int __max_iter = 1000; + for (unsigned int __i = 2; __i < __max_iter; ++__i) + { + const _Tp __i2m = 2 * __i - 1; + const _Tp __i2 = 2 * __i; + __term *= __i2m * __i2m * __kk / (__i2 * __i2); + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + __sum += __term / __i2m; + } + + return __numeric_constants<_Tp>::__pi_2() * (_Tp(1) - __sum); + } +# 314 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rd(_Tp __x, _Tp __y, _Tp __z) + { + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6)); + const _Tp __max = std::numeric_limits<_Tp>::max(); + const _Tp __lolim = _Tp(2) / std::pow(__max, _Tp(2) / _Tp(3)); + + if (__x < _Tp(0) || __y < _Tp(0)) + std::__throw_domain_error(("Argument less than zero " "in __ellint_rd.") + ); + else if (__x + __y < __lolim || __z < __lolim) + std::__throw_domain_error(("Argument too small " "in __ellint_rd.") + ); + else + { + const _Tp __c0 = _Tp(1) / _Tp(4); + const _Tp __c1 = _Tp(3) / _Tp(14); + const _Tp __c2 = _Tp(1) / _Tp(6); + const _Tp __c3 = _Tp(9) / _Tp(22); + const _Tp __c4 = _Tp(3) / _Tp(26); + + _Tp __xn = __x; + _Tp __yn = __y; + _Tp __zn = __z; + _Tp __sigma = _Tp(0); + _Tp __power4 = _Tp(1); + + _Tp __mu; + _Tp __xndev, __yndev, __zndev; + + const unsigned int __max_iter = 100; + for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) + { + __mu = (__xn + __yn + _Tp(3) * __zn) / _Tp(5); + __xndev = (__mu - __xn) / __mu; + __yndev = (__mu - __yn) / __mu; + __zndev = (__mu - __zn) / __mu; + _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); + __epsilon = std::max(__epsilon, std::abs(__zndev)); + if (__epsilon < __errtol) + break; + _Tp __xnroot = std::sqrt(__xn); + _Tp __ynroot = std::sqrt(__yn); + _Tp __znroot = std::sqrt(__zn); + _Tp __lambda = __xnroot * (__ynroot + __znroot) + + __ynroot * __znroot; + __sigma += __power4 / (__znroot * (__zn + __lambda)); + __power4 *= __c0; + __xn = __c0 * (__xn + __lambda); + __yn = __c0 * (__yn + __lambda); + __zn = __c0 * (__zn + __lambda); + } + + _Tp __ea = __xndev * __yndev; + _Tp __eb = __zndev * __zndev; + _Tp __ec = __ea - __eb; + _Tp __ed = __ea - _Tp(6) * __eb; + _Tp __ef = __ed + __ec + __ec; + _Tp __s1 = __ed * (-__c1 + __c3 * __ed + / _Tp(3) - _Tp(3) * __c4 * __zndev * __ef + / _Tp(2)); + _Tp __s2 = __zndev + * (__c2 * __ef + + __zndev * (-__c3 * __ec - __zndev * __c4 - __ea)); + + return _Tp(3) * __sigma + __power4 * (_Tp(1) + __s1 + __s2) + / (__mu * std::sqrt(__mu)); + } + } +# 399 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_2(_Tp __k) + { + + if (__isnan(__k)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) == 1) + return _Tp(1); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __comp_ellint_2.")); + else + { + const _Tp __kk = __k * __k; + + return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1)) + - __kk * __ellint_rd(_Tp(0), _Tp(1) - __kk, _Tp(1)) / _Tp(3); + } + } +# 433 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_2(_Tp __k, _Tp __phi) + { + + if (__isnan(__k) || __isnan(__phi)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __ellint_2.")); + else + { + + const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + + _Tp(0.5L)); + const _Tp __phi_red = __phi + - __n * __numeric_constants<_Tp>::__pi(); + + const _Tp __kk = __k * __k; + const _Tp __s = std::sin(__phi_red); + const _Tp __ss = __s * __s; + const _Tp __sss = __ss * __s; + const _Tp __c = std::cos(__phi_red); + const _Tp __cc = __c * __c; + + const _Tp __E = __s + * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1)) + - __kk * __sss + * __ellint_rd(__cc, _Tp(1) - __kk * __ss, _Tp(1)) + / _Tp(3); + + if (__n == 0) + return __E; + else + return __E + _Tp(2) * __n * __comp_ellint_2(__k); + } + } +# 492 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rc(_Tp __x, _Tp __y) + { + const _Tp __min = std::numeric_limits<_Tp>::min(); + const _Tp __lolim = _Tp(5) * __min; + + if (__x < _Tp(0) || __y < _Tp(0) || __x + __y < __lolim) + std::__throw_domain_error(("Argument less than zero " "in __ellint_rc.") + ); + else + { + const _Tp __c0 = _Tp(1) / _Tp(4); + const _Tp __c1 = _Tp(1) / _Tp(7); + const _Tp __c2 = _Tp(9) / _Tp(22); + const _Tp __c3 = _Tp(3) / _Tp(10); + const _Tp __c4 = _Tp(3) / _Tp(8); + + _Tp __xn = __x; + _Tp __yn = __y; + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol = std::pow(__eps / _Tp(30), _Tp(1) / _Tp(6)); + _Tp __mu; + _Tp __sn; + + const unsigned int __max_iter = 100; + for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) + { + __mu = (__xn + _Tp(2) * __yn) / _Tp(3); + __sn = (__yn + __mu) / __mu - _Tp(2); + if (std::abs(__sn) < __errtol) + break; + const _Tp __lambda = _Tp(2) * std::sqrt(__xn) * std::sqrt(__yn) + + __yn; + __xn = __c0 * (__xn + __lambda); + __yn = __c0 * (__yn + __lambda); + } + + _Tp __s = __sn * __sn + * (__c3 + __sn*(__c1 + __sn * (__c4 + __sn * __c2))); + + return (_Tp(1) + __s) / std::sqrt(__mu); + } + } +# 561 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rj(_Tp __x, _Tp __y, _Tp __z, _Tp __p) + { + const _Tp __min = std::numeric_limits<_Tp>::min(); + const _Tp __lolim = std::pow(_Tp(5) * __min, _Tp(1)/_Tp(3)); + + if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0)) + std::__throw_domain_error(("Argument less than zero " "in __ellint_rj.") + ); + else if (__x + __y < __lolim || __x + __z < __lolim + || __y + __z < __lolim || __p < __lolim) + std::__throw_domain_error(("Argument too small " "in __ellint_rj") + ); + else + { + const _Tp __c0 = _Tp(1) / _Tp(4); + const _Tp __c1 = _Tp(3) / _Tp(14); + const _Tp __c2 = _Tp(1) / _Tp(3); + const _Tp __c3 = _Tp(3) / _Tp(22); + const _Tp __c4 = _Tp(3) / _Tp(26); + + _Tp __xn = __x; + _Tp __yn = __y; + _Tp __zn = __z; + _Tp __pn = __p; + _Tp __sigma = _Tp(0); + _Tp __power4 = _Tp(1); + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6)); + + _Tp __mu; + _Tp __xndev, __yndev, __zndev, __pndev; + + const unsigned int __max_iter = 100; + for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) + { + __mu = (__xn + __yn + __zn + _Tp(2) * __pn) / _Tp(5); + __xndev = (__mu - __xn) / __mu; + __yndev = (__mu - __yn) / __mu; + __zndev = (__mu - __zn) / __mu; + __pndev = (__mu - __pn) / __mu; + _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); + __epsilon = std::max(__epsilon, std::abs(__zndev)); + __epsilon = std::max(__epsilon, std::abs(__pndev)); + if (__epsilon < __errtol) + break; + const _Tp __xnroot = std::sqrt(__xn); + const _Tp __ynroot = std::sqrt(__yn); + const _Tp __znroot = std::sqrt(__zn); + const _Tp __lambda = __xnroot * (__ynroot + __znroot) + + __ynroot * __znroot; + const _Tp __alpha1 = __pn * (__xnroot + __ynroot + __znroot) + + __xnroot * __ynroot * __znroot; + const _Tp __alpha2 = __alpha1 * __alpha1; + const _Tp __beta = __pn * (__pn + __lambda) + * (__pn + __lambda); + __sigma += __power4 * __ellint_rc(__alpha2, __beta); + __power4 *= __c0; + __xn = __c0 * (__xn + __lambda); + __yn = __c0 * (__yn + __lambda); + __zn = __c0 * (__zn + __lambda); + __pn = __c0 * (__pn + __lambda); + } + + _Tp __ea = __xndev * (__yndev + __zndev) + __yndev * __zndev; + _Tp __eb = __xndev * __yndev * __zndev; + _Tp __ec = __pndev * __pndev; + _Tp __e2 = __ea - _Tp(3) * __ec; + _Tp __e3 = __eb + _Tp(2) * __pndev * (__ea - __ec); + _Tp __s1 = _Tp(1) + __e2 * (-__c1 + _Tp(3) * __c3 * __e2 / _Tp(4) + - _Tp(3) * __c4 * __e3 / _Tp(2)); + _Tp __s2 = __eb * (__c2 / _Tp(2) + + __pndev * (-__c3 - __c3 + __pndev * __c4)); + _Tp __s3 = __pndev * __ea * (__c2 - __pndev * __c3) + - __c2 * __pndev * __ec; + + return _Tp(3) * __sigma + __power4 * (__s1 + __s2 + __s3) + / (__mu * std::sqrt(__mu)); + } + } +# 661 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_3(_Tp __k, _Tp __nu) + { + + if (__isnan(__k) || __isnan(__nu)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__nu == _Tp(1)) + return std::numeric_limits<_Tp>::infinity(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __comp_ellint_3.")); + else + { + const _Tp __kk = __k * __k; + + return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1)) + + __nu + * __ellint_rj(_Tp(0), _Tp(1) - __kk, _Tp(1), _Tp(1) - __nu) + / _Tp(3); + } + } +# 701 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_3(_Tp __k, _Tp __nu, _Tp __phi) + { + + if (__isnan(__k) || __isnan(__nu) || __isnan(__phi)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __ellint_3.")); + else + { + + const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + + _Tp(0.5L)); + const _Tp __phi_red = __phi + - __n * __numeric_constants<_Tp>::__pi(); + + const _Tp __kk = __k * __k; + const _Tp __s = std::sin(__phi_red); + const _Tp __ss = __s * __s; + const _Tp __sss = __ss * __s; + const _Tp __c = std::cos(__phi_red); + const _Tp __cc = __c * __c; + + const _Tp __Pi = __s + * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1)) + + __nu * __sss + * __ellint_rj(__cc, _Tp(1) - __kk * __ss, _Tp(1), + _Tp(1) - __nu * __ss) / _Tp(3); + + if (__n == 0) + return __Pi; + else + return __Pi + _Tp(2) * __n * __comp_ellint_3(__k, __nu); + } + } + } + + + + + +} +# 51 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 1 3 +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + namespace __detail + { + template _Tp __expint_E1(_Tp); +# 81 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_E1_series(_Tp __x) + { + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + _Tp __term = _Tp(1); + _Tp __esum = _Tp(0); + _Tp __osum = _Tp(0); + const unsigned int __max_iter = 1000; + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + __term *= - __x / __i; + if (std::abs(__term) < __eps) + break; + if (__term >= _Tp(0)) + __esum += __term / __i; + else + __osum += __term / __i; + } + + return - __esum - __osum + - __numeric_constants<_Tp>::__gamma_e() - std::log(__x); + } +# 118 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_E1_asymp(_Tp __x) + { + _Tp __term = _Tp(1); + _Tp __esum = _Tp(1); + _Tp __osum = _Tp(0); + const unsigned int __max_iter = 1000; + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + _Tp __prev = __term; + __term *= - __i / __x; + if (std::abs(__term) > std::abs(__prev)) + break; + if (__term >= _Tp(0)) + __esum += __term; + else + __osum += __term; + } + + return std::exp(- __x) * (__esum + __osum) / __x; + } +# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_En_series(unsigned int __n, _Tp __x) + { + const unsigned int __max_iter = 1000; + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const int __nm1 = __n - 1; + _Tp __ans = (__nm1 != 0 + ? _Tp(1) / __nm1 : -std::log(__x) + - __numeric_constants<_Tp>::__gamma_e()); + _Tp __fact = _Tp(1); + for (int __i = 1; __i <= __max_iter; ++__i) + { + __fact *= -__x / _Tp(__i); + _Tp __del; + if ( __i != __nm1 ) + __del = -__fact / _Tp(__i - __nm1); + else + { + _Tp __psi = -__numeric_constants<_Tp>::gamma_e(); + for (int __ii = 1; __ii <= __nm1; ++__ii) + __psi += _Tp(1) / _Tp(__ii); + __del = __fact * (__psi - std::log(__x)); + } + __ans += __del; + if (std::abs(__del) < __eps * std::abs(__ans)) + return __ans; + } + std::__throw_runtime_error(("Series summation failed " "in __expint_En_series.") + ); + } +# 201 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_En_cont_frac(unsigned int __n, _Tp __x) + { + const unsigned int __max_iter = 1000; + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __fp_min = std::numeric_limits<_Tp>::min(); + const int __nm1 = __n - 1; + _Tp __b = __x + _Tp(__n); + _Tp __c = _Tp(1) / __fp_min; + _Tp __d = _Tp(1) / __b; + _Tp __h = __d; + for ( unsigned int __i = 1; __i <= __max_iter; ++__i ) + { + _Tp __a = -_Tp(__i * (__nm1 + __i)); + __b += _Tp(2); + __d = _Tp(1) / (__a * __d + __b); + __c = __b + __a / __c; + const _Tp __del = __c * __d; + __h *= __del; + if (std::abs(__del - _Tp(1)) < __eps) + { + const _Tp __ans = __h * std::exp(-__x); + return __ans; + } + } + std::__throw_runtime_error(("Continued fraction failed " "in __expint_En_cont_frac.") + ); + } +# 246 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_En_recursion(unsigned int __n, _Tp __x) + { + _Tp __En; + _Tp __E1 = __expint_E1(__x); + if (__x < _Tp(__n)) + { + + __En = __E1; + for (unsigned int __j = 2; __j < __n; ++__j) + __En = (std::exp(-__x) - __x * __En) / _Tp(__j - 1); + } + else + { + + __En = _Tp(1); + const int __N = __n + 20; + _Tp __save = _Tp(0); + for (int __j = __N; __j > 0; --__j) + { + __En = (std::exp(-__x) - __j * __En) / __x; + if (__j == __n) + __save = __En; + } + _Tp __norm = __En / __E1; + __En /= __norm; + } + + return __En; + } +# 290 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_Ei_series(_Tp __x) + { + _Tp __term = _Tp(1); + _Tp __sum = _Tp(0); + const unsigned int __max_iter = 1000; + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + __term *= __x / __i; + __sum += __term / __i; + if (__term < std::numeric_limits<_Tp>::epsilon() * __sum) + break; + } + + return __numeric_constants<_Tp>::__gamma_e() + __sum + std::log(__x); + } +# 321 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_Ei_asymp(_Tp __x) + { + _Tp __term = _Tp(1); + _Tp __sum = _Tp(1); + const unsigned int __max_iter = 1000; + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + _Tp __prev = __term; + __term *= __i / __x; + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + if (__term >= __prev) + break; + __sum += __term; + } + + return std::exp(__x) * __sum / __x; + } +# 354 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_Ei(_Tp __x) + { + if (__x < _Tp(0)) + return -__expint_E1(-__x); + else if (__x < -std::log(std::numeric_limits<_Tp>::epsilon())) + return __expint_Ei_series(__x); + else + return __expint_Ei_asymp(__x); + } +# 378 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_E1(_Tp __x) + { + if (__x < _Tp(0)) + return -__expint_Ei(-__x); + else if (__x < _Tp(1)) + return __expint_E1_series(__x); + else if (__x < _Tp(100)) + return __expint_En_cont_frac(1, __x); + else + return __expint_E1_asymp(__x); + } +# 408 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_asymp(unsigned int __n, _Tp __x) + { + _Tp __term = _Tp(1); + _Tp __sum = _Tp(1); + for (unsigned int __i = 1; __i <= __n; ++__i) + { + _Tp __prev = __term; + __term *= -(__n - __i + 1) / __x; + if (std::abs(__term) > std::abs(__prev)) + break; + __sum += __term; + } + + return std::exp(-__x) * __sum / __x; + } +# 442 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_large_n(unsigned int __n, _Tp __x) + { + const _Tp __xpn = __x + __n; + const _Tp __xpn2 = __xpn * __xpn; + _Tp __term = _Tp(1); + _Tp __sum = _Tp(1); + for (unsigned int __i = 1; __i <= __n; ++__i) + { + _Tp __prev = __term; + __term *= (__n - 2 * (__i - 1) * __x) / __xpn2; + if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon()) + break; + __sum += __term; + } + + return std::exp(-__x) * __sum / __xpn; + } +# 476 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + _Tp + __expint(unsigned int __n, _Tp __x) + { + + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__n <= 1 && __x == _Tp(0)) + return std::numeric_limits<_Tp>::infinity(); + else + { + _Tp __E0 = std::exp(__x) / __x; + if (__n == 0) + return __E0; + + _Tp __E1 = __expint_E1(__x); + if (__n == 1) + return __E1; + + if (__x == _Tp(0)) + return _Tp(1) / static_cast<_Tp>(__n - 1); + + _Tp __En = __expint_En_recursion(__n, __x); + + return __En; + } + } +# 516 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 + template + inline _Tp + __expint(_Tp __x) + { + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __expint_Ei(__x); + } + } + + + + + +} +# 52 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 1 3 +# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + namespace __detail + { +# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __conf_hyperg_series(_Tp __a, _Tp __c, _Tp __x) + { + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + _Tp __term = _Tp(1); + _Tp __Fac = _Tp(1); + const unsigned int __max_iter = 100000; + unsigned int __i; + for (__i = 0; __i < __max_iter; ++__i) + { + __term *= (__a + _Tp(__i)) * __x + / ((__c + _Tp(__i)) * _Tp(1 + __i)); + if (std::abs(__term) < __eps) + { + break; + } + __Fac += __term; + } + if (__i == __max_iter) + std::__throw_runtime_error(("Series failed to converge " "in __conf_hyperg_series.") + ); + + return __Fac; + } +# 120 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __conf_hyperg_luke(_Tp __a, _Tp __c, _Tp __xin) + { + const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L)); + const int __nmax = 20000; + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __x = -__xin; + const _Tp __x3 = __x * __x * __x; + const _Tp __t0 = __a / __c; + const _Tp __t1 = (__a + _Tp(1)) / (_Tp(2) * __c); + const _Tp __t2 = (__a + _Tp(2)) / (_Tp(2) * (__c + _Tp(1))); + _Tp __F = _Tp(1); + _Tp __prec; + + _Tp __Bnm3 = _Tp(1); + _Tp __Bnm2 = _Tp(1) + __t1 * __x; + _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x); + + _Tp __Anm3 = _Tp(1); + _Tp __Anm2 = __Bnm2 - __t0 * __x; + _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x + + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x; + + int __n = 3; + while(1) + { + _Tp __npam1 = _Tp(__n - 1) + __a; + _Tp __npcm1 = _Tp(__n - 1) + __c; + _Tp __npam2 = _Tp(__n - 2) + __a; + _Tp __npcm2 = _Tp(__n - 2) + __c; + _Tp __tnm1 = _Tp(2 * __n - 1); + _Tp __tnm3 = _Tp(2 * __n - 3); + _Tp __tnm5 = _Tp(2 * __n - 5); + _Tp __F1 = (_Tp(__n - 2) - __a) / (_Tp(2) * __tnm3 * __npcm1); + _Tp __F2 = (_Tp(__n) + __a) * __npam1 + / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1); + _Tp __F3 = -__npam2 * __npam1 * (_Tp(__n - 2) - __a) + / (_Tp(8) * __tnm3 * __tnm3 * __tnm5 + * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1); + _Tp __E = -__npam1 * (_Tp(__n - 1) - __c) + / (_Tp(2) * __tnm3 * __npcm2 * __npcm1); + + _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1 + + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3; + _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1 + + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3; + _Tp __r = __An / __Bn; + + __prec = std::abs((__F - __r) / __F); + __F = __r; + + if (__prec < __eps || __n > __nmax) + break; + + if (std::abs(__An) > __big || std::abs(__Bn) > __big) + { + __An /= __big; + __Bn /= __big; + __Anm1 /= __big; + __Bnm1 /= __big; + __Anm2 /= __big; + __Bnm2 /= __big; + __Anm3 /= __big; + __Bnm3 /= __big; + } + else if (std::abs(__An) < _Tp(1) / __big + || std::abs(__Bn) < _Tp(1) / __big) + { + __An *= __big; + __Bn *= __big; + __Anm1 *= __big; + __Bnm1 *= __big; + __Anm2 *= __big; + __Bnm2 *= __big; + __Anm3 *= __big; + __Bnm3 *= __big; + } + + ++__n; + __Bnm3 = __Bnm2; + __Bnm2 = __Bnm1; + __Bnm1 = __Bn; + __Anm3 = __Anm2; + __Anm2 = __Anm1; + __Anm1 = __An; + } + + if (__n >= __nmax) + std::__throw_runtime_error(("Iteration failed to converge " "in __conf_hyperg_luke.") + ); + + return __F; + } +# 227 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __conf_hyperg(_Tp __a, _Tp __c, _Tp __x) + { + + const _Tp __c_nint = ::std::nearbyint(__c); + + + + if (__isnan(__a) || __isnan(__c) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__c_nint == __c && __c_nint <= 0) + return std::numeric_limits<_Tp>::infinity(); + else if (__a == _Tp(0)) + return _Tp(1); + else if (__c == __a) + return std::exp(__x); + else if (__x < _Tp(0)) + return __conf_hyperg_luke(__a, __c, __x); + else + return __conf_hyperg_series(__a, __c, __x); + } +# 271 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __hyperg_series(_Tp __a, _Tp __b, _Tp __c, _Tp __x) + { + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + _Tp __term = _Tp(1); + _Tp __Fabc = _Tp(1); + const unsigned int __max_iter = 100000; + unsigned int __i; + for (__i = 0; __i < __max_iter; ++__i) + { + __term *= (__a + _Tp(__i)) * (__b + _Tp(__i)) * __x + / ((__c + _Tp(__i)) * _Tp(1 + __i)); + if (std::abs(__term) < __eps) + { + break; + } + __Fabc += __term; + } + if (__i == __max_iter) + std::__throw_runtime_error(("Series failed to converge " "in __hyperg_series.") + ); + + return __Fabc; + } + + + + + + + + template + _Tp + __hyperg_luke(_Tp __a, _Tp __b, _Tp __c, _Tp __xin) + { + const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L)); + const int __nmax = 20000; + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __x = -__xin; + const _Tp __x3 = __x * __x * __x; + const _Tp __t0 = __a * __b / __c; + const _Tp __t1 = (__a + _Tp(1)) * (__b + _Tp(1)) / (_Tp(2) * __c); + const _Tp __t2 = (__a + _Tp(2)) * (__b + _Tp(2)) + / (_Tp(2) * (__c + _Tp(1))); + + _Tp __F = _Tp(1); + + _Tp __Bnm3 = _Tp(1); + _Tp __Bnm2 = _Tp(1) + __t1 * __x; + _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x); + + _Tp __Anm3 = _Tp(1); + _Tp __Anm2 = __Bnm2 - __t0 * __x; + _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x + + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x; + + int __n = 3; + while (1) + { + const _Tp __npam1 = _Tp(__n - 1) + __a; + const _Tp __npbm1 = _Tp(__n - 1) + __b; + const _Tp __npcm1 = _Tp(__n - 1) + __c; + const _Tp __npam2 = _Tp(__n - 2) + __a; + const _Tp __npbm2 = _Tp(__n - 2) + __b; + const _Tp __npcm2 = _Tp(__n - 2) + __c; + const _Tp __tnm1 = _Tp(2 * __n - 1); + const _Tp __tnm3 = _Tp(2 * __n - 3); + const _Tp __tnm5 = _Tp(2 * __n - 5); + const _Tp __n2 = __n * __n; + const _Tp __F1 = (_Tp(3) * __n2 + (__a + __b - _Tp(6)) * __n + + _Tp(2) - __a * __b - _Tp(2) * (__a + __b)) + / (_Tp(2) * __tnm3 * __npcm1); + const _Tp __F2 = -(_Tp(3) * __n2 - (__a + __b + _Tp(6)) * __n + + _Tp(2) - __a * __b) * __npam1 * __npbm1 + / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1); + const _Tp __F3 = (__npam2 * __npam1 * __npbm2 * __npbm1 + * (_Tp(__n - 2) - __a) * (_Tp(__n - 2) - __b)) + / (_Tp(8) * __tnm3 * __tnm3 * __tnm5 + * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1); + const _Tp __E = -__npam1 * __npbm1 * (_Tp(__n - 1) - __c) + / (_Tp(2) * __tnm3 * __npcm2 * __npcm1); + + _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1 + + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3; + _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1 + + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3; + const _Tp __r = __An / __Bn; + + const _Tp __prec = std::abs((__F - __r) / __F); + __F = __r; + + if (__prec < __eps || __n > __nmax) + break; + + if (std::abs(__An) > __big || std::abs(__Bn) > __big) + { + __An /= __big; + __Bn /= __big; + __Anm1 /= __big; + __Bnm1 /= __big; + __Anm2 /= __big; + __Bnm2 /= __big; + __Anm3 /= __big; + __Bnm3 /= __big; + } + else if (std::abs(__An) < _Tp(1) / __big + || std::abs(__Bn) < _Tp(1) / __big) + { + __An *= __big; + __Bn *= __big; + __Anm1 *= __big; + __Bnm1 *= __big; + __Anm2 *= __big; + __Bnm2 *= __big; + __Anm3 *= __big; + __Bnm3 *= __big; + } + + ++__n; + __Bnm3 = __Bnm2; + __Bnm2 = __Bnm1; + __Bnm1 = __Bn; + __Anm3 = __Anm2; + __Anm2 = __Anm1; + __Anm1 = __An; + } + + if (__n >= __nmax) + std::__throw_runtime_error(("Iteration failed to converge " "in __hyperg_luke.") + ); + + return __F; + } +# 438 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __hyperg_reflect(_Tp __a, _Tp __b, _Tp __c, _Tp __x) + { + const _Tp __d = __c - __a - __b; + const int __intd = std::floor(__d + _Tp(0.5L)); + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __toler = _Tp(1000) * __eps; + const _Tp __log_max = std::log(std::numeric_limits<_Tp>::max()); + const bool __d_integer = (std::abs(__d - __intd) < __toler); + + if (__d_integer) + { + const _Tp __ln_omx = std::log(_Tp(1) - __x); + const _Tp __ad = std::abs(__d); + _Tp __F1, __F2; + + _Tp __d1, __d2; + if (__d >= _Tp(0)) + { + __d1 = __d; + __d2 = _Tp(0); + } + else + { + __d1 = _Tp(0); + __d2 = __d; + } + + const _Tp __lng_c = __log_gamma(__c); + + + if (__ad < __eps) + { + + __F1 = _Tp(0); + } + else + { + + bool __ok_d1 = true; + _Tp __lng_ad, __lng_ad1, __lng_bd1; + try + { + __lng_ad = __log_gamma(__ad); + __lng_ad1 = __log_gamma(__a + __d1); + __lng_bd1 = __log_gamma(__b + __d1); + } + catch(...) + { + __ok_d1 = false; + } + + if (__ok_d1) + { + + + + _Tp __sum1 = _Tp(1); + _Tp __term = _Tp(1); + _Tp __ln_pre1 = __lng_ad + __lng_c + __d2 * __ln_omx + - __lng_ad1 - __lng_bd1; + + + + for (int __i = 1; __i < __ad; ++__i) + { + const int __j = __i - 1; + __term *= (__a + __d2 + __j) * (__b + __d2 + __j) + / (_Tp(1) + __d2 + __j) / __i * (_Tp(1) - __x); + __sum1 += __term; + } + + if (__ln_pre1 > __log_max) + std::__throw_runtime_error(("Overflow of gamma functions" " in __hyperg_luke.") + ); + else + __F1 = std::exp(__ln_pre1) * __sum1; + } + else + { + + + __F1 = _Tp(0); + } + } + + + bool __ok_d2 = true; + _Tp __lng_ad2, __lng_bd2; + try + { + __lng_ad2 = __log_gamma(__a + __d2); + __lng_bd2 = __log_gamma(__b + __d2); + } + catch(...) + { + __ok_d2 = false; + } + + if (__ok_d2) + { + + + const int __maxiter = 2000; + const _Tp __psi_1 = -__numeric_constants<_Tp>::__gamma_e(); + const _Tp __psi_1pd = __psi(_Tp(1) + __ad); + const _Tp __psi_apd1 = __psi(__a + __d1); + const _Tp __psi_bpd1 = __psi(__b + __d1); + + _Tp __psi_term = __psi_1 + __psi_1pd - __psi_apd1 + - __psi_bpd1 - __ln_omx; + _Tp __fact = _Tp(1); + _Tp __sum2 = __psi_term; + _Tp __ln_pre2 = __lng_c + __d1 * __ln_omx + - __lng_ad2 - __lng_bd2; + + + int __j; + for (__j = 1; __j < __maxiter; ++__j) + { + + + const _Tp __term1 = _Tp(1) / _Tp(__j) + + _Tp(1) / (__ad + __j); + const _Tp __term2 = _Tp(1) / (__a + __d1 + _Tp(__j - 1)) + + _Tp(1) / (__b + __d1 + _Tp(__j - 1)); + __psi_term += __term1 - __term2; + __fact *= (__a + __d1 + _Tp(__j - 1)) + * (__b + __d1 + _Tp(__j - 1)) + / ((__ad + __j) * __j) * (_Tp(1) - __x); + const _Tp __delta = __fact * __psi_term; + __sum2 += __delta; + if (std::abs(__delta) < __eps * std::abs(__sum2)) + break; + } + if (__j == __maxiter) + std::__throw_runtime_error(("Sum F2 failed to converge " "in __hyperg_reflect") + ); + + if (__sum2 == _Tp(0)) + __F2 = _Tp(0); + else + __F2 = std::exp(__ln_pre2) * __sum2; + } + else + { + + + __F2 = _Tp(0); + } + + const _Tp __sgn_2 = (__intd % 2 == 1 ? -_Tp(1) : _Tp(1)); + const _Tp __F = __F1 + __sgn_2 * __F2; + + return __F; + } + else + { + + + + + bool __ok1 = true; + _Tp __sgn_g1ca = _Tp(0), __ln_g1ca = _Tp(0); + _Tp __sgn_g1cb = _Tp(0), __ln_g1cb = _Tp(0); + try + { + __sgn_g1ca = __log_gamma_sign(__c - __a); + __ln_g1ca = __log_gamma(__c - __a); + __sgn_g1cb = __log_gamma_sign(__c - __b); + __ln_g1cb = __log_gamma(__c - __b); + } + catch(...) + { + __ok1 = false; + } + + bool __ok2 = true; + _Tp __sgn_g2a = _Tp(0), __ln_g2a = _Tp(0); + _Tp __sgn_g2b = _Tp(0), __ln_g2b = _Tp(0); + try + { + __sgn_g2a = __log_gamma_sign(__a); + __ln_g2a = __log_gamma(__a); + __sgn_g2b = __log_gamma_sign(__b); + __ln_g2b = __log_gamma(__b); + } + catch(...) + { + __ok2 = false; + } + + const _Tp __sgn_gc = __log_gamma_sign(__c); + const _Tp __ln_gc = __log_gamma(__c); + const _Tp __sgn_gd = __log_gamma_sign(__d); + const _Tp __ln_gd = __log_gamma(__d); + const _Tp __sgn_gmd = __log_gamma_sign(-__d); + const _Tp __ln_gmd = __log_gamma(-__d); + + const _Tp __sgn1 = __sgn_gc * __sgn_gd * __sgn_g1ca * __sgn_g1cb; + const _Tp __sgn2 = __sgn_gc * __sgn_gmd * __sgn_g2a * __sgn_g2b; + + _Tp __pre1, __pre2; + if (__ok1 && __ok2) + { + _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb; + _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b + + __d * std::log(_Tp(1) - __x); + if (__ln_pre1 < __log_max && __ln_pre2 < __log_max) + { + __pre1 = std::exp(__ln_pre1); + __pre2 = std::exp(__ln_pre2); + __pre1 *= __sgn1; + __pre2 *= __sgn2; + } + else + { + std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect") + ); + } + } + else if (__ok1 && !__ok2) + { + _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb; + if (__ln_pre1 < __log_max) + { + __pre1 = std::exp(__ln_pre1); + __pre1 *= __sgn1; + __pre2 = _Tp(0); + } + else + { + std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect") + ); + } + } + else if (!__ok1 && __ok2) + { + _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b + + __d * std::log(_Tp(1) - __x); + if (__ln_pre2 < __log_max) + { + __pre1 = _Tp(0); + __pre2 = std::exp(__ln_pre2); + __pre2 *= __sgn2; + } + else + { + std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect") + ); + } + } + else + { + __pre1 = _Tp(0); + __pre2 = _Tp(0); + std::__throw_runtime_error(("Underflow of gamma functions " "in __hyperg_reflect") + ); + } + + const _Tp __F1 = __hyperg_series(__a, __b, _Tp(1) - __d, + _Tp(1) - __x); + const _Tp __F2 = __hyperg_series(__c - __a, __c - __b, _Tp(1) + __d, + _Tp(1) - __x); + + const _Tp __F = __pre1 * __F1 + __pre2 * __F2; + + return __F; + } + } +# 728 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 + template + _Tp + __hyperg(_Tp __a, _Tp __b, _Tp __c, _Tp __x) + { + + const _Tp __a_nint = ::std::nearbyint(__a); + const _Tp __b_nint = ::std::nearbyint(__b); + const _Tp __c_nint = ::std::nearbyint(__c); + + + + + + const _Tp __toler = _Tp(1000) * std::numeric_limits<_Tp>::epsilon(); + if (std::abs(__x) >= _Tp(1)) + std::__throw_domain_error(("Argument outside unit circle " "in __hyperg.") + ); + else if (__isnan(__a) || __isnan(__b) + || __isnan(__c) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__c_nint == __c && __c_nint <= _Tp(0)) + return std::numeric_limits<_Tp>::infinity(); + else if (std::abs(__c - __b) < __toler || std::abs(__c - __a) < __toler) + return std::pow(_Tp(1) - __x, __c - __a - __b); + else if (__a >= _Tp(0) && __b >= _Tp(0) && __c >= _Tp(0) + && __x >= _Tp(0) && __x < _Tp(0.995L)) + return __hyperg_series(__a, __b, __c, __x); + else if (std::abs(__a) < _Tp(10) && std::abs(__b) < _Tp(10)) + { + + + if (__a < _Tp(0) && std::abs(__a - __a_nint) < __toler) + return __hyperg_series(__a_nint, __b, __c, __x); + else if (__b < _Tp(0) && std::abs(__b - __b_nint) < __toler) + return __hyperg_series(__a, __b_nint, __c, __x); + else if (__x < -_Tp(0.25L)) + return __hyperg_luke(__a, __b, __c, __x); + else if (__x < _Tp(0.5L)) + return __hyperg_series(__a, __b, __c, __x); + else + if (std::abs(__c) > _Tp(10)) + return __hyperg_series(__a, __b, __c, __x); + else + return __hyperg_reflect(__a, __b, __c, __x); + } + else + return __hyperg_luke(__a, __b, __c, __x); + } + } + + + + + + +} +# 53 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 1 3 +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 + namespace __detail + { +# 80 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 + template + _Tp + __poly_legendre_p(unsigned int __l, _Tp __x) + { + + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x == +_Tp(1)) + return +_Tp(1); + else if (__x == -_Tp(1)) + return (__l % 2 == 1 ? -_Tp(1) : +_Tp(1)); + else + { + _Tp __p_lm2 = _Tp(1); + if (__l == 0) + return __p_lm2; + + _Tp __p_lm1 = __x; + if (__l == 1) + return __p_lm1; + + _Tp __p_l = 0; + for (unsigned int __ll = 2; __ll <= __l; ++__ll) + { + + + __p_l = _Tp(2) * __x * __p_lm1 - __p_lm2 + - (__x * __p_lm1 - __p_lm2) / _Tp(__ll); + __p_lm2 = __p_lm1; + __p_lm1 = __p_l; + } + + return __p_l; + } + } +# 136 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 + template + _Tp + __assoc_legendre_p(unsigned int __l, unsigned int __m, _Tp __x, + _Tp __phase = _Tp(+1)) + { + + if (__m > __l) + return _Tp(0); + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__m == 0) + return __poly_legendre_p(__l, __x); + else + { + _Tp __p_mm = _Tp(1); + if (__m > 0) + { + + + _Tp __root = std::sqrt(_Tp(1) - __x) * std::sqrt(_Tp(1) + __x); + _Tp __fact = _Tp(1); + for (unsigned int __i = 1; __i <= __m; ++__i) + { + __p_mm *= __phase * __fact * __root; + __fact += _Tp(2); + } + } + if (__l == __m) + return __p_mm; + + _Tp __p_mp1m = _Tp(2 * __m + 1) * __x * __p_mm; + if (__l == __m + 1) + return __p_mp1m; + + _Tp __p_lm2m = __p_mm; + _Tp __P_lm1m = __p_mp1m; + _Tp __p_lm = _Tp(0); + for (unsigned int __j = __m + 2; __j <= __l; ++__j) + { + __p_lm = (_Tp(2 * __j - 1) * __x * __P_lm1m + - _Tp(__j + __m - 1) * __p_lm2m) / _Tp(__j - __m); + __p_lm2m = __P_lm1m; + __P_lm1m = __p_lm; + } + + return __p_lm; + } + } +# 214 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 + template + _Tp + __sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta) + { + if (__isnan(__theta)) + return std::numeric_limits<_Tp>::quiet_NaN(); + + const _Tp __x = std::cos(__theta); + + if (__m > __l) + return _Tp(0); + else if (__m == 0) + { + _Tp __P = __poly_legendre_p(__l, __x); + _Tp __fact = std::sqrt(_Tp(2 * __l + 1) + / (_Tp(4) * __numeric_constants<_Tp>::__pi())); + __P *= __fact; + return __P; + } + else if (__x == _Tp(1) || __x == -_Tp(1)) + { + + return _Tp(0); + } + else + { + + + + + + const _Tp __sgn = ( __m % 2 == 1 ? -_Tp(1) : _Tp(1)); + const _Tp __y_mp1m_factor = __x * std::sqrt(_Tp(2 * __m + 3)); + + const _Tp __lncirc = ::std::log1p(-__x * __x); + + + + + + const _Tp __lnpoch = ::std::lgamma(_Tp(__m + _Tp(0.5L))) + - ::std::lgamma(_Tp(__m)); + + + + + const _Tp __lnpre_val = + -_Tp(0.25L) * __numeric_constants<_Tp>::__lnpi() + + _Tp(0.5L) * (__lnpoch + __m * __lncirc); + const _Tp __sr = std::sqrt((_Tp(2) + _Tp(1) / __m) + / (_Tp(4) * __numeric_constants<_Tp>::__pi())); + _Tp __y_mm = __sgn * __sr * std::exp(__lnpre_val); + _Tp __y_mp1m = __y_mp1m_factor * __y_mm; + + if (__l == __m) + return __y_mm; + else if (__l == __m + 1) + return __y_mp1m; + else + { + _Tp __y_lm = _Tp(0); + + + for (unsigned int __ll = __m + 2; __ll <= __l; ++__ll) + { + const _Tp __rat1 = _Tp(__ll - __m) / _Tp(__ll + __m); + const _Tp __rat2 = _Tp(__ll - __m - 1) / _Tp(__ll + __m - 1); + const _Tp __fact1 = std::sqrt(__rat1 * _Tp(2 * __ll + 1) + * _Tp(2 * __ll - 1)); + const _Tp __fact2 = std::sqrt(__rat1 * __rat2 * _Tp(2 * __ll + 1) + / _Tp(2 * __ll - 3)); + __y_lm = (__x * __y_mp1m * __fact1 + - (__ll + __m - 1) * __y_mm * __fact2) / _Tp(__ll - __m); + __y_mm = __y_mp1m; + __y_mp1m = __y_lm; + } + + return __y_lm; + } + } + } + } + + + + + + +} +# 54 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 1 3 +# 51 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + namespace __detail + { +# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + template + void + __bessel_ik(_Tp __nu, _Tp __x, + _Tp & __Inu, _Tp & __Knu, _Tp & __Ipnu, _Tp & __Kpnu) + { + if (__x == _Tp(0)) + { + if (__nu == _Tp(0)) + { + __Inu = _Tp(1); + __Ipnu = _Tp(0); + } + else if (__nu == _Tp(1)) + { + __Inu = _Tp(0); + __Ipnu = _Tp(0.5L); + } + else + { + __Inu = _Tp(0); + __Ipnu = _Tp(0); + } + __Knu = std::numeric_limits<_Tp>::infinity(); + __Kpnu = -std::numeric_limits<_Tp>::infinity(); + return; + } + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __fp_min = _Tp(10) * std::numeric_limits<_Tp>::epsilon(); + const int __max_iter = 15000; + const _Tp __x_min = _Tp(2); + + const int __nl = static_cast(__nu + _Tp(0.5L)); + + const _Tp __mu = __nu - __nl; + const _Tp __mu2 = __mu * __mu; + const _Tp __xi = _Tp(1) / __x; + const _Tp __xi2 = _Tp(2) * __xi; + _Tp __h = __nu * __xi; + if ( __h < __fp_min ) + __h = __fp_min; + _Tp __b = __xi2 * __nu; + _Tp __d = _Tp(0); + _Tp __c = __h; + int __i; + for ( __i = 1; __i <= __max_iter; ++__i ) + { + __b += __xi2; + __d = _Tp(1) / (__b + __d); + __c = __b + _Tp(1) / __c; + const _Tp __del = __c * __d; + __h *= __del; + if (std::abs(__del - _Tp(1)) < __eps) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Argument x too large " "in __bessel_ik; " "try asymptotic expansion.") + + ); + _Tp __Inul = __fp_min; + _Tp __Ipnul = __h * __Inul; + _Tp __Inul1 = __Inul; + _Tp __Ipnu1 = __Ipnul; + _Tp __fact = __nu * __xi; + for (int __l = __nl; __l >= 1; --__l) + { + const _Tp __Inutemp = __fact * __Inul + __Ipnul; + __fact -= __xi; + __Ipnul = __fact * __Inutemp + __Inul; + __Inul = __Inutemp; + } + _Tp __f = __Ipnul / __Inul; + _Tp __Kmu, __Knu1; + if (__x < __x_min) + { + const _Tp __x2 = __x / _Tp(2); + const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu; + const _Tp __fact = (std::abs(__pimu) < __eps + ? _Tp(1) : __pimu / std::sin(__pimu)); + _Tp __d = -std::log(__x2); + _Tp __e = __mu * __d; + const _Tp __fact2 = (std::abs(__e) < __eps + ? _Tp(1) : std::sinh(__e) / __e); + _Tp __gam1, __gam2, __gampl, __gammi; + __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi); + _Tp __ff = __fact + * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d); + _Tp __sum = __ff; + __e = std::exp(__e); + _Tp __p = __e / (_Tp(2) * __gampl); + _Tp __q = _Tp(1) / (_Tp(2) * __e * __gammi); + _Tp __c = _Tp(1); + __d = __x2 * __x2; + _Tp __sum1 = __p; + int __i; + for (__i = 1; __i <= __max_iter; ++__i) + { + __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2); + __c *= __d / __i; + __p /= __i - __mu; + __q /= __i + __mu; + const _Tp __del = __c * __ff; + __sum += __del; + const _Tp __del1 = __c * (__p - __i * __ff); + __sum1 += __del1; + if (std::abs(__del) < __eps * std::abs(__sum)) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Bessel k series failed to converge " "in __bessel_ik.") + ); + __Kmu = __sum; + __Knu1 = __sum1 * __xi2; + } + else + { + _Tp __b = _Tp(2) * (_Tp(1) + __x); + _Tp __d = _Tp(1) / __b; + _Tp __delh = __d; + _Tp __h = __delh; + _Tp __q1 = _Tp(0); + _Tp __q2 = _Tp(1); + _Tp __a1 = _Tp(0.25L) - __mu2; + _Tp __q = __c = __a1; + _Tp __a = -__a1; + _Tp __s = _Tp(1) + __q * __delh; + int __i; + for (__i = 2; __i <= __max_iter; ++__i) + { + __a -= 2 * (__i - 1); + __c = -__a * __c / __i; + const _Tp __qnew = (__q1 - __b * __q2) / __a; + __q1 = __q2; + __q2 = __qnew; + __q += __c * __qnew; + __b += _Tp(2); + __d = _Tp(1) / (__b + __a * __d); + __delh = (__b * __d - _Tp(1)) * __delh; + __h += __delh; + const _Tp __dels = __q * __delh; + __s += __dels; + if ( std::abs(__dels / __s) < __eps ) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Steed's method failed " "in __bessel_ik.") + ); + __h = __a1 * __h; + __Kmu = std::sqrt(__numeric_constants<_Tp>::__pi() / (_Tp(2) * __x)) + * std::exp(-__x) / __s; + __Knu1 = __Kmu * (__mu + __x + _Tp(0.5L) - __h) * __xi; + } + + _Tp __Kpmu = __mu * __xi * __Kmu - __Knu1; + _Tp __Inumu = __xi / (__f * __Kmu - __Kpmu); + __Inu = __Inumu * __Inul1 / __Inul; + __Ipnu = __Inumu * __Ipnu1 / __Inul; + for ( __i = 1; __i <= __nl; ++__i ) + { + const _Tp __Knutemp = (__mu + __i) * __xi2 * __Knu1 + __Kmu; + __Kmu = __Knu1; + __Knu1 = __Knutemp; + } + __Knu = __Kmu; + __Kpnu = __nu * __xi * __Kmu - __Knu1; + + return; + } +# 267 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + template + _Tp + __cyl_bessel_i(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_i.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x * __x < _Tp(10) * (__nu + _Tp(1))) + return __cyl_bessel_ij_series(__nu, __x, +_Tp(1), 200); + else + { + _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + return __I_nu; + } + } +# 303 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + template + _Tp + __cyl_bessel_k(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_k.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + { + _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + return __K_nu; + } + } +# 337 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + template + void + __sph_bessel_ik(unsigned int __n, _Tp __x, + _Tp & __i_n, _Tp & __k_n, _Tp & __ip_n, _Tp & __kp_n) + { + const _Tp __nu = _Tp(__n) + _Tp(0.5L); + + _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + + const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2() + / std::sqrt(__x); + + __i_n = __factor * __I_nu; + __k_n = __factor * __K_nu; + __ip_n = __factor * __Ip_nu - __i_n / (_Tp(2) * __x); + __kp_n = __factor * __Kp_nu - __k_n / (_Tp(2) * __x); + + return; + } +# 373 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 + template + void + __airy(_Tp __x, _Tp & __Ai, _Tp & __Bi, _Tp & __Aip, _Tp & __Bip) + { + const _Tp __absx = std::abs(__x); + const _Tp __rootx = std::sqrt(__absx); + const _Tp __z = _Tp(2) * __absx * __rootx / _Tp(3); + const _Tp _S_inf = std::numeric_limits<_Tp>::infinity(); + + if (__isnan(__x)) + __Bip = __Aip = __Bi = __Ai = std::numeric_limits<_Tp>::quiet_NaN(); + else if (__z == _S_inf) + { + __Aip = __Ai = _Tp(0); + __Bip = __Bi = _S_inf; + } + else if (__z == -_S_inf) + __Bip = __Aip = __Bi = __Ai = _Tp(0); + else if (__x > _Tp(0)) + { + _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu; + + __bessel_ik(_Tp(1) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + __Ai = __rootx * __K_nu + / (__numeric_constants<_Tp>::__sqrt3() + * __numeric_constants<_Tp>::__pi()); + __Bi = __rootx * (__K_nu / __numeric_constants<_Tp>::__pi() + + _Tp(2) * __I_nu / __numeric_constants<_Tp>::__sqrt3()); + + __bessel_ik(_Tp(2) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + __Aip = -__x * __K_nu + / (__numeric_constants<_Tp>::__sqrt3() + * __numeric_constants<_Tp>::__pi()); + __Bip = __x * (__K_nu / __numeric_constants<_Tp>::__pi() + + _Tp(2) * __I_nu + / __numeric_constants<_Tp>::__sqrt3()); + } + else if (__x < _Tp(0)) + { + _Tp __J_nu, __Jp_nu, __N_nu, __Np_nu; + + __bessel_jn(_Tp(1) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu); + __Ai = __rootx * (__J_nu + - __N_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2); + __Bi = -__rootx * (__N_nu + + __J_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2); + + __bessel_jn(_Tp(2) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu); + __Aip = __absx * (__N_nu / __numeric_constants<_Tp>::__sqrt3() + + __J_nu) / _Tp(2); + __Bip = __absx * (__J_nu / __numeric_constants<_Tp>::__sqrt3() + - __N_nu) / _Tp(2); + } + else + { + + + + __Ai = _Tp(0.35502805388781723926L); + __Bi = __Ai * __numeric_constants<_Tp>::__sqrt3(); + + + + + __Aip = -_Tp(0.25881940379280679840L); + __Bip = -__Aip * __numeric_constants<_Tp>::__sqrt3(); + } + + return; + } + } + + + + + +} +# 55 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 1 3 +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 56 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 + namespace __detail + { +# 72 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 + template + _Tp + __poly_hermite_recursion(unsigned int __n, _Tp __x) + { + + _Tp __H_0 = 1; + if (__n == 0) + return __H_0; + + + _Tp __H_1 = 2 * __x; + if (__n == 1) + return __H_1; + + + _Tp __H_n, __H_nm1, __H_nm2; + unsigned int __i; + for (__H_nm2 = __H_0, __H_nm1 = __H_1, __i = 2; __i <= __n; ++__i) + { + __H_n = 2 * (__x * __H_nm1 - (__i - 1) * __H_nm2); + __H_nm2 = __H_nm1; + __H_nm1 = __H_n; + } + + return __H_n; + } +# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 + template + inline _Tp + __poly_hermite(unsigned int __n, _Tp __x) + { + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __poly_hermite_recursion(__n, __x); + } + } + + + + + +} +# 56 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 1 3 +# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + namespace __detail + { +# 75 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre_large_n(unsigned __n, _Tpa __alpha1, _Tp __x) + { + const _Tp __a = -_Tp(__n); + const _Tp __b = _Tp(__alpha1) + _Tp(1); + const _Tp __eta = _Tp(2) * __b - _Tp(4) * __a; + const _Tp __cos2th = __x / __eta; + const _Tp __sin2th = _Tp(1) - __cos2th; + const _Tp __th = std::acos(std::sqrt(__cos2th)); + const _Tp __pre_h = __numeric_constants<_Tp>::__pi_2() + * __numeric_constants<_Tp>::__pi_2() + * __eta * __eta * __cos2th * __sin2th; + + + const _Tp __lg_b = ::std::lgamma(_Tp(__n) + __b); + const _Tp __lnfact = ::std::lgamma(_Tp(__n + 1)); + + + + + + _Tp __pre_term1 = _Tp(0.5L) * (_Tp(1) - __b) + * std::log(_Tp(0.25L) * __x * __eta); + _Tp __pre_term2 = _Tp(0.25L) * std::log(__pre_h); + _Tp __lnpre = __lg_b - __lnfact + _Tp(0.5L) * __x + + __pre_term1 - __pre_term2; + _Tp __ser_term1 = std::sin(__a * __numeric_constants<_Tp>::__pi()); + _Tp __ser_term2 = std::sin(_Tp(0.25L) * __eta + * (_Tp(2) * __th + - std::sin(_Tp(2) * __th)) + + __numeric_constants<_Tp>::__pi_4()); + _Tp __ser = __ser_term1 + __ser_term2; + + return std::exp(__lnpre) * __ser; + } +# 129 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre_hyperg(unsigned int __n, _Tpa __alpha1, _Tp __x) + { + const _Tp __b = _Tp(__alpha1) + _Tp(1); + const _Tp __mx = -__x; + const _Tp __tc_sgn = (__x < _Tp(0) ? _Tp(1) + : ((__n % 2 == 1) ? -_Tp(1) : _Tp(1))); + + _Tp __tc = _Tp(1); + const _Tp __ax = std::abs(__x); + for (unsigned int __k = 1; __k <= __n; ++__k) + __tc *= (__ax / __k); + + _Tp __term = __tc * __tc_sgn; + _Tp __sum = __term; + for (int __k = int(__n) - 1; __k >= 0; --__k) + { + __term *= ((__b + _Tp(__k)) / _Tp(int(__n) - __k)) + * _Tp(__k + 1) / __mx; + __sum += __term; + } + + return __sum; + } +# 185 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre_recursion(unsigned int __n, _Tpa __alpha1, _Tp __x) + { + + _Tp __l_0 = _Tp(1); + if (__n == 0) + return __l_0; + + + _Tp __l_1 = -__x + _Tp(1) + _Tp(__alpha1); + if (__n == 1) + return __l_1; + + + _Tp __l_n2 = __l_0; + _Tp __l_n1 = __l_1; + _Tp __l_n = _Tp(0); + for (unsigned int __nn = 2; __nn <= __n; ++__nn) + { + __l_n = (_Tp(2 * __nn - 1) + _Tp(__alpha1) - __x) + * __l_n1 / _Tp(__nn) + - (_Tp(__nn - 1) + _Tp(__alpha1)) * __l_n2 / _Tp(__nn); + __l_n2 = __l_n1; + __l_n1 = __l_n; + } + + return __l_n; + } +# 244 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre(unsigned int __n, _Tpa __alpha1, _Tp __x) + { + if (__x < _Tp(0)) + std::__throw_domain_error(("Negative argument " "in __poly_laguerre.") + ); + + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__n == 0) + return _Tp(1); + else if (__n == 1) + return _Tp(1) + _Tp(__alpha1) - __x; + else if (__x == _Tp(0)) + { + _Tp __prod = _Tp(__alpha1) + _Tp(1); + for (unsigned int __k = 2; __k <= __n; ++__k) + __prod *= (_Tp(__alpha1) + _Tp(__k)) / _Tp(__k); + return __prod; + } + else if (__n > 10000000 && _Tp(__alpha1) > -_Tp(1) + && __x < _Tp(2) * (_Tp(__alpha1) + _Tp(1)) + _Tp(4 * __n)) + return __poly_laguerre_large_n(__n, __alpha1, __x); + else if (_Tp(__alpha1) >= _Tp(0) + || (__x > _Tp(0) && _Tp(__alpha1) < -_Tp(__n + 1))) + return __poly_laguerre_recursion(__n, __alpha1, __x); + else + return __poly_laguerre_hyperg(__n, __alpha1, __x); + } +# 296 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + inline _Tp + __assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x) + { return __poly_laguerre(__n, __m, __x); } +# 316 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 + template + inline _Tp + __laguerre(unsigned int __n, _Tp __x) + { return __poly_laguerre(__n, 0, __x); } + } + + + + + + +} +# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + namespace __detail + { +# 78 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_sum(_Tp __s) + { + + if (__s < _Tp(1)) + std::__throw_domain_error(("Bad argument in zeta sum.")); + + const unsigned int max_iter = 10000; + _Tp __zeta = _Tp(0); + for (unsigned int __k = 1; __k < max_iter; ++__k) + { + _Tp __term = std::pow(static_cast<_Tp>(__k), -__s); + if (__term < std::numeric_limits<_Tp>::epsilon()) + { + break; + } + __zeta += __term; + } + + return __zeta; + } +# 115 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_alt(_Tp __s) + { + _Tp __sgn = _Tp(1); + _Tp __zeta = _Tp(0); + for (unsigned int __i = 1; __i < 10000000; ++__i) + { + _Tp __term = __sgn / std::pow(__i, __s); + if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon()) + break; + __zeta += __term; + __sgn *= _Tp(-1); + } + __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s); + + return __zeta; + } +# 157 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_glob(_Tp __s) + { + _Tp __zeta = _Tp(0); + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + + + if (__s < _Tp(0)) + { + + if (::std::fmod(__s,_Tp(2)) == _Tp(0)) + return _Tp(0); + else + + { + _Tp __zeta = __riemann_zeta_glob(_Tp(1) - __s); + __zeta *= std::pow(_Tp(2) + * __numeric_constants<_Tp>::__pi(), __s) + * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) + + * std::exp(::std::lgamma(_Tp(1) - __s)) + + + + / __numeric_constants<_Tp>::__pi(); + return __zeta; + } + } + + _Tp __num = _Tp(0.5L); + const unsigned int __maxit = 10000; + for (unsigned int __i = 0; __i < __maxit; ++__i) + { + bool __punt = false; + _Tp __sgn = _Tp(1); + _Tp __term = _Tp(0); + for (unsigned int __j = 0; __j <= __i; ++__j) + { + + _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i)) + - ::std::lgamma(_Tp(1 + __j)) + - ::std::lgamma(_Tp(1 + __i - __j)); + + + + + + if (__bincoeff > __max_bincoeff) + { + + __punt = true; + break; + } + __bincoeff = std::exp(__bincoeff); + __term += __sgn * __bincoeff * std::pow(_Tp(1 + __j), -__s); + __sgn *= _Tp(-1); + } + if (__punt) + break; + __term *= __num; + __zeta += __term; + if (std::abs(__term/__zeta) < __eps) + break; + __num *= _Tp(0.5L); + } + + __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s); + + return __zeta; + } +# 252 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_product(_Tp __s) + { + static const _Tp __prime[] = { + _Tp(2), _Tp(3), _Tp(5), _Tp(7), _Tp(11), _Tp(13), _Tp(17), _Tp(19), + _Tp(23), _Tp(29), _Tp(31), _Tp(37), _Tp(41), _Tp(43), _Tp(47), + _Tp(53), _Tp(59), _Tp(61), _Tp(67), _Tp(71), _Tp(73), _Tp(79), + _Tp(83), _Tp(89), _Tp(97), _Tp(101), _Tp(103), _Tp(107), _Tp(109) + }; + static const unsigned int __num_primes = sizeof(__prime) / sizeof(_Tp); + + _Tp __zeta = _Tp(1); + for (unsigned int __i = 0; __i < __num_primes; ++__i) + { + const _Tp __fact = _Tp(1) - std::pow(__prime[__i], -__s); + __zeta *= __fact; + if (_Tp(1) - __fact < std::numeric_limits<_Tp>::epsilon()) + break; + } + + __zeta = _Tp(1) / __zeta; + + return __zeta; + } +# 293 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta(_Tp __s) + { + if (__isnan(__s)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__s == _Tp(1)) + return std::numeric_limits<_Tp>::infinity(); + else if (__s < -_Tp(19)) + { + _Tp __zeta = __riemann_zeta_product(_Tp(1) - __s); + __zeta *= std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s) + * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) + + * std::exp(::std::lgamma(_Tp(1) - __s)) + + + + / __numeric_constants<_Tp>::__pi(); + return __zeta; + } + else if (__s < _Tp(20)) + { + + bool __glob = true; + if (__glob) + return __riemann_zeta_glob(__s); + else + { + if (__s > _Tp(1)) + return __riemann_zeta_sum(__s); + else + { + _Tp __zeta = std::pow(_Tp(2) + * __numeric_constants<_Tp>::__pi(), __s) + * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) + + * ::std::tgamma(_Tp(1) - __s) + + + + * __riemann_zeta_sum(_Tp(1) - __s); + return __zeta; + } + } + } + else + return __riemann_zeta_product(__s); + } +# 365 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + _Tp + __hurwitz_zeta_glob(_Tp __a, _Tp __s) + { + _Tp __zeta = _Tp(0); + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + const unsigned int __maxit = 10000; + for (unsigned int __i = 0; __i < __maxit; ++__i) + { + bool __punt = false; + _Tp __sgn = _Tp(1); + _Tp __term = _Tp(0); + for (unsigned int __j = 0; __j <= __i; ++__j) + { + + _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i)) + - ::std::lgamma(_Tp(1 + __j)) + - ::std::lgamma(_Tp(1 + __i - __j)); + + + + + + if (__bincoeff > __max_bincoeff) + { + + __punt = true; + break; + } + __bincoeff = std::exp(__bincoeff); + __term += __sgn * __bincoeff * std::pow(_Tp(__a + __j), -__s); + __sgn *= _Tp(-1); + } + if (__punt) + break; + __term /= _Tp(__i + 1); + if (std::abs(__term / __zeta) < __eps) + break; + __zeta += __term; + } + + __zeta /= __s - _Tp(1); + + return __zeta; + } +# 430 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 + template + inline _Tp + __hurwitz_zeta(_Tp __a, _Tp __s) + { return __hurwitz_zeta_glob(__a, __s); } + } + + + + + + +} +# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 203 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + assoc_laguerref(unsigned int __n, unsigned int __m, float __x) + { return __detail::__assoc_laguerre(__n, __m, __x); } + + + + + + + + inline long double + assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x) + { return __detail::__assoc_laguerre(__n, __m, __x); } +# 248 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__assoc_laguerre<__type>(__n, __m, __x); + } +# 264 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + assoc_legendref(unsigned int __l, unsigned int __m, float __x) + { return __detail::__assoc_legendre_p(__l, __m, __x); } + + + + + + + inline long double + assoc_legendrel(unsigned int __l, unsigned int __m, long double __x) + { return __detail::__assoc_legendre_p(__l, __m, __x); } +# 294 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__assoc_legendre_p<__type>(__l, __m, __x); + } +# 309 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + betaf(float __a, float __b) + { return __detail::__beta(__a, __b); } + + + + + + + + inline long double + betal(long double __a, long double __b) + { return __detail::__beta(__a, __b); } +# 339 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type + beta(_Tpa __a, _Tpb __b) + { + typedef typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type __type; + return __detail::__beta<__type>(__a, __b); + } +# 355 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + comp_ellint_1f(float __k) + { return __detail::__comp_ellint_1(__k); } + + + + + + + + inline long double + comp_ellint_1l(long double __k) + { return __detail::__comp_ellint_1(__k); } +# 387 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + comp_ellint_1(_Tp __k) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__comp_ellint_1<__type>(__k); + } +# 403 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + comp_ellint_2f(float __k) + { return __detail::__comp_ellint_2(__k); } + + + + + + + + inline long double + comp_ellint_2l(long double __k) + { return __detail::__comp_ellint_2(__k); } +# 434 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + comp_ellint_2(_Tp __k) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__comp_ellint_2<__type>(__k); + } +# 450 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + comp_ellint_3f(float __k, float __nu) + { return __detail::__comp_ellint_3(__k, __nu); } + + + + + + + + inline long double + comp_ellint_3l(long double __k, long double __nu) + { return __detail::__comp_ellint_3(__k, __nu); } +# 485 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type + comp_ellint_3(_Tp __k, _Tpn __nu) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type; + return __detail::__comp_ellint_3<__type>(__k, __nu); + } +# 501 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + cyl_bessel_if(float __nu, float __x) + { return __detail::__cyl_bessel_i(__nu, __x); } + + + + + + + + inline long double + cyl_bessel_il(long double __nu, long double __x) + { return __detail::__cyl_bessel_i(__nu, __x); } +# 531 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_bessel_i(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_bessel_i<__type>(__nu, __x); + } +# 547 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + cyl_bessel_jf(float __nu, float __x) + { return __detail::__cyl_bessel_j(__nu, __x); } + + + + + + + + inline long double + cyl_bessel_jl(long double __nu, long double __x) + { return __detail::__cyl_bessel_j(__nu, __x); } +# 577 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_bessel_j(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_bessel_j<__type>(__nu, __x); + } +# 593 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + cyl_bessel_kf(float __nu, float __x) + { return __detail::__cyl_bessel_k(__nu, __x); } + + + + + + + + inline long double + cyl_bessel_kl(long double __nu, long double __x) + { return __detail::__cyl_bessel_k(__nu, __x); } +# 629 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_bessel_k(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_bessel_k<__type>(__nu, __x); + } +# 645 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + cyl_neumannf(float __nu, float __x) + { return __detail::__cyl_neumann_n(__nu, __x); } + + + + + + + + inline long double + cyl_neumannl(long double __nu, long double __x) + { return __detail::__cyl_neumann_n(__nu, __x); } +# 677 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_neumann(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_neumann_n<__type>(__nu, __x); + } +# 693 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + ellint_1f(float __k, float __phi) + { return __detail::__ellint_1(__k, __phi); } + + + + + + + + inline long double + ellint_1l(long double __k, long double __phi) + { return __detail::__ellint_1(__k, __phi); } +# 725 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type + ellint_1(_Tp __k, _Tpp __phi) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type; + return __detail::__ellint_1<__type>(__k, __phi); + } +# 741 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + ellint_2f(float __k, float __phi) + { return __detail::__ellint_2(__k, __phi); } + + + + + + + + inline long double + ellint_2l(long double __k, long double __phi) + { return __detail::__ellint_2(__k, __phi); } +# 773 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type + ellint_2(_Tp __k, _Tpp __phi) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type; + return __detail::__ellint_2<__type>(__k, __phi); + } +# 789 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + ellint_3f(float __k, float __nu, float __phi) + { return __detail::__ellint_3(__k, __nu, __phi); } + + + + + + + + inline long double + ellint_3l(long double __k, long double __nu, long double __phi) + { return __detail::__ellint_3(__k, __nu, __phi); } +# 826 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type + ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi) + { + typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type; + return __detail::__ellint_3<__type>(__k, __nu, __phi); + } +# 841 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + expintf(float __x) + { return __detail::__expint(__x); } + + + + + + + + inline long double + expintl(long double __x) + { return __detail::__expint(__x); } +# 866 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + expint(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__expint<__type>(__x); + } +# 882 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + hermitef(unsigned int __n, float __x) + { return __detail::__poly_hermite(__n, __x); } + + + + + + + + inline long double + hermitel(unsigned int __n, long double __x) + { return __detail::__poly_hermite(__n, __x); } +# 914 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + hermite(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__poly_hermite<__type>(__n, __x); + } +# 930 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + laguerref(unsigned int __n, float __x) + { return __detail::__laguerre(__n, __x); } + + + + + + + + inline long double + laguerrel(unsigned int __n, long double __x) + { return __detail::__laguerre(__n, __x); } +# 958 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + laguerre(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__laguerre<__type>(__n, __x); + } +# 974 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + legendref(unsigned int __l, float __x) + { return __detail::__poly_legendre_p(__l, __x); } + + + + + + + + inline long double + legendrel(unsigned int __l, long double __x) + { return __detail::__poly_legendre_p(__l, __x); } +# 1003 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + legendre(unsigned int __l, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__poly_legendre_p<__type>(__l, __x); + } +# 1019 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + riemann_zetaf(float __s) + { return __detail::__riemann_zeta(__s); } + + + + + + + + inline long double + riemann_zetal(long double __s) + { return __detail::__riemann_zeta(__s); } +# 1054 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + riemann_zeta(_Tp __s) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__riemann_zeta<__type>(__s); + } +# 1070 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + sph_besself(unsigned int __n, float __x) + { return __detail::__sph_bessel(__n, __x); } + + + + + + + + inline long double + sph_bessell(unsigned int __n, long double __x) + { return __detail::__sph_bessel(__n, __x); } +# 1098 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + sph_bessel(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__sph_bessel<__type>(__n, __x); + } +# 1114 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + sph_legendref(unsigned int __l, unsigned int __m, float __theta) + { return __detail::__sph_legendre(__l, __m, __theta); } +# 1125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline long double + sph_legendrel(unsigned int __l, unsigned int __m, long double __theta) + { return __detail::__sph_legendre(__l, __m, __theta); } +# 1145 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__sph_legendre<__type>(__l, __m, __theta); + } +# 1161 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + sph_neumannf(unsigned int __n, float __x) + { return __detail::__sph_neumann(__n, __x); } + + + + + + + + inline long double + sph_neumannl(unsigned int __n, long double __x) + { return __detail::__sph_neumann(__n, __x); } +# 1189 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + sph_neumann(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__sph_neumann<__type>(__n, __x); + } + + + + +} + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 1216 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + airy_aif(float __x) + { + float __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Ai; + } + + + + + inline long double + airy_ail(long double __x) + { + long double __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Ai; + } + + + + + template + inline typename __gnu_cxx::__promote<_Tp>::__type + airy_ai(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + __type __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy<__type>(__x, __Ai, __Bi, __Aip, __Bip); + return __Ai; + } + + + + + inline float + airy_bif(float __x) + { + float __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Bi; + } + + + + + inline long double + airy_bil(long double __x) + { + long double __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Bi; + } + + + + + template + inline typename __gnu_cxx::__promote<_Tp>::__type + airy_bi(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + __type __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy<__type>(__x, __Ai, __Bi, __Aip, __Bip); + return __Bi; + } +# 1292 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + conf_hypergf(float __a, float __c, float __x) + { return std::__detail::__conf_hyperg(__a, __c, __x); } +# 1303 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline long double + conf_hypergl(long double __a, long double __c, long double __x) + { return std::__detail::__conf_hyperg(__a, __c, __x); } +# 1323 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type + conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x) + { + typedef typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type __type; + return std::__detail::__conf_hyperg<__type>(__a, __c, __x); + } +# 1340 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline float + hypergf(float __a, float __b, float __c, float __x) + { return std::__detail::__hyperg(__a, __b, __c, __x); } +# 1351 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + inline long double + hypergl(long double __a, long double __b, long double __c, long double __x) + { return std::__detail::__hyperg(__a, __b, __c, __x); } +# 1372 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type + hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x) + { + typedef typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp> + ::__type __type; + return std::__detail::__hyperg<__type>(__a, __b, __c, __x); + } + + + +} +# 3907 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 2 3 + + +} +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/math.h" 2 3 + +using std::abs; +using std::acos; +using std::asin; +using std::atan; +using std::atan2; +using std::cos; +using std::sin; +using std::tan; +using std::cosh; +using std::sinh; +using std::tanh; +using std::exp; +using std::frexp; +using std::ldexp; +using std::log; +using std::log10; +using std::modf; +using std::pow; +using std::sqrt; +using std::ceil; +using std::fabs; +using std::floor; +using std::fmod; + + +using std::fpclassify; +using std::isfinite; +using std::isinf; +using std::isnan; +using std::isnormal; +using std::signbit; +using std::isgreater; +using std::isgreaterequal; +using std::isless; +using std::islessequal; +using std::islessgreater; +using std::isunordered; + + + +using std::acosh; +using std::asinh; +using std::atanh; +using std::cbrt; +using std::copysign; +using std::erf; +using std::erfc; +using std::exp2; +using std::expm1; +using std::fdim; +using std::fma; +using std::fmax; +using std::fmin; +using std::hypot; +using std::ilogb; +using std::lgamma; +using std::llrint; +using std::llround; +using std::log1p; +using std::log2; +using std::logb; +using std::lrint; +using std::lround; +using std::nearbyint; +using std::nextafter; +using std::nexttoward; +using std::remainder; +using std::remquo; +using std::rint; +using std::round; +using std::scalbln; +using std::scalbn; +using std::tgamma; +using std::trunc; +# 4578 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h" 1 3 +# 4579 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +# 4582 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +# 4583 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 4653 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + +# 4653 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool signbit(float x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool signbit(double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool signbit(long double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isfinite(float x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isfinite(double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isfinite(long double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isnan(float x); + + + + +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isnan(double x); + +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isnan(long double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isinf(float x); + + + + +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isinf(double x); + +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isinf(long double x); +} +# 4832 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std +{ + template extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) T __pow_helper(T, int); + template extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) T __cmath_power(T, unsigned int); +} + +using std::abs; +using std::fabs; +using std::ceil; +using std::floor; +using std::sqrt; + +using std::pow; + +using std::log; +using std::log10; +using std::fmod; +using std::modf; +using std::exp; +using std::frexp; +using std::ldexp; +using std::asin; +using std::sin; +using std::sinh; +using std::acos; +using std::cos; +using std::cosh; +using std::atan; +using std::atan2; +using std::tan; +using std::tanh; +# 5243 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +# 5252 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int abs(long long int); +# 5272 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int abs(long int a); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float abs(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double abs(double); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float fabs(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float ceil(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float floor(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sqrt(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float pow(float, float); + + + + +template +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) +typename __gnu_cxx::__promote_2<_Tp, _Up>::__type pow(_Tp, _Up); + + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float log(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float log10(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float fmod(float, float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float modf(float, float*); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float exp(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float frexp(float, int*); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float ldexp(float, int); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float asin(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sin(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sinh(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float acos(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cos(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cosh(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float atan(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float atan2(float, float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float tan(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float tanh(float); +# 5399 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +} +# 5505 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float logb(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr int ilogb(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float scalbn(float a, int b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float scalbln(float a, long int b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float exp2(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float expm1(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float log2(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float log1p(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float acosh(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float asinh(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float atanh(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float hypot(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float cbrt(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float erf(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float erfc(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float lgamma(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float tgamma(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float copysign(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float nextafter(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float remainder(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float remquo(float a, float b, int *quo); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float round(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr long int lround(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr long long int llround(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float trunc(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float rint(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr long int lrint(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr long long int llrint(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float nearbyint(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float fdim(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float fma(float a, float b, float c); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float fmax(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float fmin(float a, float b); +} +# 5644 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float exp10(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float rsqrt(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float rcbrt(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sinpi(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cospi(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void sincospi(const float a, float *const sptr, float *const cptr); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void sincos(const float a, float *const sptr, float *const cptr); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float j0(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float j1(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float jn(const int n, const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float y0(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float y1(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float yn(const int n, const float a); + +static inline __attribute__((device)) __attribute__((cudart_builtin)) float cyl_bessel_i0(const float a); + +static inline __attribute__((device)) __attribute__((cudart_builtin)) float cyl_bessel_i1(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfinv(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfcinv(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float normcdfinv(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float normcdf(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfcx(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double copysign(const double a, const float b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double copysign(const float a, const double b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(const unsigned int a, const unsigned int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(const int a, const unsigned int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(const unsigned int a, const int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int min(const long int a, const long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(const unsigned long int a, const unsigned long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(const long int a, const unsigned long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(const unsigned long int a, const long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int min(const long long int a, const long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(const unsigned long long int a, const unsigned long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(const long long int a, const unsigned long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(const unsigned long long int a, const long long int b); +# 5785 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float min(const float a, const float b); +# 5796 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(const double a, const double b); +# 5806 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(const float a, const double b); +# 5816 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(const double a, const float b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(const unsigned int a, const unsigned int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(const int a, const unsigned int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(const unsigned int a, const int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int max(const long int a, const long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(const unsigned long int a, const unsigned long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(const long int a, const unsigned long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(const unsigned long int a, const long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int max(const long long int a, const long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(const unsigned long long int a, const unsigned long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(const long long int a, const unsigned long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(const unsigned long long int a, const long long int b); +# 5915 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float max(const float a, const float b); +# 5926 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const double a, const double b); +# 5936 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const float a, const double b); +# 5946 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const double a, const float b); +# 5958 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern "C"{ +inline __attribute__((device)) void *__nv_aligned_device_malloc(size_t size, size_t align) +{ + __attribute__((device)) void *__nv_aligned_device_malloc_impl(size_t, size_t); + return __nv_aligned_device_malloc_impl(size, align); +} +} +# 6248 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" 1 +# 77 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 78 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 79 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" 2 +# 758 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +static inline __attribute__((host)) __attribute__((device)) float exp10(const float a) +{ + return exp10f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float rsqrt(const float a) +{ + return rsqrtf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float rcbrt(const float a) +{ + return rcbrtf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float sinpi(const float a) +{ + return sinpif(a); +} + +static inline __attribute__((host)) __attribute__((device)) float cospi(const float a) +{ + return cospif(a); +} + +static inline __attribute__((host)) __attribute__((device)) void sincospi(const float a, float *const sptr, float *const cptr) +{ + sincospif(a, sptr, cptr); +} + +static inline __attribute__((host)) __attribute__((device)) void sincos(const float a, float *const sptr, float *const cptr) +{ + sincosf(a, sptr, cptr); +} + +static inline __attribute__((host)) __attribute__((device)) float j0(const float a) +{ + return j0f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float j1(const float a) +{ + return j1f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float jn(const int n, const float a) +{ + return jnf(n, a); +} + +static inline __attribute__((host)) __attribute__((device)) float y0(const float a) +{ + return y0f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float y1(const float a) +{ + return y1f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float yn(const int n, const float a) +{ + return ynf(n, a); +} + +static inline __attribute__((device)) float cyl_bessel_i0(const float a) +{ + return cyl_bessel_i0f(a); +} + +static inline __attribute__((device)) float cyl_bessel_i1(const float a) +{ + return cyl_bessel_i1f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float erfinv(const float a) +{ + return erfinvf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float erfcinv(const float a) +{ + return erfcinvf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float normcdfinv(const float a) +{ + return normcdfinvf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float normcdf(const float a) +{ + return normcdff(a); +} + +static inline __attribute__((host)) __attribute__((device)) float erfcx(const float a) +{ + return erfcxf(a); +} + +static inline __attribute__((host)) __attribute__((device)) double copysign(const double a, const float b) +{ + return copysign(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) double copysign(const float a, const double b) +{ + return copysign(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int min(const unsigned int a, const unsigned int b) +{ + return umin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int min(const int a, const unsigned int b) +{ + return umin(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int min(const unsigned int a, const int b) +{ + return umin(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) long int min(const long int a, const long int b) +{ + long int retval; + + + + + + + if (sizeof(long int) == sizeof(int)) { + + + + retval = static_cast(min(static_cast(a), static_cast(b))); + } else { + retval = static_cast(llmin(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int min(const unsigned long int a, const unsigned long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umin(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmin(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int min(const long int a, const unsigned long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umin(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmin(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int min(const unsigned long int a, const long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umin(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmin(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) long long int min(const long long int a, const long long int b) +{ + return llmin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(const unsigned long long int a, const unsigned long long int b) +{ + return ullmin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(const long long int a, const unsigned long long int b) +{ + return ullmin(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(const unsigned long long int a, const long long int b) +{ + return ullmin(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) float min(const float a, const float b) +{ + return fminf(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double min(const double a, const double b) +{ + return fmin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double min(const float a, const double b) +{ + return fmin(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) double min(const double a, const float b) +{ + return fmin(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int max(const unsigned int a, const unsigned int b) +{ + return umax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int max(const int a, const unsigned int b) +{ + return umax(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int max(const unsigned int a, const int b) +{ + return umax(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) long int max(const long int a, const long int b) +{ + long int retval; + + + + + + if (sizeof(long int) == sizeof(int)) { + + + + retval = static_cast(max(static_cast(a), static_cast(b))); + } else { + retval = static_cast(llmax(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int max(const unsigned long int a, const unsigned long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umax(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmax(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int max(const long int a, const unsigned long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umax(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmax(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int max(const unsigned long int a, const long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umax(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmax(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) long long int max(const long long int a, const long long int b) +{ + return llmax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(const unsigned long long int a, const unsigned long long int b) +{ + return ullmax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(const long long int a, const unsigned long long int b) +{ + return ullmax(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(const unsigned long long int a, const long long int b) +{ + return ullmax(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) float max(const float a, const float b) +{ + return fmaxf(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double max(const double a, const double b) +{ + return fmax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double max(const float a, const double b) +{ + return fmax(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) double max(const double a, const float b) +{ + return fmax(a, static_cast(b)); +} +# 1135 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +inline __attribute__((host)) __attribute__((device)) int min(const int a, const int b) +{ + return (a < b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) unsigned int umin(const unsigned int a, const unsigned int b) +{ + return (a < b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) long long int llmin(const long long int a, const long long int b) +{ + return (a < b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) unsigned long long int ullmin(const unsigned long long int a, + const unsigned long long int b) +{ + return (a < b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) int max(const int a, const int b) +{ + return (a > b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) unsigned int umax(const unsigned int a, const unsigned int b) +{ + return (a > b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) long long int llmax(const long long int a, const long long int b) +{ + return (a > b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) unsigned long long int ullmax(const unsigned long long int a, + const unsigned long long int b) +{ + return (a > b) ? a : b; +} +# 6249 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 304 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 118 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 1 +# 81 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 82 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" 1 +# 83 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +extern "C" +{ +# 106 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __mulhi(int x, int y); +# 116 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __umulhi(unsigned int x, unsigned int y); +# 126 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __mul64hi(long long int x, long long int y); +# 136 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __umul64hi(unsigned long long int x, unsigned long long int y); +# 145 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int_as_float(int x); +# 154 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float_as_int(float x); +# 163 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint_as_float(unsigned int x); +# 172 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float_as_uint(float x); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __syncthreads(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __prof_trigger(int); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __threadfence(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __threadfence_block(void); +__attribute__((device)) __attribute__((cudart_builtin)) + +__attribute__((__noreturn__)) + + + +__attribute__((device_builtin)) void __trap(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __brkpt(); +# 196 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __saturatef(float x); +# 215 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __sad(int x, int y, unsigned int z); +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __usad(unsigned int x, unsigned int y, unsigned int z); +# 243 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __mul24(int x, int y); +# 253 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __umul24(unsigned int x, unsigned int y); +# 269 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float fdividef(float x, float y); +# 289 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdividef(float x, float y); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) double fdivide(double x, double y); +# 303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __sinf(float x) +# 303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 303 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 315 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __cosf(float x) +# 315 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 315 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __tanf(float x) +# 328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __tanhf(float x) +# 340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 340 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void __sincosf(float x, float *sptr, float *cptr) +# 353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 371 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __expf(float x) +# 371 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 371 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 385 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __exp10f(float x) +# 385 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 385 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 398 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __log2f(float x) +# 398 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 398 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __log10f(float x) +# 411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 428 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __logf(float x) +# 428 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 428 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 443 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __powf(float x, float y) +# 443 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 443 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 453 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rn(float x); +# 463 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rz(float x); +# 473 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_ru(float); +# 483 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rd(float x); +# 493 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rn(float x); +# 503 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rz(float x); +# 513 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_ru(float x); +# 523 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rd(float x); +# 532 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rn(int x); +# 541 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rz(int x); +# 550 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_ru(int x); +# 559 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rd(int x); +# 568 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rn(unsigned int x); +# 577 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rz(unsigned int x); +# 586 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_ru(unsigned int x); +# 595 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rd(unsigned int x); +# 605 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rn(float x); +# 615 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rz(float x); +# 625 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_ru(float x); +# 635 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rd(float x); +# 645 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rn(float x); +# 655 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rz(float x); +# 665 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_ru(float x); +# 675 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rd(float x); +# 684 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rn(long long int x); +# 693 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rz(long long int x); +# 702 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_ru(long long int x); +# 711 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rd(long long int x); +# 720 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rn(unsigned long long int x); +# 729 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rz(unsigned long long int x); +# 738 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_ru(unsigned long long int x); +# 747 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rd(unsigned long long int x); +# 766 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rn(float x, float y); +# 785 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rz(float x, float y); +# 804 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_ru(float x, float y); +# 823 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rd(float x, float y); +# 842 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rn(float x, float y); +# 861 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rz(float x, float y); +# 880 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_ru(float x, float y); +# 899 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rd(float x, float y); +# 917 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rn(float x, float y); +# 935 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rz(float x, float y); +# 953 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_ru(float x, float y); +# 971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rd(float x, float y); +# 1015 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rn(float x, float y, float z); +# 1059 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rz(float x, float y, float z); +# 1103 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_ru(float x, float y, float z); +# 1147 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rd(float x, float y, float z); +# 1164 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rn(float x); +# 1181 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rz(float x); +# 1198 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_ru(float x); +# 1215 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rd(float x); +# 1233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rn(float x); +# 1251 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rz(float x); +# 1269 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_ru(float x); +# 1287 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rd(float x); +# 1305 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frsqrt_rn(float x); +# 1324 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rn(float x, float y); +# 1343 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rz(float x, float y); +# 1362 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_ru(float x, float y); +# 1381 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rd(float x, float y); +# 1390 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __clz(int x); +# 1401 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __ffs(int x); +# 1410 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __popc(unsigned int x); +# 1419 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __brev(unsigned int x); +# 1428 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __clzll(long long int x); +# 1439 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __ffsll(long long int x); +# 1450 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __popcll(unsigned long long int x); +# 1459 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __brevll(unsigned long long int x); +# 1482 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __byte_perm(unsigned int x, unsigned int y, unsigned int s); +# 1494 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __hadd(int x, int y); +# 1507 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __rhadd(int x, int y); +# 1519 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __uhadd(unsigned int x, unsigned int y); +# 1532 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __urhadd(unsigned int x, unsigned int y); +# 1543 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __double2int_rz(double x); +# 1553 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __double2uint_rz(double x); +# 1563 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __double2ll_rz(double x); +# 1573 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __double2ull_rz(double x); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __pm0(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __pm1(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __pm2(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __pm3(void); +# 1603 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabs2(unsigned int a); +# 1614 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsss2(unsigned int a); +# 1625 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vadd2(unsigned int a, unsigned int b); +# 1636 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddss2 (unsigned int a, unsigned int b); +# 1646 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddus2 (unsigned int a, unsigned int b); +# 1657 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgs2(unsigned int a, unsigned int b); +# 1668 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgu2(unsigned int a, unsigned int b); +# 1679 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vhaddu2(unsigned int a, unsigned int b); +# 1690 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpeq2(unsigned int a, unsigned int b); +# 1701 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpges2(unsigned int a, unsigned int b); +# 1712 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgeu2(unsigned int a, unsigned int b); +# 1723 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgts2(unsigned int a, unsigned int b); +# 1734 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgtu2(unsigned int a, unsigned int b); +# 1745 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmples2(unsigned int a, unsigned int b); +# 1756 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpleu2(unsigned int a, unsigned int b); +# 1767 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmplts2(unsigned int a, unsigned int b); +# 1778 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpltu2(unsigned int a, unsigned int b); +# 1789 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpne2(unsigned int a, unsigned int b); +# 1800 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffu2(unsigned int a, unsigned int b); +# 1811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxs2(unsigned int a, unsigned int b); +# 1822 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxu2(unsigned int a, unsigned int b); +# 1833 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmins2(unsigned int a, unsigned int b); +# 1844 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vminu2(unsigned int a, unsigned int b); +# 1855 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vseteq2(unsigned int a, unsigned int b); +# 1866 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetges2(unsigned int a, unsigned int b); +# 1877 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgeu2(unsigned int a, unsigned int b); +# 1888 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgts2(unsigned int a, unsigned int b); +# 1899 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgtu2(unsigned int a, unsigned int b); +# 1910 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetles2(unsigned int a, unsigned int b); +# 1921 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetleu2(unsigned int a, unsigned int b); +# 1932 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetlts2(unsigned int a, unsigned int b); +# 1943 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetltu2(unsigned int a, unsigned int b); +# 1954 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetne2(unsigned int a, unsigned int b); +# 1965 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsadu2(unsigned int a, unsigned int b); +# 1976 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsub2(unsigned int a, unsigned int b); +# 1987 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubss2 (unsigned int a, unsigned int b); +# 1998 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubus2 (unsigned int a, unsigned int b); +# 2008 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vneg2(unsigned int a); +# 2018 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vnegss2(unsigned int a); +# 2029 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffs2(unsigned int a, unsigned int b); +# 2040 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsads2(unsigned int a, unsigned int b); +# 2050 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabs4(unsigned int a); +# 2061 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsss4(unsigned int a); +# 2072 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vadd4(unsigned int a, unsigned int b); +# 2083 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddss4 (unsigned int a, unsigned int b); +# 2093 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddus4 (unsigned int a, unsigned int b); +# 2104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgs4(unsigned int a, unsigned int b); +# 2115 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgu4(unsigned int a, unsigned int b); +# 2126 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vhaddu4(unsigned int a, unsigned int b); +# 2137 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpeq4(unsigned int a, unsigned int b); +# 2148 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpges4(unsigned int a, unsigned int b); +# 2159 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgeu4(unsigned int a, unsigned int b); +# 2170 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgts4(unsigned int a, unsigned int b); +# 2181 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgtu4(unsigned int a, unsigned int b); +# 2192 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmples4(unsigned int a, unsigned int b); +# 2203 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpleu4(unsigned int a, unsigned int b); +# 2214 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmplts4(unsigned int a, unsigned int b); +# 2225 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpltu4(unsigned int a, unsigned int b); +# 2236 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpne4(unsigned int a, unsigned int b); +# 2247 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffu4(unsigned int a, unsigned int b); +# 2258 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxs4(unsigned int a, unsigned int b); +# 2269 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxu4(unsigned int a, unsigned int b); +# 2280 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmins4(unsigned int a, unsigned int b); +# 2291 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vminu4(unsigned int a, unsigned int b); +# 2302 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vseteq4(unsigned int a, unsigned int b); +# 2313 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetles4(unsigned int a, unsigned int b); +# 2324 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetleu4(unsigned int a, unsigned int b); +# 2335 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetlts4(unsigned int a, unsigned int b); +# 2346 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetltu4(unsigned int a, unsigned int b); +# 2357 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetges4(unsigned int a, unsigned int b); +# 2368 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgeu4(unsigned int a, unsigned int b); +# 2379 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgts4(unsigned int a, unsigned int b); +# 2390 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgtu4(unsigned int a, unsigned int b); +# 2401 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetne4(unsigned int a, unsigned int b); +# 2412 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsadu4(unsigned int a, unsigned int b); +# 2423 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsub4(unsigned int a, unsigned int b); +# 2434 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubss4(unsigned int a, unsigned int b); +# 2445 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubus4(unsigned int a, unsigned int b); +# 2455 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vneg4(unsigned int a); +# 2465 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vnegss4(unsigned int a); +# 2476 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffs4(unsigned int a, unsigned int b); +# 2487 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsads4(unsigned int a, unsigned int b); +# 2497 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax_s32_relu(const int a, const int b); +# 2509 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax_s16x2_relu(const unsigned int a, const unsigned int b); +# 2518 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin_s32_relu(const int a, const int b); +# 2530 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin_s16x2_relu(const unsigned int a, const unsigned int b); +# 2539 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax3_s32(const int a, const int b, const int c); +# 2551 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_s16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2560 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_u32(const unsigned int a, const unsigned int b, const unsigned int c); +# 2572 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_u16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2581 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin3_s32(const int a, const int b, const int c); +# 2593 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_s16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2602 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_u32(const unsigned int a, const unsigned int b, const unsigned int c); +# 2614 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_u16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2623 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax3_s32_relu(const int a, const int b, const int c); +# 2635 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c); +# 2644 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin3_s32_relu(const int a, const int b, const int c); +# 2656 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c); +# 2665 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmax_s32(const int a, const int b, const int c); +# 2677 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_s16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2686 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_u32(const unsigned int a, const unsigned int b, const unsigned int c); +# 2698 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_u16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2707 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmin_s32(const int a, const int b, const int c); +# 2719 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_s16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2728 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_u32(const unsigned int a, const unsigned int b, const unsigned int c); +# 2740 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_u16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2750 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmax_s32_relu(const int a, const int b, const int c); +# 2762 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c); +# 2772 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmin_s32_relu(const int a, const int b, const int c); +# 2784 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c); +# 2793 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vibmax_s32(const int a, const int b, bool* const pred); +# 2802 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_u32(const unsigned int a, const unsigned int b, bool* const pred); +# 2811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vibmin_s32(const int a, const int b, bool* const pred); +# 2820 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_u32(const unsigned int a, const unsigned int b, bool* const pred); +# 2834 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_s16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo); +# 2848 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo); +# 2862 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_s16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo); +# 2876 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo); + + + + + + +} +# 2899 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" 1 +# 81 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 82 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" 2 +# 116 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +static __attribute__((host)) __attribute__((device)) short __internal_cast_u2s(unsigned short x) +{ + short res; + + (void)memcpy(&res, &x, sizeof(x)); + + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax_s32_relu(const int a, const int b){ + + + + + + + int ans = max(a, b); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax_s16x2_relu(const unsigned int a, const unsigned int b){ + unsigned int res; + + + + + + + + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + + int ansI_lo = max(aS_lo, bS_lo); + int ansI_hi = max(aS_hi, bS_hi); + + + if(ansI_lo < 0){ ansI_lo = 0; } + if(ansI_hi < 0){ ansI_hi = 0; } + + + unsigned ansU_lo = (unsigned)ansI_lo; + unsigned ansU_hi = (unsigned)ansI_hi; + + + res = ansU_lo | (ansU_hi << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin_s32_relu(const int a, const int b){ + + + + + + + int ans = min(a, b); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin_s16x2_relu(const unsigned int a, const unsigned int b){ + unsigned int res; + + + + + + + + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + + int ansI_lo = min(aS_lo, bS_lo); + int ansI_hi = min(aS_hi, bS_hi); + + + if(ansI_lo < 0){ ansI_lo = 0; } + if(ansI_hi < 0){ ansI_hi = 0; } + + + unsigned ansU_lo = (unsigned)ansI_lo; + unsigned ansU_hi = (unsigned)ansI_hi; + + + res = ansU_lo | (ansU_hi << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax3_s32(const int a, const int b, const int c){ +# 245 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return max(max(a, b), c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_s16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 262 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned int ansU_lo = (unsigned int)max(max(aS_lo, bS_lo), cS_lo); + unsigned int ansU_hi = (unsigned int)max(max(aS_hi, bS_hi), cS_hi); + + + res = (ansU_lo & 0x0000FFFFU) | (ansU_hi << 16); + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_u32(const unsigned int a, const unsigned int b, const unsigned int c){ +# 301 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return max(max(a, b), c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_u16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 317 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + unsigned short ansU_lo = (unsigned short)max(max(aU_lo, bU_lo), cU_lo); + unsigned short ansU_hi = (unsigned short)max(max(aU_hi, bU_hi), cU_hi); + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin3_s32(const int a, const int b, const int c){ +# 347 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return min(min(a, b), c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_s16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 363 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned int ansU_lo = (unsigned int)min(min(aS_lo, bS_lo), cS_lo); + unsigned int ansU_hi = (unsigned int)min(min(aS_hi, bS_hi), cS_hi); + + + res = (ansU_lo & 0x0000FFFFU) | (ansU_hi << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_u32(const unsigned int a, const unsigned int b, const unsigned int c){ +# 403 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return min(min(a, b), c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_u16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 419 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + unsigned short ansU_lo = (unsigned short)min(min(aU_lo, bU_lo), cU_lo); + unsigned short ansU_hi = (unsigned short)min(min(aU_hi, bU_hi), cU_hi); + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax3_s32_relu(const int a, const int b, const int c){ +# 449 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = max(max(a, b), c); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 467 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned ansU_lo = (unsigned)max(0, max(max(aS_lo, bS_lo), cS_lo)); + unsigned ansU_hi = (unsigned)max(0, max(max(aS_hi, bS_hi), cS_hi)); + + + res = ansU_lo | (ansU_hi << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin3_s32_relu(const int a, const int b, const int c){ +# 507 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = min(min(a, b), c); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned res; +# 525 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned ansU_lo = (unsigned)max(0, min(min(aS_lo, bS_lo), cS_lo)); + unsigned ansU_hi = (unsigned)max(0, min(min(aS_hi, bS_hi), cS_hi)); + + + res = ansU_lo | (ansU_hi << 16); + + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmax_s32(const int a, const int b, const int c){ +# 566 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return max(a + b, c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_s16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 582 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + aU_lo += bU_lo; + aU_hi += bU_hi; + + + short sS_lo = __internal_cast_u2s(aU_lo); + short sS_hi = __internal_cast_u2s(aU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned ansU_lo = (unsigned)max(sS_lo, cS_lo); + unsigned ansU_hi = (unsigned)max(sS_hi, cS_hi); + + + res = (ansU_lo & 0x0000FFFFU) | (ansU_hi << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_u32(const unsigned int a, const unsigned int b, const unsigned int c){ +# 622 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return max(a + b, c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_u16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 638 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + unsigned short ansU_lo = (unsigned short)max((unsigned short)(aU_lo + bU_lo), cU_lo); + unsigned short ansU_hi = (unsigned short)max((unsigned short)(aU_hi + bU_hi), cU_hi); + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmin_s32(const int a, const int b, const int c){ +# 668 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return min(a + b, c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_s16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 684 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + aU_lo += bU_lo; + aU_hi += bU_hi; + + + short sS_lo = __internal_cast_u2s(aU_lo); + short sS_hi = __internal_cast_u2s(aU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned ansU_lo = (unsigned)min(sS_lo, cS_lo); + unsigned ansU_hi = (unsigned)min(sS_hi, cS_hi); + + + res = (ansU_lo & 0x0000FFFFU) | (ansU_hi << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_u32(const unsigned int a, const unsigned int b, const unsigned int c){ +# 724 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return min(a + b, c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_u16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 740 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + unsigned short ansU_lo = (unsigned short)min((unsigned short)(aU_lo + bU_lo), cU_lo); + unsigned short ansU_hi = (unsigned short)min((unsigned short)(aU_hi + bU_hi), cU_hi); + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmax_s32_relu(const int a, const int b, const int c){ +# 770 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = max(a + b, c); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 788 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + aU_lo += bU_lo; + aU_hi += bU_hi; + + + short sS_lo = __internal_cast_u2s(aU_lo); + short sS_hi = __internal_cast_u2s(aU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned ansU_lo = (unsigned)max(0, max(sS_lo, cS_lo)); + unsigned ansU_hi = (unsigned)max(0, max(sS_hi, cS_hi)); + + + res = ansU_lo | (ansU_hi << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmin_s32_relu(const int a, const int b, const int c){ +# 828 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = min(a + b, c); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 846 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + aU_lo += bU_lo; + aU_hi += bU_hi; + + + short sS_lo = __internal_cast_u2s(aU_lo); + short sS_hi = __internal_cast_u2s(aU_hi); + + short cS_lo = __internal_cast_u2s(cU_lo); + short cS_hi = __internal_cast_u2s(cU_hi); + + + unsigned ansU_lo = (unsigned)max(0, min(sS_lo, cS_lo)); + unsigned ansU_hi = (unsigned)max(0, min(sS_hi, cS_hi)); + + + res = ansU_lo | (ansU_hi << 16); + + + return res; +} + + + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vibmax_s32(const int a, const int b, bool* const pred){ +# 892 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = max(a, b); + + *pred = (a >= b); + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_u32(const unsigned int a, const unsigned int b, bool* const pred){ +# 913 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned int ans = max(a, b); + + *pred = (a >= b); + return ans; + +} + + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vibmin_s32(const int a, const int b, bool* const pred){ +# 935 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = min(a, b); + + *pred = (a <= b); + return ans; + +} + + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_u32(const unsigned int a, const unsigned int b, bool* const pred){ +# 957 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned int ans = min(a, b); + + *pred = (a <= b); + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_s16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 986 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + + unsigned int ansU_lo = (unsigned int)max(aS_lo, bS_lo); + unsigned int ansU_hi = (unsigned int)max(aS_hi, bS_hi); + + *pred_hi = (aS_hi >= bS_hi); + *pred_lo = (aS_lo >= bS_lo); + + + unsigned int ans = (ansU_lo & 0x0000FFFFU) | (ansU_hi << 16); + + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 1035 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + unsigned short ansU_lo = (unsigned short)max(aU_lo, bU_lo); + unsigned short ansU_hi = (unsigned short)max(aU_hi, bU_hi); + + *pred_hi = (aU_hi >= bU_hi); + *pred_lo = (aU_lo >= bU_lo); + + + unsigned int ans = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_s16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 1077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + short aS_lo = __internal_cast_u2s(aU_lo); + short aS_hi = __internal_cast_u2s(aU_hi); + + short bS_lo = __internal_cast_u2s(bU_lo); + short bS_hi = __internal_cast_u2s(bU_hi); + + + unsigned int ansU_lo = (unsigned int)min(aS_lo, bS_lo); + unsigned int ansU_hi = (unsigned int)min(aS_hi, bS_hi); + + *pred_hi = (aS_hi <= bS_hi); + *pred_lo = (aS_lo <= bS_lo); + + + unsigned int ans = (ansU_lo & 0x0000FFFFU) | (ansU_hi << 16); + + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 1126 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + unsigned short ansU_lo = (unsigned short)min(aU_lo, bU_lo); + unsigned short ansU_hi = (unsigned short)min(aU_hi, bU_hi); + + *pred_hi = (aU_hi <= bU_hi); + *pred_lo = (aU_lo <= bU_lo); + + + unsigned int ans = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + return ans; + +} +# 2900 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" 1 +# 89 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +static __inline__ __attribute__((device)) int atomicAdd(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicAdd(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicSub(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicSub(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicExch(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicExch(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) float atomicExch(float *address, float val) { } + +static __inline__ __attribute__((device)) int atomicMin(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicMin(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicMax(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicMax(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicInc(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicDec(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicAnd(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicAnd(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicOr(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicOr(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicXor(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicXor(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicCAS(int *address, int compare, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicCAS(unsigned int *address, unsigned int compare, unsigned int val) { } +# 156 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) __attribute__((deprecated("__any""() is deprecated in favor of ""__any""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __any(int cond); +extern __attribute__((device)) __attribute__((device_builtin)) __attribute__((deprecated("__all""() is deprecated in favor of ""__all""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __all(int cond); +} +# 169 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +static __inline__ __attribute__((device)) unsigned long long int atomicAdd(unsigned long long int *address, unsigned long long int val) { } + +static __inline__ __attribute__((device)) unsigned long long int atomicExch(unsigned long long int *address, unsigned long long int val) { } + +static __inline__ __attribute__((device)) unsigned long long int atomicCAS(unsigned long long int *address, unsigned long long int compare, unsigned long long int val) { } + +static __inline__ __attribute__((device)) __attribute__((deprecated("__any""() is deprecated in favor of ""__any""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) bool any(bool cond) { } + +static __inline__ __attribute__((device)) __attribute__((deprecated("__all""() is deprecated in favor of ""__all""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) bool all(bool cond) { } +# 2903 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" 1 +# 83 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" 2 + + + + +extern "C" +{ +# 100 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double_as_longlong(double x); +# 109 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __longlong_as_double(long long int x); +# 266 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rn(double x, double y, double z); +# 423 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rz(double x, double y, double z); +# 580 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_ru(double x, double y, double z); +# 737 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rd(double x, double y, double z); +# 749 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rn(double x, double y); +# 761 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rz(double x, double y); +# 773 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_ru(double x, double y); +# 785 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rd(double x, double y); +# 797 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rn(double x, double y); +# 809 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rz(double x, double y); +# 821 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_ru(double x, double y); +# 833 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rd(double x, double y); +# 845 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rn(double x, double y); +# 857 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rz(double x, double y); +# 869 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_ru(double x, double y); +# 881 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rd(double x, double y); +# 890 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rn(double x); +# 899 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rz(double x); +# 908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_ru(double x); +# 917 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rd(double x); +# 926 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rn(double x); +# 935 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_ru(double x); +# 944 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rd(double x); +# 953 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rn(double x); +# 962 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_ru(double x); +# 971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rd(double x); +# 980 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rn(double x); +# 989 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_ru(double x); +# 998 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rd(double x); +# 1007 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rn(double x); +# 1016 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_ru(double x); +# 1025 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rd(double x); + + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) double __int2double_rn(int x); + + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) double __uint2double_rn(unsigned int x); +# 1050 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rn(long long int x); +# 1059 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rz(long long int x); +# 1068 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_ru(long long int x); +# 1077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rd(long long int x); +# 1086 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rn(unsigned long long int x); +# 1095 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rz(unsigned long long int x); +# 1104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_ru(unsigned long long int x); +# 1113 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rd(unsigned long long int x); +# 1122 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2hiint(double x); +# 1131 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2loint(double x); +# 1141 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __hiloint2double(int hi, int lo); +} + + + + + + + +static __inline__ __attribute__((device)) double fma(double a, double b, double c, enum cudaRoundMode mode); + + + +static __inline__ __attribute__((device)) double dmul(double a, double b, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double dadd(double a, double b, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double dsub(double a, double b, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) int double2int(double a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) unsigned int double2uint(double a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) long long int double2ll(double a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) unsigned long long int double2ull(double a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) double ll2double(long long int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double ull2double(unsigned long long int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double int2double(int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double uint2double(unsigned int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double float2double(float a, enum cudaRoundMode mode = cudaRoundNearest); + + + + + + + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" 1 +# 83 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" 2 + + + + + + + +static __inline__ __attribute__((device)) double fma(double a, double b, double c, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __fma_rz(a, b, c) : + mode == cudaRoundPosInf ? __fma_ru(a, b, c) : + mode == cudaRoundMinInf ? __fma_rd(a, b, c) : + __fma_rn(a, b, c); +} + +static __inline__ __attribute__((device)) double dmul(double a, double b, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __dmul_rz(a, b) : + mode == cudaRoundPosInf ? __dmul_ru(a, b) : + mode == cudaRoundMinInf ? __dmul_rd(a, b) : + __dmul_rn(a, b); +} + +static __inline__ __attribute__((device)) double dadd(double a, double b, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __dadd_rz(a, b) : + mode == cudaRoundPosInf ? __dadd_ru(a, b) : + mode == cudaRoundMinInf ? __dadd_rd(a, b) : + __dadd_rn(a, b); +} + +static __inline__ __attribute__((device)) double dsub(double a, double b, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __dsub_rz(a, b) : + mode == cudaRoundPosInf ? __dsub_ru(a, b) : + mode == cudaRoundMinInf ? __dsub_rd(a, b) : + __dsub_rn(a, b); +} + +static __inline__ __attribute__((device)) int double2int(double a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __double2int_rn(a) : + mode == cudaRoundPosInf ? __double2int_ru(a) : + mode == cudaRoundMinInf ? __double2int_rd(a) : + __double2int_rz(a); +} + +static __inline__ __attribute__((device)) unsigned int double2uint(double a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __double2uint_rn(a) : + mode == cudaRoundPosInf ? __double2uint_ru(a) : + mode == cudaRoundMinInf ? __double2uint_rd(a) : + __double2uint_rz(a); +} + +static __inline__ __attribute__((device)) long long int double2ll(double a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __double2ll_rn(a) : + mode == cudaRoundPosInf ? __double2ll_ru(a) : + mode == cudaRoundMinInf ? __double2ll_rd(a) : + __double2ll_rz(a); +} + +static __inline__ __attribute__((device)) unsigned long long int double2ull(double a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __double2ull_rn(a) : + mode == cudaRoundPosInf ? __double2ull_ru(a) : + mode == cudaRoundMinInf ? __double2ull_rd(a) : + __double2ull_rz(a); +} + +static __inline__ __attribute__((device)) double ll2double(long long int a, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __ll2double_rz(a) : + mode == cudaRoundPosInf ? __ll2double_ru(a) : + mode == cudaRoundMinInf ? __ll2double_rd(a) : + __ll2double_rn(a); +} + +static __inline__ __attribute__((device)) double ull2double(unsigned long long int a, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __ull2double_rz(a) : + mode == cudaRoundPosInf ? __ull2double_ru(a) : + mode == cudaRoundMinInf ? __ull2double_rd(a) : + __ull2double_rn(a); +} + +static __inline__ __attribute__((device)) double int2double(int a, enum cudaRoundMode mode) +{ + return (double)a; +} + +static __inline__ __attribute__((device)) double uint2double(unsigned int a, enum cudaRoundMode mode) +{ + return (double)a; +} + +static __inline__ __attribute__((device)) double float2double(float a, enum cudaRoundMode mode) +{ + return (double)a; +} +# 1185 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" 2 +# 2904 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_atomic_functions.h" 1 +# 88 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_atomic_functions.h" +static __inline__ __attribute__((device)) float atomicAdd(float *address, float val) { } +# 2905 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" 1 +# 89 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +static __inline__ __attribute__((device)) long long atomicMin(long long *address, long long val) { } + +static __inline__ __attribute__((device)) long long atomicMax(long long *address, long long val) { } + +static __inline__ __attribute__((device)) long long atomicAnd(long long *address, long long val) { } + +static __inline__ __attribute__((device)) long long atomicOr(long long *address, long long val) { } + +static __inline__ __attribute__((device)) long long atomicXor(long long *address, long long val) { } + +static __inline__ __attribute__((device)) unsigned long long atomicMin(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) unsigned long long atomicMax(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) unsigned long long atomicAnd(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) unsigned long long atomicOr(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) unsigned long long atomicXor(unsigned long long *address, unsigned long long val) { } +# 2906 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_35_atomic_functions.h" 1 +# 56 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_35_atomic_functions.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" 1 +# 57 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_35_atomic_functions.h" 2 +# 2907 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" 1 +# 93 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +static __inline__ __attribute__((device)) double atomicAdd(double *address, double val) { } + +static __inline__ __attribute__((device)) +int atomicAdd_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicAdd_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicAdd_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicAdd_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicAdd_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicAdd_system(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +float atomicAdd_block(float *address, float val) { } + +static __inline__ __attribute__((device)) +float atomicAdd_system(float *address, float val) { } + +static __inline__ __attribute__((device)) +double atomicAdd_block(double *address, double val) { } + +static __inline__ __attribute__((device)) +double atomicAdd_system(double *address, double val) { } + +static __inline__ __attribute__((device)) +int atomicSub_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicSub_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicSub_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicSub_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +int atomicExch_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicExch_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicExch_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicExch_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicExch_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicExch_system(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +float atomicExch_block(float *address, float val) { } + +static __inline__ __attribute__((device)) +float atomicExch_system(float *address, float val) { } + +static __inline__ __attribute__((device)) +int atomicMin_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicMin_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +long long atomicMin_block(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +long long atomicMin_system(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicMin_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicMin_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicMin_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicMin_system(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +int atomicMax_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicMax_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +long long atomicMax_block(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +long long atomicMax_system(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicMax_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicMax_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicMax_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicMax_system(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicInc_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicInc_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicDec_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicDec_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +int atomicCAS_block(int *address, int compare, int val) { } + +static __inline__ __attribute__((device)) +int atomicCAS_system(int *address, int compare, int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicCAS_block(unsigned int *address, unsigned int compare, + unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicCAS_system(unsigned int *address, unsigned int compare, + unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long int atomicCAS_block(unsigned long long int *address, + unsigned long long int compare, + unsigned long long int val) { } + +static __inline__ __attribute__((device)) +unsigned long long int atomicCAS_system(unsigned long long int *address, + unsigned long long int compare, + unsigned long long int val) { } + +static __inline__ __attribute__((device)) +int atomicAnd_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicAnd_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +long long atomicAnd_block(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +long long atomicAnd_system(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicAnd_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicAnd_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicAnd_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicAnd_system(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +int atomicOr_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicOr_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +long long atomicOr_block(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +long long atomicOr_system(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicOr_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicOr_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicOr_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicOr_system(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +int atomicXor_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicXor_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +long long atomicXor_block(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +long long atomicXor_system(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicXor_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicXor_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicXor_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicXor_system(unsigned long long *address, unsigned long long val) { } +# 2908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" 1 +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) void __threadfence_system(void); +# 119 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rn(double x, double y); +# 139 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rz(double x, double y); +# 159 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_ru(double x, double y); +# 179 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rd(double x, double y); +# 194 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rn(double x); +# 209 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rz(double x); +# 224 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_ru(double x); +# 239 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rd(double x); +# 254 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rn(double x); +# 269 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rz(double x); +# 284 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_ru(double x); +# 299 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rd(double x); +extern __attribute__((device)) __attribute__((device_builtin)) __attribute__((deprecated("__ballot""() is deprecated in favor of ""__ballot""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __ballot(int); +extern __attribute__((device)) __attribute__((device_builtin)) int __syncthreads_count(int); +extern __attribute__((device)) __attribute__((device_builtin)) int __syncthreads_and(int); +extern __attribute__((device)) __attribute__((device_builtin)) int __syncthreads_or(int); +extern __attribute__((device)) __attribute__((device_builtin)) long long int clock64(void); +# 314 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rn(float x, float y, float z); +# 323 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rd(float x, float y, float z); +# 332 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_ru(float x, float y, float z); +# 341 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rz(float x, float y, float z); +# 354 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double_as_longlong(double x); +# 363 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __longlong_as_double(long long int x); +# 407 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rn(double x, double y, double z); +# 451 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rz(double x, double y, double z); +# 495 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_ru(double x, double y, double z); +# 539 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rd(double x, double y, double z); +# 558 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rn(double x, double y); +# 577 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rz(double x, double y); +# 596 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_ru(double x, double y); +# 615 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rd(double x, double y); +# 634 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rn(double x, double y); +# 653 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rz(double x, double y); +# 672 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_ru(double x, double y); +# 691 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rd(double x, double y); +# 709 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rn(double x, double y); +# 727 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rz(double x, double y); +# 745 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_ru(double x, double y); +# 763 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rd(double x, double y); +# 772 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rn(double x); +# 781 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rz(double x); +# 790 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_ru(double x); +# 799 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rd(double x); +# 809 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rn(double x); +# 819 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_ru(double x); +# 829 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rd(double x); +# 839 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rn(double x); +# 849 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_ru(double x); +# 859 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rd(double x); +# 869 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rn(double x); +# 879 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_ru(double x); +# 889 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rd(double x); +# 899 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rn(double x); +# 909 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_ru(double x); +# 919 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rd(double x); + + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) double __int2double_rn(int x); + + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) double __uint2double_rn(unsigned int x); +# 944 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rn(long long int x); +# 953 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rz(long long int x); +# 962 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_ru(long long int x); +# 971 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rd(long long int x); +# 980 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rn(unsigned long long int x); +# 989 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rz(unsigned long long int x); +# 998 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_ru(unsigned long long int x); +# 1007 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rd(unsigned long long int x); +# 1016 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2hiint(double x); +# 1025 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2loint(double x); +# 1035 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __hiloint2double(int hi, int lo); + + +} + + + + + + +static __inline__ __attribute__((device)) __attribute__((deprecated("__ballot""() is deprecated in favor of ""__ballot""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int ballot(bool pred) { } + +static __inline__ __attribute__((device)) int syncthreads_count(bool pred) { } + +static __inline__ __attribute__((device)) bool syncthreads_and(bool pred) { } + +static __inline__ __attribute__((device)) bool syncthreads_or(bool pred) { } + + + + +static __inline__ __attribute__((device)) unsigned int __isGlobal(const void *ptr) { } +static __inline__ __attribute__((device)) unsigned int __isShared(const void *ptr) { } +static __inline__ __attribute__((device)) unsigned int __isConstant(const void *ptr) { } +static __inline__ __attribute__((device)) unsigned int __isLocal(const void *ptr) { } + +static __inline__ __attribute__((device)) unsigned int __isGridConstant(const void *ptr) { } + +static __inline__ __attribute__((device)) size_t __cvta_generic_to_global(const void *ptr) { } +static __inline__ __attribute__((device)) size_t __cvta_generic_to_shared(const void *ptr) { } +static __inline__ __attribute__((device)) size_t __cvta_generic_to_constant(const void *ptr) { } +static __inline__ __attribute__((device)) size_t __cvta_generic_to_local(const void *ptr) { } + +static __inline__ __attribute__((device)) size_t __cvta_generic_to_grid_constant(const void *ptr) { } + + +static __inline__ __attribute__((device)) void * __cvta_global_to_generic(size_t rawbits) { } +static __inline__ __attribute__((device)) void * __cvta_shared_to_generic(size_t rawbits) { } +static __inline__ __attribute__((device)) void * __cvta_constant_to_generic(size_t rawbits) { } +static __inline__ __attribute__((device)) void * __cvta_local_to_generic(size_t rawbits) { } + +static __inline__ __attribute__((device)) void * __cvta_grid_constant_to_generic(size_t rawbits) { } +# 1090 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +static __inline__ __attribute__((host)) __attribute__((device)) unsigned short __nv_bswap16(unsigned short x) { + + return __builtin_bswap16(x); + + + + + +} +# 1109 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +static __inline__ __attribute__((host)) __attribute__((device)) unsigned int __nv_bswap32(unsigned int x) { + + return __builtin_bswap32(x); + + + + + + +} +# 1129 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +static __inline__ __attribute__((host)) __attribute__((device)) unsigned long long __nv_bswap64(unsigned long long x) { + + return __builtin_bswap64(x); + + + + + + +} +# 2909 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" 1 +# 123 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +static __attribute__((device)) __inline__ unsigned __fns(unsigned mask, unsigned base, int offset) { } +static __attribute__((device)) __inline__ void __barrier_sync(unsigned id) { } +static __attribute__((device)) __inline__ void __barrier_sync_count(unsigned id, unsigned cnt) { } +static __attribute__((device)) __inline__ void __syncwarp(unsigned mask=0xFFFFFFFF) { } +static __attribute__((device)) __inline__ int __all_sync(unsigned mask, int pred) { } +static __attribute__((device)) __inline__ int __any_sync(unsigned mask, int pred) { } +static __attribute__((device)) __inline__ int __uni_sync(unsigned mask, int pred) { } +static __attribute__((device)) __inline__ unsigned __ballot_sync(unsigned mask, int pred) { } +static __attribute__((device)) __inline__ unsigned __activemask() { } +# 140 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __shfl(int var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __shfl(unsigned int var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __shfl_up(int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __shfl_up(unsigned int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __shfl_down(int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __shfl_down(unsigned int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __shfl_xor(int var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __shfl_xor(unsigned int var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) float __shfl(float var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) float __shfl_up(float var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) float __shfl_down(float var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) float __shfl_xor(float var, int laneMask, int width=32) { } + + +static __attribute__((device)) __inline__ int __shfl_sync(unsigned mask, int var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ unsigned int __shfl_sync(unsigned mask, unsigned int var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ int __shfl_up_sync(unsigned mask, int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ unsigned int __shfl_up_sync(unsigned mask, unsigned int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ int __shfl_down_sync(unsigned mask, int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ unsigned int __shfl_down_sync(unsigned mask, unsigned int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ int __shfl_xor_sync(unsigned mask, int var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ unsigned int __shfl_xor_sync(unsigned mask, unsigned int var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ float __shfl_sync(unsigned mask, float var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ float __shfl_up_sync(unsigned mask, float var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ float __shfl_down_sync(unsigned mask, float var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ float __shfl_xor_sync(unsigned mask, float var, int laneMask, int width=32) { } + + + +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long long __shfl(unsigned long long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long long __shfl(long long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long long __shfl_up(long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long long __shfl_up(unsigned long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long long __shfl_down(long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long long __shfl_down(unsigned long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long long __shfl_xor(long long var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long long __shfl_xor(unsigned long long var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) double __shfl(double var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) double __shfl_up(double var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) double __shfl_down(double var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) double __shfl_xor(double var, int laneMask, int width=32) { } + + +static __attribute__((device)) __inline__ long long __shfl_sync(unsigned mask, long long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ unsigned long long __shfl_sync(unsigned mask, unsigned long long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ long long __shfl_up_sync(unsigned mask, long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ unsigned long long __shfl_up_sync(unsigned mask, unsigned long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ long long __shfl_down_sync(unsigned mask, long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ unsigned long long __shfl_down_sync(unsigned mask, unsigned long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ long long __shfl_xor_sync(unsigned mask, long long var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ unsigned long long __shfl_xor_sync(unsigned mask, unsigned long long var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ double __shfl_sync(unsigned mask, double var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ double __shfl_up_sync(unsigned mask, double var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ double __shfl_down_sync(unsigned mask, double var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ double __shfl_xor_sync(unsigned mask, double var, int laneMask, int width=32) { } + + + +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long __shfl(long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long __shfl(unsigned long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long __shfl_up(long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long __shfl_up(unsigned long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long __shfl_down(long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long __shfl_down(unsigned long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long __shfl_xor(long var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long __shfl_xor(unsigned long var, int laneMask, int width=32) { } + + +static __attribute__((device)) __inline__ long __shfl_sync(unsigned mask, long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ unsigned long __shfl_sync(unsigned mask, unsigned long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ long __shfl_up_sync(unsigned mask, long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ unsigned long __shfl_up_sync(unsigned mask, unsigned long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ long __shfl_down_sync(unsigned mask, long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ unsigned long __shfl_down_sync(unsigned mask, unsigned long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ long __shfl_xor_sync(unsigned mask, long var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ unsigned long __shfl_xor_sync(unsigned mask, unsigned long var, int laneMask, int width=32) { } +# 2910 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" 1 +# 91 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ long __ldg(const long *ptr) { } +static __attribute__((device)) __inline__ unsigned long __ldg(const unsigned long *ptr) { } + +static __attribute__((device)) __inline__ char __ldg(const char *ptr) { } +static __attribute__((device)) __inline__ signed char __ldg(const signed char *ptr) { } +static __attribute__((device)) __inline__ short __ldg(const short *ptr) { } +static __attribute__((device)) __inline__ int __ldg(const int *ptr) { } +static __attribute__((device)) __inline__ long long __ldg(const long long *ptr) { } +static __attribute__((device)) __inline__ char2 __ldg(const char2 *ptr) { } +static __attribute__((device)) __inline__ char4 __ldg(const char4 *ptr) { } +static __attribute__((device)) __inline__ short2 __ldg(const short2 *ptr) { } +static __attribute__((device)) __inline__ short4 __ldg(const short4 *ptr) { } +static __attribute__((device)) __inline__ int2 __ldg(const int2 *ptr) { } +static __attribute__((device)) __inline__ int4 __ldg(const int4 *ptr) { } +static __attribute__((device)) __inline__ longlong2 __ldg(const longlong2 *ptr) { } + +static __attribute__((device)) __inline__ unsigned char __ldg(const unsigned char *ptr) { } +static __attribute__((device)) __inline__ unsigned short __ldg(const unsigned short *ptr) { } +static __attribute__((device)) __inline__ unsigned int __ldg(const unsigned int *ptr) { } +static __attribute__((device)) __inline__ unsigned long long __ldg(const unsigned long long *ptr) { } +static __attribute__((device)) __inline__ uchar2 __ldg(const uchar2 *ptr) { } +static __attribute__((device)) __inline__ uchar4 __ldg(const uchar4 *ptr) { } +static __attribute__((device)) __inline__ ushort2 __ldg(const ushort2 *ptr) { } +static __attribute__((device)) __inline__ ushort4 __ldg(const ushort4 *ptr) { } +static __attribute__((device)) __inline__ uint2 __ldg(const uint2 *ptr) { } +static __attribute__((device)) __inline__ uint4 __ldg(const uint4 *ptr) { } +static __attribute__((device)) __inline__ ulonglong2 __ldg(const ulonglong2 *ptr) { } + +static __attribute__((device)) __inline__ float __ldg(const float *ptr) { } +static __attribute__((device)) __inline__ double __ldg(const double *ptr) { } +static __attribute__((device)) __inline__ float2 __ldg(const float2 *ptr) { } +static __attribute__((device)) __inline__ float4 __ldg(const float4 *ptr) { } +static __attribute__((device)) __inline__ double2 __ldg(const double2 *ptr) { } + + + + +static __attribute__((device)) __inline__ long __ldcg(const long *ptr) { } +static __attribute__((device)) __inline__ unsigned long __ldcg(const unsigned long *ptr) { } + +static __attribute__((device)) __inline__ char __ldcg(const char *ptr) { } +static __attribute__((device)) __inline__ signed char __ldcg(const signed char *ptr) { } +static __attribute__((device)) __inline__ short __ldcg(const short *ptr) { } +static __attribute__((device)) __inline__ int __ldcg(const int *ptr) { } +static __attribute__((device)) __inline__ long long __ldcg(const long long *ptr) { } +static __attribute__((device)) __inline__ char2 __ldcg(const char2 *ptr) { } +static __attribute__((device)) __inline__ char4 __ldcg(const char4 *ptr) { } +static __attribute__((device)) __inline__ short2 __ldcg(const short2 *ptr) { } +static __attribute__((device)) __inline__ short4 __ldcg(const short4 *ptr) { } +static __attribute__((device)) __inline__ int2 __ldcg(const int2 *ptr) { } +static __attribute__((device)) __inline__ int4 __ldcg(const int4 *ptr) { } +static __attribute__((device)) __inline__ longlong2 __ldcg(const longlong2 *ptr) { } + +static __attribute__((device)) __inline__ unsigned char __ldcg(const unsigned char *ptr) { } +static __attribute__((device)) __inline__ unsigned short __ldcg(const unsigned short *ptr) { } +static __attribute__((device)) __inline__ unsigned int __ldcg(const unsigned int *ptr) { } +static __attribute__((device)) __inline__ unsigned long long __ldcg(const unsigned long long *ptr) { } +static __attribute__((device)) __inline__ uchar2 __ldcg(const uchar2 *ptr) { } +static __attribute__((device)) __inline__ uchar4 __ldcg(const uchar4 *ptr) { } +static __attribute__((device)) __inline__ ushort2 __ldcg(const ushort2 *ptr) { } +static __attribute__((device)) __inline__ ushort4 __ldcg(const ushort4 *ptr) { } +static __attribute__((device)) __inline__ uint2 __ldcg(const uint2 *ptr) { } +static __attribute__((device)) __inline__ uint4 __ldcg(const uint4 *ptr) { } +static __attribute__((device)) __inline__ ulonglong2 __ldcg(const ulonglong2 *ptr) { } + +static __attribute__((device)) __inline__ float __ldcg(const float *ptr) { } +static __attribute__((device)) __inline__ double __ldcg(const double *ptr) { } +static __attribute__((device)) __inline__ float2 __ldcg(const float2 *ptr) { } +static __attribute__((device)) __inline__ float4 __ldcg(const float4 *ptr) { } +static __attribute__((device)) __inline__ double2 __ldcg(const double2 *ptr) { } + + + +static __attribute__((device)) __inline__ long __ldca(const long *ptr) { } +static __attribute__((device)) __inline__ unsigned long __ldca(const unsigned long *ptr) { } + +static __attribute__((device)) __inline__ char __ldca(const char *ptr) { } +static __attribute__((device)) __inline__ signed char __ldca(const signed char *ptr) { } +static __attribute__((device)) __inline__ short __ldca(const short *ptr) { } +static __attribute__((device)) __inline__ int __ldca(const int *ptr) { } +static __attribute__((device)) __inline__ long long __ldca(const long long *ptr) { } +static __attribute__((device)) __inline__ char2 __ldca(const char2 *ptr) { } +static __attribute__((device)) __inline__ char4 __ldca(const char4 *ptr) { } +static __attribute__((device)) __inline__ short2 __ldca(const short2 *ptr) { } +static __attribute__((device)) __inline__ short4 __ldca(const short4 *ptr) { } +static __attribute__((device)) __inline__ int2 __ldca(const int2 *ptr) { } +static __attribute__((device)) __inline__ int4 __ldca(const int4 *ptr) { } +static __attribute__((device)) __inline__ longlong2 __ldca(const longlong2 *ptr) { } + +static __attribute__((device)) __inline__ unsigned char __ldca(const unsigned char *ptr) { } +static __attribute__((device)) __inline__ unsigned short __ldca(const unsigned short *ptr) { } +static __attribute__((device)) __inline__ unsigned int __ldca(const unsigned int *ptr) { } +static __attribute__((device)) __inline__ unsigned long long __ldca(const unsigned long long *ptr) { } +static __attribute__((device)) __inline__ uchar2 __ldca(const uchar2 *ptr) { } +static __attribute__((device)) __inline__ uchar4 __ldca(const uchar4 *ptr) { } +static __attribute__((device)) __inline__ ushort2 __ldca(const ushort2 *ptr) { } +static __attribute__((device)) __inline__ ushort4 __ldca(const ushort4 *ptr) { } +static __attribute__((device)) __inline__ uint2 __ldca(const uint2 *ptr) { } +static __attribute__((device)) __inline__ uint4 __ldca(const uint4 *ptr) { } +static __attribute__((device)) __inline__ ulonglong2 __ldca(const ulonglong2 *ptr) { } + +static __attribute__((device)) __inline__ float __ldca(const float *ptr) { } +static __attribute__((device)) __inline__ double __ldca(const double *ptr) { } +static __attribute__((device)) __inline__ float2 __ldca(const float2 *ptr) { } +static __attribute__((device)) __inline__ float4 __ldca(const float4 *ptr) { } +static __attribute__((device)) __inline__ double2 __ldca(const double2 *ptr) { } + + + +static __attribute__((device)) __inline__ long __ldcs(const long *ptr) { } +static __attribute__((device)) __inline__ unsigned long __ldcs(const unsigned long *ptr) { } + +static __attribute__((device)) __inline__ char __ldcs(const char *ptr) { } +static __attribute__((device)) __inline__ signed char __ldcs(const signed char *ptr) { } +static __attribute__((device)) __inline__ short __ldcs(const short *ptr) { } +static __attribute__((device)) __inline__ int __ldcs(const int *ptr) { } +static __attribute__((device)) __inline__ long long __ldcs(const long long *ptr) { } +static __attribute__((device)) __inline__ char2 __ldcs(const char2 *ptr) { } +static __attribute__((device)) __inline__ char4 __ldcs(const char4 *ptr) { } +static __attribute__((device)) __inline__ short2 __ldcs(const short2 *ptr) { } +static __attribute__((device)) __inline__ short4 __ldcs(const short4 *ptr) { } +static __attribute__((device)) __inline__ int2 __ldcs(const int2 *ptr) { } +static __attribute__((device)) __inline__ int4 __ldcs(const int4 *ptr) { } +static __attribute__((device)) __inline__ longlong2 __ldcs(const longlong2 *ptr) { } + +static __attribute__((device)) __inline__ unsigned char __ldcs(const unsigned char *ptr) { } +static __attribute__((device)) __inline__ unsigned short __ldcs(const unsigned short *ptr) { } +static __attribute__((device)) __inline__ unsigned int __ldcs(const unsigned int *ptr) { } +static __attribute__((device)) __inline__ unsigned long long __ldcs(const unsigned long long *ptr) { } +static __attribute__((device)) __inline__ uchar2 __ldcs(const uchar2 *ptr) { } +static __attribute__((device)) __inline__ uchar4 __ldcs(const uchar4 *ptr) { } +static __attribute__((device)) __inline__ ushort2 __ldcs(const ushort2 *ptr) { } +static __attribute__((device)) __inline__ ushort4 __ldcs(const ushort4 *ptr) { } +static __attribute__((device)) __inline__ uint2 __ldcs(const uint2 *ptr) { } +static __attribute__((device)) __inline__ uint4 __ldcs(const uint4 *ptr) { } +static __attribute__((device)) __inline__ ulonglong2 __ldcs(const ulonglong2 *ptr) { } + +static __attribute__((device)) __inline__ float __ldcs(const float *ptr) { } +static __attribute__((device)) __inline__ double __ldcs(const double *ptr) { } +static __attribute__((device)) __inline__ float2 __ldcs(const float2 *ptr) { } +static __attribute__((device)) __inline__ float4 __ldcs(const float4 *ptr) { } +static __attribute__((device)) __inline__ double2 __ldcs(const double2 *ptr) { } + + + +static __attribute__((device)) __inline__ long __ldlu(const long *ptr) { } +static __attribute__((device)) __inline__ unsigned long __ldlu(const unsigned long *ptr) { } + +static __attribute__((device)) __inline__ char __ldlu(const char *ptr) { } +static __attribute__((device)) __inline__ signed char __ldlu(const signed char *ptr) { } +static __attribute__((device)) __inline__ short __ldlu(const short *ptr) { } +static __attribute__((device)) __inline__ int __ldlu(const int *ptr) { } +static __attribute__((device)) __inline__ long long __ldlu(const long long *ptr) { } +static __attribute__((device)) __inline__ char2 __ldlu(const char2 *ptr) { } +static __attribute__((device)) __inline__ char4 __ldlu(const char4 *ptr) { } +static __attribute__((device)) __inline__ short2 __ldlu(const short2 *ptr) { } +static __attribute__((device)) __inline__ short4 __ldlu(const short4 *ptr) { } +static __attribute__((device)) __inline__ int2 __ldlu(const int2 *ptr) { } +static __attribute__((device)) __inline__ int4 __ldlu(const int4 *ptr) { } +static __attribute__((device)) __inline__ longlong2 __ldlu(const longlong2 *ptr) { } + +static __attribute__((device)) __inline__ unsigned char __ldlu(const unsigned char *ptr) { } +static __attribute__((device)) __inline__ unsigned short __ldlu(const unsigned short *ptr) { } +static __attribute__((device)) __inline__ unsigned int __ldlu(const unsigned int *ptr) { } +static __attribute__((device)) __inline__ unsigned long long __ldlu(const unsigned long long *ptr) { } +static __attribute__((device)) __inline__ uchar2 __ldlu(const uchar2 *ptr) { } +static __attribute__((device)) __inline__ uchar4 __ldlu(const uchar4 *ptr) { } +static __attribute__((device)) __inline__ ushort2 __ldlu(const ushort2 *ptr) { } +static __attribute__((device)) __inline__ ushort4 __ldlu(const ushort4 *ptr) { } +static __attribute__((device)) __inline__ uint2 __ldlu(const uint2 *ptr) { } +static __attribute__((device)) __inline__ uint4 __ldlu(const uint4 *ptr) { } +static __attribute__((device)) __inline__ ulonglong2 __ldlu(const ulonglong2 *ptr) { } + +static __attribute__((device)) __inline__ float __ldlu(const float *ptr) { } +static __attribute__((device)) __inline__ double __ldlu(const double *ptr) { } +static __attribute__((device)) __inline__ float2 __ldlu(const float2 *ptr) { } +static __attribute__((device)) __inline__ float4 __ldlu(const float4 *ptr) { } +static __attribute__((device)) __inline__ double2 __ldlu(const double2 *ptr) { } + + + +static __attribute__((device)) __inline__ long __ldcv(const long *ptr) { } +static __attribute__((device)) __inline__ unsigned long __ldcv(const unsigned long *ptr) { } + +static __attribute__((device)) __inline__ char __ldcv(const char *ptr) { } +static __attribute__((device)) __inline__ signed char __ldcv(const signed char *ptr) { } +static __attribute__((device)) __inline__ short __ldcv(const short *ptr) { } +static __attribute__((device)) __inline__ int __ldcv(const int *ptr) { } +static __attribute__((device)) __inline__ long long __ldcv(const long long *ptr) { } +static __attribute__((device)) __inline__ char2 __ldcv(const char2 *ptr) { } +static __attribute__((device)) __inline__ char4 __ldcv(const char4 *ptr) { } +static __attribute__((device)) __inline__ short2 __ldcv(const short2 *ptr) { } +static __attribute__((device)) __inline__ short4 __ldcv(const short4 *ptr) { } +static __attribute__((device)) __inline__ int2 __ldcv(const int2 *ptr) { } +static __attribute__((device)) __inline__ int4 __ldcv(const int4 *ptr) { } +static __attribute__((device)) __inline__ longlong2 __ldcv(const longlong2 *ptr) { } + +static __attribute__((device)) __inline__ unsigned char __ldcv(const unsigned char *ptr) { } +static __attribute__((device)) __inline__ unsigned short __ldcv(const unsigned short *ptr) { } +static __attribute__((device)) __inline__ unsigned int __ldcv(const unsigned int *ptr) { } +static __attribute__((device)) __inline__ unsigned long long __ldcv(const unsigned long long *ptr) { } +static __attribute__((device)) __inline__ uchar2 __ldcv(const uchar2 *ptr) { } +static __attribute__((device)) __inline__ uchar4 __ldcv(const uchar4 *ptr) { } +static __attribute__((device)) __inline__ ushort2 __ldcv(const ushort2 *ptr) { } +static __attribute__((device)) __inline__ ushort4 __ldcv(const ushort4 *ptr) { } +static __attribute__((device)) __inline__ uint2 __ldcv(const uint2 *ptr) { } +static __attribute__((device)) __inline__ uint4 __ldcv(const uint4 *ptr) { } +static __attribute__((device)) __inline__ ulonglong2 __ldcv(const ulonglong2 *ptr) { } + +static __attribute__((device)) __inline__ float __ldcv(const float *ptr) { } +static __attribute__((device)) __inline__ double __ldcv(const double *ptr) { } +static __attribute__((device)) __inline__ float2 __ldcv(const float2 *ptr) { } +static __attribute__((device)) __inline__ float4 __ldcv(const float4 *ptr) { } +static __attribute__((device)) __inline__ double2 __ldcv(const double2 *ptr) { } + + + +static __attribute__((device)) __inline__ void __stwb(long *ptr, long value) { } +static __attribute__((device)) __inline__ void __stwb(unsigned long *ptr, unsigned long value) { } + +static __attribute__((device)) __inline__ void __stwb(char *ptr, char value) { } +static __attribute__((device)) __inline__ void __stwb(signed char *ptr, signed char value) { } +static __attribute__((device)) __inline__ void __stwb(short *ptr, short value) { } +static __attribute__((device)) __inline__ void __stwb(int *ptr, int value) { } +static __attribute__((device)) __inline__ void __stwb(long long *ptr, long long value) { } +static __attribute__((device)) __inline__ void __stwb(char2 *ptr, char2 value) { } +static __attribute__((device)) __inline__ void __stwb(char4 *ptr, char4 value) { } +static __attribute__((device)) __inline__ void __stwb(short2 *ptr, short2 value) { } +static __attribute__((device)) __inline__ void __stwb(short4 *ptr, short4 value) { } +static __attribute__((device)) __inline__ void __stwb(int2 *ptr, int2 value) { } +static __attribute__((device)) __inline__ void __stwb(int4 *ptr, int4 value) { } +static __attribute__((device)) __inline__ void __stwb(longlong2 *ptr, longlong2 value) { } + +static __attribute__((device)) __inline__ void __stwb(unsigned char *ptr, unsigned char value) { } +static __attribute__((device)) __inline__ void __stwb(unsigned short *ptr, unsigned short value) { } +static __attribute__((device)) __inline__ void __stwb(unsigned int *ptr, unsigned int value) { } +static __attribute__((device)) __inline__ void __stwb(unsigned long long *ptr, unsigned long long value) { } +static __attribute__((device)) __inline__ void __stwb(uchar2 *ptr, uchar2 value) { } +static __attribute__((device)) __inline__ void __stwb(uchar4 *ptr, uchar4 value) { } +static __attribute__((device)) __inline__ void __stwb(ushort2 *ptr, ushort2 value) { } +static __attribute__((device)) __inline__ void __stwb(ushort4 *ptr, ushort4 value) { } +static __attribute__((device)) __inline__ void __stwb(uint2 *ptr, uint2 value) { } +static __attribute__((device)) __inline__ void __stwb(uint4 *ptr, uint4 value) { } +static __attribute__((device)) __inline__ void __stwb(ulonglong2 *ptr, ulonglong2 value) { } + +static __attribute__((device)) __inline__ void __stwb(float *ptr, float value) { } +static __attribute__((device)) __inline__ void __stwb(double *ptr, double value) { } +static __attribute__((device)) __inline__ void __stwb(float2 *ptr, float2 value) { } +static __attribute__((device)) __inline__ void __stwb(float4 *ptr, float4 value) { } +static __attribute__((device)) __inline__ void __stwb(double2 *ptr, double2 value) { } + + + +static __attribute__((device)) __inline__ void __stcg(long *ptr, long value) { } +static __attribute__((device)) __inline__ void __stcg(unsigned long *ptr, unsigned long value) { } + +static __attribute__((device)) __inline__ void __stcg(char *ptr, char value) { } +static __attribute__((device)) __inline__ void __stcg(signed char *ptr, signed char value) { } +static __attribute__((device)) __inline__ void __stcg(short *ptr, short value) { } +static __attribute__((device)) __inline__ void __stcg(int *ptr, int value) { } +static __attribute__((device)) __inline__ void __stcg(long long *ptr, long long value) { } +static __attribute__((device)) __inline__ void __stcg(char2 *ptr, char2 value) { } +static __attribute__((device)) __inline__ void __stcg(char4 *ptr, char4 value) { } +static __attribute__((device)) __inline__ void __stcg(short2 *ptr, short2 value) { } +static __attribute__((device)) __inline__ void __stcg(short4 *ptr, short4 value) { } +static __attribute__((device)) __inline__ void __stcg(int2 *ptr, int2 value) { } +static __attribute__((device)) __inline__ void __stcg(int4 *ptr, int4 value) { } +static __attribute__((device)) __inline__ void __stcg(longlong2 *ptr, longlong2 value) { } + +static __attribute__((device)) __inline__ void __stcg(unsigned char *ptr, unsigned char value) { } +static __attribute__((device)) __inline__ void __stcg(unsigned short *ptr, unsigned short value) { } +static __attribute__((device)) __inline__ void __stcg(unsigned int *ptr, unsigned int value) { } +static __attribute__((device)) __inline__ void __stcg(unsigned long long *ptr, unsigned long long value) { } +static __attribute__((device)) __inline__ void __stcg(uchar2 *ptr, uchar2 value) { } +static __attribute__((device)) __inline__ void __stcg(uchar4 *ptr, uchar4 value) { } +static __attribute__((device)) __inline__ void __stcg(ushort2 *ptr, ushort2 value) { } +static __attribute__((device)) __inline__ void __stcg(ushort4 *ptr, ushort4 value) { } +static __attribute__((device)) __inline__ void __stcg(uint2 *ptr, uint2 value) { } +static __attribute__((device)) __inline__ void __stcg(uint4 *ptr, uint4 value) { } +static __attribute__((device)) __inline__ void __stcg(ulonglong2 *ptr, ulonglong2 value) { } + +static __attribute__((device)) __inline__ void __stcg(float *ptr, float value) { } +static __attribute__((device)) __inline__ void __stcg(double *ptr, double value) { } +static __attribute__((device)) __inline__ void __stcg(float2 *ptr, float2 value) { } +static __attribute__((device)) __inline__ void __stcg(float4 *ptr, float4 value) { } +static __attribute__((device)) __inline__ void __stcg(double2 *ptr, double2 value) { } + + + +static __attribute__((device)) __inline__ void __stcs(long *ptr, long value) { } +static __attribute__((device)) __inline__ void __stcs(unsigned long *ptr, unsigned long value) { } + +static __attribute__((device)) __inline__ void __stcs(char *ptr, char value) { } +static __attribute__((device)) __inline__ void __stcs(signed char *ptr, signed char value) { } +static __attribute__((device)) __inline__ void __stcs(short *ptr, short value) { } +static __attribute__((device)) __inline__ void __stcs(int *ptr, int value) { } +static __attribute__((device)) __inline__ void __stcs(long long *ptr, long long value) { } +static __attribute__((device)) __inline__ void __stcs(char2 *ptr, char2 value) { } +static __attribute__((device)) __inline__ void __stcs(char4 *ptr, char4 value) { } +static __attribute__((device)) __inline__ void __stcs(short2 *ptr, short2 value) { } +static __attribute__((device)) __inline__ void __stcs(short4 *ptr, short4 value) { } +static __attribute__((device)) __inline__ void __stcs(int2 *ptr, int2 value) { } +static __attribute__((device)) __inline__ void __stcs(int4 *ptr, int4 value) { } +static __attribute__((device)) __inline__ void __stcs(longlong2 *ptr, longlong2 value) { } + +static __attribute__((device)) __inline__ void __stcs(unsigned char *ptr, unsigned char value) { } +static __attribute__((device)) __inline__ void __stcs(unsigned short *ptr, unsigned short value) { } +static __attribute__((device)) __inline__ void __stcs(unsigned int *ptr, unsigned int value) { } +static __attribute__((device)) __inline__ void __stcs(unsigned long long *ptr, unsigned long long value) { } +static __attribute__((device)) __inline__ void __stcs(uchar2 *ptr, uchar2 value) { } +static __attribute__((device)) __inline__ void __stcs(uchar4 *ptr, uchar4 value) { } +static __attribute__((device)) __inline__ void __stcs(ushort2 *ptr, ushort2 value) { } +static __attribute__((device)) __inline__ void __stcs(ushort4 *ptr, ushort4 value) { } +static __attribute__((device)) __inline__ void __stcs(uint2 *ptr, uint2 value) { } +static __attribute__((device)) __inline__ void __stcs(uint4 *ptr, uint4 value) { } +static __attribute__((device)) __inline__ void __stcs(ulonglong2 *ptr, ulonglong2 value) { } + +static __attribute__((device)) __inline__ void __stcs(float *ptr, float value) { } +static __attribute__((device)) __inline__ void __stcs(double *ptr, double value) { } +static __attribute__((device)) __inline__ void __stcs(float2 *ptr, float2 value) { } +static __attribute__((device)) __inline__ void __stcs(float4 *ptr, float4 value) { } +static __attribute__((device)) __inline__ void __stcs(double2 *ptr, double2 value) { } + + + +static __attribute__((device)) __inline__ void __stwt(long *ptr, long value) { } +static __attribute__((device)) __inline__ void __stwt(unsigned long *ptr, unsigned long value) { } + +static __attribute__((device)) __inline__ void __stwt(char *ptr, char value) { } +static __attribute__((device)) __inline__ void __stwt(signed char *ptr, signed char value) { } +static __attribute__((device)) __inline__ void __stwt(short *ptr, short value) { } +static __attribute__((device)) __inline__ void __stwt(int *ptr, int value) { } +static __attribute__((device)) __inline__ void __stwt(long long *ptr, long long value) { } +static __attribute__((device)) __inline__ void __stwt(char2 *ptr, char2 value) { } +static __attribute__((device)) __inline__ void __stwt(char4 *ptr, char4 value) { } +static __attribute__((device)) __inline__ void __stwt(short2 *ptr, short2 value) { } +static __attribute__((device)) __inline__ void __stwt(short4 *ptr, short4 value) { } +static __attribute__((device)) __inline__ void __stwt(int2 *ptr, int2 value) { } +static __attribute__((device)) __inline__ void __stwt(int4 *ptr, int4 value) { } +static __attribute__((device)) __inline__ void __stwt(longlong2 *ptr, longlong2 value) { } + +static __attribute__((device)) __inline__ void __stwt(unsigned char *ptr, unsigned char value) { } +static __attribute__((device)) __inline__ void __stwt(unsigned short *ptr, unsigned short value) { } +static __attribute__((device)) __inline__ void __stwt(unsigned int *ptr, unsigned int value) { } +static __attribute__((device)) __inline__ void __stwt(unsigned long long *ptr, unsigned long long value) { } +static __attribute__((device)) __inline__ void __stwt(uchar2 *ptr, uchar2 value) { } +static __attribute__((device)) __inline__ void __stwt(uchar4 *ptr, uchar4 value) { } +static __attribute__((device)) __inline__ void __stwt(ushort2 *ptr, ushort2 value) { } +static __attribute__((device)) __inline__ void __stwt(ushort4 *ptr, ushort4 value) { } +static __attribute__((device)) __inline__ void __stwt(uint2 *ptr, uint2 value) { } +static __attribute__((device)) __inline__ void __stwt(uint4 *ptr, uint4 value) { } +static __attribute__((device)) __inline__ void __stwt(ulonglong2 *ptr, ulonglong2 value) { } + +static __attribute__((device)) __inline__ void __stwt(float *ptr, float value) { } +static __attribute__((device)) __inline__ void __stwt(double *ptr, double value) { } +static __attribute__((device)) __inline__ void __stwt(float2 *ptr, float2 value) { } +static __attribute__((device)) __inline__ void __stwt(float4 *ptr, float4 value) { } +static __attribute__((device)) __inline__ void __stwt(double2 *ptr, double2 value) { } +# 465 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_l(unsigned int lo, unsigned int hi, unsigned int shift) { } +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_lc(unsigned int lo, unsigned int hi, unsigned int shift) { } +# 490 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_r(unsigned int lo, unsigned int hi, unsigned int shift) { } +# 502 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_rc(unsigned int lo, unsigned int hi, unsigned int shift) { } +# 2911 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_35_intrinsics.h" 1 +# 2912 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" 1 +# 102 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp2a_lo(int srcA, int srcB, int c) { } +# 113 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp2a_lo(unsigned int srcA, unsigned int srcB, unsigned int c) { } +# 125 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp2a_lo(short2 srcA, char4 srcB, int c) { } +# 136 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp2a_lo(ushort2 srcA, uchar4 srcB, unsigned int c) { } +# 148 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp2a_hi(int srcA, int srcB, int c) { } +# 159 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp2a_hi(unsigned int srcA, unsigned int srcB, unsigned int c) { } +# 171 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp2a_hi(short2 srcA, char4 srcB, int c) { } +# 182 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp2a_hi(ushort2 srcA, uchar4 srcB, unsigned int c) { } +# 197 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp4a(int srcA, int srcB, int c) { } +# 206 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp4a(unsigned int srcA, unsigned int srcB, unsigned int c) { } +# 216 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp4a(char4 srcA, char4 srcB, int c) { } +# 225 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp4a(uchar4 srcA, uchar4 srcB, unsigned int c) { } +# 2913 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" 1 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 85 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 87 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" 2 +# 98 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, unsigned value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, int value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, unsigned long value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, long value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, unsigned long long value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, long long value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, float value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, double value) { } + +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, unsigned value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, int value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, unsigned long value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, long value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, unsigned long long value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, long long value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, float value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, double value, int *pred) { } + +static __attribute__((device)) __inline__ void __nanosleep(unsigned int ns) { } + +static __attribute__((device)) __inline__ unsigned short int atomicCAS(unsigned short int *address, unsigned short int compare, unsigned short int val) { } +# 2914 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" 1 +# 81 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 82 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 84 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" 2 +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +static __attribute__((device)) __inline__ unsigned __reduce_add_sync(unsigned mask, unsigned value) { } +static __attribute__((device)) __inline__ unsigned __reduce_min_sync(unsigned mask, unsigned value) { } +static __attribute__((device)) __inline__ unsigned __reduce_max_sync(unsigned mask, unsigned value) { } + +static __attribute__((device)) __inline__ int __reduce_add_sync(unsigned mask, int value) { } +static __attribute__((device)) __inline__ int __reduce_min_sync(unsigned mask, int value) { } +static __attribute__((device)) __inline__ int __reduce_max_sync(unsigned mask, int value) { } + +static __attribute__((device)) __inline__ unsigned __reduce_and_sync(unsigned mask, unsigned value) { } +static __attribute__((device)) __inline__ unsigned __reduce_or_sync(unsigned mask, unsigned value) { } +static __attribute__((device)) __inline__ unsigned __reduce_xor_sync(unsigned mask, unsigned value) { } + + + + +extern "C" { +inline __attribute__((device)) void *__nv_associate_access_property(const void *ptr, + unsigned long long property) { + extern __attribute__((device)) void *__nv_associate_access_property_impl(const void *, + unsigned long long); + return __nv_associate_access_property_impl(ptr, property); +} + +inline __attribute__((device)) void __nv_memcpy_async_shared_global_4(void *dst, + const void *src, + unsigned src_size) { + extern __attribute__((device)) void __nv_memcpy_async_shared_global_4_impl(void *, + const void *, + unsigned); + __nv_memcpy_async_shared_global_4_impl(dst, src, src_size); +} + +inline __attribute__((device)) void __nv_memcpy_async_shared_global_8(void *dst, + const void *src, + unsigned src_size) { + extern __attribute__((device)) void __nv_memcpy_async_shared_global_8_impl(void *, + const void *, + unsigned); + __nv_memcpy_async_shared_global_8_impl(dst, src, src_size); +} + +inline __attribute__((device)) void __nv_memcpy_async_shared_global_16(void *dst, + const void *src, + unsigned src_size) { + extern __attribute__((device)) void __nv_memcpy_async_shared_global_16_impl(void *, + const void *, + unsigned); + __nv_memcpy_async_shared_global_16_impl(dst, src, src_size); +} + +} +# 2915 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" 1 +# 79 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 80 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 82 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" 2 +# 92 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +static __attribute__((device)) __inline__ unsigned __isCtaShared(const void *ptr) { } +static __attribute__((device)) __inline__ unsigned __isClusterShared(const void *ptr) { } +static __attribute__((device)) __inline__ void *__cluster_map_shared_rank(const void *ptr, unsigned target_block_rank) { } +static __attribute__((device)) __inline__ unsigned __cluster_query_shared_rank(const void *ptr) { } +static __attribute__((device)) __inline__ uint2 __cluster_map_shared_multicast(const void *ptr, unsigned cluster_cta_mask) { } +static __attribute__((device)) __inline__ unsigned __clusterDimIsSpecified() { } +static __attribute__((device)) __inline__ dim3 __clusterDim() { } +static __attribute__((device)) __inline__ dim3 __clusterRelativeBlockIdx() { } +static __attribute__((device)) __inline__ dim3 __clusterGridDimInClusters() { } +static __attribute__((device)) __inline__ dim3 __clusterIdx() { } +static __attribute__((device)) __inline__ unsigned __clusterRelativeBlockRank() { } +static __attribute__((device)) __inline__ unsigned __clusterSizeInBlocks() { } +static __attribute__((device)) __inline__ void __cluster_barrier_arrive() { } +static __attribute__((device)) __inline__ void __cluster_barrier_arrive_relaxed() { } +static __attribute__((device)) __inline__ void __cluster_barrier_wait() { } +static __attribute__((device)) __inline__ void __threadfence_cluster() { } + +static __attribute__((device)) __inline__ float2 atomicAdd(float2 *__address, float2 val) { } +static __attribute__((device)) __inline__ float2 atomicAdd_block(float2 *__address, float2 val) { } +static __attribute__((device)) __inline__ float2 atomicAdd_system(float2 *__address, float2 val) { } +static __attribute__((device)) __inline__ float4 atomicAdd(float4 *__address, float4 val) { } +static __attribute__((device)) __inline__ float4 atomicAdd_block(float4 *__address, float4 val) { } +static __attribute__((device)) __inline__ float4 atomicAdd_system(float4 *__address, float4 val) { } +# 125 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +extern "C" { + __attribute__((device)) __attribute__((device_builtin)) void __u128AtomicCAS(void *, void *, void *, void *); + __attribute__((device)) __attribute__((device_builtin)) void __u128AtomicCAS_block(void *, void *, void *, void *); + __attribute__((device)) __attribute__((device_builtin)) void __u128AtomicCAS_system(void *, void *, void *, void *); + __attribute__((device)) __attribute__((device_builtin)) void __u128AtomicExch(void *, void *, void *); + __attribute__((device)) __attribute__((device_builtin)) void __u128AtomicExch_block(void *, void *, void *); + __attribute__((device)) __attribute__((device_builtin)) void __u128AtomicExch_system(void *, void *, void *); +} + + + + + + +template +struct __nv_atomic_enable_if { }; + +template +struct __nv_atomic_enable_if { typedef _T __type; }; +# 153 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +template +struct __nv_atomic_triv_cp_helper { + + + + + + + static const bool __val = __is_trivially_copyable(_T); + + + + +}; +# 201 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +template +static __attribute__((device)) __inline__ typename __nv_atomic_enable_if= 16 && __nv_atomic_triv_cp_helper<_T>::__val, _T>::__type +atomicCAS(_T *__address, _T __compare, _T __val) { + union _U {_T __ret; __attribute__((device)) __inline__ _U() {}}; _U __u; + __u128AtomicCAS((void *)(__address), + (void *)(&(const_cast(reinterpret_cast(__compare)))), + (void *)(&(const_cast(reinterpret_cast(__val)))), + (void *)(&(const_cast(reinterpret_cast(__u.__ret))))); + return __u.__ret; +} + +template +static __attribute__((device)) __inline__ typename __nv_atomic_enable_if= 16 && __nv_atomic_triv_cp_helper<_T>::__val, _T>::__type +atomicCAS_block(_T *__address, _T __compare, _T __val) { + union _U {_T __ret; __attribute__((device)) __inline__ _U() {}}; _U __u; + __u128AtomicCAS_block((void *)(__address), + (void *)(&(const_cast(reinterpret_cast(__compare)))), + (void *)(&(const_cast(reinterpret_cast(__val)))), + (void *)(&(const_cast(reinterpret_cast(__u.__ret))))); + return __u.__ret; +} + +template +static __attribute__((device)) __inline__ typename __nv_atomic_enable_if= 16 && __nv_atomic_triv_cp_helper<_T>::__val, _T>::__type +atomicCAS_system(_T *__address, _T __compare, _T __val) { + union _U {_T __ret; __attribute__((device)) __inline__ _U() {}}; _U __u; + __u128AtomicCAS_system((void *)(__address), + (void *)(&(const_cast(reinterpret_cast(__compare)))), + (void *)(&(const_cast(reinterpret_cast(__val)))), + (void *)(&(const_cast(reinterpret_cast(__u.__ret))))); + return __u.__ret; +} + +template +static __attribute__((device)) __inline__ typename __nv_atomic_enable_if= 16 && __nv_atomic_triv_cp_helper<_T>::__val, _T>::__type +atomicExch(_T *__address, _T __val) { + union _U {_T __ret; __attribute__((device)) __inline__ _U() {}}; _U __u; + __u128AtomicExch((void *)(__address), + (void *)(&(const_cast(reinterpret_cast(__val)))), + (void *)(&(const_cast(reinterpret_cast(__u.__ret))))); + return __u.__ret; +} + +template +static __attribute__((device)) __inline__ typename __nv_atomic_enable_if= 16 && __nv_atomic_triv_cp_helper<_T>::__val, _T>::__type +atomicExch_block(_T *__address, _T __val) { + union _U {_T __ret; __attribute__((device)) __inline__ _U() {}}; _U __u; + __u128AtomicExch_block((void *)(__address), + (void *)(&(const_cast(reinterpret_cast(__val)))), + (void *)(&(const_cast(reinterpret_cast(__u.__ret))))); + return __u.__ret; +} + +template +static __attribute__((device)) __inline__ typename __nv_atomic_enable_if= 16 && __nv_atomic_triv_cp_helper<_T>::__val, _T>::__type +atomicExch_system(_T *__address, _T __val) { + union _U {_T __ret; __attribute__((device)) __inline__ _U() {}}; _U __u; + __u128AtomicExch_system((void *)(__address), + (void *)(&(const_cast(reinterpret_cast(__val)))), + (void *)(&(const_cast(reinterpret_cast(__u.__ret))))); + return __u.__ret; +} +# 2916 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" 1 +# 79 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 80 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 82 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" 2 +# 100 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __ffma2_rn(float2 x, float2 y, float2 z) { } +# 112 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __ffma2_rz(float2 x, float2 y, float2 z) { } +# 124 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __ffma2_rd(float2 x, float2 y, float2 z) { } +# 136 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __ffma2_ru(float2 x, float2 y, float2 z) { } +# 149 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __fadd2_rn(float2 x, float2 y) { } +# 161 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __fadd2_rz(float2 x, float2 y) { } +# 173 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __fadd2_rd(float2 x, float2 y) { } +# 185 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __fadd2_ru(float2 x, float2 y) { } +# 198 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __fmul2_rn(float2 x, float2 y) { } +# 210 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __fmul2_rz(float2 x, float2 y) { } +# 222 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __fmul2_rd(float2 x, float2 y) { } +# 234 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +static __attribute__((device)) __inline__ float2 __fmul2_ru(float2 x, float2 y) { } +# 2917 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" 1 +# 65 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template struct __nv_itex_trait { }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1Dfetch(T *ptr, cudaTextureObject_t obj, int x) +{ + __nv_tex_surf_handler("__itex1Dfetch", ptr, obj, x); +} + +template +static __attribute__((device)) T tex1Dfetch(cudaTextureObject_t texObject, int x) +{ + T ret; + tex1Dfetch(&ret, texObject, x); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1D(T *ptr, cudaTextureObject_t obj, float x) +{ + __nv_tex_surf_handler("__itex1D", ptr, obj, x); +} + + +template +static __attribute__((device)) T tex1D(cudaTextureObject_t texObject, float x) +{ + T ret; + tex1D(&ret, texObject, x); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2D(T *ptr, cudaTextureObject_t obj, float x, float y) +{ + __nv_tex_surf_handler("__itex2D", ptr, obj, x, y); +} + +template +static __attribute__((device)) T tex2D(cudaTextureObject_t texObject, float x, float y) +{ + T ret; + tex2D(&ret, texObject, x, y); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2D(T *ptr, cudaTextureObject_t obj, float x, float y, + bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2D_sparse", ptr, obj, x, y, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2D(cudaTextureObject_t texObject, float x, float y, bool* isResident) +{ + T ret; + tex2D(&ret, texObject, x, y, isResident); + return ret; +} + + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex3D(T *ptr, cudaTextureObject_t obj, float x, float y, float z) +{ + __nv_tex_surf_handler("__itex3D", ptr, obj, x, y, z); +} + +template +static __attribute__((device)) T tex3D(cudaTextureObject_t texObject, float x, float y, float z) +{ + T ret; + tex3D(&ret, texObject, x, y, z); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex3D(T *ptr, cudaTextureObject_t obj, float x, float y, float z, + bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex3D_sparse", ptr, obj, x, y, z, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex3D(cudaTextureObject_t texObject, float x, float y, float z, bool* isResident) +{ + T ret; + tex3D(&ret, texObject, x, y, z, isResident); + return ret; +} + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DLayered(T *ptr, cudaTextureObject_t obj, float x, int layer) +{ + __nv_tex_surf_handler("__itex1DLayered", ptr, obj, x, layer); +} + +template +static __attribute__((device)) T tex1DLayered(cudaTextureObject_t texObject, float x, int layer) +{ + T ret; + tex1DLayered(&ret, texObject, x, layer); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayered(T *ptr, cudaTextureObject_t obj, float x, float y, int layer) +{ + __nv_tex_surf_handler("__itex2DLayered", ptr, obj, x, y, layer); +} + +template +static __attribute__((device)) T tex2DLayered(cudaTextureObject_t texObject, float x, float y, int layer) +{ + T ret; + tex2DLayered(&ret, texObject, x, y, layer); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayered(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2DLayered_sparse", ptr, obj, x, y, layer, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2DLayered(cudaTextureObject_t texObject, float x, float y, int layer, bool* isResident) +{ + T ret; + tex2DLayered(&ret, texObject, x, y, layer, isResident); + return ret; +} + + + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemap(T *ptr, cudaTextureObject_t obj, float x, float y, float z) +{ + __nv_tex_surf_handler("__itexCubemap", ptr, obj, x, y, z); +} + + +template +static __attribute__((device)) T texCubemap(cudaTextureObject_t texObject, float x, float y, float z) +{ + T ret; + texCubemap(&ret, texObject, x, y, z); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapLayered(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer) +{ + __nv_tex_surf_handler("__itexCubemapLayered", ptr, obj, x, y, z, layer); +} + +template +static __attribute__((device)) T texCubemapLayered(cudaTextureObject_t texObject, float x, float y, float z, int layer) +{ + T ret; + texCubemapLayered(&ret, texObject, x, y, z, layer); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2Dgather(T *ptr, cudaTextureObject_t obj, float x, float y, int comp = 0) +{ + __nv_tex_surf_handler("__itex2Dgather", ptr, obj, x, y, comp); +} + +template +static __attribute__((device)) T tex2Dgather(cudaTextureObject_t to, float x, float y, int comp = 0) +{ + T ret; + tex2Dgather(&ret, to, x, y, comp); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2Dgather(T *ptr, cudaTextureObject_t obj, float x, float y, bool* isResident, int comp = 0) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2Dgather_sparse", ptr, obj, x, y, comp, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2Dgather(cudaTextureObject_t to, float x, float y, bool* isResident, int comp = 0) +{ + T ret; + tex2Dgather(&ret, to, x, y, isResident, comp); + return ret; +} + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DLod(T *ptr, cudaTextureObject_t obj, float x, float level) +{ + __nv_tex_surf_handler("__itex1DLod", ptr, obj, x, level); +} + +template +static __attribute__((device)) T tex1DLod(cudaTextureObject_t texObject, float x, float level) +{ + T ret; + tex1DLod(&ret, texObject, x, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float level) +{ + __nv_tex_surf_handler("__itex2DLod", ptr, obj, x, y, level); +} + +template +static __attribute__((device)) T tex2DLod(cudaTextureObject_t texObject, float x, float y, float level) +{ + T ret; + tex2DLod(&ret, texObject, x, y, level); + return ret; +} + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float level, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2DLod_sparse", ptr, obj, x, y, level, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2DLod(cudaTextureObject_t texObject, float x, float y, float level, bool* isResident) +{ + T ret; + tex2DLod(&ret, texObject, x, y, level, isResident); + return ret; +} + + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex3DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level) +{ + __nv_tex_surf_handler("__itex3DLod", ptr, obj, x, y, z, level); +} + +template +static __attribute__((device)) T tex3DLod(cudaTextureObject_t texObject, float x, float y, float z, float level) +{ + T ret; + tex3DLod(&ret, texObject, x, y, z, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex3DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex3DLod_sparse", ptr, obj, x, y, z, level, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex3DLod(cudaTextureObject_t texObject, float x, float y, float z, float level, bool* isResident) +{ + T ret; + tex3DLod(&ret, texObject, x, y, z, level, isResident); + return ret; +} + + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, int layer, float level) +{ + __nv_tex_surf_handler("__itex1DLayeredLod", ptr, obj, x, layer, level); +} + +template +static __attribute__((device)) T tex1DLayeredLod(cudaTextureObject_t texObject, float x, int layer, float level) +{ + T ret; + tex1DLayeredLod(&ret, texObject, x, layer, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, float level) +{ + __nv_tex_surf_handler("__itex2DLayeredLod", ptr, obj, x, y, layer, level); +} + +template +static __attribute__((device)) T tex2DLayeredLod(cudaTextureObject_t texObject, float x, float y, int layer, float level) +{ + T ret; + tex2DLayeredLod(&ret, texObject, x, y, layer, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, float level, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2DLayeredLod_sparse", ptr, obj, x, y, layer, level, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2DLayeredLod(cudaTextureObject_t texObject, float x, float y, int layer, float level, bool* isResident) +{ + T ret; + tex2DLayeredLod(&ret, texObject, x, y, layer, level, isResident); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level) +{ + __nv_tex_surf_handler("__itexCubemapLod", ptr, obj, x, y, z, level); +} + +template +static __attribute__((device)) T texCubemapLod(cudaTextureObject_t texObject, float x, float y, float z, float level) +{ + T ret; + texCubemapLod(&ret, texObject, x, y, z, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + __nv_tex_surf_handler("__itexCubemapGrad_v2", ptr, obj, x, y, z, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T texCubemapGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + T ret; + texCubemapGrad(&ret, texObject, x, y, z, dPdx, dPdy); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer, float level) +{ + __nv_tex_surf_handler("__itexCubemapLayeredLod", ptr, obj, x, y, z, layer, level); +} + +template +static __attribute__((device)) T texCubemapLayeredLod(cudaTextureObject_t texObject, float x, float y, float z, int layer, float level) +{ + T ret; + texCubemapLayeredLod(&ret, texObject, x, y, z, layer, level); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DGrad(T *ptr, cudaTextureObject_t obj, float x, float dPdx, float dPdy) +{ + __nv_tex_surf_handler("__itex1DGrad", ptr, obj, x, dPdx, dPdy); +} + +template +static __attribute__((device)) T tex1DGrad(cudaTextureObject_t texObject, float x, float dPdx, float dPdy) +{ + T ret; + tex1DGrad(&ret, texObject, x, dPdx, dPdy); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float2 dPdx, float2 dPdy) +{ + __nv_tex_surf_handler("__itex2DGrad_v2", ptr, obj, x, y, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T tex2DGrad(cudaTextureObject_t texObject, float x, float y, float2 dPdx, float2 dPdy) +{ + T ret; + tex2DGrad(&ret, texObject, x, y, dPdx, dPdy); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float2 dPdx, float2 dPdy, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2DGrad_sparse", ptr, obj, x, y, &dPdx, &dPdy, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2DGrad(cudaTextureObject_t texObject, float x, float y, float2 dPdx, float2 dPdy, bool* isResident) +{ + T ret; + tex2DGrad(&ret, texObject, x, y, dPdx, dPdy, isResident); + return ret; +} + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex3DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + __nv_tex_surf_handler("__itex3DGrad_v2", ptr, obj, x, y, z, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T tex3DGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + T ret; + tex3DGrad(&ret, texObject, x, y, z, dPdx, dPdy); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex3DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex3DGrad_sparse", ptr, obj, x, y, z, &dPdx, &dPdy, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex3DGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy, bool* isResident) +{ + T ret; + tex3DGrad(&ret, texObject, x, y, z, dPdx, dPdy, isResident); + return ret; +} + + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DLayeredGrad(T *ptr, cudaTextureObject_t obj, float x, int layer, float dPdx, float dPdy) +{ + __nv_tex_surf_handler("__itex1DLayeredGrad", ptr, obj, x, layer, dPdx, dPdy); +} + +template +static __attribute__((device)) T tex1DLayeredGrad(cudaTextureObject_t texObject, float x, int layer, float dPdx, float dPdy) +{ + T ret; + tex1DLayeredGrad(&ret, texObject, x, layer, dPdx, dPdy); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayeredGrad(T * ptr, cudaTextureObject_t obj, float x, float y, int layer, float2 dPdx, float2 dPdy) +{ + __nv_tex_surf_handler("__itex2DLayeredGrad_v2", ptr, obj, x, y, layer, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T tex2DLayeredGrad(cudaTextureObject_t texObject, float x, float y, int layer, float2 dPdx, float2 dPdy) +{ + T ret; + tex2DLayeredGrad(&ret, texObject, x, y, layer, dPdx, dPdy); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayeredGrad(T * ptr, cudaTextureObject_t obj, float x, float y, int layer, float2 dPdx, float2 dPdy, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2DLayeredGrad_sparse", ptr, obj, x, y, layer, &dPdx, &dPdy, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2DLayeredGrad(cudaTextureObject_t texObject, float x, float y, int layer, float2 dPdx, float2 dPdy, bool* isResident) +{ + T ret; + tex2DLayeredGrad(&ret, texObject, x, y, layer, dPdx, dPdy, isResident); + return ret; +} + + + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapLayeredGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer, float4 dPdx, float4 dPdy) +{ + __nv_tex_surf_handler("__itexCubemapLayeredGrad_v2", ptr, obj, x, y, z, layer, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T texCubemapLayeredGrad(cudaTextureObject_t texObject, float x, float y, float z, int layer, float4 dPdx, float4 dPdy) +{ + T ret; + texCubemapLayeredGrad(&ret, texObject, x, y, z, layer, dPdx, dPdy); + return ret; +} +# 2919 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" 1 +# 58 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template struct __nv_isurf_trait { }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; + +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; + +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; + + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf1Dread(T *ptr, cudaSurfaceObject_t obj, int x, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf1Dread", ptr, obj, x, mode); +} + +template +static __attribute__((device)) T surf1Dread(cudaSurfaceObject_t surfObject, int x, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf1Dread(&ret, surfObject, x, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf2Dread(T *ptr, cudaSurfaceObject_t obj, int x, int y, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf2Dread", ptr, obj, x, y, mode); +} + +template +static __attribute__((device)) T surf2Dread(cudaSurfaceObject_t surfObject, int x, int y, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf2Dread(&ret, surfObject, x, y, boundaryMode); + return ret; +} + + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf3Dread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int z, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf3Dread", ptr, obj, x, y, z, mode); +} + +template +static __attribute__((device)) T surf3Dread(cudaSurfaceObject_t surfObject, int x, int y, int z, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf3Dread(&ret, surfObject, x, y, z, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf1DLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf1DLayeredread", ptr, obj, x, layer, mode); +} + +template +static __attribute__((device)) T surf1DLayeredread(cudaSurfaceObject_t surfObject, int x, int layer, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf1DLayeredread(&ret, surfObject, x, layer, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf2DLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf2DLayeredread", ptr, obj, x, y, layer, mode); +} + +template +static __attribute__((device)) T surf2DLayeredread(cudaSurfaceObject_t surfObject, int x, int y, int layer, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf2DLayeredread(&ret, surfObject, x, y, layer, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surfCubemapread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int face, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurfCubemapread", ptr, obj, x, y, face, mode); +} + +template +static __attribute__((device)) T surfCubemapread(cudaSurfaceObject_t surfObject, int x, int y, int face, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surfCubemapread(&ret, surfObject, x, y, face, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surfCubemapLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int layerface, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurfCubemapLayeredread", ptr, obj, x, y, layerface, mode); +} + +template +static __attribute__((device)) T surfCubemapLayeredread(cudaSurfaceObject_t surfObject, int x, int y, int layerface, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surfCubemapLayeredread(&ret, surfObject, x, y, layerface, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf1Dwrite(T val, cudaSurfaceObject_t obj, int x, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf1Dwrite_v2", &val, obj, x, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf2Dwrite(T val, cudaSurfaceObject_t obj, int x, int y, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf2Dwrite_v2", &val, obj, x, y, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf3Dwrite(T val, cudaSurfaceObject_t obj, int x, int y, int z, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf3Dwrite_v2", &val, obj, x, y, z, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf1DLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf1DLayeredwrite_v2", &val, obj, x, layer, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf2DLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int y, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf2DLayeredwrite_v2", &val, obj, x, y, layer, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surfCubemapwrite(T val, cudaSurfaceObject_t obj, int x, int y, int face, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurfCubemapwrite_v2", &val, obj, x, y, face, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surfCubemapLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int y, int layerface, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurfCubemapLayeredwrite_v2", &val, obj, x, y, layerface, mode); +} +# 2920 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 + +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/cudacc_ext.h" 1 +# 2922 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 + + +extern "C" __attribute__((host)) __attribute__((device)) unsigned __cudaPushCallConfiguration(dim3 gridDim, + dim3 blockDim, + size_t sharedMem = 0, + struct CUstream_st *stream = 0); +# 2969 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +enum { + __NV_ATOMIC_RELAXED, + __NV_ATOMIC_CONSUME, + __NV_ATOMIC_ACQUIRE, + __NV_ATOMIC_RELEASE, + __NV_ATOMIC_ACQ_REL, + __NV_ATOMIC_SEQ_CST +}; + +enum { + __NV_THREAD_SCOPE_THREAD, + __NV_THREAD_SCOPE_BLOCK, + __NV_THREAD_SCOPE_CLUSTER, + __NV_THREAD_SCOPE_DEVICE, + __NV_THREAD_SCOPE_SYSTEM +}; +# 119 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 1 "/opt/cuda/bin/../targets/x86_64-linux/include/device_launch_parameters.h" 1 +# 68 "/opt/cuda/bin/../targets/x86_64-linux/include/device_launch_parameters.h" +extern "C" { + + +uint3 __attribute__((device_builtin)) extern const threadIdx; +uint3 __attribute__((device_builtin)) extern const blockIdx; +dim3 __attribute__((device_builtin)) extern const blockDim; +dim3 __attribute__((device_builtin)) extern const gridDim; +int __attribute__((device_builtin)) extern const warpSize; + + + + +} +# 120 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 148 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 1 3 +# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 + +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 1 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 + +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + namespace rel_ops + { +# 86 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 + template + inline bool + operator!=(const _Tp& __x, const _Tp& __y) + { return !(__x == __y); } +# 99 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 + template + inline bool + operator>(const _Tp& __x, const _Tp& __y) + { return __y < __x; } +# 112 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 + template + inline bool + operator<=(const _Tp& __x, const _Tp& __y) + { return !(__y < __x); } +# 125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 + template + inline bool + operator>=(const _Tp& __x, const _Tp& __y) + { return !(__x < __y); } + } + + +} +# 69 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 2 3 + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/initializer_list" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/initializer_list" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/initializer_list" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + template + class initializer_list + { + public: + typedef _E value_type; + typedef const _E& reference; + typedef const _E& const_reference; + typedef size_t size_type; + typedef const _E* iterator; + typedef const _E* const_iterator; + + private: + iterator _M_array; + size_type _M_len; + + + constexpr initializer_list(const_iterator __a, size_type __l) + : _M_array(__a), _M_len(__l) { } + + public: + constexpr initializer_list() noexcept + : _M_array(0), _M_len(0) { } + + + constexpr size_type + size() const noexcept { return _M_len; } + + + constexpr const_iterator + begin() const noexcept { return _M_array; } + + + constexpr const_iterator + end() const noexcept { return begin() + size(); } + }; + + + + + + + + template + constexpr const _Tp* + begin(initializer_list<_Tp> __ils) noexcept + { return __ils.begin(); } + + + + + + + + template + constexpr const _Tp* + end(initializer_list<_Tp> __ils) noexcept + { return __ils.end(); } +} +# 74 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 2 3 +# 96 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 + +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/version.h" 3 +# 97 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template + + inline _Tp + exchange(_Tp& __obj, _Up&& __new_val) + noexcept(__and_, + is_nothrow_assignable<_Tp&, _Up>>::value) + { return std::__exchange(__obj, std::forward<_Up>(__new_val)); } + + + + template + [[nodiscard]] + constexpr add_const_t<_Tp>& + as_const(_Tp& __t) noexcept + { return __t; } + + template + void as_const(const _Tp&&) = delete; +# 230 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 + +} +# 149 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" + +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchKernel( + T *func, + dim3 gridDim, + dim3 blockDim, + void **args, + size_t sharedMem = 0, + cudaStream_t stream = 0 +) +{ + return ::cudaLaunchKernel((const void *)func, gridDim, blockDim, args, sharedMem, stream); +} +# 279 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchKernelEx( + const cudaLaunchConfig_t *config, + void (*kernel)(ExpTypes...), + ActTypes &&... args +) +{ + return [&](ExpTypes... coercedArgs){ + void *pArgs[] = { &coercedArgs... }; + return ::cudaLaunchKernelExC(config, (const void *)kernel, pArgs); + }(std::forward(args)...); +} +# 348 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchKernelEx( + const cudaLaunchConfig_t *config, + const cudaKernel_t kernel, + ActTypes &&... args +) +{ + void *pArgs[] = { &args... }; + return ::cudaLaunchKernelExC(config, (const void *)kernel, pArgs); +} +# 410 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchCooperativeKernel( + T *func, + dim3 gridDim, + dim3 blockDim, + void **args, + size_t sharedMem = 0, + cudaStream_t stream = 0 +) +{ + return ::cudaLaunchCooperativeKernel((const void *)func, gridDim, blockDim, args, sharedMem, stream); +} +# 454 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaEventCreate( + cudaEvent_t *event, + unsigned int flags +) +{ + return ::cudaEventCreateWithFlags(event, flags); +} +# 498 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaGraphInstantiate( + cudaGraphExec_t *pGraphExec, + cudaGraph_t graph, + cudaGraphNode_t *pErrorNode, + char *pLogBuffer, + size_t bufferSize +) +{ + (void)pErrorNode; + (void)pLogBuffer; + (void)bufferSize; + return ::cudaGraphInstantiate(pGraphExec, graph, 0); +} +# 569 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaMallocHost( + void **ptr, + size_t size, + unsigned int flags +) +{ + return ::cudaHostAlloc(ptr, size, flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaHostAlloc( + T **ptr, + size_t size, + unsigned int flags +) +{ + return ::cudaHostAlloc((void**)(void*)ptr, size, flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaHostGetDevicePointer( + T **pDevice, + void *pHost, + unsigned int flags +) +{ + return ::cudaHostGetDevicePointer((void**)(void*)pDevice, pHost, flags); +} +# 698 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocManaged( + T **devPtr, + size_t size, + unsigned int flags = 0x01 +) +{ + return ::cudaMallocManaged((void**)(void*)devPtr, size, flags); +} +# 716 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +cudaError_t cudaMemAdvise( + T *devPtr, + size_t count, + enum cudaMemoryAdvise advice, + struct cudaMemLocation location +) +{ + return ::cudaMemAdvise_v2((const void *)devPtr, count, advice, location); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMemPrefetchAsync( + T *devPtr, + size_t count, + struct cudaMemLocation location, + unsigned int flags, + cudaStream_t stream = 0 +) +{ + return ::cudaMemPrefetchAsync_v2((const void *)devPtr, count, location, flags, stream); +} +# 819 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaStreamAttachMemAsync( + cudaStream_t stream, + T *devPtr, + size_t length = 0, + unsigned int flags = 0x04 +) +{ + return ::cudaStreamAttachMemAsync(stream, (void*)devPtr, length, flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMalloc( + T **devPtr, + size_t size +) +{ + return ::cudaMalloc((void**)(void*)devPtr, size); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocHost( + T **ptr, + size_t size, + unsigned int flags = 0 +) +{ + return cudaMallocHost((void**)(void*)ptr, size, flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocPitch( + T **devPtr, + size_t *pitch, + size_t width, + size_t height +) +{ + return ::cudaMallocPitch((void**)(void*)devPtr, pitch, width, height); +} +# 869 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaMallocAsync( + void **ptr, + size_t size, + cudaMemPool_t memPool, + cudaStream_t stream +) +{ + return ::cudaMallocFromPoolAsync(ptr, size, memPool, stream); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocAsync( + T **ptr, + size_t size, + cudaMemPool_t memPool, + cudaStream_t stream +) +{ + return ::cudaMallocFromPoolAsync((void**)(void*)ptr, size, memPool, stream); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocAsync( + T **ptr, + size_t size, + cudaStream_t stream +) +{ + return ::cudaMallocAsync((void**)(void*)ptr, size, stream); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocFromPoolAsync( + T **ptr, + size_t size, + cudaMemPool_t memPool, + cudaStream_t stream +) +{ + return ::cudaMallocFromPoolAsync((void**)(void*)ptr, size, memPool, stream); +} +# 919 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyBatchAsync( + T **dsts, U **srcs, size_t *sizes, size_t count, struct cudaMemcpyAttributes *attrs, + size_t *attrsIdxs, size_t numAttrs, size_t *failIdx, cudaStream_t hStream +) +{ + return ::cudaMemcpyBatchAsync((void **)dsts, (void **)srcs, sizes, count, attrs, attrsIdxs, numAttrs, failIdx, hStream); +} +# 938 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyBatchAsync( + T **dsts, U **srcs, size_t *sizes, size_t count, struct cudaMemcpyAttributes attr, size_t *failIdx, cudaStream_t hStream +) +{ + size_t attrsIdxs = 0; + return ::cudaMemcpyBatchAsync((void **)dsts, (void **)srcs, sizes, count, &attr, &attrsIdxs, 1, failIdx, hStream); +} +# 984 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyToSymbol( + const T &symbol, + const void *src, + size_t count, + size_t offset = 0, + enum cudaMemcpyKind kind = cudaMemcpyHostToDevice +) +{ + return ::cudaMemcpyToSymbol((const void*)&symbol, src, count, offset, kind); +} +# 1038 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyToSymbolAsync( + const T &symbol, + const void *src, + size_t count, + size_t offset = 0, + enum cudaMemcpyKind kind = cudaMemcpyHostToDevice, + cudaStream_t stream = 0 +) +{ + return ::cudaMemcpyToSymbolAsync((const void*)&symbol, src, count, offset, kind, stream); +} +# 1086 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyFromSymbol( + void *dst, + const T &symbol, + size_t count, + size_t offset = 0, + enum cudaMemcpyKind kind = cudaMemcpyDeviceToHost +) +{ + return ::cudaMemcpyFromSymbol(dst, (const void*)&symbol, count, offset, kind); +} +# 1140 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyFromSymbolAsync( + void *dst, + const T &symbol, + size_t count, + size_t offset = 0, + enum cudaMemcpyKind kind = cudaMemcpyDeviceToHost, + cudaStream_t stream = 0 +) +{ + return ::cudaMemcpyFromSymbolAsync(dst, (const void*)&symbol, count, offset, kind, stream); +} +# 1209 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphAddMemcpyNodeToSymbol( + cudaGraphNode_t *pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t *pDependencies, + size_t numDependencies, + const T &symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphAddMemcpyNodeToSymbol(pGraphNode, graph, pDependencies, numDependencies, (const void*)&symbol, src, count, offset, kind); +} +# 1280 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphAddMemcpyNodeFromSymbol( + cudaGraphNode_t* pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t* pDependencies, + size_t numDependencies, + void* dst, + const T &symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphAddMemcpyNodeFromSymbol(pGraphNode, graph, pDependencies, numDependencies, dst, (const void*)&symbol, count, offset, kind); +} +# 1331 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParamsToSymbol( + cudaGraphNode_t node, + const T &symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphMemcpyNodeSetParamsToSymbol(node, (const void*)&symbol, src, count, offset, kind); +} +# 1379 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParamsFromSymbol( + cudaGraphNode_t node, + void* dst, + const T &symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphMemcpyNodeSetParamsFromSymbol(node, dst, (const void*)&symbol, count, offset, kind); +} +# 1437 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParamsToSymbol( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + const T &symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphExecMemcpyNodeSetParamsToSymbol(hGraphExec, node, (const void*)&symbol, src, count, offset, kind); +} +# 1496 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParamsFromSymbol( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + void* dst, + const T &symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphExecMemcpyNodeSetParamsFromSymbol(hGraphExec, node, dst, (const void*)&symbol, count, offset, kind); +} + + +static __inline__ __attribute__((host)) cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphNode_t *hErrorNode_out, enum cudaGraphExecUpdateResult *updateResult_out) +{ + cudaGraphExecUpdateResultInfo resultInfo; + cudaError_t status = cudaGraphExecUpdate(hGraphExec, hGraph, &resultInfo); + if (hErrorNode_out) { + *hErrorNode_out = resultInfo.errorNode; + } + if (updateResult_out) { + *updateResult_out = resultInfo.result; + } + return status; +} +# 1549 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaUserObjectCreate( + cudaUserObject_t *object_out, + T *objectToWrap, + unsigned int initialRefcount, + unsigned int flags) +{ + return ::cudaUserObjectCreate( + object_out, + objectToWrap, + [](void *vpObj) { delete reinterpret_cast(vpObj); }, + initialRefcount, + flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaUserObjectCreate( + cudaUserObject_t *object_out, + T *objectToWrap, + unsigned int initialRefcount, + cudaUserObjectFlags flags) +{ + return cudaUserObjectCreate(object_out, objectToWrap, initialRefcount, (unsigned int)flags); +} +# 1599 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetSymbolAddress( + void **devPtr, + const T &symbol +) +{ + return ::cudaGetSymbolAddress(devPtr, (const void*)&symbol); +} +# 1631 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetSymbolSize( + size_t *size, + const T &symbol +) +{ + return ::cudaGetSymbolSize(size, (const void*)&symbol); +} +# 1683 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncSetCacheConfig( + T *func, + enum cudaFuncCache cacheConfig +) +{ + return ::cudaFuncSetCacheConfig((const void*)func, cacheConfig); +} + +template +static __inline__ +__attribute__((deprecated)) +__attribute__((host)) cudaError_t cudaFuncSetSharedMemConfig( + T *func, + enum cudaSharedMemConfig config +) +{ + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + + return ::cudaFuncSetSharedMemConfig((const void*)func, config); + +#pragma GCC diagnostic pop + +} +# 1743 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor( + int *numBlocks, + T func, + int blockSize, + size_t dynamicSMemSize) +{ + return ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, (const void*)func, blockSize, dynamicSMemSize, 0x00); +} +# 1796 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags( + int *numBlocks, + T func, + int blockSize, + size_t dynamicSMemSize, + unsigned int flags) +{ + return ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, (const void*)func, blockSize, dynamicSMemSize, flags); +} + + + + +class __cudaOccupancyB2DHelper { + size_t n; +public: + inline __attribute__((host)) __attribute__((device)) __cudaOccupancyB2DHelper(size_t n_) : n(n_) {} + inline __attribute__((host)) __attribute__((device)) size_t operator()(int) + { + return n; + } +}; +# 1866 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) __attribute__((device)) cudaError_t cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags( + int *minGridSize, + int *blockSize, + T func, + UnaryFunction blockSizeToDynamicSMemSize, + int blockSizeLimit = 0, + unsigned int flags = 0) +{ + cudaError_t status; + + + int device; + struct cudaFuncAttributes attr; + + + int maxThreadsPerMultiProcessor; + int warpSize; + int devMaxThreadsPerBlock; + int multiProcessorCount; + int funcMaxThreadsPerBlock; + int occupancyLimit; + int granularity; + + + int maxBlockSize = 0; + int numBlocks = 0; + int maxOccupancy = 0; + + + int blockSizeToTryAligned; + int blockSizeToTry; + int blockSizeLimitAligned; + int occupancyInBlocks; + int occupancyInThreads; + size_t dynamicSMemSize; + + + + + + if (!minGridSize || !blockSize || !func) { + return cudaErrorInvalidValue; + } + + + + + + status = ::cudaGetDevice(&device); + if (status != cudaSuccess) { + return status; + } + + status = cudaDeviceGetAttribute( + &maxThreadsPerMultiProcessor, + cudaDevAttrMaxThreadsPerMultiProcessor, + device); + if (status != cudaSuccess) { + return status; + } + + status = cudaDeviceGetAttribute( + &warpSize, + cudaDevAttrWarpSize, + device); + if (status != cudaSuccess) { + return status; + } + + status = cudaDeviceGetAttribute( + &devMaxThreadsPerBlock, + cudaDevAttrMaxThreadsPerBlock, + device); + if (status != cudaSuccess) { + return status; + } + + status = cudaDeviceGetAttribute( + &multiProcessorCount, + cudaDevAttrMultiProcessorCount, + device); + if (status != cudaSuccess) { + return status; + } + + status = cudaFuncGetAttributes(&attr, func); + if (status != cudaSuccess) { + return status; + } + + funcMaxThreadsPerBlock = attr.maxThreadsPerBlock; + + + + + + occupancyLimit = maxThreadsPerMultiProcessor; + granularity = warpSize; + + if (blockSizeLimit == 0) { + blockSizeLimit = devMaxThreadsPerBlock; + } + + if (devMaxThreadsPerBlock < blockSizeLimit) { + blockSizeLimit = devMaxThreadsPerBlock; + } + + if (funcMaxThreadsPerBlock < blockSizeLimit) { + blockSizeLimit = funcMaxThreadsPerBlock; + } + + blockSizeLimitAligned = ((blockSizeLimit + (granularity - 1)) / granularity) * granularity; + + for (blockSizeToTryAligned = blockSizeLimitAligned; blockSizeToTryAligned > 0; blockSizeToTryAligned -= granularity) { + + + + if (blockSizeLimit < blockSizeToTryAligned) { + blockSizeToTry = blockSizeLimit; + } else { + blockSizeToTry = blockSizeToTryAligned; + } + + dynamicSMemSize = blockSizeToDynamicSMemSize(blockSizeToTry); + + status = cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags( + &occupancyInBlocks, + func, + blockSizeToTry, + dynamicSMemSize, + flags); + + if (status != cudaSuccess) { + return status; + } + + occupancyInThreads = blockSizeToTry * occupancyInBlocks; + + if (occupancyInThreads > maxOccupancy) { + maxBlockSize = blockSizeToTry; + numBlocks = occupancyInBlocks; + maxOccupancy = occupancyInThreads; + } + + + + if (occupancyLimit == maxOccupancy) { + break; + } + } + + + + + + + + *minGridSize = numBlocks * multiProcessorCount; + *blockSize = maxBlockSize; + + return status; +} +# 2062 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) __attribute__((device)) cudaError_t cudaOccupancyMaxPotentialBlockSizeVariableSMem( + int *minGridSize, + int *blockSize, + T func, + UnaryFunction blockSizeToDynamicSMemSize, + int blockSizeLimit = 0) +{ + return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, blockSizeToDynamicSMemSize, blockSizeLimit, 0x00); +} +# 2108 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) __attribute__((device)) cudaError_t cudaOccupancyMaxPotentialBlockSize( + int *minGridSize, + int *blockSize, + T func, + size_t dynamicSMemSize = 0, + int blockSizeLimit = 0) +{ + return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, __cudaOccupancyB2DHelper(dynamicSMemSize), blockSizeLimit, 0x00); +} +# 2147 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock( + size_t *dynamicSmemSize, + T *func, + int numBlocks, + int blockSize) +{ + return ::cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, (const void*)func, numBlocks, blockSize); +} +# 2206 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) __attribute__((device)) cudaError_t cudaOccupancyMaxPotentialBlockSizeWithFlags( + int *minGridSize, + int *blockSize, + T func, + size_t dynamicSMemSize = 0, + int blockSizeLimit = 0, + unsigned int flags = 0) +{ + return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, __cudaOccupancyB2DHelper(dynamicSMemSize), blockSizeLimit, flags); +} +# 2251 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxPotentialClusterSize( + int *clusterSize, + T *func, + const cudaLaunchConfig_t *config) +{ + return ::cudaOccupancyMaxPotentialClusterSize(clusterSize, (const void*)func, config); +} +# 2295 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxActiveClusters( + int *numClusters, + T *func, + const cudaLaunchConfig_t *config) +{ + return ::cudaOccupancyMaxActiveClusters(numClusters, (const void*)func, config); +} +# 2336 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncGetAttributes( + struct cudaFuncAttributes *attr, + T *entry +) +{ + return ::cudaFuncGetAttributes(attr, (const void*)entry); +} +# 2402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncSetAttribute( + T *func, + enum cudaFuncAttribute attr, + int value +) +{ + return ::cudaFuncSetAttribute((const void*)func, attr, value); +} +# 2435 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncGetName( + const char **name, + T *func +) +{ + return ::cudaFuncGetName(name, (const void *)func); +} +# 2458 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetKernel( + cudaKernel_t *kernelPtr, + T *func +) +{ + return ::cudaGetKernel(kernelPtr, (const void *)func); +} +# 2496 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLibraryGetGlobal(T **dptr, size_t *bytes, cudaLibrary_t library, const char *name) +{ + return ::cudaLibraryGetGlobal((void**)(void*)dptr, bytes, library, name); +} +# 2530 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLibraryGetManaged(T **dptr, size_t *bytes, cudaLibrary_t library, const char *name) +{ + return ::cudaLibraryGetManaged((void**)(void*)dptr, bytes, library, name); +} +# 2560 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLibraryGetUnifiedFunction(T **fptr, cudaLibrary_t library, const char *symbol) +{ + return ::cudaLibraryGetUnifiedFunction((void**)(void*)fptr, library, symbol); +} +# 2576 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +#pragma GCC diagnostic pop +# 0 "" 2 +# 1 "CMakeCUDACompilerId.cu" +# 477 "CMakeCUDACompilerId.cu" +char const* info_compiler = "INFO" ":" "compiler[" "NVIDIA" "]"; + +char const* info_simulate = "INFO" ":" "simulate[" "GNU" "]"; +# 790 "CMakeCUDACompilerId.cu" +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + ('0' + (((12) / 10000000)%10)), ('0' + (((12) / 1000000)%10)), ('0' + (((12) / 100000)%10)), ('0' + (((12) / 10000)%10)), ('0' + (((12) / 1000)%10)), ('0' + (((12) / 100)%10)), ('0' + (((12) / 10)%10)), ('0' + ((12) % 10)), + + '.', ('0' + (((8) / 10000000)%10)), ('0' + (((8) / 1000000)%10)), ('0' + (((8) / 100000)%10)), ('0' + (((8) / 10000)%10)), ('0' + (((8) / 1000)%10)), ('0' + (((8) / 100)%10)), ('0' + (((8) / 10)%10)), ('0' + ((8) % 10)), + + '.', ('0' + (((93) / 10000000)%10)), ('0' + (((93) / 1000000)%10)), ('0' + (((93) / 100000)%10)), ('0' + (((93) / 10000)%10)), ('0' + (((93) / 1000)%10)), ('0' + (((93) / 100)%10)), ('0' + (((93) / 10)%10)), ('0' + ((93) % 10)), + + + + + + ']','\0'}; +# 819 "CMakeCUDACompilerId.cu" +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + ('0' + (((14) / 10000000)%10)), ('0' + (((14) / 1000000)%10)), ('0' + (((14) / 100000)%10)), ('0' + (((14) / 10000)%10)), ('0' + (((14) / 1000)%10)), ('0' + (((14) / 100)%10)), ('0' + (((14) / 10)%10)), ('0' + ((14) % 10)), + + '.', ('0' + (((2) / 10000000)%10)), ('0' + (((2) / 1000000)%10)), ('0' + (((2) / 100000)%10)), ('0' + (((2) / 10000)%10)), ('0' + (((2) / 1000)%10)), ('0' + (((2) / 100)%10)), ('0' + (((2) / 10)%10)), ('0' + ((2) % 10)), + + + + + + + + ']','\0'}; + + + + + + +char const* info_platform = "INFO" ":" "platform[" "Linux" "]"; +char const* info_arch = "INFO" ":" "arch[" "]"; + + + + +char const* info_host_compiler = "INFO" ":" "host_compiler[" "GNU" "]"; + + + + +char const info_host_compiler_version[] = { + 'I', 'N', 'F', 'O', ':','h','o','s','t','_', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + ('0' + (((14) / 10000000)%10)), ('0' + (((14) / 1000000)%10)), ('0' + (((14) / 100000)%10)), ('0' + (((14) / 10000)%10)), ('0' + (((14) / 1000)%10)), ('0' + (((14) / 100)%10)), ('0' + (((14) / 10)%10)), ('0' + ((14) % 10)), + + '.', ('0' + (((2) / 10000000)%10)), ('0' + (((2) / 1000000)%10)), ('0' + (((2) / 100000)%10)), ('0' + (((2) / 10000)%10)), ('0' + (((2) / 1000)%10)), ('0' + (((2) / 100)%10)), ('0' + (((2) / 10)%10)), ('0' + ((2) % 10)), + + '.', ('0' + (((1) / 10000000)%10)), ('0' + (((1) / 1000000)%10)), ('0' + (((1) / 100000)%10)), ('0' + (((1) / 10000)%10)), ('0' + (((1) / 1000)%10)), ('0' + (((1) / 100)%10)), ('0' + (((1) / 10)%10)), ('0' + ((1) % 10)), + + + + + + ']','\0'}; +# 882 "CMakeCUDACompilerId.cu" +const char* info_language_standard_default = "INFO" ":" "standard_default[" + + + + + + + + "17" + + + + + + + +"]"; + +const char* info_language_extensions_default = "INFO" ":" "extensions_default[" + + + "ON" + + + +"]"; + + + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; + + require += info_version[argc]; + + + require += info_simulate[argc]; + + + require += info_simulate_version[argc]; + + + require += info_host_compiler[argc]; + + + require += info_host_compiler_version[argc]; + + require += info_language_standard_default[argc]; + require += info_language_extensions_default[argc]; + (void)argv; + return require; +} diff --git a/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.c b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.c new file mode 100644 index 0000000..4b1ecad --- /dev/null +++ b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.c @@ -0,0 +1,51 @@ +# 1 "CMakeCUDACompilerId.cu" +# 477 "CMakeCUDACompilerId.cu" +extern const char *info_compiler; + +extern const char *info_simulate; +# 790 "CMakeCUDACompilerId.cu" +static const char info_version[50]; +# 819 "CMakeCUDACompilerId.cu" +static const char info_simulate_version[41]; +# 839 "CMakeCUDACompilerId.cu" +extern const char *info_platform; +extern const char *info_arch; + + + + +extern const char *info_host_compiler; + + + + +static const char info_host_compiler_version[55]; +# 882 "CMakeCUDACompilerId.cu" +extern const char *info_language_standard_default; +# 900 "CMakeCUDACompilerId.cu" +extern const char *info_language_extensions_default; +# 477 "CMakeCUDACompilerId.cu" +const char *info_compiler = ((const char *)"INFO:compiler[NVIDIA]"); + +const char *info_simulate = ((const char *)"INFO:simulate[GNU]"); +# 790 "CMakeCUDACompilerId.cu" +static const char info_version[50] = {((char)73),((char)78),((char)70),((char)79),((char)58),((char)99),((char)111),((char)109),((char)112),((char)105),((char)108),((char)101),((char)114),((char)95),((char)118),((char)101),((char)114),((char)115),((char)105),((char)111),((char)110),((char)91),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)49),((char)50),((char)46),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)56),((char)46),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)57),((char)51),((char)93),((char)0)}; +# 819 "CMakeCUDACompilerId.cu" +static const char info_simulate_version[41] = {((char)73),((char)78),((char)70),((char)79),((char)58),((char)115),((char)105),((char)109),((char)117),((char)108),((char)97),((char)116),((char)101),((char)95),((char)118),((char)101),((char)114),((char)115),((char)105),((char)111),((char)110),((char)91),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)49),((char)52),((char)46),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)50),((char)93),((char)0)}; +# 839 "CMakeCUDACompilerId.cu" +const char *info_platform = ((const char *)"INFO:platform[Linux]"); +const char *info_arch = ((const char *)"INFO:arch[]"); + + + + +const char *info_host_compiler = ((const char *)"INFO:host_compiler[GNU]"); + + + + +static const char info_host_compiler_version[55] = {((char)73),((char)78),((char)70),((char)79),((char)58),((char)104),((char)111),((char)115),((char)116),((char)95),((char)99),((char)111),((char)109),((char)112),((char)105),((char)108),((char)101),((char)114),((char)95),((char)118),((char)101),((char)114),((char)115),((char)105),((char)111),((char)110),((char)91),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)49),((char)52),((char)46),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)50),((char)46),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)49),((char)93),((char)0)}; +# 882 "CMakeCUDACompilerId.cu" +const char *info_language_standard_default = ((const char *)"INFO:standard_default[17]"); +# 900 "CMakeCUDACompilerId.cu" +const char *info_language_extensions_default = ((const char *)"INFO:extensions_default[ON]"); diff --git a/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.cpp b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.cpp new file mode 100644 index 0000000..599e687 --- /dev/null +++ b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.cpp @@ -0,0 +1,36281 @@ +# 1 "CMakeCUDACompilerId.cu" +#pragma GCC diagnostic ignored "-Wunused-local-typedefs" +# 1 +#pragma GCC diagnostic push +# 1 +#pragma GCC diagnostic ignored "-Wunused-variable" +# 1 +#pragma GCC diagnostic ignored "-Wunused-function" +# 1 +static char __nv_inited_managed_rt = 0; static void **__nv_fatbinhandle_for_managed_rt; static void __nv_save_fatbinhandle_for_managed_rt(void **in){__nv_fatbinhandle_for_managed_rt = in;} static char __nv_init_managed_rt_with_module(void **); static inline void __nv_init_managed_rt(void) { __nv_inited_managed_rt = (__nv_inited_managed_rt ? __nv_inited_managed_rt : __nv_init_managed_rt_with_module(__nv_fatbinhandle_for_managed_rt));} +# 1 +#pragma GCC diagnostic pop +# 1 +#pragma GCC diagnostic ignored "-Wunused-variable" + +# 1 +#define __nv_is_extended_device_lambda_closure_type(X) false +#define __nv_is_extended_host_device_lambda_closure_type(X) false +#define __nv_is_extended_device_lambda_with_preserved_return_type(X) false +#if defined(__nv_is_extended_device_lambda_closure_type) && defined(__nv_is_extended_host_device_lambda_closure_type)&& defined(__nv_is_extended_device_lambda_with_preserved_return_type) +#endif + +# 1 +# 61 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +#pragma GCC diagnostic push +# 64 +#pragma GCC diagnostic ignored "-Wunused-function" +# 31 "/usr/include/bits/types.h" 3 +typedef unsigned char __u_char; +# 32 +typedef unsigned short __u_short; +# 33 +typedef unsigned __u_int; +# 34 +typedef unsigned long __u_long; +# 37 +typedef signed char __int8_t; +# 38 +typedef unsigned char __uint8_t; +# 39 +typedef signed short __int16_t; +# 40 +typedef unsigned short __uint16_t; +# 41 +typedef signed int __int32_t; +# 42 +typedef unsigned __uint32_t; +# 44 +typedef signed long __int64_t; +# 45 +typedef unsigned long __uint64_t; +# 52 +typedef __int8_t __int_least8_t; +# 53 +typedef __uint8_t __uint_least8_t; +# 54 +typedef __int16_t __int_least16_t; +# 55 +typedef __uint16_t __uint_least16_t; +# 56 +typedef __int32_t __int_least32_t; +# 57 +typedef __uint32_t __uint_least32_t; +# 58 +typedef __int64_t __int_least64_t; +# 59 +typedef __uint64_t __uint_least64_t; +# 63 +typedef long __quad_t; +# 64 +typedef unsigned long __u_quad_t; +# 72 +typedef long __intmax_t; +# 73 +typedef unsigned long __uintmax_t; +# 145 "/usr/include/bits/types.h" 3 +typedef unsigned long __dev_t; +# 146 +typedef unsigned __uid_t; +# 147 +typedef unsigned __gid_t; +# 148 +typedef unsigned long __ino_t; +# 149 +typedef unsigned long __ino64_t; +# 150 +typedef unsigned __mode_t; +# 151 +typedef unsigned long __nlink_t; +# 152 +typedef long __off_t; +# 153 +typedef long __off64_t; +# 154 +typedef int __pid_t; +# 155 +typedef struct { int __val[2]; } __fsid_t; +# 156 +typedef long __clock_t; +# 157 +typedef unsigned long __rlim_t; +# 158 +typedef unsigned long __rlim64_t; +# 159 +typedef unsigned __id_t; +# 160 +typedef long __time_t; +# 161 +typedef unsigned __useconds_t; +# 162 +typedef long __suseconds_t; +# 163 +typedef long __suseconds64_t; +# 165 +typedef int __daddr_t; +# 166 +typedef int __key_t; +# 169 +typedef int __clockid_t; +# 172 +typedef void *__timer_t; +# 175 +typedef long __blksize_t; +# 180 +typedef long __blkcnt_t; +# 181 +typedef long __blkcnt64_t; +# 184 +typedef unsigned long __fsblkcnt_t; +# 185 +typedef unsigned long __fsblkcnt64_t; +# 188 +typedef unsigned long __fsfilcnt_t; +# 189 +typedef unsigned long __fsfilcnt64_t; +# 192 +typedef long __fsword_t; +# 194 +typedef long __ssize_t; +# 197 +typedef long __syscall_slong_t; +# 199 +typedef unsigned long __syscall_ulong_t; +# 203 +typedef __off64_t __loff_t; +# 204 +typedef char *__caddr_t; +# 207 +typedef long __intptr_t; +# 210 +typedef unsigned __socklen_t; +# 215 +typedef int __sig_atomic_t; +# 28 "/usr/include/ctype.h" 3 +extern "C" { +# 47 "/usr/include/ctype.h" 3 +enum { +# 48 +_ISupper = ((0 < 8) ? (1 << 0) << 8 : ((1 << 0) >> 8)), +# 49 +_ISlower = ((1 < 8) ? (1 << 1) << 8 : ((1 << 1) >> 8)), +# 50 +_ISalpha = ((2 < 8) ? (1 << 2) << 8 : ((1 << 2) >> 8)), +# 51 +_ISdigit = ((3 < 8) ? (1 << 3) << 8 : ((1 << 3) >> 8)), +# 52 +_ISxdigit = ((4 < 8) ? (1 << 4) << 8 : ((1 << 4) >> 8)), +# 53 +_ISspace = ((5 < 8) ? (1 << 5) << 8 : ((1 << 5) >> 8)), +# 54 +_ISprint = ((6 < 8) ? (1 << 6) << 8 : ((1 << 6) >> 8)), +# 55 +_ISgraph = ((7 < 8) ? (1 << 7) << 8 : ((1 << 7) >> 8)), +# 56 +_ISblank = ((8 < 8) ? (1 << 8) << 8 : ((1 << 8) >> 8)), +# 57 +_IScntrl, +# 58 +_ISpunct = ((10 < 8) ? (1 << 10) << 8 : ((1 << 10) >> 8)), +# 59 +_ISalnum = ((11 < 8) ? (1 << 11) << 8 : ((1 << 11) >> 8)) +# 60 +}; +# 79 "/usr/include/ctype.h" 3 +extern const unsigned short **__ctype_b_loc() noexcept(true) +# 80 + __attribute((const)); +# 81 +extern const __int32_t **__ctype_tolower_loc() noexcept(true) +# 82 + __attribute((const)); +# 83 +extern const __int32_t **__ctype_toupper_loc() noexcept(true) +# 84 + __attribute((const)); +# 108 "/usr/include/ctype.h" 3 +extern int isalnum(int) noexcept(true); +# 109 +extern int isalpha(int) noexcept(true); +# 110 +extern int iscntrl(int) noexcept(true); +# 111 +extern int isdigit(int) noexcept(true); +# 112 +extern int islower(int) noexcept(true); +# 113 +extern int isgraph(int) noexcept(true); +# 114 +extern int isprint(int) noexcept(true); +# 115 +extern int ispunct(int) noexcept(true); +# 116 +extern int isspace(int) noexcept(true); +# 117 +extern int isupper(int) noexcept(true); +# 118 +extern int isxdigit(int) noexcept(true); +# 122 +extern int tolower(int __c) noexcept(true); +# 125 +extern int toupper(int __c) noexcept(true); +# 130 +extern int isblank(int) noexcept(true); +# 135 +extern int isctype(int __c, int __mask) noexcept(true); +# 142 +extern int isascii(int __c) noexcept(true); +# 146 +extern int toascii(int __c) noexcept(true); +# 150 +extern int _toupper(int) noexcept(true); +# 151 +extern int _tolower(int) noexcept(true); +# 27 "/usr/include/bits/types/__locale_t.h" 3 +struct __locale_struct { +# 30 +struct __locale_data *__locales[13]; +# 33 +const unsigned short *__ctype_b; +# 34 +const int *__ctype_tolower; +# 35 +const int *__ctype_toupper; +# 38 +const char *__names[13]; +# 39 +}; +# 41 +typedef __locale_struct *__locale_t; +# 24 "/usr/include/bits/types/locale_t.h" 3 +typedef __locale_t locale_t; +# 251 "/usr/include/ctype.h" 3 +extern int isalnum_l(int, locale_t) noexcept(true); +# 252 +extern int isalpha_l(int, locale_t) noexcept(true); +# 253 +extern int iscntrl_l(int, locale_t) noexcept(true); +# 254 +extern int isdigit_l(int, locale_t) noexcept(true); +# 255 +extern int islower_l(int, locale_t) noexcept(true); +# 256 +extern int isgraph_l(int, locale_t) noexcept(true); +# 257 +extern int isprint_l(int, locale_t) noexcept(true); +# 258 +extern int ispunct_l(int, locale_t) noexcept(true); +# 259 +extern int isspace_l(int, locale_t) noexcept(true); +# 260 +extern int isupper_l(int, locale_t) noexcept(true); +# 261 +extern int isxdigit_l(int, locale_t) noexcept(true); +# 263 +extern int isblank_l(int, locale_t) noexcept(true); +# 267 +extern int __tolower_l(int __c, locale_t __l) noexcept(true); +# 268 +extern int tolower_l(int __c, locale_t __l) noexcept(true); +# 271 +extern int __toupper_l(int __c, locale_t __l) noexcept(true); +# 272 +extern int toupper_l(int __c, locale_t __l) noexcept(true); +# 327 "/usr/include/ctype.h" 3 +} +# 68 "/opt/cuda/bin/../targets/x86_64-linux/include/device_types.h" +#if 0 +# 68 +enum cudaRoundMode { +# 70 +cudaRoundNearest, +# 71 +cudaRoundZero, +# 72 +cudaRoundPosInf, +# 73 +cudaRoundMinInf +# 74 +}; +#endif +# 104 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 104 +struct char1 { +# 106 +signed char x; +# 107 +}; +#endif +# 109 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 109 +struct uchar1 { +# 111 +unsigned char x; +# 112 +}; +#endif +# 115 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 115 +struct __attribute((aligned(2))) char2 { +# 117 +signed char x, y; +# 118 +}; +#endif +# 120 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 120 +struct __attribute((aligned(2))) uchar2 { +# 122 +unsigned char x, y; +# 123 +}; +#endif +# 125 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 125 +struct char3 { +# 127 +signed char x, y, z; +# 128 +}; +#endif +# 130 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 130 +struct uchar3 { +# 132 +unsigned char x, y, z; +# 133 +}; +#endif +# 135 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 135 +struct __attribute((aligned(4))) char4 { +# 137 +signed char x, y, z, w; +# 138 +}; +#endif +# 140 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 140 +struct __attribute((aligned(4))) uchar4 { +# 142 +unsigned char x, y, z, w; +# 143 +}; +#endif +# 145 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 145 +struct short1 { +# 147 +short x; +# 148 +}; +#endif +# 150 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 150 +struct ushort1 { +# 152 +unsigned short x; +# 153 +}; +#endif +# 155 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 155 +struct __attribute((aligned(4))) short2 { +# 157 +short x, y; +# 158 +}; +#endif +# 160 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 160 +struct __attribute((aligned(4))) ushort2 { +# 162 +unsigned short x, y; +# 163 +}; +#endif +# 165 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 165 +struct short3 { +# 167 +short x, y, z; +# 168 +}; +#endif +# 170 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 170 +struct ushort3 { +# 172 +unsigned short x, y, z; +# 173 +}; +#endif +# 175 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 175 +struct __attribute((aligned(8))) short4 { short x; short y; short z; short w; }; +#endif +# 176 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 176 +struct __attribute((aligned(8))) ushort4 { unsigned short x; unsigned short y; unsigned short z; unsigned short w; }; +#endif +# 178 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 178 +struct int1 { +# 180 +int x; +# 181 +}; +#endif +# 183 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 183 +struct uint1 { +# 185 +unsigned x; +# 186 +}; +#endif +# 188 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 188 +struct __attribute((aligned(8))) int2 { int x; int y; }; +#endif +# 189 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 189 +struct __attribute((aligned(8))) uint2 { unsigned x; unsigned y; }; +#endif +# 191 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 191 +struct int3 { +# 193 +int x, y, z; +# 194 +}; +#endif +# 196 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 196 +struct uint3 { +# 198 +unsigned x, y, z; +# 199 +}; +#endif +# 201 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 201 +struct __attribute((aligned(16))) int4 { +# 203 +int x, y, z, w; +# 204 +}; +#endif +# 206 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 206 +struct __attribute((aligned(16))) uint4 { +# 208 +unsigned x, y, z, w; +# 209 +}; +#endif +# 211 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 211 +struct long1 { +# 213 +long x; +# 214 +}; +#endif +# 216 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 216 +struct ulong1 { +# 218 +unsigned long x; +# 219 +}; +#endif +# 226 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 226 +struct __attribute((aligned((2) * sizeof(long)))) long2 { +# 228 +long x, y; +# 229 +}; +#endif +# 231 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 231 +struct __attribute((aligned((2) * sizeof(unsigned long)))) ulong2 { +# 233 +unsigned long x, y; +# 234 +}; +#endif +# 238 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 238 +struct long3 { +# 240 +long x, y, z; +# 241 +}; +#endif +# 243 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 243 +struct ulong3 { +# 245 +unsigned long x, y, z; +# 246 +}; +#endif +# 248 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 248 +struct __attribute((aligned(16))) long4 { +# 250 +long x, y, z, w; +# 251 +}; +#endif +# 253 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 253 +struct __attribute((aligned(16))) ulong4 { +# 255 +unsigned long x, y, z, w; +# 256 +}; +#endif +# 258 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 258 +struct float1 { +# 260 +float x; +# 261 +}; +#endif +# 280 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 280 +struct __attribute((aligned(8))) float2 { float x; float y; }; +#endif +# 285 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 285 +struct float3 { +# 287 +float x, y, z; +# 288 +}; +#endif +# 290 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 290 +struct __attribute((aligned(16))) float4 { +# 292 +float x, y, z, w; +# 293 +}; +#endif +# 295 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 295 +struct longlong1 { +# 297 +long long x; +# 298 +}; +#endif +# 300 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 300 +struct ulonglong1 { +# 302 +unsigned long long x; +# 303 +}; +#endif +# 305 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 305 +struct __attribute((aligned(16))) longlong2 { +# 307 +long long x, y; +# 308 +}; +#endif +# 310 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 310 +struct __attribute((aligned(16))) ulonglong2 { +# 312 +unsigned long long x, y; +# 313 +}; +#endif +# 315 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 315 +struct longlong3 { +# 317 +long long x, y, z; +# 318 +}; +#endif +# 320 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 320 +struct ulonglong3 { +# 322 +unsigned long long x, y, z; +# 323 +}; +#endif +# 325 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 325 +struct __attribute((aligned(16))) longlong4 { +# 327 +long long x, y, z, w; +# 328 +}; +#endif +# 330 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 330 +struct __attribute((aligned(16))) ulonglong4 { +# 332 +unsigned long long x, y, z, w; +# 333 +}; +#endif +# 335 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 335 +struct double1 { +# 337 +double x; +# 338 +}; +#endif +# 340 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 340 +struct __attribute((aligned(16))) double2 { +# 342 +double x, y; +# 343 +}; +#endif +# 345 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 345 +struct double3 { +# 347 +double x, y, z; +# 348 +}; +#endif +# 350 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 350 +struct __attribute((aligned(16))) double4 { +# 352 +double x, y, z, w; +# 353 +}; +#endif +# 367 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef char1 +# 367 +char1; +#endif +# 368 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef uchar1 +# 368 +uchar1; +#endif +# 369 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef char2 +# 369 +char2; +#endif +# 370 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef uchar2 +# 370 +uchar2; +#endif +# 371 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef char3 +# 371 +char3; +#endif +# 372 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef uchar3 +# 372 +uchar3; +#endif +# 373 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef char4 +# 373 +char4; +#endif +# 374 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef uchar4 +# 374 +uchar4; +#endif +# 375 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef short1 +# 375 +short1; +#endif +# 376 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ushort1 +# 376 +ushort1; +#endif +# 377 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef short2 +# 377 +short2; +#endif +# 378 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ushort2 +# 378 +ushort2; +#endif +# 379 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef short3 +# 379 +short3; +#endif +# 380 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ushort3 +# 380 +ushort3; +#endif +# 381 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef short4 +# 381 +short4; +#endif +# 382 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ushort4 +# 382 +ushort4; +#endif +# 383 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef int1 +# 383 +int1; +#endif +# 384 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef uint1 +# 384 +uint1; +#endif +# 385 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef int2 +# 385 +int2; +#endif +# 386 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef uint2 +# 386 +uint2; +#endif +# 387 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef int3 +# 387 +int3; +#endif +# 388 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef uint3 +# 388 +uint3; +#endif +# 389 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef int4 +# 389 +int4; +#endif +# 390 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef uint4 +# 390 +uint4; +#endif +# 391 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef long1 +# 391 +long1; +#endif +# 392 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ulong1 +# 392 +ulong1; +#endif +# 393 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef long2 +# 393 +long2; +#endif +# 394 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ulong2 +# 394 +ulong2; +#endif +# 395 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef long3 +# 395 +long3; +#endif +# 396 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ulong3 +# 396 +ulong3; +#endif +# 397 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef long4 +# 397 +long4; +#endif +# 398 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ulong4 +# 398 +ulong4; +#endif +# 399 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef float1 +# 399 +float1; +#endif +# 400 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef float2 +# 400 +float2; +#endif +# 401 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef float3 +# 401 +float3; +#endif +# 402 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef float4 +# 402 +float4; +#endif +# 403 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef longlong1 +# 403 +longlong1; +#endif +# 404 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ulonglong1 +# 404 +ulonglong1; +#endif +# 405 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef longlong2 +# 405 +longlong2; +#endif +# 406 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ulonglong2 +# 406 +ulonglong2; +#endif +# 407 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef longlong3 +# 407 +longlong3; +#endif +# 408 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ulonglong3 +# 408 +ulonglong3; +#endif +# 409 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef longlong4 +# 409 +longlong4; +#endif +# 410 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef ulonglong4 +# 410 +ulonglong4; +#endif +# 411 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef double1 +# 411 +double1; +#endif +# 412 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef double2 +# 412 +double2; +#endif +# 413 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef double3 +# 413 +double3; +#endif +# 414 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef double4 +# 414 +double4; +#endif +# 426 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +# 426 +struct dim3 { +# 428 +unsigned x, y, z; +# 440 +}; +#endif +# 442 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +#if 0 +typedef dim3 +# 442 +dim3; +#endif +# 23 "/usr/include/bits/pthread_stack_min-dynamic.h" 3 +extern "C" { +# 24 +extern long __sysconf(int __name) noexcept(true); +# 25 +} +# 145 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 +typedef long ptrdiff_t; +# 214 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 +typedef unsigned long size_t; +#if !defined(__CUDA_INCLUDE_COMPILER_INTERNAL_HEADERS__) +#define __CUDA_INCLUDE_COMPILER_INTERNAL_HEADERS__ +#endif +#include "crt/host_runtime.h" +# 436 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 +typedef +# 425 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 +struct { +# 426 +long long __max_align_ll __attribute((__aligned__(__alignof__(long long)))); +# 427 +long double __max_align_ld __attribute((__aligned__(__alignof__(long double)))); +# 436 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 +} max_align_t; +# 443 +typedef __decltype((nullptr)) nullptr_t; +# 205 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 205 +enum cudaError { +# 212 +cudaSuccess, +# 218 +cudaErrorInvalidValue, +# 224 +cudaErrorMemoryAllocation, +# 230 +cudaErrorInitializationError, +# 237 +cudaErrorCudartUnloading, +# 244 +cudaErrorProfilerDisabled, +# 252 +cudaErrorProfilerNotInitialized, +# 259 +cudaErrorProfilerAlreadyStarted, +# 266 +cudaErrorProfilerAlreadyStopped, +# 274 +cudaErrorInvalidConfiguration, +# 280 +cudaErrorInvalidPitchValue = 12, +# 286 +cudaErrorInvalidSymbol, +# 294 +cudaErrorInvalidHostPointer = 16, +# 302 +cudaErrorInvalidDevicePointer, +# 307 +cudaErrorInvalidTexture, +# 313 +cudaErrorInvalidTextureBinding, +# 320 +cudaErrorInvalidChannelDescriptor, +# 326 +cudaErrorInvalidMemcpyDirection, +# 336 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorAddressOfConstant, +# 345 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorTextureFetchFailed, +# 354 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorTextureNotBound, +# 363 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorSynchronizationError, +# 368 +cudaErrorInvalidFilterSetting, +# 374 +cudaErrorInvalidNormSetting, +# 382 +cudaErrorMixedDeviceExecution, +# 390 +cudaErrorNotYetImplemented = 31, +# 399 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorMemoryValueTooLarge, +# 405 +cudaErrorStubLibrary = 34, +# 412 +cudaErrorInsufficientDriver, +# 419 +cudaErrorCallRequiresNewerDriver, +# 425 +cudaErrorInvalidSurface, +# 431 +cudaErrorDuplicateVariableName = 43, +# 437 +cudaErrorDuplicateTextureName, +# 443 +cudaErrorDuplicateSurfaceName, +# 453 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorDevicesUnavailable, +# 466 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorIncompatibleDriverContext = 49, +# 472 +cudaErrorMissingConfiguration = 52, +# 481 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorPriorLaunchFailure, +# 487 +cudaErrorLaunchMaxDepthExceeded = 65, +# 495 +cudaErrorLaunchFileScopedTex, +# 503 +cudaErrorLaunchFileScopedSurf, +# 519 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorSyncDepthExceeded, +# 531 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorLaunchPendingCountExceeded, +# 537 +cudaErrorInvalidDeviceFunction = 98, +# 543 +cudaErrorNoDevice = 100, +# 550 +cudaErrorInvalidDevice, +# 555 +cudaErrorDeviceNotLicensed, +# 564 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorSoftwareValidityNotEstablished, +# 569 +cudaErrorStartupFailure = 127, +# 574 +cudaErrorInvalidKernelImage = 200, +# 584 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorDeviceUninitialized, +# 589 +cudaErrorMapBufferObjectFailed = 205, +# 594 +cudaErrorUnmapBufferObjectFailed, +# 600 +cudaErrorArrayIsMapped, +# 605 +cudaErrorAlreadyMapped, +# 613 +cudaErrorNoKernelImageForDevice, +# 618 +cudaErrorAlreadyAcquired, +# 623 +cudaErrorNotMapped, +# 629 +cudaErrorNotMappedAsArray, +# 635 +cudaErrorNotMappedAsPointer, +# 641 +cudaErrorECCUncorrectable, +# 647 +cudaErrorUnsupportedLimit, +# 653 +cudaErrorDeviceAlreadyInUse, +# 659 +cudaErrorPeerAccessUnsupported, +# 665 +cudaErrorInvalidPtx, +# 670 +cudaErrorInvalidGraphicsContext, +# 676 +cudaErrorNvlinkUncorrectable, +# 683 +cudaErrorJitCompilerNotFound, +# 690 +cudaErrorUnsupportedPtxVersion, +# 697 +cudaErrorJitCompilationDisabled, +# 702 +cudaErrorUnsupportedExecAffinity, +# 708 +cudaErrorUnsupportedDevSideSync, +# 719 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorContained, +# 724 +cudaErrorInvalidSource = 300, +# 729 +cudaErrorFileNotFound, +# 734 +cudaErrorSharedObjectSymbolNotFound, +# 739 +cudaErrorSharedObjectInitFailed, +# 744 +cudaErrorOperatingSystem, +# 751 +cudaErrorInvalidResourceHandle = 400, +# 757 +cudaErrorIllegalState, +# 765 +cudaErrorLossyQuery, +# 772 +cudaErrorSymbolNotFound = 500, +# 780 +cudaErrorNotReady = 600, +# 788 +cudaErrorIllegalAddress = 700, +# 797 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorLaunchOutOfResources, +# 808 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorLaunchTimeout, +# 814 +cudaErrorLaunchIncompatibleTexturing, +# 821 +cudaErrorPeerAccessAlreadyEnabled, +# 828 +cudaErrorPeerAccessNotEnabled, +# 841 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorSetOnActiveProcess = 708, +# 848 +cudaErrorContextIsDestroyed, +# 855 +cudaErrorAssert, +# 862 +cudaErrorTooManyPeers, +# 868 +cudaErrorHostMemoryAlreadyRegistered, +# 874 +cudaErrorHostMemoryNotRegistered, +# 883 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorHardwareStackError, +# 891 +cudaErrorIllegalInstruction, +# 900 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorMisalignedAddress, +# 911 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorInvalidAddressSpace, +# 919 +cudaErrorInvalidPc, +# 930 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorLaunchFailure, +# 939 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorCooperativeLaunchTooLarge, +# 947 +cudaErrorTensorMemoryLeak, +# 952 +cudaErrorNotPermitted = 800, +# 958 +cudaErrorNotSupported, +# 967 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorSystemNotReady, +# 974 +cudaErrorSystemDriverMismatch, +# 983 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorCompatNotSupportedOnDevice, +# 988 +cudaErrorMpsConnectionFailed, +# 993 +cudaErrorMpsRpcFailure, +# 999 +cudaErrorMpsServerNotReady, +# 1004 +cudaErrorMpsMaxClientsReached, +# 1009 +cudaErrorMpsMaxConnectionsReached, +# 1014 +cudaErrorMpsClientTerminated, +# 1019 +cudaErrorCdpNotSupported, +# 1024 +cudaErrorCdpVersionMismatch, +# 1029 +cudaErrorStreamCaptureUnsupported = 900, +# 1035 +cudaErrorStreamCaptureInvalidated, +# 1041 +cudaErrorStreamCaptureMerge, +# 1046 +cudaErrorStreamCaptureUnmatched, +# 1052 +cudaErrorStreamCaptureUnjoined, +# 1059 +cudaErrorStreamCaptureIsolation, +# 1065 +cudaErrorStreamCaptureImplicit, +# 1071 +cudaErrorCapturedEvent, +# 1078 +cudaErrorStreamCaptureWrongThread, +# 1083 +cudaErrorTimeout, +# 1089 +cudaErrorGraphExecUpdateFailure, +# 1099 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaErrorExternalDevice, +# 1105 +cudaErrorInvalidClusterSize, +# 1111 +cudaErrorFunctionNotLoaded, +# 1117 +cudaErrorInvalidResourceType, +# 1123 +cudaErrorInvalidResourceConfiguration, +# 1128 +cudaErrorUnknown = 999, +# 1136 +cudaErrorApiFailureBase = 10000 +# 1137 +}; +#endif +# 1142 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1142 +enum cudaChannelFormatKind { +# 1144 +cudaChannelFormatKindSigned, +# 1145 +cudaChannelFormatKindUnsigned, +# 1146 +cudaChannelFormatKindFloat, +# 1147 +cudaChannelFormatKindNone, +# 1148 +cudaChannelFormatKindNV12, +# 1149 +cudaChannelFormatKindUnsignedNormalized8X1, +# 1150 +cudaChannelFormatKindUnsignedNormalized8X2, +# 1151 +cudaChannelFormatKindUnsignedNormalized8X4, +# 1152 +cudaChannelFormatKindUnsignedNormalized16X1, +# 1153 +cudaChannelFormatKindUnsignedNormalized16X2, +# 1154 +cudaChannelFormatKindUnsignedNormalized16X4, +# 1155 +cudaChannelFormatKindSignedNormalized8X1, +# 1156 +cudaChannelFormatKindSignedNormalized8X2, +# 1157 +cudaChannelFormatKindSignedNormalized8X4, +# 1158 +cudaChannelFormatKindSignedNormalized16X1, +# 1159 +cudaChannelFormatKindSignedNormalized16X2, +# 1160 +cudaChannelFormatKindSignedNormalized16X4, +# 1161 +cudaChannelFormatKindUnsignedBlockCompressed1, +# 1162 +cudaChannelFormatKindUnsignedBlockCompressed1SRGB, +# 1163 +cudaChannelFormatKindUnsignedBlockCompressed2, +# 1164 +cudaChannelFormatKindUnsignedBlockCompressed2SRGB, +# 1165 +cudaChannelFormatKindUnsignedBlockCompressed3, +# 1166 +cudaChannelFormatKindUnsignedBlockCompressed3SRGB, +# 1167 +cudaChannelFormatKindUnsignedBlockCompressed4, +# 1168 +cudaChannelFormatKindSignedBlockCompressed4, +# 1169 +cudaChannelFormatKindUnsignedBlockCompressed5, +# 1170 +cudaChannelFormatKindSignedBlockCompressed5, +# 1171 +cudaChannelFormatKindUnsignedBlockCompressed6H, +# 1172 +cudaChannelFormatKindSignedBlockCompressed6H, +# 1173 +cudaChannelFormatKindUnsignedBlockCompressed7, +# 1174 +cudaChannelFormatKindUnsignedBlockCompressed7SRGB, +# 1175 +cudaChannelFormatKindUnsignedNormalized1010102 +# 1177 +}; +#endif +# 1182 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1182 +struct cudaChannelFormatDesc { +# 1184 +int x; +# 1185 +int y; +# 1186 +int z; +# 1187 +int w; +# 1188 +cudaChannelFormatKind f; +# 1189 +}; +#endif +# 1194 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef struct cudaArray *cudaArray_t; +# 1199 +typedef const cudaArray *cudaArray_const_t; +# 1201 +struct cudaArray; +# 1206 +typedef struct cudaMipmappedArray *cudaMipmappedArray_t; +# 1211 +typedef const cudaMipmappedArray *cudaMipmappedArray_const_t; +# 1213 +struct cudaMipmappedArray; +# 1223 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1223 +struct cudaArraySparseProperties { +# 1224 +struct { +# 1225 +unsigned width; +# 1226 +unsigned height; +# 1227 +unsigned depth; +# 1228 +} tileExtent; +# 1229 +unsigned miptailFirstLevel; +# 1230 +unsigned long long miptailSize; +# 1231 +unsigned flags; +# 1232 +unsigned reserved[4]; +# 1233 +}; +#endif +# 1238 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1238 +struct cudaArrayMemoryRequirements { +# 1239 +size_t size; +# 1240 +size_t alignment; +# 1241 +unsigned reserved[4]; +# 1242 +}; +#endif +# 1247 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1247 +enum cudaMemoryType { +# 1249 +cudaMemoryTypeUnregistered, +# 1250 +cudaMemoryTypeHost, +# 1251 +cudaMemoryTypeDevice, +# 1252 +cudaMemoryTypeManaged +# 1253 +}; +#endif +# 1258 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1258 +enum cudaMemcpyKind { +# 1260 +cudaMemcpyHostToHost, +# 1261 +cudaMemcpyHostToDevice, +# 1262 +cudaMemcpyDeviceToHost, +# 1263 +cudaMemcpyDeviceToDevice, +# 1264 +cudaMemcpyDefault +# 1265 +}; +#endif +# 1272 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1272 +struct cudaPitchedPtr { +# 1274 +void *ptr; +# 1275 +size_t pitch; +# 1276 +size_t xsize; +# 1277 +size_t ysize; +# 1278 +}; +#endif +# 1285 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1285 +struct cudaExtent { +# 1287 +size_t width; +# 1288 +size_t height; +# 1289 +size_t depth; +# 1290 +}; +#endif +# 1297 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1297 +struct cudaPos { +# 1299 +size_t x; +# 1300 +size_t y; +# 1301 +size_t z; +# 1302 +}; +#endif +# 1307 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1307 +struct cudaMemcpy3DParms { +# 1309 +cudaArray_t srcArray; +# 1310 +cudaPos srcPos; +# 1311 +cudaPitchedPtr srcPtr; +# 1313 +cudaArray_t dstArray; +# 1314 +cudaPos dstPos; +# 1315 +cudaPitchedPtr dstPtr; +# 1317 +cudaExtent extent; +# 1318 +cudaMemcpyKind kind; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 1319 +}; +#endif +# 1324 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1324 +struct cudaMemcpyNodeParams { +# 1325 +int flags; +# 1326 +int reserved[3]; +# 1327 +cudaMemcpy3DParms copyParams; +# 1328 +}; +#endif +# 1333 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1333 +struct cudaMemcpy3DPeerParms { +# 1335 +cudaArray_t srcArray; +# 1336 +cudaPos srcPos; +# 1337 +cudaPitchedPtr srcPtr; +# 1338 +int srcDevice; +# 1340 +cudaArray_t dstArray; +# 1341 +cudaPos dstPos; +# 1342 +cudaPitchedPtr dstPtr; +# 1343 +int dstDevice; +# 1345 +cudaExtent extent; +# 1346 +}; +#endif +# 1351 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1351 +struct cudaMemsetParams { +# 1352 +void *dst; +# 1353 +size_t pitch; +# 1354 +unsigned value; +# 1355 +unsigned elementSize; +# 1356 +size_t width; +# 1357 +size_t height; +# 1358 +}; +#endif +# 1363 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1363 +struct cudaMemsetParamsV2 { +# 1364 +void *dst; +# 1365 +size_t pitch; +# 1366 +unsigned value; +# 1367 +unsigned elementSize; +# 1368 +size_t width; +# 1369 +size_t height; +# 1370 +}; +#endif +# 1375 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1375 +enum cudaAccessProperty { +# 1376 +cudaAccessPropertyNormal, +# 1377 +cudaAccessPropertyStreaming, +# 1378 +cudaAccessPropertyPersisting +# 1379 +}; +#endif +# 1392 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1392 +struct cudaAccessPolicyWindow { +# 1393 +void *base_ptr; +# 1394 +size_t num_bytes; +# 1395 +float hitRatio; +# 1396 +cudaAccessProperty hitProp; +# 1397 +cudaAccessProperty missProp; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 1398 +}; +#endif +# 1410 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef void (*cudaHostFn_t)(void * userData); +# 1415 +#if 0 +# 1415 +struct cudaHostNodeParams { +# 1416 +cudaHostFn_t fn; +# 1417 +void *userData; +# 1418 +}; +#endif +# 1423 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1423 +struct cudaHostNodeParamsV2 { +# 1424 +cudaHostFn_t fn; +# 1425 +void *userData; +# 1426 +}; +#endif +# 1431 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1431 +enum cudaStreamCaptureStatus { +# 1432 +cudaStreamCaptureStatusNone, +# 1433 +cudaStreamCaptureStatusActive, +# 1434 +cudaStreamCaptureStatusInvalidated +# 1436 +}; +#endif +# 1442 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1442 +enum cudaStreamCaptureMode { +# 1443 +cudaStreamCaptureModeGlobal, +# 1444 +cudaStreamCaptureModeThreadLocal, +# 1445 +cudaStreamCaptureModeRelaxed +# 1446 +}; +#endif +# 1448 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1448 +enum cudaSynchronizationPolicy { +# 1449 +cudaSyncPolicyAuto = 1, +# 1450 +cudaSyncPolicySpin, +# 1451 +cudaSyncPolicyYield, +# 1452 +cudaSyncPolicyBlockingSync +# 1453 +}; +#endif +# 1458 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1458 +enum cudaClusterSchedulingPolicy { +# 1459 +cudaClusterSchedulingPolicyDefault, +# 1460 +cudaClusterSchedulingPolicySpread, +# 1461 +cudaClusterSchedulingPolicyLoadBalancing +# 1462 +}; +#endif +# 1467 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1467 +enum cudaStreamUpdateCaptureDependenciesFlags { +# 1468 +cudaStreamAddCaptureDependencies, +# 1469 +cudaStreamSetCaptureDependencies +# 1470 +}; +#endif +# 1475 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1475 +enum cudaUserObjectFlags { +# 1476 +cudaUserObjectNoDestructorSync = 1 +# 1477 +}; +#endif +# 1482 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1482 +enum cudaUserObjectRetainFlags { +# 1483 +cudaGraphUserObjectMove = 1 +# 1484 +}; +#endif +# 1489 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct cudaGraphicsResource; +# 1494 +#if 0 +# 1494 +enum cudaGraphicsRegisterFlags { +# 1496 +cudaGraphicsRegisterFlagsNone, +# 1497 +cudaGraphicsRegisterFlagsReadOnly, +# 1498 +cudaGraphicsRegisterFlagsWriteDiscard, +# 1499 +cudaGraphicsRegisterFlagsSurfaceLoadStore = 4, +# 1500 +cudaGraphicsRegisterFlagsTextureGather = 8 +# 1501 +}; +#endif +# 1506 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1506 +enum cudaGraphicsMapFlags { +# 1508 +cudaGraphicsMapFlagsNone, +# 1509 +cudaGraphicsMapFlagsReadOnly, +# 1510 +cudaGraphicsMapFlagsWriteDiscard +# 1511 +}; +#endif +# 1516 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1516 +enum cudaGraphicsCubeFace { +# 1518 +cudaGraphicsCubeFacePositiveX, +# 1519 +cudaGraphicsCubeFaceNegativeX, +# 1520 +cudaGraphicsCubeFacePositiveY, +# 1521 +cudaGraphicsCubeFaceNegativeY, +# 1522 +cudaGraphicsCubeFacePositiveZ, +# 1523 +cudaGraphicsCubeFaceNegativeZ +# 1524 +}; +#endif +# 1529 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1529 +enum cudaResourceType { +# 1531 +cudaResourceTypeArray, +# 1532 +cudaResourceTypeMipmappedArray, +# 1533 +cudaResourceTypeLinear, +# 1534 +cudaResourceTypePitch2D +# 1535 +}; +#endif +# 1540 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1540 +enum cudaResourceViewFormat { +# 1542 +cudaResViewFormatNone, +# 1543 +cudaResViewFormatUnsignedChar1, +# 1544 +cudaResViewFormatUnsignedChar2, +# 1545 +cudaResViewFormatUnsignedChar4, +# 1546 +cudaResViewFormatSignedChar1, +# 1547 +cudaResViewFormatSignedChar2, +# 1548 +cudaResViewFormatSignedChar4, +# 1549 +cudaResViewFormatUnsignedShort1, +# 1550 +cudaResViewFormatUnsignedShort2, +# 1551 +cudaResViewFormatUnsignedShort4, +# 1552 +cudaResViewFormatSignedShort1, +# 1553 +cudaResViewFormatSignedShort2, +# 1554 +cudaResViewFormatSignedShort4, +# 1555 +cudaResViewFormatUnsignedInt1, +# 1556 +cudaResViewFormatUnsignedInt2, +# 1557 +cudaResViewFormatUnsignedInt4, +# 1558 +cudaResViewFormatSignedInt1, +# 1559 +cudaResViewFormatSignedInt2, +# 1560 +cudaResViewFormatSignedInt4, +# 1561 +cudaResViewFormatHalf1, +# 1562 +cudaResViewFormatHalf2, +# 1563 +cudaResViewFormatHalf4, +# 1564 +cudaResViewFormatFloat1, +# 1565 +cudaResViewFormatFloat2, +# 1566 +cudaResViewFormatFloat4, +# 1567 +cudaResViewFormatUnsignedBlockCompressed1, +# 1568 +cudaResViewFormatUnsignedBlockCompressed2, +# 1569 +cudaResViewFormatUnsignedBlockCompressed3, +# 1570 +cudaResViewFormatUnsignedBlockCompressed4, +# 1571 +cudaResViewFormatSignedBlockCompressed4, +# 1572 +cudaResViewFormatUnsignedBlockCompressed5, +# 1573 +cudaResViewFormatSignedBlockCompressed5, +# 1574 +cudaResViewFormatUnsignedBlockCompressed6H, +# 1575 +cudaResViewFormatSignedBlockCompressed6H, +# 1576 +cudaResViewFormatUnsignedBlockCompressed7 +# 1577 +}; +#endif +# 1582 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1582 +struct cudaResourceDesc { +# 1583 +cudaResourceType resType; +# 1585 +union { +# 1586 +struct { +# 1587 +cudaArray_t array; +# 1588 +} array; +# 1589 +struct { +# 1590 +cudaMipmappedArray_t mipmap; +# 1591 +} mipmap; +# 1592 +struct { +# 1593 +void *devPtr; +# 1594 +cudaChannelFormatDesc desc; +# 1595 +size_t sizeInBytes; +# 1596 +} linear; +# 1597 +struct { +# 1598 +void *devPtr; +# 1599 +cudaChannelFormatDesc desc; +# 1600 +size_t width; +# 1601 +size_t height; +# 1602 +size_t pitchInBytes; +# 1603 +} pitch2D; +# 1604 +} res; +# 1605 +}; +#endif +# 1610 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1610 +struct cudaResourceViewDesc { +# 1612 +cudaResourceViewFormat format; +# 1613 +size_t width; +# 1614 +size_t height; +# 1615 +size_t depth; +# 1616 +unsigned firstMipmapLevel; +# 1617 +unsigned lastMipmapLevel; +# 1618 +unsigned firstLayer; +# 1619 +unsigned lastLayer; +# 1620 +}; +#endif +# 1625 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1625 +struct cudaPointerAttributes { +# 1631 +cudaMemoryType type; +# 1642 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +int device; +# 1648 +void *devicePointer; +# 1657 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +void *hostPointer; +# 1658 +}; +#endif +# 1663 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1663 +struct cudaFuncAttributes { +# 1670 +size_t sharedSizeBytes; +# 1676 +size_t constSizeBytes; +# 1681 +size_t localSizeBytes; +# 1688 +int maxThreadsPerBlock; +# 1693 +int numRegs; +# 1700 +int ptxVersion; +# 1707 +int binaryVersion; +# 1713 +int cacheModeCA; +# 1720 +int maxDynamicSharedSizeBytes; +# 1729 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +int preferredShmemCarveout; +# 1735 +int clusterDimMustBeSet; +# 1746 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +int requiredClusterWidth; +# 1747 +int requiredClusterHeight; +# 1748 +int requiredClusterDepth; +# 1754 +int clusterSchedulingPolicyPreference; +# 1776 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +int nonPortableClusterSizeAllowed; +# 1781 +int reserved[16]; +# 1782 +}; +#endif +# 1787 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1787 +enum cudaFuncAttribute { +# 1789 +cudaFuncAttributeMaxDynamicSharedMemorySize = 8, +# 1790 +cudaFuncAttributePreferredSharedMemoryCarveout, +# 1791 +cudaFuncAttributeClusterDimMustBeSet, +# 1792 +cudaFuncAttributeRequiredClusterWidth, +# 1793 +cudaFuncAttributeRequiredClusterHeight, +# 1794 +cudaFuncAttributeRequiredClusterDepth, +# 1795 +cudaFuncAttributeNonPortableClusterSizeAllowed, +# 1796 +cudaFuncAttributeClusterSchedulingPolicyPreference, +# 1797 +cudaFuncAttributeMax +# 1798 +}; +#endif +# 1803 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1803 +enum cudaFuncCache { +# 1805 +cudaFuncCachePreferNone, +# 1806 +cudaFuncCachePreferShared, +# 1807 +cudaFuncCachePreferL1, +# 1808 +cudaFuncCachePreferEqual +# 1809 +}; +#endif +# 1815 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1815 +enum cudaSharedMemConfig { +# 1817 +cudaSharedMemBankSizeDefault, +# 1818 +cudaSharedMemBankSizeFourByte, +# 1819 +cudaSharedMemBankSizeEightByte +# 1820 +}; +#endif +# 1825 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1825 +enum cudaSharedCarveout { +# 1826 +cudaSharedmemCarveoutDefault = (-1), +# 1827 +cudaSharedmemCarveoutMaxShared = 100, +# 1828 +cudaSharedmemCarveoutMaxL1 = 0 +# 1829 +}; +#endif +# 1834 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1834 +enum cudaComputeMode { +# 1836 +cudaComputeModeDefault, +# 1837 +cudaComputeModeExclusive, +# 1838 +cudaComputeModeProhibited, +# 1839 +cudaComputeModeExclusiveProcess +# 1840 +}; +#endif +# 1845 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1845 +enum cudaLimit { +# 1847 +cudaLimitStackSize, +# 1848 +cudaLimitPrintfFifoSize, +# 1849 +cudaLimitMallocHeapSize, +# 1850 +cudaLimitDevRuntimeSyncDepth, +# 1851 +cudaLimitDevRuntimePendingLaunchCount, +# 1852 +cudaLimitMaxL2FetchGranularity, +# 1853 +cudaLimitPersistingL2CacheSize +# 1854 +}; +#endif +# 1859 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1859 +enum cudaMemoryAdvise { +# 1861 +cudaMemAdviseSetReadMostly = 1, +# 1862 +cudaMemAdviseUnsetReadMostly, +# 1863 +cudaMemAdviseSetPreferredLocation, +# 1864 +cudaMemAdviseUnsetPreferredLocation, +# 1865 +cudaMemAdviseSetAccessedBy, +# 1866 +cudaMemAdviseUnsetAccessedBy +# 1867 +}; +#endif +# 1872 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1872 +enum cudaMemRangeAttribute { +# 1874 +cudaMemRangeAttributeReadMostly = 1, +# 1875 +cudaMemRangeAttributePreferredLocation, +# 1876 +cudaMemRangeAttributeAccessedBy, +# 1877 +cudaMemRangeAttributeLastPrefetchLocation, +# 1878 +cudaMemRangeAttributePreferredLocationType, +# 1879 +cudaMemRangeAttributePreferredLocationId, +# 1880 +cudaMemRangeAttributeLastPrefetchLocationType, +# 1881 +cudaMemRangeAttributeLastPrefetchLocationId +# 1882 +}; +#endif +# 1887 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1887 +enum cudaFlushGPUDirectRDMAWritesOptions { +# 1888 +cudaFlushGPUDirectRDMAWritesOptionHost = (1 << 0), +# 1889 +cudaFlushGPUDirectRDMAWritesOptionMemOps +# 1890 +}; +#endif +# 1895 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1895 +enum cudaGPUDirectRDMAWritesOrdering { +# 1896 +cudaGPUDirectRDMAWritesOrderingNone, +# 1897 +cudaGPUDirectRDMAWritesOrderingOwner = 100, +# 1898 +cudaGPUDirectRDMAWritesOrderingAllDevices = 200 +# 1899 +}; +#endif +# 1904 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1904 +enum cudaFlushGPUDirectRDMAWritesScope { +# 1905 +cudaFlushGPUDirectRDMAWritesToOwner = 100, +# 1906 +cudaFlushGPUDirectRDMAWritesToAllDevices = 200 +# 1907 +}; +#endif +# 1912 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1912 +enum cudaFlushGPUDirectRDMAWritesTarget { +# 1913 +cudaFlushGPUDirectRDMAWritesTargetCurrentDevice +# 1914 +}; +#endif +# 1920 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 1920 +enum cudaDeviceAttr { +# 1922 +cudaDevAttrMaxThreadsPerBlock = 1, +# 1923 +cudaDevAttrMaxBlockDimX, +# 1924 +cudaDevAttrMaxBlockDimY, +# 1925 +cudaDevAttrMaxBlockDimZ, +# 1926 +cudaDevAttrMaxGridDimX, +# 1927 +cudaDevAttrMaxGridDimY, +# 1928 +cudaDevAttrMaxGridDimZ, +# 1929 +cudaDevAttrMaxSharedMemoryPerBlock, +# 1930 +cudaDevAttrTotalConstantMemory, +# 1931 +cudaDevAttrWarpSize, +# 1932 +cudaDevAttrMaxPitch, +# 1933 +cudaDevAttrMaxRegistersPerBlock, +# 1934 +cudaDevAttrClockRate, +# 1935 +cudaDevAttrTextureAlignment, +# 1936 +cudaDevAttrGpuOverlap, +# 1937 +cudaDevAttrMultiProcessorCount, +# 1938 +cudaDevAttrKernelExecTimeout, +# 1939 +cudaDevAttrIntegrated, +# 1940 +cudaDevAttrCanMapHostMemory, +# 1941 +cudaDevAttrComputeMode, +# 1942 +cudaDevAttrMaxTexture1DWidth, +# 1943 +cudaDevAttrMaxTexture2DWidth, +# 1944 +cudaDevAttrMaxTexture2DHeight, +# 1945 +cudaDevAttrMaxTexture3DWidth, +# 1946 +cudaDevAttrMaxTexture3DHeight, +# 1947 +cudaDevAttrMaxTexture3DDepth, +# 1948 +cudaDevAttrMaxTexture2DLayeredWidth, +# 1949 +cudaDevAttrMaxTexture2DLayeredHeight, +# 1950 +cudaDevAttrMaxTexture2DLayeredLayers, +# 1951 +cudaDevAttrSurfaceAlignment, +# 1952 +cudaDevAttrConcurrentKernels, +# 1953 +cudaDevAttrEccEnabled, +# 1954 +cudaDevAttrPciBusId, +# 1955 +cudaDevAttrPciDeviceId, +# 1956 +cudaDevAttrTccDriver, +# 1957 +cudaDevAttrMemoryClockRate, +# 1958 +cudaDevAttrGlobalMemoryBusWidth, +# 1959 +cudaDevAttrL2CacheSize, +# 1960 +cudaDevAttrMaxThreadsPerMultiProcessor, +# 1961 +cudaDevAttrAsyncEngineCount, +# 1962 +cudaDevAttrUnifiedAddressing, +# 1963 +cudaDevAttrMaxTexture1DLayeredWidth, +# 1964 +cudaDevAttrMaxTexture1DLayeredLayers, +# 1965 +cudaDevAttrMaxTexture2DGatherWidth = 45, +# 1966 +cudaDevAttrMaxTexture2DGatherHeight, +# 1967 +cudaDevAttrMaxTexture3DWidthAlt, +# 1968 +cudaDevAttrMaxTexture3DHeightAlt, +# 1969 +cudaDevAttrMaxTexture3DDepthAlt, +# 1970 +cudaDevAttrPciDomainId, +# 1971 +cudaDevAttrTexturePitchAlignment, +# 1972 +cudaDevAttrMaxTextureCubemapWidth, +# 1973 +cudaDevAttrMaxTextureCubemapLayeredWidth, +# 1974 +cudaDevAttrMaxTextureCubemapLayeredLayers, +# 1975 +cudaDevAttrMaxSurface1DWidth, +# 1976 +cudaDevAttrMaxSurface2DWidth, +# 1977 +cudaDevAttrMaxSurface2DHeight, +# 1978 +cudaDevAttrMaxSurface3DWidth, +# 1979 +cudaDevAttrMaxSurface3DHeight, +# 1980 +cudaDevAttrMaxSurface3DDepth, +# 1981 +cudaDevAttrMaxSurface1DLayeredWidth, +# 1982 +cudaDevAttrMaxSurface1DLayeredLayers, +# 1983 +cudaDevAttrMaxSurface2DLayeredWidth, +# 1984 +cudaDevAttrMaxSurface2DLayeredHeight, +# 1985 +cudaDevAttrMaxSurface2DLayeredLayers, +# 1986 +cudaDevAttrMaxSurfaceCubemapWidth, +# 1987 +cudaDevAttrMaxSurfaceCubemapLayeredWidth, +# 1988 +cudaDevAttrMaxSurfaceCubemapLayeredLayers, +# 1989 +cudaDevAttrMaxTexture1DLinearWidth, +# 1990 +cudaDevAttrMaxTexture2DLinearWidth, +# 1991 +cudaDevAttrMaxTexture2DLinearHeight, +# 1992 +cudaDevAttrMaxTexture2DLinearPitch, +# 1993 +cudaDevAttrMaxTexture2DMipmappedWidth, +# 1994 +cudaDevAttrMaxTexture2DMipmappedHeight, +# 1995 +cudaDevAttrComputeCapabilityMajor, +# 1996 +cudaDevAttrComputeCapabilityMinor, +# 1997 +cudaDevAttrMaxTexture1DMipmappedWidth, +# 1998 +cudaDevAttrStreamPrioritiesSupported, +# 1999 +cudaDevAttrGlobalL1CacheSupported, +# 2000 +cudaDevAttrLocalL1CacheSupported, +# 2001 +cudaDevAttrMaxSharedMemoryPerMultiprocessor, +# 2002 +cudaDevAttrMaxRegistersPerMultiprocessor, +# 2003 +cudaDevAttrManagedMemory, +# 2004 +cudaDevAttrIsMultiGpuBoard, +# 2005 +cudaDevAttrMultiGpuBoardGroupID, +# 2006 +cudaDevAttrHostNativeAtomicSupported, +# 2007 +cudaDevAttrSingleToDoublePrecisionPerfRatio, +# 2008 +cudaDevAttrPageableMemoryAccess, +# 2009 +cudaDevAttrConcurrentManagedAccess, +# 2010 +cudaDevAttrComputePreemptionSupported, +# 2011 +cudaDevAttrCanUseHostPointerForRegisteredMem, +# 2012 +cudaDevAttrReserved92, +# 2013 +cudaDevAttrReserved93, +# 2014 +cudaDevAttrReserved94, +# 2015 +cudaDevAttrCooperativeLaunch, +# 2016 +cudaDevAttrCooperativeMultiDeviceLaunch, +# 2017 +cudaDevAttrMaxSharedMemoryPerBlockOptin, +# 2018 +cudaDevAttrCanFlushRemoteWrites, +# 2019 +cudaDevAttrHostRegisterSupported, +# 2020 +cudaDevAttrPageableMemoryAccessUsesHostPageTables, +# 2021 +cudaDevAttrDirectManagedMemAccessFromHost, +# 2022 +cudaDevAttrMaxBlocksPerMultiprocessor = 106, +# 2023 +cudaDevAttrMaxPersistingL2CacheSize = 108, +# 2024 +cudaDevAttrMaxAccessPolicyWindowSize, +# 2025 +cudaDevAttrReservedSharedMemoryPerBlock = 111, +# 2026 +cudaDevAttrSparseCudaArraySupported, +# 2027 +cudaDevAttrHostRegisterReadOnlySupported, +# 2028 +cudaDevAttrTimelineSemaphoreInteropSupported, +# 2029 +cudaDevAttrMaxTimelineSemaphoreInteropSupported = 114, +# 2030 +cudaDevAttrMemoryPoolsSupported, +# 2031 +cudaDevAttrGPUDirectRDMASupported, +# 2032 +cudaDevAttrGPUDirectRDMAFlushWritesOptions, +# 2033 +cudaDevAttrGPUDirectRDMAWritesOrdering, +# 2034 +cudaDevAttrMemoryPoolSupportedHandleTypes, +# 2035 +cudaDevAttrClusterLaunch, +# 2036 +cudaDevAttrDeferredMappingCudaArraySupported, +# 2037 +cudaDevAttrReserved122, +# 2038 +cudaDevAttrReserved123, +# 2039 +cudaDevAttrReserved124, +# 2040 +cudaDevAttrIpcEventSupport, +# 2041 +cudaDevAttrMemSyncDomainCount, +# 2042 +cudaDevAttrReserved127, +# 2043 +cudaDevAttrReserved128, +# 2044 +cudaDevAttrReserved129, +# 2045 +cudaDevAttrNumaConfig, +# 2046 +cudaDevAttrNumaId, +# 2047 +cudaDevAttrReserved132, +# 2048 +cudaDevAttrMpsEnabled, +# 2049 +cudaDevAttrHostNumaId, +# 2050 +cudaDevAttrD3D12CigSupported, +# 2051 +cudaDevAttrGpuPciDeviceId = 139, +# 2052 +cudaDevAttrGpuPciSubsystemId, +# 2053 +cudaDevAttrHostNumaMultinodeIpcSupported = 143, +# 2054 +cudaDevAttrMax +# 2055 +}; +#endif +# 2060 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2060 +enum cudaMemPoolAttr { +# 2070 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaMemPoolReuseFollowEventDependencies = 1, +# 2077 +cudaMemPoolReuseAllowOpportunistic, +# 2085 +cudaMemPoolReuseAllowInternalDependencies, +# 2096 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaMemPoolAttrReleaseThreshold, +# 2102 +cudaMemPoolAttrReservedMemCurrent, +# 2109 +cudaMemPoolAttrReservedMemHigh, +# 2115 +cudaMemPoolAttrUsedMemCurrent, +# 2122 +cudaMemPoolAttrUsedMemHigh +# 2123 +}; +#endif +# 2128 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2128 +enum cudaMemLocationType { +# 2129 +cudaMemLocationTypeInvalid, +# 2130 +cudaMemLocationTypeDevice, +# 2131 +cudaMemLocationTypeHost, +# 2132 +cudaMemLocationTypeHostNuma, +# 2133 +cudaMemLocationTypeHostNumaCurrent +# 2134 +}; +#endif +# 2142 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2142 +struct cudaMemLocation { +# 2143 +cudaMemLocationType type; +# 2144 +int id; +# 2145 +}; +#endif +# 2150 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2150 +enum cudaMemAccessFlags { +# 2151 +cudaMemAccessFlagsProtNone, +# 2152 +cudaMemAccessFlagsProtRead, +# 2153 +cudaMemAccessFlagsProtReadWrite = 3 +# 2154 +}; +#endif +# 2159 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2159 +struct cudaMemAccessDesc { +# 2160 +cudaMemLocation location; +# 2161 +cudaMemAccessFlags flags; +# 2162 +}; +#endif +# 2167 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2167 +enum cudaMemAllocationType { +# 2168 +cudaMemAllocationTypeInvalid, +# 2172 +cudaMemAllocationTypePinned, +# 2173 +cudaMemAllocationTypeMax = 2147483647 +# 2174 +}; +#endif +# 2179 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2179 +enum cudaMemAllocationHandleType { +# 2180 +cudaMemHandleTypeNone, +# 2181 +cudaMemHandleTypePosixFileDescriptor, +# 2182 +cudaMemHandleTypeWin32, +# 2183 +cudaMemHandleTypeWin32Kmt = 4, +# 2184 +cudaMemHandleTypeFabric = 8 +# 2185 +}; +#endif +# 2196 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2196 +struct cudaMemPoolProps { +# 2197 +cudaMemAllocationType allocType; +# 2198 +cudaMemAllocationHandleType handleTypes; +# 2199 +cudaMemLocation location; +# 2206 +void *win32SecurityAttributes; +# 2207 +size_t maxSize; +# 2208 +unsigned short usage; +# 2209 +unsigned char reserved[54]; +# 2210 +}; +#endif +# 2215 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2215 +struct cudaMemPoolPtrExportData { +# 2216 +unsigned char reserved[64]; +# 2217 +}; +#endif +# 2222 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2222 +struct cudaMemAllocNodeParams { +# 2227 +cudaMemPoolProps poolProps; +# 2228 +const cudaMemAccessDesc *accessDescs; +# 2229 +size_t accessDescCount; +# 2230 +size_t bytesize; +# 2231 +void *dptr; +# 2232 +}; +#endif +# 2237 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2237 +struct cudaMemAllocNodeParamsV2 { +# 2242 +cudaMemPoolProps poolProps; +# 2243 +const cudaMemAccessDesc *accessDescs; +# 2244 +size_t accessDescCount; +# 2245 +size_t bytesize; +# 2246 +void *dptr; +# 2247 +}; +#endif +# 2252 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2252 +struct cudaMemFreeNodeParams { +# 2253 +void *dptr; +# 2254 +}; +#endif +# 2259 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2259 +enum cudaGraphMemAttributeType { +# 2264 +cudaGraphMemAttrUsedMemCurrent, +# 2271 +cudaGraphMemAttrUsedMemHigh, +# 2278 +cudaGraphMemAttrReservedMemCurrent, +# 2285 +cudaGraphMemAttrReservedMemHigh +# 2286 +}; +#endif +# 2291 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2291 +enum cudaMemcpyFlags { +# 2292 +cudaMemcpyFlagDefault, +# 2297 +cudaMemcpyFlagPreferOverlapWithCompute +# 2298 +}; +#endif +# 2300 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2300 +enum cudaMemcpySrcAccessOrder { +# 2304 +cudaMemcpySrcAccessOrderInvalid, +# 2309 +cudaMemcpySrcAccessOrderStream, +# 2320 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaMemcpySrcAccessOrderDuringApiCall, +# 2329 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaMemcpySrcAccessOrderAny, +# 2331 +cudaMemcpySrcAccessOrderMax = 2147483647 +# 2332 +}; +#endif +# 2337 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2337 +struct cudaMemcpyAttributes { +# 2338 +cudaMemcpySrcAccessOrder srcAccessOrder; +# 2339 +cudaMemLocation srcLocHint; +# 2340 +cudaMemLocation dstLocHint; +# 2341 +unsigned flags; +# 2342 +}; +#endif +# 2347 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2347 +enum cudaMemcpy3DOperandType { +# 2348 +cudaMemcpyOperandTypePointer = 1, +# 2349 +cudaMemcpyOperandTypeArray, +# 2350 +cudaMemcpyOperandTypeMax = 2147483647 +# 2351 +}; +#endif +# 2356 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2356 +struct cudaOffset3D { +# 2357 +size_t x; +# 2358 +size_t y; +# 2359 +size_t z; +# 2360 +}; +#endif +# 2365 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2365 +struct cudaMemcpy3DOperand { +# 2366 +cudaMemcpy3DOperandType type; +# 2367 +union { +# 2371 +struct { +# 2372 +void *ptr; +# 2373 +size_t rowLength; +# 2374 +size_t layerHeight; +# 2375 +cudaMemLocation locHint; +# 2376 +} ptr; +# 2381 +struct { +# 2382 +cudaArray_t array; +# 2383 +cudaOffset3D offset; +# 2384 +} array; +# 2385 +} op; +# 2386 +}; +#endif +# 2388 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2388 +struct cudaMemcpy3DBatchOp { +# 2389 +cudaMemcpy3DOperand src; +# 2390 +cudaMemcpy3DOperand dst; +# 2391 +cudaExtent extent; +# 2392 +cudaMemcpySrcAccessOrder srcAccessOrder; +# 2393 +unsigned flags; +# 2394 +}; +#endif +# 2400 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2400 +enum cudaDeviceP2PAttr { +# 2401 +cudaDevP2PAttrPerformanceRank = 1, +# 2402 +cudaDevP2PAttrAccessSupported, +# 2403 +cudaDevP2PAttrNativeAtomicSupported, +# 2404 +cudaDevP2PAttrCudaArrayAccessSupported +# 2405 +}; +#endif +# 2412 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2412 +struct CUuuid_st { +# 2413 +char bytes[16]; +# 2414 +}; +#endif +# 2415 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef CUuuid_st +# 2415 +CUuuid; +#endif +# 2417 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef CUuuid_st +# 2417 +cudaUUID_t; +#endif +# 2422 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2422 +struct cudaDeviceProp { +# 2424 +char name[256]; +# 2425 +cudaUUID_t uuid; +# 2426 +char luid[8]; +# 2427 +unsigned luidDeviceNodeMask; +# 2428 +size_t totalGlobalMem; +# 2429 +size_t sharedMemPerBlock; +# 2430 +int regsPerBlock; +# 2431 +int warpSize; +# 2432 +size_t memPitch; +# 2433 +int maxThreadsPerBlock; +# 2434 +int maxThreadsDim[3]; +# 2435 +int maxGridSize[3]; +# 2436 +int clockRate; +# 2437 +size_t totalConstMem; +# 2438 +int major; +# 2439 +int minor; +# 2440 +size_t textureAlignment; +# 2441 +size_t texturePitchAlignment; +# 2442 +int deviceOverlap; +# 2443 +int multiProcessorCount; +# 2444 +int kernelExecTimeoutEnabled; +# 2445 +int integrated; +# 2446 +int canMapHostMemory; +# 2447 +int computeMode; +# 2448 +int maxTexture1D; +# 2449 +int maxTexture1DMipmap; +# 2450 +int maxTexture1DLinear; +# 2451 +int maxTexture2D[2]; +# 2452 +int maxTexture2DMipmap[2]; +# 2453 +int maxTexture2DLinear[3]; +# 2454 +int maxTexture2DGather[2]; +# 2455 +int maxTexture3D[3]; +# 2456 +int maxTexture3DAlt[3]; +# 2457 +int maxTextureCubemap; +# 2458 +int maxTexture1DLayered[2]; +# 2459 +int maxTexture2DLayered[3]; +# 2460 +int maxTextureCubemapLayered[2]; +# 2461 +int maxSurface1D; +# 2462 +int maxSurface2D[2]; +# 2463 +int maxSurface3D[3]; +# 2464 +int maxSurface1DLayered[2]; +# 2465 +int maxSurface2DLayered[3]; +# 2466 +int maxSurfaceCubemap; +# 2467 +int maxSurfaceCubemapLayered[2]; +# 2468 +size_t surfaceAlignment; +# 2469 +int concurrentKernels; +# 2470 +int ECCEnabled; +# 2471 +int pciBusID; +# 2472 +int pciDeviceID; +# 2473 +int pciDomainID; +# 2474 +int tccDriver; +# 2475 +int asyncEngineCount; +# 2476 +int unifiedAddressing; +# 2477 +int memoryClockRate; +# 2478 +int memoryBusWidth; +# 2479 +int l2CacheSize; +# 2480 +int persistingL2CacheMaxSize; +# 2481 +int maxThreadsPerMultiProcessor; +# 2482 +int streamPrioritiesSupported; +# 2483 +int globalL1CacheSupported; +# 2484 +int localL1CacheSupported; +# 2485 +size_t sharedMemPerMultiprocessor; +# 2486 +int regsPerMultiprocessor; +# 2487 +int managedMemory; +# 2488 +int isMultiGpuBoard; +# 2489 +int multiGpuBoardGroupID; +# 2490 +int hostNativeAtomicSupported; +# 2491 +int singleToDoublePrecisionPerfRatio; +# 2492 +int pageableMemoryAccess; +# 2493 +int concurrentManagedAccess; +# 2494 +int computePreemptionSupported; +# 2495 +int canUseHostPointerForRegisteredMem; +# 2496 +int cooperativeLaunch; +# 2497 +int cooperativeMultiDeviceLaunch; +# 2498 +size_t sharedMemPerBlockOptin; +# 2499 +int pageableMemoryAccessUsesHostPageTables; +# 2500 +int directManagedMemAccessFromHost; +# 2501 +int maxBlocksPerMultiProcessor; +# 2502 +int accessPolicyMaxWindowSize; +# 2503 +size_t reservedSharedMemPerBlock; +# 2504 +int hostRegisterSupported; +# 2505 +int sparseCudaArraySupported; +# 2506 +int hostRegisterReadOnlySupported; +# 2507 +int timelineSemaphoreInteropSupported; +# 2508 +int memoryPoolsSupported; +# 2509 +int gpuDirectRDMASupported; +# 2510 +unsigned gpuDirectRDMAFlushWritesOptions; +# 2511 +int gpuDirectRDMAWritesOrdering; +# 2512 +unsigned memoryPoolSupportedHandleTypes; +# 2513 +int deferredMappingCudaArraySupported; +# 2514 +int ipcEventSupported; +# 2515 +int clusterLaunch; +# 2516 +int unifiedFunctionPointers; +# 2517 +int reserved[63]; +# 2518 +}; +#endif +# 2531 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 2528 +struct cudaIpcEventHandle_st { +# 2530 +char reserved[64]; +# 2531 +} cudaIpcEventHandle_t; +#endif +# 2539 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 2536 +struct cudaIpcMemHandle_st { +# 2538 +char reserved[64]; +# 2539 +} cudaIpcMemHandle_t; +#endif +# 2547 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 2544 +struct cudaMemFabricHandle_st { +# 2546 +char reserved[64]; +# 2547 +} cudaMemFabricHandle_t; +#endif +# 2552 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2552 +enum cudaExternalMemoryHandleType { +# 2556 +cudaExternalMemoryHandleTypeOpaqueFd = 1, +# 2560 +cudaExternalMemoryHandleTypeOpaqueWin32, +# 2564 +cudaExternalMemoryHandleTypeOpaqueWin32Kmt, +# 2568 +cudaExternalMemoryHandleTypeD3D12Heap, +# 2572 +cudaExternalMemoryHandleTypeD3D12Resource, +# 2576 +cudaExternalMemoryHandleTypeD3D11Resource, +# 2580 +cudaExternalMemoryHandleTypeD3D11ResourceKmt, +# 2584 +cudaExternalMemoryHandleTypeNvSciBuf +# 2585 +}; +#endif +# 2627 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2627 +struct cudaExternalMemoryHandleDesc { +# 2631 +cudaExternalMemoryHandleType type; +# 2632 +union { +# 2638 +int fd; +# 2654 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct { +# 2658 +void *handle; +# 2663 +const void *name; +# 2664 +} win32; +# 2669 +const void *nvSciBufObject; +# 2670 +} handle; +# 2674 +unsigned long long size; +# 2678 +unsigned flags; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 2679 +}; +#endif +# 2684 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2684 +struct cudaExternalMemoryBufferDesc { +# 2688 +unsigned long long offset; +# 2692 +unsigned long long size; +# 2696 +unsigned flags; +# 2697 +}; +#endif +# 2702 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2702 +struct cudaExternalMemoryMipmappedArrayDesc { +# 2707 +unsigned long long offset; +# 2711 +cudaChannelFormatDesc formatDesc; +# 2715 +cudaExtent extent; +# 2720 +unsigned flags; +# 2724 +unsigned numLevels; +# 2725 +}; +#endif +# 2730 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2730 +enum cudaExternalSemaphoreHandleType { +# 2734 +cudaExternalSemaphoreHandleTypeOpaqueFd = 1, +# 2738 +cudaExternalSemaphoreHandleTypeOpaqueWin32, +# 2742 +cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt, +# 2746 +cudaExternalSemaphoreHandleTypeD3D12Fence, +# 2750 +cudaExternalSemaphoreHandleTypeD3D11Fence, +# 2754 +cudaExternalSemaphoreHandleTypeNvSciSync, +# 2758 +cudaExternalSemaphoreHandleTypeKeyedMutex, +# 2762 +cudaExternalSemaphoreHandleTypeKeyedMutexKmt, +# 2766 +cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd, +# 2770 +cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32 +# 2771 +}; +#endif +# 2776 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2776 +struct cudaExternalSemaphoreHandleDesc { +# 2780 +cudaExternalSemaphoreHandleType type; +# 2781 +union { +# 2788 +int fd; +# 2804 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct { +# 2808 +void *handle; +# 2813 +const void *name; +# 2814 +} win32; +# 2818 +const void *nvSciSyncObj; +# 2819 +} handle; +# 2823 +unsigned flags; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 2824 +}; +#endif +# 2829 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2829 +struct cudaExternalSemaphoreSignalParams_v1 { +# 2830 +struct { +# 2834 +struct { +# 2838 +unsigned long long value; +# 2839 +} fence; +# 2840 +union { +# 2845 +void *fence; +# 2846 +unsigned long long reserved; +# 2847 +} nvSciSync; +# 2851 +struct { +# 2855 +unsigned long long key; +# 2856 +} keyedMutex; +# 2857 +} params; +# 2868 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +unsigned flags; +# 2869 +}; +#endif +# 2874 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2874 +struct cudaExternalSemaphoreWaitParams_v1 { +# 2875 +struct { +# 2879 +struct { +# 2883 +unsigned long long value; +# 2884 +} fence; +# 2885 +union { +# 2890 +void *fence; +# 2891 +unsigned long long reserved; +# 2892 +} nvSciSync; +# 2896 +struct { +# 2900 +unsigned long long key; +# 2904 +unsigned timeoutMs; +# 2905 +} keyedMutex; +# 2906 +} params; +# 2917 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +unsigned flags; +# 2918 +}; +#endif +# 2923 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2923 +struct cudaExternalSemaphoreSignalParams { +# 2924 +struct { +# 2928 +struct { +# 2932 +unsigned long long value; +# 2933 +} fence; +# 2934 +union { +# 2939 +void *fence; +# 2940 +unsigned long long reserved; +# 2941 +} nvSciSync; +# 2945 +struct { +# 2949 +unsigned long long key; +# 2950 +} keyedMutex; +# 2951 +unsigned reserved[12]; +# 2952 +} params; +# 2963 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +unsigned flags; +# 2964 +unsigned reserved[16]; +# 2965 +}; +#endif +# 2970 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 2970 +struct cudaExternalSemaphoreWaitParams { +# 2971 +struct { +# 2975 +struct { +# 2979 +unsigned long long value; +# 2980 +} fence; +# 2981 +union { +# 2986 +void *fence; +# 2987 +unsigned long long reserved; +# 2988 +} nvSciSync; +# 2992 +struct { +# 2996 +unsigned long long key; +# 3000 +unsigned timeoutMs; +# 3001 +} keyedMutex; +# 3002 +unsigned reserved[10]; +# 3003 +} params; +# 3014 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +unsigned flags; +# 3015 +unsigned reserved[16]; +# 3016 +}; +#endif +# 3027 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef cudaError +# 3027 +cudaError_t; +#endif +# 3032 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUstream_st * +# 3032 +cudaStream_t; +#endif +# 3037 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUevent_st * +# 3037 +cudaEvent_t; +#endif +# 3042 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef cudaGraphicsResource * +# 3042 +cudaGraphicsResource_t; +#endif +# 3047 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUexternalMemory_st * +# 3047 +cudaExternalMemory_t; +#endif +# 3052 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUexternalSemaphore_st * +# 3052 +cudaExternalSemaphore_t; +#endif +# 3057 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUgraph_st * +# 3057 +cudaGraph_t; +#endif +# 3062 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUgraphNode_st * +# 3062 +cudaGraphNode_t; +#endif +# 3067 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUuserObject_st * +# 3067 +cudaUserObject_t; +#endif +# 3072 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef unsigned long long +# 3072 +cudaGraphConditionalHandle; +#endif +# 3077 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUfunc_st * +# 3077 +cudaFunction_t; +#endif +# 3082 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUkern_st * +# 3082 +cudaKernel_t; +#endif +# 3087 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3087 +enum cudaJitOption { +# 3094 +cudaJitMaxRegisters, +# 3108 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaJitThreadsPerBlock, +# 3116 +cudaJitWallTime, +# 3125 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaJitInfoLogBuffer, +# 3134 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaJitInfoLogBufferSizeBytes, +# 3143 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaJitErrorLogBuffer, +# 3152 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaJitErrorLogBufferSizeBytes, +# 3160 +cudaJitOptimizationLevel, +# 3168 +cudaJitFallbackStrategy = 10, +# 3176 +cudaJitGenerateDebugInfo, +# 3183 +cudaJitLogVerbose, +# 3190 +cudaJitGenerateLineInfo, +# 3198 +cudaJitCacheMode, +# 3205 +cudaJitPositionIndependentCode = 30, +# 3218 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaJitMinCtaPerSm, +# 3231 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaJitMaxThreadsPerBlock, +# 3241 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaJitOverrideDirectiveValues +# 3242 +}; +#endif +# 3248 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3248 +enum cudaLibraryOption { +# 3250 +cudaLibraryHostUniversalFunctionAndDataTable, +# 3261 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaLibraryBinaryIsPreserved +# 3262 +}; +#endif +# 3264 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3264 +struct cudalibraryHostUniversalFunctionAndDataTable { +# 3266 +void *functionTable; +# 3267 +size_t functionWindowSize; +# 3268 +void *dataTable; +# 3269 +size_t dataWindowSize; +# 3270 +}; +#endif +# 3275 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3275 +enum cudaJit_CacheMode { +# 3277 +cudaJitCacheOptionNone, +# 3278 +cudaJitCacheOptionCG, +# 3279 +cudaJitCacheOptionCA +# 3280 +}; +#endif +# 3285 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3285 +enum cudaJit_Fallback { +# 3287 +cudaPreferPtx, +# 3289 +cudaPreferBinary +# 3290 +}; +#endif +# 3295 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUlib_st * +# 3295 +cudaLibrary_t; +#endif +# 3300 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef struct CUmemPoolHandle_st * +# 3300 +cudaMemPool_t; +#endif +# 3305 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3305 +enum cudaCGScope { +# 3306 +cudaCGScopeInvalid, +# 3307 +cudaCGScopeGrid, +# 3308 +cudaCGScopeMultiGrid +# 3309 +}; +#endif +# 3314 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3314 +struct cudaLaunchParams { +# 3316 +void *func; +# 3317 +dim3 gridDim; +# 3318 +dim3 blockDim; +# 3319 +void **args; +# 3320 +size_t sharedMem; +# 3321 +cudaStream_t stream; +# 3322 +}; +#endif +# 3327 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3327 +struct cudaKernelNodeParams { +# 3328 +void *func; +# 3329 +dim3 gridDim; +# 3330 +dim3 blockDim; +# 3331 +unsigned sharedMemBytes; +# 3332 +void **kernelParams; +# 3333 +void **extra; +# 3334 +}; +#endif +# 3339 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3339 +struct cudaKernelNodeParamsV2 { +# 3340 +void *func; +# 3342 +dim3 gridDim; +# 3343 +dim3 blockDim; +# 3349 +unsigned sharedMemBytes; +# 3350 +void **kernelParams; +# 3351 +void **extra; +# 3352 +}; +#endif +# 3357 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3357 +struct cudaExternalSemaphoreSignalNodeParams { +# 3358 +cudaExternalSemaphore_t *extSemArray; +# 3359 +const cudaExternalSemaphoreSignalParams *paramsArray; +# 3360 +unsigned numExtSems; +# 3361 +}; +#endif +# 3366 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3366 +struct cudaExternalSemaphoreSignalNodeParamsV2 { +# 3367 +cudaExternalSemaphore_t *extSemArray; +# 3368 +const cudaExternalSemaphoreSignalParams *paramsArray; +# 3369 +unsigned numExtSems; +# 3370 +}; +#endif +# 3375 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3375 +struct cudaExternalSemaphoreWaitNodeParams { +# 3376 +cudaExternalSemaphore_t *extSemArray; +# 3377 +const cudaExternalSemaphoreWaitParams *paramsArray; +# 3378 +unsigned numExtSems; +# 3379 +}; +#endif +# 3384 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3384 +struct cudaExternalSemaphoreWaitNodeParamsV2 { +# 3385 +cudaExternalSemaphore_t *extSemArray; +# 3386 +const cudaExternalSemaphoreWaitParams *paramsArray; +# 3387 +unsigned numExtSems; +# 3388 +}; +#endif +# 3390 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3390 +enum cudaGraphConditionalHandleFlags { +# 3391 +cudaGraphCondAssignDefault = 1 +# 3392 +}; +#endif +# 3397 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3397 +enum cudaGraphConditionalNodeType { +# 3398 +cudaGraphCondTypeIf, +# 3399 +cudaGraphCondTypeWhile, +# 3400 +cudaGraphCondTypeSwitch +# 3401 +}; +#endif +# 3406 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3406 +struct cudaConditionalNodeParams { +# 3407 +cudaGraphConditionalHandle handle; +# 3410 +cudaGraphConditionalNodeType type; +# 3411 +unsigned size; +# 3413 +cudaGraph_t *phGraph_out; +# 3432 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +}; +#endif +# 3437 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3437 +enum cudaGraphNodeType { +# 3438 +cudaGraphNodeTypeKernel, +# 3439 +cudaGraphNodeTypeMemcpy, +# 3440 +cudaGraphNodeTypeMemset, +# 3441 +cudaGraphNodeTypeHost, +# 3442 +cudaGraphNodeTypeGraph, +# 3443 +cudaGraphNodeTypeEmpty, +# 3444 +cudaGraphNodeTypeWaitEvent, +# 3445 +cudaGraphNodeTypeEventRecord, +# 3446 +cudaGraphNodeTypeExtSemaphoreSignal, +# 3447 +cudaGraphNodeTypeExtSemaphoreWait, +# 3448 +cudaGraphNodeTypeMemAlloc, +# 3449 +cudaGraphNodeTypeMemFree, +# 3450 +cudaGraphNodeTypeConditional = 13, +# 3467 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaGraphNodeTypeCount +# 3468 +}; +#endif +# 3473 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3473 +struct cudaChildGraphNodeParams { +# 3474 +cudaGraph_t graph; +# 3476 +}; +#endif +# 3481 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3481 +struct cudaEventRecordNodeParams { +# 3482 +cudaEvent_t event; +# 3483 +}; +#endif +# 3488 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3488 +struct cudaEventWaitNodeParams { +# 3489 +cudaEvent_t event; +# 3490 +}; +#endif +# 3495 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3495 +struct cudaGraphNodeParams { +# 3496 +cudaGraphNodeType type; +# 3497 +int reserved0[3]; +# 3499 +union { +# 3500 +long long reserved1[29]; +# 3501 +cudaKernelNodeParamsV2 kernel; +# 3502 +cudaMemcpyNodeParams memcpy; +# 3503 +cudaMemsetParamsV2 memset; +# 3504 +cudaHostNodeParamsV2 host; +# 3505 +cudaChildGraphNodeParams graph; +# 3506 +cudaEventWaitNodeParams eventWait; +# 3507 +cudaEventRecordNodeParams eventRecord; +# 3508 +cudaExternalSemaphoreSignalNodeParamsV2 extSemSignal; +# 3509 +cudaExternalSemaphoreWaitNodeParamsV2 extSemWait; +# 3510 +cudaMemAllocNodeParamsV2 alloc; +# 3511 +cudaMemFreeNodeParams free; +# 3512 +cudaConditionalNodeParams conditional; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 3513 +}; +# 3515 +long long reserved2; +# 3516 +}; +#endif +# 3528 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 3521 +enum cudaGraphDependencyType_enum { +# 3522 +cudaGraphDependencyTypeDefault, +# 3523 +cudaGraphDependencyTypeProgrammatic +# 3528 +} cudaGraphDependencyType; +#endif +# 3558 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 3535 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct cudaGraphEdgeData_st { +# 3536 +unsigned char from_port; +# 3546 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +unsigned char to_port; +# 3553 +unsigned char type; +# 3556 +unsigned char reserved[5]; +# 3558 +} cudaGraphEdgeData; +#endif +# 3579 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef struct CUgraphExec_st *cudaGraphExec_t; +# 3584 +#if 0 +# 3584 +enum cudaGraphExecUpdateResult { +# 3585 +cudaGraphExecUpdateSuccess, +# 3586 +cudaGraphExecUpdateError, +# 3587 +cudaGraphExecUpdateErrorTopologyChanged, +# 3588 +cudaGraphExecUpdateErrorNodeTypeChanged, +# 3589 +cudaGraphExecUpdateErrorFunctionChanged, +# 3590 +cudaGraphExecUpdateErrorParametersChanged, +# 3591 +cudaGraphExecUpdateErrorNotSupported, +# 3592 +cudaGraphExecUpdateErrorUnsupportedFunctionChange, +# 3593 +cudaGraphExecUpdateErrorAttributesChanged +# 3594 +}; +#endif +# 3606 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 3599 +enum cudaGraphInstantiateResult { +# 3600 +cudaGraphInstantiateSuccess, +# 3601 +cudaGraphInstantiateError, +# 3602 +cudaGraphInstantiateInvalidStructure, +# 3603 +cudaGraphInstantiateNodeOperationNotSupported, +# 3604 +cudaGraphInstantiateMultipleDevicesNotSupported, +# 3605 +cudaGraphInstantiateConditionalHandleUnused +# 3606 +} cudaGraphInstantiateResult; +#endif +# 3617 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 3611 +struct cudaGraphInstantiateParams_st { +# 3613 +unsigned long long flags; +# 3614 +cudaStream_t uploadStream; +# 3615 +cudaGraphNode_t errNode_out; +# 3616 +cudaGraphInstantiateResult result_out; +# 3617 +} cudaGraphInstantiateParams; +#endif +# 3639 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 3622 +struct cudaGraphExecUpdateResultInfo_st { +# 3626 +cudaGraphExecUpdateResult result; +# 3633 +cudaGraphNode_t errorNode; +# 3638 +cudaGraphNode_t errorFromNode; +# 3639 +} cudaGraphExecUpdateResultInfo; +#endif +# 3644 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef struct CUgraphDeviceUpdatableNode_st *cudaGraphDeviceNode_t; +# 3649 +#if 0 +# 3649 +enum cudaGraphKernelNodeField { +# 3651 +cudaGraphKernelNodeFieldInvalid, +# 3652 +cudaGraphKernelNodeFieldGridDim, +# 3653 +cudaGraphKernelNodeFieldParam, +# 3654 +cudaGraphKernelNodeFieldEnabled +# 3655 +}; +#endif +# 3660 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3660 +struct cudaGraphKernelNodeUpdate { +# 3661 +cudaGraphDeviceNode_t node; +# 3662 +cudaGraphKernelNodeField field; +# 3663 +union { +# 3665 +dim3 gridDim; +# 3670 +struct { +# 3671 +const void *pValue; +# 3672 +size_t offset; +# 3673 +size_t size; +# 3674 +} param; +# 3675 +unsigned isEnabled; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 3676 +} updateData; +# 3677 +}; +#endif +# 3683 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3683 +enum cudaGetDriverEntryPointFlags { +# 3684 +cudaEnableDefault, +# 3685 +cudaEnableLegacyStream, +# 3686 +cudaEnablePerThreadDefaultStream +# 3687 +}; +#endif +# 3692 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3692 +enum cudaDriverEntryPointQueryResult { +# 3693 +cudaDriverEntryPointSuccess, +# 3694 +cudaDriverEntryPointSymbolNotFound, +# 3695 +cudaDriverEntryPointVersionNotSufficent +# 3696 +}; +#endif +# 3701 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3701 +enum cudaGraphDebugDotFlags { +# 3702 +cudaGraphDebugDotFlagsVerbose = (1 << 0), +# 3703 +cudaGraphDebugDotFlagsKernelNodeParams = (1 << 2), +# 3704 +cudaGraphDebugDotFlagsMemcpyNodeParams = (1 << 3), +# 3705 +cudaGraphDebugDotFlagsMemsetNodeParams = (1 << 4), +# 3706 +cudaGraphDebugDotFlagsHostNodeParams = (1 << 5), +# 3707 +cudaGraphDebugDotFlagsEventNodeParams = (1 << 6), +# 3708 +cudaGraphDebugDotFlagsExtSemasSignalNodeParams = (1 << 7), +# 3709 +cudaGraphDebugDotFlagsExtSemasWaitNodeParams = (1 << 8), +# 3710 +cudaGraphDebugDotFlagsKernelNodeAttributes = (1 << 9), +# 3711 +cudaGraphDebugDotFlagsHandles = (1 << 10), +# 3712 +cudaGraphDebugDotFlagsConditionalNodeParams = (1 << 15) +# 3713 +}; +#endif +# 3718 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 3718 +enum cudaGraphInstantiateFlags { +# 3719 +cudaGraphInstantiateFlagAutoFreeOnLaunch = 1, +# 3720 +cudaGraphInstantiateFlagUpload, +# 3723 +cudaGraphInstantiateFlagDeviceLaunch = 4, +# 3726 +cudaGraphInstantiateFlagUseNodePriority = 8 +# 3728 +}; +#endif +# 3749 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 3746 +enum cudaLaunchMemSyncDomain { +# 3747 +cudaLaunchMemSyncDomainDefault, +# 3748 +cudaLaunchMemSyncDomainRemote +# 3749 +} cudaLaunchMemSyncDomain; +#endif +# 3765 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 3762 +struct cudaLaunchMemSyncDomainMap_st { +# 3763 +unsigned char default_; +# 3764 +unsigned char remote; +# 3765 +} cudaLaunchMemSyncDomainMap; +#endif +# 3917 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 3770 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +enum cudaLaunchAttributeID { +# 3771 +cudaLaunchAttributeIgnore, +# 3772 +cudaLaunchAttributeAccessPolicyWindow, +# 3774 +cudaLaunchAttributeCooperative, +# 3776 +cudaLaunchAttributeSynchronizationPolicy, +# 3777 +cudaLaunchAttributeClusterDimension, +# 3779 +cudaLaunchAttributeClusterSchedulingPolicyPreference, +# 3781 +cudaLaunchAttributeProgrammaticStreamSerialization, +# 3792 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaLaunchAttributeProgrammaticEvent, +# 3818 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaLaunchAttributePriority, +# 3820 +cudaLaunchAttributeMemSyncDomainMap, +# 3822 +cudaLaunchAttributeMemSyncDomain, +# 3824 +cudaLaunchAttributePreferredClusterDimension, +# 3860 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaLaunchAttributeLaunchCompletionEvent, +# 3882 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaLaunchAttributeDeviceUpdatableKernelNode, +# 3910 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +cudaLaunchAttributePreferredSharedMemoryCarveout +# 3917 +} cudaLaunchAttributeID; +#endif +# 4013 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 3922 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +union cudaLaunchAttributeValue { +# 3923 +char pad[64]; +# 3924 +cudaAccessPolicyWindow accessPolicyWindow; +# 3925 +int cooperative; +# 3927 +cudaSynchronizationPolicy syncPolicy; +# 3941 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct { +# 3942 +unsigned x; +# 3943 +unsigned y; +# 3944 +unsigned z; +# 3945 +} clusterDim; +# 3946 +cudaClusterSchedulingPolicy clusterSchedulingPolicyPreference; +# 3949 +int programmaticStreamSerializationAllowed; +# 3960 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct { +# 3961 +cudaEvent_t event; +# 3962 +int flags; +# 3963 +int triggerAtBlockStart; +# 3964 +} programmaticEvent; +# 3965 +int priority; +# 3966 +cudaLaunchMemSyncDomainMap memSyncDomainMap; +# 3969 +cudaLaunchMemSyncDomain memSyncDomain; +# 3984 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct { +# 3985 +unsigned x; +# 3986 +unsigned y; +# 3987 +unsigned z; +# 3988 +} preferredClusterDim; +# 3997 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct { +# 3998 +cudaEvent_t event; +# 3999 +int flags; +# 4000 +} launchCompletionEvent; +# 4008 +struct { +# 4009 +int deviceUpdatable; +# 4010 +cudaGraphDeviceNode_t devNode; +# 4011 +} deviceUpdatableKernelNode; +# 4012 +unsigned sharedMemCarveout; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 4013 +} cudaLaunchAttributeValue; +#endif +# 4022 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 4018 +struct cudaLaunchAttribute_st { +# 4019 +cudaLaunchAttributeID id; +# 4020 +char pad[(8) - sizeof(cudaLaunchAttributeID)]; +# 4021 +cudaLaunchAttributeValue val; +# 4022 +} cudaLaunchAttribute; +#endif +# 4034 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 4027 +struct cudaLaunchConfig_st { +# 4028 +dim3 gridDim; +# 4029 +dim3 blockDim; +# 4030 +size_t dynamicSmemBytes; +# 4031 +cudaStream_t stream; +# 4032 +cudaLaunchAttribute *attrs; +# 4033 +unsigned numAttrs; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 4034 +} cudaLaunchConfig_t; +#endif +# 4061 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +# 4061 +enum cudaDeviceNumaConfig { +# 4062 +cudaDeviceNumaConfigNone, +# 4063 +cudaDeviceNumaConfigNumaNode +# 4064 +}; +#endif +# 4069 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef struct cudaAsyncCallbackEntry *cudaAsyncCallbackHandle_t; +# 4071 +struct cudaAsyncCallbackEntry; +# 4078 +#if 0 +typedef +# 4076 +enum cudaAsyncNotificationType_enum { +# 4077 +cudaAsyncNotificationTypeOverBudget = 1 +# 4078 +} cudaAsyncNotificationType; +#endif +# 4091 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +#if 0 +typedef +# 4083 +struct cudaAsyncNotificationInfo { +# 4085 +cudaAsyncNotificationType type; +# 4086 +union { +# 4087 +struct { +# 4088 +unsigned long long bytesOverBudget; +# 4089 +} overBudget; +# 4090 +} info; +# 4091 +} cudaAsyncNotificationInfo_t; +#endif +# 4093 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef void (*cudaAsyncCallback)(cudaAsyncNotificationInfo_t *, void *, cudaAsyncCallbackHandle_t); +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_types.h" +#if 0 +# 86 +enum cudaSurfaceBoundaryMode { +# 88 +cudaBoundaryModeZero, +# 89 +cudaBoundaryModeClamp, +# 90 +cudaBoundaryModeTrap +# 91 +}; +#endif +# 96 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_types.h" +#if 0 +# 96 +enum cudaSurfaceFormatMode { +# 98 +cudaFormatModeForced, +# 99 +cudaFormatModeAuto +# 100 +}; +#endif +# 105 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_types.h" +#if 0 +typedef unsigned long long +# 105 +cudaSurfaceObject_t; +#endif +# 86 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_types.h" +#if 0 +# 86 +enum cudaTextureAddressMode { +# 88 +cudaAddressModeWrap, +# 89 +cudaAddressModeClamp, +# 90 +cudaAddressModeMirror, +# 91 +cudaAddressModeBorder +# 92 +}; +#endif +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_types.h" +#if 0 +# 97 +enum cudaTextureFilterMode { +# 99 +cudaFilterModePoint, +# 100 +cudaFilterModeLinear +# 101 +}; +#endif +# 106 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_types.h" +#if 0 +# 106 +enum cudaTextureReadMode { +# 108 +cudaReadModeElementType, +# 109 +cudaReadModeNormalizedFloat +# 110 +}; +#endif +# 115 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_types.h" +#if 0 +# 115 +struct cudaTextureDesc { +# 120 +cudaTextureAddressMode addressMode[3]; +# 124 +cudaTextureFilterMode filterMode; +# 128 +cudaTextureReadMode readMode; +# 132 +int sRGB; +# 136 +float borderColor[4]; +# 140 +int normalizedCoords; +# 144 +unsigned maxAnisotropy; +# 148 +cudaTextureFilterMode mipmapFilterMode; +# 152 +float mipmapLevelBias; +# 156 +float minMipmapLevelClamp; +# 160 +float maxMipmapLevelClamp; +# 164 +int disableTrilinearOptimization; +# 168 +int seamlessCubemap; +# 169 +}; +#endif +# 174 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_types.h" +#if 0 +typedef unsigned long long +# 174 +cudaTextureObject_t; +#endif +# 94 "/opt/cuda/bin/../targets/x86_64-linux/include/library_types.h" +typedef +# 57 +enum cudaDataType_t { +# 59 +CUDA_R_16F = 2, +# 60 +CUDA_C_16F = 6, +# 61 +CUDA_R_16BF = 14, +# 62 +CUDA_C_16BF, +# 63 +CUDA_R_32F = 0, +# 64 +CUDA_C_32F = 4, +# 65 +CUDA_R_64F = 1, +# 66 +CUDA_C_64F = 5, +# 67 +CUDA_R_4I = 16, +# 68 +CUDA_C_4I, +# 69 +CUDA_R_4U, +# 70 +CUDA_C_4U, +# 71 +CUDA_R_8I = 3, +# 72 +CUDA_C_8I = 7, +# 73 +CUDA_R_8U, +# 74 +CUDA_C_8U, +# 75 +CUDA_R_16I = 20, +# 76 +CUDA_C_16I, +# 77 +CUDA_R_16U, +# 78 +CUDA_C_16U, +# 79 +CUDA_R_32I = 10, +# 80 +CUDA_C_32I, +# 81 +CUDA_R_32U, +# 82 +CUDA_C_32U, +# 83 +CUDA_R_64I = 24, +# 84 +CUDA_C_64I, +# 85 +CUDA_R_64U, +# 86 +CUDA_C_64U, +# 87 +CUDA_R_8F_E4M3, +# 88 +CUDA_R_8F_UE4M3 = CUDA_R_8F_E4M3, +# 89 +CUDA_R_8F_E5M2, +# 90 +CUDA_R_8F_UE8M0, +# 91 +CUDA_R_6F_E2M3, +# 92 +CUDA_R_6F_E3M2, +# 93 +CUDA_R_4F_E2M1 +# 94 +} cudaDataType; +# 102 +typedef +# 97 +enum libraryPropertyType_t { +# 99 +MAJOR_VERSION, +# 100 +MINOR_VERSION, +# 101 +PATCH_LEVEL +# 102 +} libraryPropertyType; +# 308 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std { +# 310 +typedef unsigned long size_t; +# 311 +typedef long ptrdiff_t; +# 314 +typedef __decltype((nullptr)) nullptr_t; +# 317 +#pragma GCC visibility push ( default ) +# 320 +__attribute((__noreturn__, __always_inline__)) inline void +# 321 +__terminate() noexcept +# 322 +{ +# 323 +void terminate() noexcept __attribute((__noreturn__, __cold__)); +# 324 +terminate(); +# 325 +} +#pragma GCC visibility pop +} +# 341 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std { +# 343 +inline namespace __cxx11 __attribute((__abi_tag__("cxx11"))) { } +# 344 +} +# 345 +namespace __gnu_cxx { +# 347 +inline namespace __cxx11 __attribute((__abi_tag__("cxx11"))) { } +# 348 +} +# 534 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std { +# 536 +#pragma GCC visibility push ( default ) +# 541 +__attribute((__always_inline__)) constexpr bool +# 543 +__is_constant_evaluated() noexcept +# 544 +{ +# 550 +return __builtin_is_constant_evaluated(); +# 554 +} +#pragma GCC visibility pop +} +# 573 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std { +# 575 +#pragma GCC visibility push ( default ) +# 577 +__attribute((__noreturn__)) void +# 579 +__glibcxx_assert_fail(const char * __file, int __line, const char * __function, const char * __condition) noexcept; +# 583 +#pragma GCC visibility pop +} +# 604 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std { +# 606 +__attribute((__always_inline__, __visibility__("default"))) inline void +# 608 +__glibcxx_assert_fail() +# 609 +{ } +# 610 +} +# 828 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace __gnu_cxx { +# 830 +typedef __decltype(((0.0bf16))) __bfloat16_t; +# 831 +} +# 34 "/usr/include/stdlib.h" 3 +extern "C" { +# 63 "/usr/include/stdlib.h" 3 +typedef +# 60 +struct { +# 61 +int quot; +# 62 +int rem; +# 63 +} div_t; +# 71 +typedef +# 68 +struct { +# 69 +long quot; +# 70 +long rem; +# 71 +} ldiv_t; +# 81 +__extension__ typedef +# 78 +struct { +# 79 +long long quot; +# 80 +long long rem; +# 81 +} lldiv_t; +# 98 "/usr/include/stdlib.h" 3 +extern size_t __ctype_get_mb_cur_max() noexcept(true); +# 102 +extern double atof(const char * __nptr) noexcept(true) +# 103 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 105 +extern int atoi(const char * __nptr) noexcept(true) +# 106 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 108 +extern long atol(const char * __nptr) noexcept(true) +# 109 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 113 +__extension__ extern long long atoll(const char * __nptr) noexcept(true) +# 114 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 118 +extern double strtod(const char *__restrict__ __nptr, char **__restrict__ __endptr) noexcept(true) +# 120 + __attribute((__nonnull__(1))); +# 124 +extern float strtof(const char *__restrict__ __nptr, char **__restrict__ __endptr) noexcept(true) +# 125 + __attribute((__nonnull__(1))); +# 127 +extern long double strtold(const char *__restrict__ __nptr, char **__restrict__ __endptr) noexcept(true) +# 129 + __attribute((__nonnull__(1))); +# 141 "/usr/include/stdlib.h" 3 +extern _Float32 strtof32(const char *__restrict__ __nptr, char **__restrict__ __endptr) noexcept(true) +# 143 + __attribute((__nonnull__(1))); +# 147 +extern _Float64 strtof64(const char *__restrict__ __nptr, char **__restrict__ __endptr) noexcept(true) +# 149 + __attribute((__nonnull__(1))); +# 153 +extern _Float128 strtof128(const char *__restrict__ __nptr, char **__restrict__ __endptr) noexcept(true) +# 155 + __attribute((__nonnull__(1))); +# 159 +extern _Float32x strtof32x(const char *__restrict__ __nptr, char **__restrict__ __endptr) noexcept(true) +# 161 + __attribute((__nonnull__(1))); +# 165 +extern _Float64x strtof64x(const char *__restrict__ __nptr, char **__restrict__ __endptr) noexcept(true) +# 167 + __attribute((__nonnull__(1))); +# 177 "/usr/include/stdlib.h" 3 +extern long strtol(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtol") +# 179 + __attribute((__nonnull__(1))); +# 181 +extern unsigned long strtoul(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtoul") +# 183 + __attribute((__nonnull__(1))); +# 188 +__extension__ extern long long strtoq(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtoll") +# 190 + __attribute((__nonnull__(1))); +# 193 +__extension__ extern unsigned long long strtouq(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtoull") +# 195 + __attribute((__nonnull__(1))); +# 201 +__extension__ extern long long strtoll(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtoll") +# 203 + __attribute((__nonnull__(1))); +# 206 +__extension__ extern unsigned long long strtoull(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtoull") +# 208 + __attribute((__nonnull__(1))); +# 215 +extern long strtol(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtol") +# 218 + __attribute((__nonnull__(1))); +# 219 +extern unsigned long strtoul(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtoul") +# 223 + __attribute((__nonnull__(1))); +# 226 +__extension__ extern long long strtoq(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtoll") +# 229 + __attribute((__nonnull__(1))); +# 231 +__extension__ extern unsigned long long strtouq(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtoull") +# 235 + __attribute((__nonnull__(1))); +# 238 +__extension__ extern long long strtoll(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtoll") +# 241 + __attribute((__nonnull__(1))); +# 243 +__extension__ extern unsigned long long strtoull(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) __asm__("__isoc23_strtoull") +# 247 + __attribute((__nonnull__(1))); +# 278 "/usr/include/stdlib.h" 3 +extern int strfromd(char * __dest, size_t __size, const char * __format, double __f) noexcept(true) +# 280 + __attribute((__nonnull__(3))); +# 282 +extern int strfromf(char * __dest, size_t __size, const char * __format, float __f) noexcept(true) +# 284 + __attribute((__nonnull__(3))); +# 286 +extern int strfroml(char * __dest, size_t __size, const char * __format, long double __f) noexcept(true) +# 288 + __attribute((__nonnull__(3))); +# 298 "/usr/include/stdlib.h" 3 +extern int strfromf32(char * __dest, size_t __size, const char * __format, _Float32 __f) noexcept(true) +# 300 + __attribute((__nonnull__(3))); +# 304 +extern int strfromf64(char * __dest, size_t __size, const char * __format, _Float64 __f) noexcept(true) +# 306 + __attribute((__nonnull__(3))); +# 310 +extern int strfromf128(char * __dest, size_t __size, const char * __format, _Float128 __f) noexcept(true) +# 312 + __attribute((__nonnull__(3))); +# 316 +extern int strfromf32x(char * __dest, size_t __size, const char * __format, _Float32x __f) noexcept(true) +# 318 + __attribute((__nonnull__(3))); +# 322 +extern int strfromf64x(char * __dest, size_t __size, const char * __format, _Float64x __f) noexcept(true) +# 324 + __attribute((__nonnull__(3))); +# 340 "/usr/include/stdlib.h" 3 +extern long strtol_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base, locale_t __loc) noexcept(true) __asm__("__isoc23_strtol_l") +# 342 + __attribute((__nonnull__(1, 4))); +# 344 +extern unsigned long strtoul_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base, locale_t __loc) noexcept(true) __asm__("__isoc23_strtoul_l") +# 347 + __attribute((__nonnull__(1, 4))); +# 350 +__extension__ extern long long strtoll_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base, locale_t __loc) noexcept(true) __asm__("__isoc23_strtoll_l") +# 353 + __attribute((__nonnull__(1, 4))); +# 356 +__extension__ extern unsigned long long strtoull_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base, locale_t __loc) noexcept(true) __asm__("__isoc23_strtoull_l") +# 359 + __attribute((__nonnull__(1, 4))); +# 365 +extern long strtol_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base, locale_t __loc) noexcept(true) __asm__("__isoc23_strtol_l") +# 369 + __attribute((__nonnull__(1, 4))); +# 370 +extern unsigned long strtoul_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base, locale_t __loc) noexcept(true) __asm__("__isoc23_strtoul_l") +# 375 + __attribute((__nonnull__(1, 4))); +# 377 +__extension__ extern long long strtoll_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base, locale_t __loc) noexcept(true) __asm__("__isoc23_strtoll_l") +# 382 + __attribute((__nonnull__(1, 4))); +# 384 +__extension__ extern unsigned long long strtoull_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base, locale_t __loc) noexcept(true) __asm__("__isoc23_strtoull_l") +# 389 + __attribute((__nonnull__(1, 4))); +# 415 "/usr/include/stdlib.h" 3 +extern double strtod_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 417 + __attribute((__nonnull__(1, 3))); +# 419 +extern float strtof_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 421 + __attribute((__nonnull__(1, 3))); +# 423 +extern long double strtold_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 426 + __attribute((__nonnull__(1, 3))); +# 436 "/usr/include/stdlib.h" 3 +extern _Float32 strtof32_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 439 + __attribute((__nonnull__(1, 3))); +# 443 +extern _Float64 strtof64_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 446 + __attribute((__nonnull__(1, 3))); +# 450 +extern _Float128 strtof128_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 453 + __attribute((__nonnull__(1, 3))); +# 457 +extern _Float32x strtof32x_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 460 + __attribute((__nonnull__(1, 3))); +# 464 +extern _Float64x strtof64x_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 467 + __attribute((__nonnull__(1, 3))); +# 505 "/usr/include/stdlib.h" 3 +extern char *l64a(long __n) noexcept(true); +# 508 +extern long a64l(const char * __s) noexcept(true) +# 509 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 27 "/usr/include/sys/types.h" 3 +extern "C" { +# 33 +typedef __u_char u_char; +# 34 +typedef __u_short u_short; +# 35 +typedef __u_int u_int; +# 36 +typedef __u_long u_long; +# 37 +typedef __quad_t quad_t; +# 38 +typedef __u_quad_t u_quad_t; +# 39 +typedef __fsid_t fsid_t; +# 42 +typedef __loff_t loff_t; +# 47 +typedef __ino_t ino_t; +# 54 +typedef __ino64_t ino64_t; +# 59 +typedef __dev_t dev_t; +# 64 +typedef __gid_t gid_t; +# 69 +typedef __mode_t mode_t; +# 74 +typedef __nlink_t nlink_t; +# 79 +typedef __uid_t uid_t; +# 85 +typedef __off_t off_t; +# 92 +typedef __off64_t off64_t; +# 97 +typedef __pid_t pid_t; +# 103 +typedef __id_t id_t; +# 108 +typedef __ssize_t ssize_t; +# 114 +typedef __daddr_t daddr_t; +# 115 +typedef __caddr_t caddr_t; +# 121 +typedef __key_t key_t; +# 7 "/usr/include/bits/types/clock_t.h" 3 +typedef __clock_t clock_t; +# 7 "/usr/include/bits/types/clockid_t.h" 3 +typedef __clockid_t clockid_t; +# 10 "/usr/include/bits/types/time_t.h" 3 +typedef __time_t time_t; +# 7 "/usr/include/bits/types/timer_t.h" 3 +typedef __timer_t timer_t; +# 134 "/usr/include/sys/types.h" 3 +typedef __useconds_t useconds_t; +# 138 +typedef __suseconds_t suseconds_t; +# 148 "/usr/include/sys/types.h" 3 +typedef unsigned long ulong; +# 149 +typedef unsigned short ushort; +# 150 +typedef unsigned uint; +# 24 "/usr/include/bits/stdint-intn.h" 3 +typedef __int8_t int8_t; +# 25 +typedef __int16_t int16_t; +# 26 +typedef __int32_t int32_t; +# 27 +typedef __int64_t int64_t; +# 158 "/usr/include/sys/types.h" 3 +typedef __uint8_t u_int8_t; +# 159 +typedef __uint16_t u_int16_t; +# 160 +typedef __uint32_t u_int32_t; +# 161 +typedef __uint64_t u_int64_t; +# 164 +typedef long register_t __attribute((__mode__(__word__))); +# 34 "/usr/include/bits/byteswap.h" 3 +static inline __uint16_t __bswap_16(__uint16_t __bsx) +# 35 +{ +# 37 +return __builtin_bswap16(__bsx); +# 41 +} +# 49 +static inline __uint32_t __bswap_32(__uint32_t __bsx) +# 50 +{ +# 52 +return __builtin_bswap32(__bsx); +# 56 +} +# 70 "/usr/include/bits/byteswap.h" 3 +__extension__ static inline __uint64_t __bswap_64(__uint64_t __bsx) +# 71 +{ +# 73 +return __builtin_bswap64(__bsx); +# 77 +} +# 33 "/usr/include/bits/uintn-identity.h" 3 +static inline __uint16_t __uint16_identity(__uint16_t __x) +# 34 +{ +# 35 +return __x; +# 36 +} +# 39 +static inline __uint32_t __uint32_identity(__uint32_t __x) +# 40 +{ +# 41 +return __x; +# 42 +} +# 45 +static inline __uint64_t __uint64_identity(__uint64_t __x) +# 46 +{ +# 47 +return __x; +# 48 +} +# 8 "/usr/include/bits/types/__sigset_t.h" 3 +typedef +# 6 +struct { +# 7 +unsigned long __val[(1024) / ((8) * sizeof(unsigned long))]; +# 8 +} __sigset_t; +# 7 "/usr/include/bits/types/sigset_t.h" 3 +typedef __sigset_t sigset_t; +# 8 "/usr/include/bits/types/struct_timeval.h" 3 +struct timeval { +# 14 +__time_t tv_sec; +# 15 +__suseconds_t tv_usec; +# 17 +}; +# 11 "/usr/include/bits/types/struct_timespec.h" 3 +struct timespec { +# 16 +__time_t tv_sec; +# 21 +__syscall_slong_t tv_nsec; +# 31 "/usr/include/bits/types/struct_timespec.h" 3 +}; +# 49 "/usr/include/sys/select.h" 3 +typedef long __fd_mask; +# 70 "/usr/include/sys/select.h" 3 +typedef +# 60 +struct { +# 64 +__fd_mask fds_bits[1024 / (8 * ((int)sizeof(__fd_mask)))]; +# 70 +} fd_set; +# 77 +typedef __fd_mask fd_mask; +# 91 "/usr/include/sys/select.h" 3 +extern "C" { +# 102 "/usr/include/sys/select.h" 3 +extern int select(int __nfds, fd_set *__restrict__ __readfds, fd_set *__restrict__ __writefds, fd_set *__restrict__ __exceptfds, timeval *__restrict__ __timeout); +# 127 "/usr/include/sys/select.h" 3 +extern int pselect(int __nfds, fd_set *__restrict__ __readfds, fd_set *__restrict__ __writefds, fd_set *__restrict__ __exceptfds, const timespec *__restrict__ __timeout, const __sigset_t *__restrict__ __sigmask); +# 153 "/usr/include/sys/select.h" 3 +} +# 185 "/usr/include/sys/types.h" 3 +typedef __blksize_t blksize_t; +# 192 +typedef __blkcnt_t blkcnt_t; +# 196 +typedef __fsblkcnt_t fsblkcnt_t; +# 200 +typedef __fsfilcnt_t fsfilcnt_t; +# 219 "/usr/include/sys/types.h" 3 +typedef __blkcnt64_t blkcnt64_t; +# 220 +typedef __fsblkcnt64_t fsblkcnt64_t; +# 221 +typedef __fsfilcnt64_t fsfilcnt64_t; +# 33 "/usr/include/bits/atomic_wide_counter.h" 3 +typedef +# 26 +union { +# 27 +__extension__ unsigned long long __value64; +# 29 +struct { +# 30 +unsigned __low; +# 31 +unsigned __high; +# 32 +} __value32; +# 33 +} __atomic_wide_counter; +# 55 "/usr/include/bits/thread-shared-types.h" 3 +typedef +# 51 +struct __pthread_internal_list { +# 53 +__pthread_internal_list *__prev; +# 54 +__pthread_internal_list *__next; +# 55 +} __pthread_list_t; +# 60 +typedef +# 57 +struct __pthread_internal_slist { +# 59 +__pthread_internal_slist *__next; +# 60 +} __pthread_slist_t; +# 22 "/usr/include/bits/struct_mutex.h" 3 +struct __pthread_mutex_s { +# 24 +int __lock; +# 25 +unsigned __count; +# 26 +int __owner; +# 28 +unsigned __nusers; +# 32 +int __kind; +# 34 +short __spins; +# 35 +short __elision; +# 36 +__pthread_list_t __list; +# 53 "/usr/include/bits/struct_mutex.h" 3 +}; +# 23 "/usr/include/bits/struct_rwlock.h" 3 +struct __pthread_rwlock_arch_t { +# 25 +unsigned __readers; +# 26 +unsigned __writers; +# 27 +unsigned __wrphase_futex; +# 28 +unsigned __writers_futex; +# 29 +unsigned __pad3; +# 30 +unsigned __pad4; +# 32 +int __cur_writer; +# 33 +int __shared; +# 34 +signed char __rwelision; +# 39 +unsigned char __pad1[7]; +# 42 +unsigned long __pad2; +# 45 +unsigned __flags; +# 55 "/usr/include/bits/struct_rwlock.h" 3 +}; +# 94 "/usr/include/bits/thread-shared-types.h" 3 +struct __pthread_cond_s { +# 96 +__atomic_wide_counter __wseq; +# 97 +__atomic_wide_counter __g1_start; +# 98 +unsigned __g_size[2]; +# 99 +unsigned __g1_orig_size; +# 100 +unsigned __wrefs; +# 101 +unsigned __g_signals[2]; +# 102 +unsigned __unused_initialized_1; +# 103 +unsigned __unused_initialized_2; +# 104 +}; +# 106 +typedef unsigned __tss_t; +# 107 +typedef unsigned long __thrd_t; +# 112 +typedef +# 110 +struct { +# 111 +int __data; +# 112 +} __once_flag; +# 27 "/usr/include/bits/pthreadtypes.h" 3 +typedef unsigned long pthread_t; +# 36 +typedef +# 33 +union { +# 34 +char __size[4]; +# 35 +int __align; +# 36 +} pthread_mutexattr_t; +# 45 +typedef +# 42 +union { +# 43 +char __size[4]; +# 44 +int __align; +# 45 +} pthread_condattr_t; +# 49 +typedef unsigned pthread_key_t; +# 53 +typedef int pthread_once_t; +# 56 +union pthread_attr_t { +# 58 +char __size[56]; +# 59 +long __align; +# 60 +}; +# 62 +typedef pthread_attr_t pthread_attr_t; +# 72 +typedef +# 68 +union { +# 69 +__pthread_mutex_s __data; +# 70 +char __size[40]; +# 71 +long __align; +# 72 +} pthread_mutex_t; +# 80 +typedef +# 76 +union { +# 77 +__pthread_cond_s __data; +# 78 +char __size[48]; +# 79 +__extension__ long long __align; +# 80 +} pthread_cond_t; +# 91 +typedef +# 87 +union { +# 88 +__pthread_rwlock_arch_t __data; +# 89 +char __size[56]; +# 90 +long __align; +# 91 +} pthread_rwlock_t; +# 97 +typedef +# 94 +union { +# 95 +char __size[8]; +# 96 +long __align; +# 97 +} pthread_rwlockattr_t; +# 103 +typedef volatile int pthread_spinlock_t; +# 112 +typedef +# 109 +union { +# 110 +char __size[32]; +# 111 +long __align; +# 112 +} pthread_barrier_t; +# 118 +typedef +# 115 +union { +# 116 +char __size[4]; +# 117 +int __align; +# 118 +} pthread_barrierattr_t; +# 230 "/usr/include/sys/types.h" 3 +} +# 521 "/usr/include/stdlib.h" 3 +extern long random() noexcept(true); +# 524 +extern void srandom(unsigned __seed) noexcept(true); +# 530 +extern char *initstate(unsigned __seed, char * __statebuf, size_t __statelen) noexcept(true) +# 531 + __attribute((__nonnull__(2))); +# 535 +extern char *setstate(char * __statebuf) noexcept(true) __attribute((__nonnull__(1))); +# 543 +struct random_data { +# 545 +int32_t *fptr; +# 546 +int32_t *rptr; +# 547 +int32_t *state; +# 548 +int rand_type; +# 549 +int rand_deg; +# 550 +int rand_sep; +# 551 +int32_t *end_ptr; +# 552 +}; +# 554 +extern int random_r(random_data *__restrict__ __buf, int32_t *__restrict__ __result) noexcept(true) +# 555 + __attribute((__nonnull__(1, 2))); +# 557 +extern int srandom_r(unsigned __seed, random_data * __buf) noexcept(true) +# 558 + __attribute((__nonnull__(2))); +# 560 +extern int initstate_r(unsigned __seed, char *__restrict__ __statebuf, size_t __statelen, random_data *__restrict__ __buf) noexcept(true) +# 563 + __attribute((__nonnull__(2, 4))); +# 565 +extern int setstate_r(char *__restrict__ __statebuf, random_data *__restrict__ __buf) noexcept(true) +# 567 + __attribute((__nonnull__(1, 2))); +# 573 +extern int rand() noexcept(true); +# 575 +extern void srand(unsigned __seed) noexcept(true); +# 579 +extern int rand_r(unsigned * __seed) noexcept(true); +# 587 +extern double drand48() noexcept(true); +# 588 +extern double erand48(unsigned short __xsubi[3]) noexcept(true) __attribute((__nonnull__(1))); +# 591 +extern long lrand48() noexcept(true); +# 592 +extern long nrand48(unsigned short __xsubi[3]) noexcept(true) +# 593 + __attribute((__nonnull__(1))); +# 596 +extern long mrand48() noexcept(true); +# 597 +extern long jrand48(unsigned short __xsubi[3]) noexcept(true) +# 598 + __attribute((__nonnull__(1))); +# 601 +extern void srand48(long __seedval) noexcept(true); +# 602 +extern unsigned short *seed48(unsigned short __seed16v[3]) noexcept(true) +# 603 + __attribute((__nonnull__(1))); +# 604 +extern void lcong48(unsigned short __param[7]) noexcept(true) __attribute((__nonnull__(1))); +# 610 +struct drand48_data { +# 612 +unsigned short __x[3]; +# 613 +unsigned short __old_x[3]; +# 614 +unsigned short __c; +# 615 +unsigned short __init; +# 616 +__extension__ unsigned long long __a; +# 618 +}; +# 621 +extern int drand48_r(drand48_data *__restrict__ __buffer, double *__restrict__ __result) noexcept(true) +# 622 + __attribute((__nonnull__(1, 2))); +# 623 +extern int erand48_r(unsigned short __xsubi[3], drand48_data *__restrict__ __buffer, double *__restrict__ __result) noexcept(true) +# 625 + __attribute((__nonnull__(1, 2))); +# 628 +extern int lrand48_r(drand48_data *__restrict__ __buffer, long *__restrict__ __result) noexcept(true) +# 630 + __attribute((__nonnull__(1, 2))); +# 631 +extern int nrand48_r(unsigned short __xsubi[3], drand48_data *__restrict__ __buffer, long *__restrict__ __result) noexcept(true) +# 634 + __attribute((__nonnull__(1, 2))); +# 637 +extern int mrand48_r(drand48_data *__restrict__ __buffer, long *__restrict__ __result) noexcept(true) +# 639 + __attribute((__nonnull__(1, 2))); +# 640 +extern int jrand48_r(unsigned short __xsubi[3], drand48_data *__restrict__ __buffer, long *__restrict__ __result) noexcept(true) +# 643 + __attribute((__nonnull__(1, 2))); +# 646 +extern int srand48_r(long __seedval, drand48_data * __buffer) noexcept(true) +# 647 + __attribute((__nonnull__(2))); +# 649 +extern int seed48_r(unsigned short __seed16v[3], drand48_data * __buffer) noexcept(true) +# 650 + __attribute((__nonnull__(1, 2))); +# 652 +extern int lcong48_r(unsigned short __param[7], drand48_data * __buffer) noexcept(true) +# 654 + __attribute((__nonnull__(1, 2))); +# 657 +extern __uint32_t arc4random() noexcept(true); +# 661 +extern void arc4random_buf(void * __buf, size_t __size) noexcept(true) +# 662 + __attribute((__nonnull__(1))); +# 666 +extern __uint32_t arc4random_uniform(__uint32_t __upper_bound) noexcept(true); +# 672 +extern void *malloc(size_t __size) noexcept(true) __attribute((__malloc__)) +# 673 + __attribute((__alloc_size__(1))); +# 675 +extern void *calloc(size_t __nmemb, size_t __size) noexcept(true) +# 676 + __attribute((__malloc__)) __attribute((__alloc_size__(1, 2))); +# 683 +extern void *realloc(void * __ptr, size_t __size) noexcept(true) +# 684 + __attribute((__warn_unused_result__)) __attribute((__alloc_size__(2))); +# 687 +extern void free(void * __ptr) noexcept(true); +# 695 +extern void *reallocarray(void * __ptr, size_t __nmemb, size_t __size) noexcept(true) +# 696 + __attribute((__warn_unused_result__)) +# 697 + __attribute((__alloc_size__(2, 3))) +# 698 + __attribute((__malloc__(__builtin_free, 1))); +# 701 +extern void *reallocarray(void * __ptr, size_t __nmemb, size_t __size) noexcept(true) +# 702 + __attribute((__malloc__(reallocarray, 1))); +# 26 "/usr/include/alloca.h" 3 +extern "C" { +# 32 +extern void *alloca(size_t __size) noexcept(true); +# 38 +} +# 712 "/usr/include/stdlib.h" 3 +extern void *valloc(size_t __size) noexcept(true) __attribute((__malloc__)) +# 713 + __attribute((__alloc_size__(1))); +# 718 +extern int posix_memalign(void ** __memptr, size_t __alignment, size_t __size) noexcept(true) +# 719 + __attribute((__nonnull__(1))); +# 724 +extern void *aligned_alloc(size_t __alignment, size_t __size) noexcept(true) +# 725 + __attribute((__malloc__)) __attribute((__alloc_align__(1 ))) +# 726 + __attribute((__alloc_size__(2))); +# 730 +extern void abort() noexcept(true) __attribute((__noreturn__)) __attribute((__cold__)); +# 734 +extern int atexit(void (* __func)(void)) noexcept(true) __attribute((__nonnull__(1))); +# 739 +extern "C++" int at_quick_exit(void (* __func)(void)) noexcept(true) __asm__("at_quick_exit") +# 740 + __attribute((__nonnull__(1))); +# 749 "/usr/include/stdlib.h" 3 +extern int on_exit(void (* __func)(int __status, void * __arg), void * __arg) noexcept(true) +# 750 + __attribute((__nonnull__(1))); +# 756 +extern void exit(int __status) noexcept(true) __attribute((__noreturn__)); +# 762 +extern void quick_exit(int __status) noexcept(true) __attribute((__noreturn__)); +# 768 +extern void _Exit(int __status) noexcept(true) __attribute((__noreturn__)); +# 773 +extern char *getenv(const char * __name) noexcept(true) __attribute((__nonnull__(1))); +# 778 +extern char *secure_getenv(const char * __name) noexcept(true) +# 779 + __attribute((__nonnull__(1))); +# 786 +extern int putenv(char * __string) noexcept(true) __attribute((__nonnull__(1))); +# 792 +extern int setenv(const char * __name, const char * __value, int __replace) noexcept(true) +# 793 + __attribute((__nonnull__(2))); +# 796 +extern int unsetenv(const char * __name) noexcept(true) __attribute((__nonnull__(1))); +# 803 +extern int clearenv() noexcept(true); +# 814 "/usr/include/stdlib.h" 3 +extern char *mktemp(char * __template) noexcept(true) __attribute((__nonnull__(1))); +# 827 "/usr/include/stdlib.h" 3 +extern int mkstemp(char * __template) __attribute((__nonnull__(1))); +# 837 "/usr/include/stdlib.h" 3 +extern int mkstemp64(char * __template) __attribute((__nonnull__(1))); +# 849 "/usr/include/stdlib.h" 3 +extern int mkstemps(char * __template, int __suffixlen) __attribute((__nonnull__(1))); +# 859 "/usr/include/stdlib.h" 3 +extern int mkstemps64(char * __template, int __suffixlen) +# 860 + __attribute((__nonnull__(1))); +# 870 "/usr/include/stdlib.h" 3 +extern char *mkdtemp(char * __template) noexcept(true) __attribute((__nonnull__(1))); +# 881 "/usr/include/stdlib.h" 3 +extern int mkostemp(char * __template, int __flags) __attribute((__nonnull__(1))); +# 891 "/usr/include/stdlib.h" 3 +extern int mkostemp64(char * __template, int __flags) __attribute((__nonnull__(1))); +# 901 "/usr/include/stdlib.h" 3 +extern int mkostemps(char * __template, int __suffixlen, int __flags) +# 902 + __attribute((__nonnull__(1))); +# 913 "/usr/include/stdlib.h" 3 +extern int mkostemps64(char * __template, int __suffixlen, int __flags) +# 914 + __attribute((__nonnull__(1))); +# 923 "/usr/include/stdlib.h" 3 +extern int system(const char * __command); +# 929 +extern char *canonicalize_file_name(const char * __name) noexcept(true) +# 930 + __attribute((__nonnull__(1))) __attribute((__malloc__)) +# 931 + __attribute((__malloc__(__builtin_free, 1))); +# 940 "/usr/include/stdlib.h" 3 +extern char *realpath(const char *__restrict__ __name, char *__restrict__ __resolved) noexcept(true); +# 948 +typedef int (*__compar_fn_t)(const void *, const void *); +# 951 +typedef __compar_fn_t comparison_fn_t; +# 955 +typedef int (*__compar_d_fn_t)(const void *, const void *, void *); +# 960 +extern void *bsearch(const void * __key, const void * __base, size_t __nmemb, size_t __size, __compar_fn_t __compar) +# 962 + __attribute((__nonnull__(1, 2, 5))); +# 970 +extern void qsort(void * __base, size_t __nmemb, size_t __size, __compar_fn_t __compar) +# 971 + __attribute((__nonnull__(1, 4))); +# 973 +extern void qsort_r(void * __base, size_t __nmemb, size_t __size, __compar_d_fn_t __compar, void * __arg) +# 975 + __attribute((__nonnull__(1, 4))); +# 980 +extern int abs(int __x) noexcept(true) __attribute((const)); +# 981 +extern long labs(long __x) noexcept(true) __attribute((const)); +# 984 +__extension__ extern long long llabs(long long __x) noexcept(true) +# 985 + __attribute((const)); +# 992 +extern div_t div(int __numer, int __denom) noexcept(true) +# 993 + __attribute((const)); +# 994 +extern ldiv_t ldiv(long __numer, long __denom) noexcept(true) +# 995 + __attribute((const)); +# 998 +__extension__ extern lldiv_t lldiv(long long __numer, long long __denom) noexcept(true) +# 1000 + __attribute((const)); +# 1012 "/usr/include/stdlib.h" 3 +extern char *ecvt(double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign) noexcept(true) +# 1013 + __attribute((__nonnull__(3, 4))); +# 1018 +extern char *fcvt(double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign) noexcept(true) +# 1019 + __attribute((__nonnull__(3, 4))); +# 1024 +extern char *gcvt(double __value, int __ndigit, char * __buf) noexcept(true) +# 1025 + __attribute((__nonnull__(3))); +# 1030 +extern char *qecvt(long double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign) noexcept(true) +# 1032 + __attribute((__nonnull__(3, 4))); +# 1033 +extern char *qfcvt(long double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign) noexcept(true) +# 1035 + __attribute((__nonnull__(3, 4))); +# 1036 +extern char *qgcvt(long double __value, int __ndigit, char * __buf) noexcept(true) +# 1037 + __attribute((__nonnull__(3))); +# 1042 +extern int ecvt_r(double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign, char *__restrict__ __buf, size_t __len) noexcept(true) +# 1044 + __attribute((__nonnull__(3, 4, 5))); +# 1045 +extern int fcvt_r(double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign, char *__restrict__ __buf, size_t __len) noexcept(true) +# 1047 + __attribute((__nonnull__(3, 4, 5))); +# 1049 +extern int qecvt_r(long double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign, char *__restrict__ __buf, size_t __len) noexcept(true) +# 1052 + __attribute((__nonnull__(3, 4, 5))); +# 1053 +extern int qfcvt_r(long double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign, char *__restrict__ __buf, size_t __len) noexcept(true) +# 1056 + __attribute((__nonnull__(3, 4, 5))); +# 1062 +extern int mblen(const char * __s, size_t __n) noexcept(true); +# 1065 +extern int mbtowc(wchar_t *__restrict__ __pwc, const char *__restrict__ __s, size_t __n) noexcept(true); +# 1069 +extern int wctomb(char * __s, wchar_t __wchar) noexcept(true); +# 1073 +extern size_t mbstowcs(wchar_t *__restrict__ __pwcs, const char *__restrict__ __s, size_t __n) noexcept(true) +# 1075 + __attribute((__access__(__read_only__ , 2 ))); +# 1077 +extern size_t wcstombs(char *__restrict__ __s, const wchar_t *__restrict__ __pwcs, size_t __n) noexcept(true) +# 1080 + __attribute((__access__(__write_only__ , 1 , 3 ))) +# 1081 + __attribute((__access__(__read_only__ , 2 ))); +# 1088 +extern int rpmatch(const char * __response) noexcept(true) __attribute((__nonnull__(1))); +# 1099 "/usr/include/stdlib.h" 3 +extern int getsubopt(char **__restrict__ __optionp, char *const *__restrict__ __tokens, char **__restrict__ __valuep) noexcept(true) +# 1102 + __attribute((__nonnull__(1, 2, 3))); +# 1110 +extern int posix_openpt(int __oflag); +# 1118 +extern int grantpt(int __fd) noexcept(true); +# 1122 +extern int unlockpt(int __fd) noexcept(true); +# 1127 +extern char *ptsname(int __fd) noexcept(true); +# 1134 +extern int ptsname_r(int __fd, char * __buf, size_t __buflen) noexcept(true) +# 1135 + __attribute((__nonnull__(2))) __attribute((__access__(__write_only__ , 2 , 3 ))); +# 1138 +extern int getpt(); +# 1145 +extern int getloadavg(double __loadavg[], int __nelem) noexcept(true) +# 1146 + __attribute((__nonnull__(1))); +# 1167 "/usr/include/stdlib.h" 3 +} +# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 +extern "C++" { +# 48 +namespace std __attribute((__visibility__("default"))) { +# 52 +using ::abs; +# 56 +inline long abs(long __i) { return __builtin_labs(__i); } +# 61 +inline long long abs(long long __x) { return __builtin_llabs(__x); } +# 71 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 +constexpr double abs(double __x) +# 72 +{ return __builtin_fabs(__x); } +# 75 +constexpr float abs(float __x) +# 76 +{ return __builtin_fabsf(__x); } +# 79 +constexpr long double abs(long double __x) +# 80 +{ return __builtin_fabsl(__x); } +# 85 +__extension__ constexpr __int128 abs(__int128 __x) { return (__x >= (0)) ? __x : (-__x); } +# 137 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/std_abs.h" 3 +__extension__ constexpr __float128 abs(__float128 __x) +# 138 +{ +# 142 +return __builtin_fabsf128(__x); +# 147 +} +# 151 +} +# 152 +} +# 125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +extern "C++" { +# 127 +namespace std __attribute((__visibility__("default"))) { +# 131 +using ::div_t; +# 132 +using ::ldiv_t; +# 134 +using ::abort; +# 136 +using ::aligned_alloc; +# 138 +using ::atexit; +# 141 +using ::at_quick_exit; +# 144 +using ::atof; +# 145 +using ::atoi; +# 146 +using ::atol; +# 147 +using ::bsearch; +# 148 +using ::calloc; +# 149 +using ::div; +# 150 +using ::exit; +# 151 +using ::free; +# 152 +using ::getenv; +# 153 +using ::labs; +# 154 +using ::ldiv; +# 155 +using ::malloc; +# 157 +using ::mblen; +# 158 +using ::mbstowcs; +# 159 +using ::mbtowc; +# 161 +using ::qsort; +# 164 +using ::quick_exit; +# 167 +using ::rand; +# 168 +using ::realloc; +# 169 +using ::srand; +# 170 +using ::strtod; +# 171 +using ::strtol; +# 172 +using ::strtoul; +# 173 +using ::system; +# 175 +using ::wcstombs; +# 176 +using ::wctomb; +# 181 +inline ldiv_t div(long __i, long __j) noexcept { return ldiv(__i, __j); } +# 186 +} +# 199 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +namespace __gnu_cxx __attribute((__visibility__("default"))) { +# 204 +using ::lldiv_t; +# 210 +using ::_Exit; +# 214 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wlong-long" +using ::llabs; +# 219 +inline lldiv_t div(long long __n, long long __d) +# 220 +{ lldiv_t __q; (__q.quot) = (__n / __d); (__q.rem) = (__n % __d); return __q; } +# 222 +using ::lldiv; +#pragma GCC diagnostic pop +# 234 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +using ::atoll; +# 235 +using ::strtoll; +# 236 +using ::strtoull; +# 238 +using ::strtof; +# 239 +using ::strtold; +# 242 +} +# 244 +namespace std { +# 247 +using __gnu_cxx::lldiv_t; +# 249 +using __gnu_cxx::_Exit; +# 251 +using __gnu_cxx::llabs; +# 252 +using __gnu_cxx::div; +# 253 +using __gnu_cxx::lldiv; +# 255 +using __gnu_cxx::atoll; +# 256 +using __gnu_cxx::strtof; +# 257 +using __gnu_cxx::strtoll; +# 258 +using __gnu_cxx::strtoull; +# 259 +using __gnu_cxx::strtold; +# 260 +} +# 278 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cstdlib" 3 +} +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/stdlib.h" 3 +using std::abort; +# 39 +using std::atexit; +# 40 +using std::exit; +# 43 +using std::at_quick_exit; +# 46 +using std::quick_exit; +# 49 +using std::_Exit; +# 57 +using std::abs; +# 58 +using std::atof; +# 59 +using std::atoi; +# 60 +using std::atol; +# 61 +using std::bsearch; +# 62 +using std::calloc; +# 63 +using std::div; +# 64 +using std::free; +# 65 +using std::getenv; +# 66 +using std::labs; +# 67 +using std::ldiv; +# 68 +using std::malloc; +# 70 +using std::mblen; +# 71 +using std::mbstowcs; +# 72 +using std::mbtowc; +# 74 +using std::qsort; +# 75 +using std::rand; +# 76 +using std::realloc; +# 77 +using std::srand; +# 78 +using std::strtod; +# 79 +using std::strtol; +# 80 +using std::strtoul; +# 81 +using std::system; +# 83 +using std::wcstombs; +# 84 +using std::wctomb; +# 184 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern "C" { +# 191 +__attribute__((unused)) extern cudaError_t __cudaDeviceSynchronizeDeprecationAvoidance(); +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) extern cudaError_t __cudaCDP2DeviceGetAttribute(int * value, cudaDeviceAttr attr, int device); +# 245 +__attribute__((unused)) extern cudaError_t __cudaCDP2DeviceGetLimit(size_t * pValue, cudaLimit limit); +# 246 +__attribute__((unused)) extern cudaError_t __cudaCDP2DeviceGetCacheConfig(cudaFuncCache * pCacheConfig); +# 247 +__attribute__((unused)) extern cudaError_t __cudaCDP2DeviceGetSharedMemConfig(cudaSharedMemConfig * pConfig); +# 248 +__attribute__((unused)) extern cudaError_t __cudaCDP2GetLastError(); +# 249 +__attribute__((unused)) extern cudaError_t __cudaCDP2PeekAtLastError(); +# 250 +__attribute__((unused)) extern const char *__cudaCDP2GetErrorString(cudaError_t error); +# 251 +__attribute__((unused)) extern const char *__cudaCDP2GetErrorName(cudaError_t error); +# 252 +__attribute__((unused)) extern cudaError_t __cudaCDP2GetDeviceCount(int * count); +# 253 +__attribute__((unused)) extern cudaError_t __cudaCDP2GetDevice(int * device); +# 254 +__attribute__((unused)) extern cudaError_t __cudaCDP2StreamCreateWithFlags(cudaStream_t * pStream, unsigned flags); +# 255 +__attribute__((unused)) extern cudaError_t __cudaCDP2StreamDestroy(cudaStream_t stream); +# 256 +__attribute__((unused)) extern cudaError_t __cudaCDP2StreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned flags); +# 257 +__attribute__((unused)) extern cudaError_t __cudaCDP2StreamWaitEvent_ptsz(cudaStream_t stream, cudaEvent_t event, unsigned flags); +# 258 +__attribute__((unused)) extern cudaError_t __cudaCDP2EventCreateWithFlags(cudaEvent_t * event, unsigned flags); +# 259 +__attribute__((unused)) extern cudaError_t __cudaCDP2EventRecord(cudaEvent_t event, cudaStream_t stream); +# 260 +__attribute__((unused)) extern cudaError_t __cudaCDP2EventRecord_ptsz(cudaEvent_t event, cudaStream_t stream); +# 261 +__attribute__((unused)) extern cudaError_t __cudaCDP2EventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned flags); +# 262 +__attribute__((unused)) extern cudaError_t __cudaCDP2EventRecordWithFlags_ptsz(cudaEvent_t event, cudaStream_t stream, unsigned flags); +# 263 +__attribute__((unused)) extern cudaError_t __cudaCDP2EventDestroy(cudaEvent_t event); +# 264 +__attribute__((unused)) extern cudaError_t __cudaCDP2FuncGetAttributes(cudaFuncAttributes * attr, const void * func); +# 265 +__attribute__((unused)) extern cudaError_t __cudaCDP2Free(void * devPtr); +# 266 +__attribute__((unused)) extern cudaError_t __cudaCDP2Malloc(void ** devPtr, size_t size); +# 267 +__attribute__((unused)) extern cudaError_t __cudaCDP2MemcpyAsync(void * dst, const void * src, size_t count, cudaMemcpyKind kind, cudaStream_t stream); +# 268 +__attribute__((unused)) extern cudaError_t __cudaCDP2MemcpyAsync_ptsz(void * dst, const void * src, size_t count, cudaMemcpyKind kind, cudaStream_t stream); +# 269 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memcpy2DAsync(void * dst, size_t dpitch, const void * src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream); +# 270 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memcpy2DAsync_ptsz(void * dst, size_t dpitch, const void * src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream); +# 271 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memcpy3DAsync(const cudaMemcpy3DParms * p, cudaStream_t stream); +# 272 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memcpy3DAsync_ptsz(const cudaMemcpy3DParms * p, cudaStream_t stream); +# 273 +__attribute__((unused)) extern cudaError_t __cudaCDP2MemsetAsync(void * devPtr, int value, size_t count, cudaStream_t stream); +# 274 +__attribute__((unused)) extern cudaError_t __cudaCDP2MemsetAsync_ptsz(void * devPtr, int value, size_t count, cudaStream_t stream); +# 275 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memset2DAsync(void * devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream); +# 276 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memset2DAsync_ptsz(void * devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream); +# 277 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream); +# 278 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memset3DAsync_ptsz(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream); +# 279 +__attribute__((unused)) extern cudaError_t __cudaCDP2RuntimeGetVersion(int * runtimeVersion); +# 280 +__attribute__((unused)) extern void *__cudaCDP2GetParameterBuffer(size_t alignment, size_t size); +# 281 +__attribute__((unused)) extern void *__cudaCDP2GetParameterBufferV2(void * func, dim3 gridDimension, dim3 blockDimension, unsigned sharedMemSize); +# 282 +__attribute__((unused)) extern cudaError_t __cudaCDP2LaunchDevice_ptsz(void * func, void * parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned sharedMemSize, cudaStream_t stream); +# 283 +__attribute__((unused)) extern cudaError_t __cudaCDP2LaunchDeviceV2_ptsz(void * parameterBuffer, cudaStream_t stream); +# 284 +__attribute__((unused)) extern cudaError_t __cudaCDP2LaunchDevice(void * func, void * parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned sharedMemSize, cudaStream_t stream); +# 285 +__attribute__((unused)) extern cudaError_t __cudaCDP2LaunchDeviceV2(void * parameterBuffer, cudaStream_t stream); +# 286 +__attribute__((unused)) extern cudaError_t __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessor(int * numBlocks, const void * func, int blockSize, size_t dynamicSmemSize); +# 287 +__attribute__((unused)) extern cudaError_t __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int * numBlocks, const void * func, int blockSize, size_t dynamicSmemSize, unsigned flags); +# 290 +extern cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream); +# 311 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline cudaGraphExec_t cudaGetCurrentGraphExec() +# 312 +{int volatile ___ = 1; +# 316 +::exit(___);} +#if 0 +# 312 +{ +# 313 +unsigned long long current_graph_exec; +# 314 +__asm__("mov.u64 %0, %%current_graph_exec;" : "=l" (current_graph_exec) :); +# 315 +return (cudaGraphExec_t)current_graph_exec; +# 316 +} +#endif +# 346 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) extern cudaError_t cudaGraphKernelNodeSetParam(cudaGraphDeviceNode_t node, size_t offset, const void * value, size_t size); +# 374 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) extern cudaError_t cudaGraphKernelNodeSetEnabled(cudaGraphDeviceNode_t node, bool enable); +# 401 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) extern cudaError_t cudaGraphKernelNodeSetGridDim(cudaGraphDeviceNode_t node, dim3 gridDim); +# 430 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) extern cudaError_t cudaGraphKernelNodeUpdatesApply(const cudaGraphKernelNodeUpdate * updates, size_t updateCount); +# 448 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline void cudaTriggerProgrammaticLaunchCompletion() +# 449 +{int volatile ___ = 1; +# 451 +::exit(___);} +#if 0 +# 449 +{ +# 450 +__asm__ volatile("griddepcontrol.launch_dependents;" : :); +# 451 +} +#endif +# 464 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline void cudaGridDependencySynchronize() +# 465 +{int volatile ___ = 1; +# 467 +::exit(___);} +#if 0 +# 465 +{ +# 466 +__asm__ volatile("griddepcontrol.wait;" : : : "memory"); +# 467 +} +#endif +# 479 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) extern void cudaGraphSetConditional(cudaGraphConditionalHandle handle, unsigned value); +# 482 +__attribute__((unused)) extern unsigned long long cudaCGGetIntrinsicHandle(cudaCGScope scope); +# 483 +__attribute__((unused)) extern cudaError_t cudaCGSynchronize(unsigned long long handle, unsigned flags); +# 484 +__attribute__((unused)) extern cudaError_t cudaCGSynchronizeGrid(unsigned long long handle, unsigned flags); +# 485 +__attribute__((unused)) extern cudaError_t cudaCGGetSize(unsigned * numThreads, unsigned * numGrids, unsigned long long handle); +# 486 +__attribute__((unused)) extern cudaError_t cudaCGGetRank(unsigned * threadRank, unsigned * gridRank, unsigned long long handle); +# 714 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline void *cudaGetParameterBuffer(size_t alignment, size_t size) +# 715 +{int volatile ___ = 1;(void)alignment;(void)size; +# 717 +::exit(___);} +#if 0 +# 715 +{ +# 716 +return __cudaCDP2GetParameterBuffer(alignment, size); +# 717 +} +#endif +# 724 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline void *cudaGetParameterBufferV2(void *func, dim3 gridDimension, dim3 blockDimension, unsigned sharedMemSize) +# 725 +{int volatile ___ = 1;(void)func;(void)gridDimension;(void)blockDimension;(void)sharedMemSize; +# 727 +::exit(___);} +#if 0 +# 725 +{ +# 726 +return __cudaCDP2GetParameterBufferV2(func, gridDimension, blockDimension, sharedMemSize); +# 727 +} +#endif +# 734 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline cudaError_t cudaLaunchDevice_ptsz(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned sharedMemSize, cudaStream_t stream) +# 735 +{int volatile ___ = 1;(void)func;(void)parameterBuffer;(void)gridDimension;(void)blockDimension;(void)sharedMemSize;(void)stream; +# 737 +::exit(___);} +#if 0 +# 735 +{ +# 736 +return __cudaCDP2LaunchDevice_ptsz(func, parameterBuffer, gridDimension, blockDimension, sharedMemSize, stream); +# 737 +} +#endif +# 739 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline cudaError_t cudaLaunchDeviceV2_ptsz(void *parameterBuffer, cudaStream_t stream) +# 740 +{int volatile ___ = 1;(void)parameterBuffer;(void)stream; +# 742 +::exit(___);} +#if 0 +# 740 +{ +# 741 +return __cudaCDP2LaunchDeviceV2_ptsz(parameterBuffer, stream); +# 742 +} +#endif +# 800 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline cudaError_t cudaLaunchDevice(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned sharedMemSize, cudaStream_t stream) +# 801 +{int volatile ___ = 1;(void)func;(void)parameterBuffer;(void)gridDimension;(void)blockDimension;(void)sharedMemSize;(void)stream; +# 803 +::exit(___);} +#if 0 +# 801 +{ +# 802 +return __cudaCDP2LaunchDevice(func, parameterBuffer, gridDimension, blockDimension, sharedMemSize, stream); +# 803 +} +#endif +# 805 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline cudaError_t cudaLaunchDeviceV2(void *parameterBuffer, cudaStream_t stream) +# 806 +{int volatile ___ = 1;(void)parameterBuffer;(void)stream; +# 808 +::exit(___);} +#if 0 +# 806 +{ +# 807 +return __cudaCDP2LaunchDeviceV2(parameterBuffer, stream); +# 808 +} +#endif +# 862 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +} +# 868 +template< class T> static inline cudaError_t cudaMalloc(T ** devPtr, size_t size); +# 869 +template< class T> static inline cudaError_t cudaFuncGetAttributes(cudaFuncAttributes * attr, T * entry); +# 870 +template< class T> static inline cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int * numBlocks, T func, int blockSize, size_t dynamicSmemSize); +# 871 +template< class T> static inline cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int * numBlocks, T func, int blockSize, size_t dynamicSmemSize, unsigned flags); +# 901 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +template< class T> __attribute__((unused)) static inline cudaError_t +# 902 +cudaGraphKernelNodeSetParam(cudaGraphDeviceNode_t node, size_t offset, const T &value) +# 903 +{int volatile ___ = 1;(void)node;(void)offset;(void)value; +# 905 +::exit(___);} +#if 0 +# 903 +{ +# 904 +return cudaGraphKernelNodeSetParam(node, offset, &value, sizeof(T)); +# 905 +} +#endif +# 287 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern "C" { +# 334 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceReset(); +# 356 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceSynchronize(); +# 442 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceSetLimit(cudaLimit limit, size_t value); +# 478 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetLimit(size_t * pValue, cudaLimit limit); +# 501 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t * maxWidthInElements, const cudaChannelFormatDesc * fmtDesc, int device); +# 535 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetCacheConfig(cudaFuncCache * pCacheConfig); +# 572 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetStreamPriorityRange(int * leastPriority, int * greatestPriority); +# 616 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig); +# 643 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetByPCIBusId(int * device, const char * pciBusId); +# 673 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetPCIBusId(char * pciBusId, int len, int device); +# 724 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t * handle, cudaEvent_t event); +# 768 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaIpcOpenEventHandle(cudaEvent_t * event, cudaIpcEventHandle_t handle); +# 813 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t * handle, void * devPtr); +# 880 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaIpcOpenMemHandle(void ** devPtr, cudaIpcMemHandle_t handle, unsigned flags); +# 919 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaIpcCloseMemHandle(void * devPtr); +# 951 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope); +# 989 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void * userData, cudaAsyncCallbackHandle_t * callback); +# 1012 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback); +# 1059 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaDeviceGetSharedMemConfig(cudaSharedMemConfig * pConfig); +# 1105 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config); +# 1146 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaThreadExit(); +# 1172 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaThreadSynchronize(); +# 1221 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaThreadSetLimit(cudaLimit limit, size_t value); +# 1254 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaThreadGetLimit(size_t * pValue, cudaLimit limit); +# 1290 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaThreadGetCacheConfig(cudaFuncCache * pCacheConfig); +# 1337 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaThreadSetCacheConfig(cudaFuncCache cacheConfig); +# 1402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetLastError(); +# 1453 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaPeekAtLastError(); +# 1469 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern const char *cudaGetErrorName(cudaError_t error); +# 1485 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern const char *cudaGetErrorString(cudaError_t error); +# 1514 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetDeviceCount(int * count); +# 1818 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetDeviceProperties_v2(cudaDeviceProp * prop, int device); +# 2024 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetAttribute(int * value, cudaDeviceAttr attr, int device); +# 2042 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t * memPool, int device); +# 2066 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool); +# 2086 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetMemPool(cudaMemPool_t * memPool, int device); +# 2148 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetNvSciSyncAttributes(void * nvSciSyncAttrList, int device, int flags); +# 2188 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetP2PAttribute(int * value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice); +# 2210 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaChooseDevice(int * device, const cudaDeviceProp * prop); +# 2239 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaInitDevice(int device, unsigned deviceFlags, unsigned flags); +# 2285 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaSetDevice(int device); +# 2307 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetDevice(int * device); +# 2338 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaSetValidDevices(int * device_arr, int len); +# 2408 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaSetDeviceFlags(unsigned flags); +# 2453 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetDeviceFlags(unsigned * flags); +# 2497 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamCreate(cudaStream_t * pStream); +# 2533 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamCreateWithFlags(cudaStream_t * pStream, unsigned flags); +# 2585 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamCreateWithPriority(cudaStream_t * pStream, unsigned flags, int priority); +# 2613 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int * priority); +# 2639 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned * flags); +# 2676 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamGetId(cudaStream_t hStream, unsigned long long * streamId); +# 2702 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamGetDevice(cudaStream_t hStream, int * device); +# 2717 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaCtxResetPersistingL2Cache(); +# 2737 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src); +# 2758 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamGetAttribute(cudaStream_t hStream, cudaLaunchAttributeID attr, cudaLaunchAttributeValue * value_out); +# 2782 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamSetAttribute(cudaStream_t hStream, cudaLaunchAttributeID attr, const cudaLaunchAttributeValue * value); +# 2816 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamDestroy(cudaStream_t stream); +# 2847 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned flags = 0); +# 2855 +typedef void (*cudaStreamCallback_t)(cudaStream_t stream, cudaError_t status, void * userData); +# 2922 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void * userData, unsigned flags); +# 2946 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamSynchronize(cudaStream_t stream); +# 2971 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamQuery(cudaStream_t stream); +# 3055 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamAttachMemAsync(cudaStream_t stream, void * devPtr, size_t length = 0, unsigned flags = 4); +# 3094 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode); +# 3135 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t * dependencies, const cudaGraphEdgeData * dependencyData, size_t numDependencies, cudaStreamCaptureMode mode); +# 3186 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode * mode); +# 3215 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t * pGraph); +# 3253 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus * pCaptureStatus); +# 3303 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamGetCaptureInfo_v2(cudaStream_t stream, cudaStreamCaptureStatus * captureStatus_out, unsigned long long * id_out = 0, cudaGraph_t * graph_out = 0, const cudaGraphNode_t ** dependencies_out = 0, size_t * numDependencies_out = 0); +# 3362 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamGetCaptureInfo_v3(cudaStream_t stream, cudaStreamCaptureStatus * captureStatus_out, unsigned long long * id_out = 0, cudaGraph_t * graph_out = 0, const cudaGraphNode_t ** dependencies_out = 0, const cudaGraphEdgeData ** edgeData_out = 0, size_t * numDependencies_out = 0); +# 3402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t * dependencies, size_t numDependencies, unsigned flags = 0); +# 3437 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaStreamUpdateCaptureDependencies_v2(cudaStream_t stream, cudaGraphNode_t * dependencies, const cudaGraphEdgeData * dependencyData, size_t numDependencies, unsigned flags = 0); +# 3474 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaEventCreate(cudaEvent_t * event); +# 3511 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaEventCreateWithFlags(cudaEvent_t * event, unsigned flags); +# 3552 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream = 0); +# 3600 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream = 0, unsigned flags = 0); +# 3633 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaEventQuery(cudaEvent_t event); +# 3664 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaEventSynchronize(cudaEvent_t event); +# 3694 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaEventDestroy(cudaEvent_t event); +# 3739 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaEventElapsedTime(float * ms, cudaEvent_t start, cudaEvent_t end); +# 3787 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaEventElapsedTime_v2(float * ms, cudaEvent_t start, cudaEvent_t end); +# 3968 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaImportExternalMemory(cudaExternalMemory_t * extMem_out, const cudaExternalMemoryHandleDesc * memHandleDesc); +# 4023 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaExternalMemoryGetMappedBuffer(void ** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc * bufferDesc); +# 4083 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t * mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc * mipmapDesc); +# 4107 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem); +# 4261 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t * extSem_out, const cudaExternalSemaphoreHandleDesc * semHandleDesc); +# 4344 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaSignalExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t * extSemArray, const cudaExternalSemaphoreSignalParams * paramsArray, unsigned numExtSems, cudaStream_t stream = 0); +# 4420 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaWaitExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t * extSemArray, const cudaExternalSemaphoreWaitParams * paramsArray, unsigned numExtSems, cudaStream_t stream = 0); +# 4443 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem); +# 4511 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLaunchKernel(const void * func, dim3 gridDim, dim3 blockDim, void ** args, size_t sharedMem, cudaStream_t stream); +# 4574 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLaunchKernelExC(const cudaLaunchConfig_t * config, const void * func, void ** args); +# 4632 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLaunchCooperativeKernel(const void * func, dim3 gridDim, dim3 blockDim, void ** args, size_t sharedMem, cudaStream_t stream); +# 4733 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaLaunchCooperativeKernelMultiDevice(cudaLaunchParams * launchParamsList, unsigned numDevices, unsigned flags = 0); +# 4783 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaFuncSetCacheConfig(const void * func, cudaFuncCache cacheConfig); +# 4818 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaFuncGetAttributes(cudaFuncAttributes * attr, const void * func); +# 4877 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaFuncSetAttribute(const void * func, cudaFuncAttribute attr, int value); +# 4903 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaFuncGetName(const char ** name, const void * func); +# 4926 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaFuncGetParamInfo(const void * func, size_t paramIndex, size_t * paramOffset, size_t * paramSize); +# 4950 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaSetDoubleForDevice(double * d); +# 4974 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaSetDoubleForHost(double * d); +# 5040 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void * userData); +# 5114 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaFuncSetSharedMemConfig(const void * func, cudaSharedMemConfig config); +# 5171 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int * numBlocks, const void * func, int blockSize, size_t dynamicSMemSize); +# 5201 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t * dynamicSmemSize, const void * func, int numBlocks, int blockSize); +# 5247 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int * numBlocks, const void * func, int blockSize, size_t dynamicSMemSize, unsigned flags); +# 5283 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaOccupancyMaxPotentialClusterSize(int * clusterSize, const void * func, const cudaLaunchConfig_t * launchConfig); +# 5323 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaOccupancyMaxActiveClusters(int * numClusters, const void * func, const cudaLaunchConfig_t * launchConfig); +# 5443 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMallocManaged(void ** devPtr, size_t size, unsigned flags = 1); +# 5476 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMalloc(void ** devPtr, size_t size); +# 5513 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMallocHost(void ** ptr, size_t size); +# 5556 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMallocPitch(void ** devPtr, size_t * pitch, size_t width, size_t height); +# 5608 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMallocArray(cudaArray_t * array, const cudaChannelFormatDesc * desc, size_t width, size_t height = 0, unsigned flags = 0); +# 5647 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaFree(void * devPtr); +# 5670 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaFreeHost(void * ptr); +# 5693 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaFreeArray(cudaArray_t array); +# 5716 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray); +# 5782 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaHostAlloc(void ** pHost, size_t size, unsigned flags); +# 5879 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaHostRegister(void * ptr, size_t size, unsigned flags); +# 5902 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaHostUnregister(void * ptr); +# 5947 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaHostGetDevicePointer(void ** pDevice, void * pHost, unsigned flags); +# 5969 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaHostGetFlags(unsigned * pFlags, void * pHost); +# 6008 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMalloc3D(cudaPitchedPtr * pitchedDevPtr, cudaExtent extent); +# 6153 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMalloc3DArray(cudaArray_t * array, const cudaChannelFormatDesc * desc, cudaExtent extent, unsigned flags = 0); +# 6298 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMallocMipmappedArray(cudaMipmappedArray_t * mipmappedArray, const cudaChannelFormatDesc * desc, cudaExtent extent, unsigned numLevels, unsigned flags = 0); +# 6331 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t * levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned level); +# 6436 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy3D(const cudaMemcpy3DParms * p); +# 6468 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms * p); +# 6586 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy3DAsync(const cudaMemcpy3DParms * p, cudaStream_t stream = 0); +# 6613 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms * p, cudaStream_t stream = 0); +# 6647 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemGetInfo(size_t * free, size_t * total); +# 6673 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaArrayGetInfo(cudaChannelFormatDesc * desc, cudaExtent * extent, unsigned * flags, cudaArray_t array); +# 6702 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaArrayGetPlane(cudaArray_t * pPlaneArray, cudaArray_t hArray, unsigned planeIdx); +# 6725 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements * memoryRequirements, cudaArray_t array, int device); +# 6749 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements * memoryRequirements, cudaMipmappedArray_t mipmap, int device); +# 6777 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaArrayGetSparseProperties(cudaArraySparseProperties * sparseProperties, cudaArray_t array); +# 6807 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties * sparseProperties, cudaMipmappedArray_t mipmap); +# 6852 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy(void * dst, const void * src, size_t count, cudaMemcpyKind kind); +# 6887 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpyPeer(void * dst, int dstDevice, const void * src, int srcDevice, size_t count); +# 6936 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy2D(void * dst, size_t dpitch, const void * src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind); +# 6986 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void * src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind); +# 7036 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy2DFromArray(void * dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind); +# 7083 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind = cudaMemcpyDeviceToDevice); +# 7126 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpyToSymbol(const void * symbol, const void * src, size_t count, size_t offset = 0, cudaMemcpyKind kind = cudaMemcpyHostToDevice); +# 7170 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpyFromSymbol(void * dst, const void * symbol, size_t count, size_t offset = 0, cudaMemcpyKind kind = cudaMemcpyDeviceToHost); +# 7227 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpyAsync(void * dst, const void * src, size_t count, cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7262 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpyPeerAsync(void * dst, int dstDevice, const void * src, int srcDevice, size_t count, cudaStream_t stream = 0); +# 7334 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpyBatchAsync(void ** dsts, void ** srcs, size_t * sizes, size_t count, cudaMemcpyAttributes * attrs, size_t * attrsIdxs, size_t numAttrs, size_t * failIdx, cudaStream_t stream); +# 7402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp * opList, size_t * failIdx, unsigned long long flags, cudaStream_t stream); +# 7465 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy2DAsync(void * dst, size_t dpitch, const void * src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7523 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void * src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7580 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy2DFromArrayAsync(void * dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7631 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpyToSymbolAsync(const void * symbol, const void * src, size_t count, size_t offset, cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7682 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpyFromSymbolAsync(void * dst, const void * symbol, size_t count, size_t offset, cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7711 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemset(void * devPtr, int value, size_t count); +# 7745 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemset2D(void * devPtr, size_t pitch, int value, size_t width, size_t height); +# 7791 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent); +# 7827 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemsetAsync(void * devPtr, int value, size_t count, cudaStream_t stream = 0); +# 7868 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemset2DAsync(void * devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream = 0); +# 7921 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream = 0); +# 7949 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetSymbolAddress(void ** devPtr, const void * symbol); +# 7976 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetSymbolSize(size_t * size, const void * symbol); +# 8048 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPrefetchAsync(const void * devPtr, size_t count, int dstDevice, cudaStream_t stream = 0); +# 8129 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPrefetchAsync_v2(const void * devPtr, size_t count, cudaMemLocation location, unsigned flags, cudaStream_t stream = 0); +# 8243 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemAdvise(const void * devPtr, size_t count, cudaMemoryAdvise advice, int device); +# 8366 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemAdvise_v2(const void * devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location); +# 8448 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemRangeGetAttribute(void * data, size_t dataSize, cudaMemRangeAttribute attribute, const void * devPtr, size_t count); +# 8491 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemRangeGetAttributes(void ** data, size_t * dataSizes, cudaMemRangeAttribute * attributes, size_t numAttributes, const void * devPtr, size_t count); +# 8551 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void * src, size_t count, cudaMemcpyKind kind); +# 8593 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaMemcpyFromArray(void * dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind); +# 8636 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind = cudaMemcpyDeviceToDevice); +# 8687 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void * src, size_t count, cudaMemcpyKind kind, cudaStream_t stream = 0); +# 8737 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaMemcpyFromArrayAsync(void * dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream = 0); +# 8806 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMallocAsync(void ** devPtr, size_t size, cudaStream_t hStream); +# 8832 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaFreeAsync(void * devPtr, cudaStream_t hStream); +# 8857 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep); +# 8901 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void * value); +# 8949 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void * value); +# 8964 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc * descList, size_t count); +# 8977 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolGetAccess(cudaMemAccessFlags * flags, cudaMemPool_t memPool, cudaMemLocation * location); +# 9021 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolCreate(cudaMemPool_t * memPool, const cudaMemPoolProps * poolProps); +# 9043 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool); +# 9079 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMallocFromPoolAsync(void ** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream); +# 9104 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolExportToShareableHandle(void * shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned flags); +# 9131 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolImportFromShareableHandle(cudaMemPool_t * memPool, void * shareableHandle, cudaMemAllocationHandleType handleType, unsigned flags); +# 9154 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolExportPointer(cudaMemPoolPtrExportData * exportData, void * ptr); +# 9183 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolImportPointer(void ** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData * exportData); +# 9336 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaPointerGetAttributes(cudaPointerAttributes * attributes, const void * ptr); +# 9377 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceCanAccessPeer(int * canAccessPeer, int device, int peerDevice); +# 9419 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned flags); +# 9441 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceDisablePeerAccess(int peerDevice); +# 9505 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource); +# 9540 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned flags); +# 9579 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t * resources, cudaStream_t stream = 0); +# 9614 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t * resources, cudaStream_t stream = 0); +# 9646 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsResourceGetMappedPointer(void ** devPtr, size_t * size, cudaGraphicsResource_t resource); +# 9684 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t * array, cudaGraphicsResource_t resource, unsigned arrayIndex, unsigned mipLevel); +# 9713 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t * mipmappedArray, cudaGraphicsResource_t resource); +# 9748 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetChannelDesc(cudaChannelFormatDesc * desc, cudaArray_const_t array); +# 9778 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f); +# 10003 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaCreateTextureObject(cudaTextureObject_t * pTexObject, const cudaResourceDesc * pResDesc, const cudaTextureDesc * pTexDesc, const cudaResourceViewDesc * pResViewDesc); +# 10023 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject); +# 10043 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetTextureObjectResourceDesc(cudaResourceDesc * pResDesc, cudaTextureObject_t texObject); +# 10063 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetTextureObjectTextureDesc(cudaTextureDesc * pTexDesc, cudaTextureObject_t texObject); +# 10084 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc * pResViewDesc, cudaTextureObject_t texObject); +# 10129 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t * pSurfObject, const cudaResourceDesc * pResDesc); +# 10149 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject); +# 10168 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetSurfaceObjectResourceDesc(cudaResourceDesc * pResDesc, cudaSurfaceObject_t surfObject); +# 10202 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDriverGetVersion(int * driverVersion); +# 10231 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaRuntimeGetVersion(int * runtimeVersion); +# 10278 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphCreate(cudaGraph_t * pGraph, unsigned flags); +# 10377 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddKernelNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, const cudaKernelNodeParams * pNodeParams); +# 10410 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams * pNodeParams); +# 10437 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams * pNodeParams); +# 10457 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hSrc, cudaGraphNode_t hDst); +# 10480 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaLaunchAttributeID attr, cudaLaunchAttributeValue * value_out); +# 10504 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaLaunchAttributeID attr, const cudaLaunchAttributeValue * value); +# 10555 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddMemcpyNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, const cudaMemcpy3DParms * pCopyParams); +# 10614 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddMemcpyNodeToSymbol(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, const void * symbol, const void * src, size_t count, size_t offset, cudaMemcpyKind kind); +# 10683 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddMemcpyNodeFromSymbol(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, void * dst, const void * symbol, size_t count, size_t offset, cudaMemcpyKind kind); +# 10751 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddMemcpyNode1D(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, void * dst, const void * src, size_t count, cudaMemcpyKind kind); +# 10783 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms * pNodeParams); +# 10810 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms * pNodeParams); +# 10849 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemcpyNodeSetParamsToSymbol(cudaGraphNode_t node, const void * symbol, const void * src, size_t count, size_t offset, cudaMemcpyKind kind); +# 10895 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemcpyNodeSetParamsFromSymbol(cudaGraphNode_t node, void * dst, const void * symbol, size_t count, size_t offset, cudaMemcpyKind kind); +# 10941 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void * dst, const void * src, size_t count, cudaMemcpyKind kind); +# 10989 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddMemsetNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, const cudaMemsetParams * pMemsetParams); +# 11012 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams * pNodeParams); +# 11036 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams * pNodeParams); +# 11078 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddHostNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, const cudaHostNodeParams * pNodeParams); +# 11101 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams * pNodeParams); +# 11125 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams * pNodeParams); +# 11166 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddChildGraphNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, cudaGraph_t childGraph); +# 11193 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t * pGraph); +# 11231 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies); +# 11275 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddEventRecordNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, cudaEvent_t event); +# 11302 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t * event_out); +# 11330 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event); +# 11377 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddEventWaitNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, cudaEvent_t event); +# 11404 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t * event_out); +# 11432 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event); +# 11482 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams * nodeParams); +# 11515 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams * params_out); +# 11543 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams * nodeParams); +# 11593 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams * nodeParams); +# 11626 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams * params_out); +# 11654 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams * nodeParams); +# 11732 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddMemAllocNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, cudaMemAllocNodeParams * nodeParams); +# 11759 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams * params_out); +# 11820 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddMemFreeNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, void * dptr); +# 11844 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void * dptr_out); +# 11872 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGraphMemTrim(int device); +# 11909 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void * value); +# 11943 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void * value); +# 11971 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphClone(cudaGraph_t * pGraphClone, cudaGraph_t originalGraph); +# 11999 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t * pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph); +# 12030 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType * pType); +# 12061 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t * nodes, size_t * numNodes); +# 12092 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t * pRootNodes, size_t * pNumRootNodes); +# 12126 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t * from, cudaGraphNode_t * to, size_t * numEdges); +# 12166 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphGetEdges_v2(cudaGraph_t graph, cudaGraphNode_t * from, cudaGraphNode_t * to, cudaGraphEdgeData * edgeData, size_t * numEdges); +# 12197 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t * pDependencies, size_t * pNumDependencies); +# 12234 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeGetDependencies_v2(cudaGraphNode_t node, cudaGraphNode_t * pDependencies, cudaGraphEdgeData * edgeData, size_t * pNumDependencies); +# 12266 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t * pDependentNodes, size_t * pNumDependentNodes); +# 12304 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeGetDependentNodes_v2(cudaGraphNode_t node, cudaGraphNode_t * pDependentNodes, cudaGraphEdgeData * edgeData, size_t * pNumDependentNodes); +# 12335 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t * from, const cudaGraphNode_t * to, size_t numDependencies); +# 12367 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t * from, const cudaGraphNode_t * to, const cudaGraphEdgeData * edgeData, size_t numDependencies); +# 12398 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t * from, const cudaGraphNode_t * to, size_t numDependencies); +# 12433 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphRemoveDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t * from, const cudaGraphNode_t * to, const cudaGraphEdgeData * edgeData, size_t numDependencies); +# 12463 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node); +# 12534 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphInstantiate(cudaGraphExec_t * pGraphExec, cudaGraph_t graph, unsigned long long flags = 0); +# 12607 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t * pGraphExec, cudaGraph_t graph, unsigned long long flags = 0); +# 12714 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphInstantiateWithParams(cudaGraphExec_t * pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams * instantiateParams); +# 12739 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long * flags); +# 12799 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams * pNodeParams); +# 12850 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms * pNodeParams); +# 12905 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecMemcpyNodeSetParamsToSymbol(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const void * symbol, const void * src, size_t count, size_t offset, cudaMemcpyKind kind); +# 12968 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecMemcpyNodeSetParamsFromSymbol(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void * dst, const void * symbol, size_t count, size_t offset, cudaMemcpyKind kind); +# 13029 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void * dst, const void * src, size_t count, cudaMemcpyKind kind); +# 13088 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams * pNodeParams); +# 13128 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams * pNodeParams); +# 13175 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph); +# 13220 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event); +# 13265 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event); +# 13313 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams * nodeParams); +# 13361 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams * nodeParams); +# 13401 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned isEnabled); +# 13435 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned * isEnabled); +# 13529 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo * resultInfo); +# 13554 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream); +# 13585 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream); +# 13608 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec); +# 13629 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphDestroy(cudaGraph_t graph); +# 13648 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char * path, unsigned flags); +# 13684 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaUserObjectCreate(cudaUserObject_t * object_out, void * ptr, cudaHostFn_t destroy, unsigned initialRefcount, unsigned flags); +# 13708 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned count = 1); +# 13736 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned count = 1); +# 13764 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned count = 1, unsigned flags = 0); +# 13789 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned count = 1); +# 13831 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, cudaGraphNodeParams * nodeParams); +# 13875 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddNode_v2(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, const cudaGraphEdgeData * dependencyData, size_t numDependencies, cudaGraphNodeParams * nodeParams); +# 13904 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams * nodeParams); +# 13953 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams * nodeParams); +# 13980 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle * pHandle_out, cudaGraph_t graph, unsigned defaultLaunchValue = 0, unsigned flags = 0); +# 14061 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetDriverEntryPoint(const char * symbol, void ** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult * driverStatus = 0); +# 14137 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetDriverEntryPointByVersion(const char * symbol, void ** funcPtr, unsigned cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult * driverStatus = 0); +# 14212 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLibraryLoadData(cudaLibrary_t * library, const void * code, cudaJitOption * jitOptions, void ** jitOptionsValues, unsigned numJitOptions, cudaLibraryOption * libraryOptions, void ** libraryOptionValues, unsigned numLibraryOptions); +# 14272 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLibraryLoadFromFile(cudaLibrary_t * library, const char * fileName, cudaJitOption * jitOptions, void ** jitOptionsValues, unsigned numJitOptions, cudaLibraryOption * libraryOptions, void ** libraryOptionValues, unsigned numLibraryOptions); +# 14293 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLibraryUnload(cudaLibrary_t library); +# 14318 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLibraryGetKernel(cudaKernel_t * pKernel, cudaLibrary_t library, const char * name); +# 14352 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLibraryGetGlobal(void ** dptr, size_t * bytes, cudaLibrary_t library, const char * name); +# 14385 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLibraryGetManaged(void ** dptr, size_t * bytes, cudaLibrary_t library, const char * name); +# 14412 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLibraryGetUnifiedFunction(void ** fptr, cudaLibrary_t library, const char * symbol); +# 14434 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLibraryGetKernelCount(unsigned * count, cudaLibrary_t lib); +# 14456 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaLibraryEnumerateKernels(cudaKernel_t * kernels, unsigned numKernels, cudaLibrary_t lib); +# 14525 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device); +# 14530 +extern cudaError_t cudaGetExportTable(const void ** ppExportTable, const cudaUUID_t * pExportTableId); +# 14716 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetFuncBySymbol(cudaFunction_t * functionPtr, const void * symbolPtr); +# 14740 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern cudaError_t cudaGetKernel(cudaKernel_t * kernelPtr, const void * entryFuncAddr); +# 14918 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +} +# 120 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" +template< class T> inline cudaChannelFormatDesc cudaCreateChannelDesc() +# 121 +{ +# 122 +return cudaCreateChannelDesc(0, 0, 0, 0, cudaChannelFormatKindNone); +# 123 +} +# 125 +static inline cudaChannelFormatDesc cudaCreateChannelDescHalf() +# 126 +{ +# 127 +int e = (((int)sizeof(unsigned short)) * 8); +# 129 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +# 130 +} +# 132 +static inline cudaChannelFormatDesc cudaCreateChannelDescHalf1() +# 133 +{ +# 134 +int e = (((int)sizeof(unsigned short)) * 8); +# 136 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +# 137 +} +# 139 +static inline cudaChannelFormatDesc cudaCreateChannelDescHalf2() +# 140 +{ +# 141 +int e = (((int)sizeof(unsigned short)) * 8); +# 143 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindFloat); +# 144 +} +# 146 +static inline cudaChannelFormatDesc cudaCreateChannelDescHalf4() +# 147 +{ +# 148 +int e = (((int)sizeof(unsigned short)) * 8); +# 150 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindFloat); +# 151 +} +# 153 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< char> () +# 154 +{ +# 155 +int e = (((int)sizeof(char)) * 8); +# 160 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 162 +} +# 164 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< signed char> () +# 165 +{ +# 166 +int e = (((int)sizeof(signed char)) * 8); +# 168 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 169 +} +# 171 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< unsigned char> () +# 172 +{ +# 173 +int e = (((int)sizeof(unsigned char)) * 8); +# 175 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +# 176 +} +# 178 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< char1> () +# 179 +{ +# 180 +int e = (((int)sizeof(signed char)) * 8); +# 182 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 183 +} +# 185 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< uchar1> () +# 186 +{ +# 187 +int e = (((int)sizeof(unsigned char)) * 8); +# 189 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +# 190 +} +# 192 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< char2> () +# 193 +{ +# 194 +int e = (((int)sizeof(signed char)) * 8); +# 196 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +# 197 +} +# 199 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< uchar2> () +# 200 +{ +# 201 +int e = (((int)sizeof(unsigned char)) * 8); +# 203 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +# 204 +} +# 206 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< char4> () +# 207 +{ +# 208 +int e = (((int)sizeof(signed char)) * 8); +# 210 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +# 211 +} +# 213 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< uchar4> () +# 214 +{ +# 215 +int e = (((int)sizeof(unsigned char)) * 8); +# 217 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +# 218 +} +# 220 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< short> () +# 221 +{ +# 222 +int e = (((int)sizeof(short)) * 8); +# 224 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 225 +} +# 227 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< unsigned short> () +# 228 +{ +# 229 +int e = (((int)sizeof(unsigned short)) * 8); +# 231 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +# 232 +} +# 234 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< short1> () +# 235 +{ +# 236 +int e = (((int)sizeof(short)) * 8); +# 238 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 239 +} +# 241 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< ushort1> () +# 242 +{ +# 243 +int e = (((int)sizeof(unsigned short)) * 8); +# 245 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +# 246 +} +# 248 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< short2> () +# 249 +{ +# 250 +int e = (((int)sizeof(short)) * 8); +# 252 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +# 253 +} +# 255 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< ushort2> () +# 256 +{ +# 257 +int e = (((int)sizeof(unsigned short)) * 8); +# 259 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +# 260 +} +# 262 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< short4> () +# 263 +{ +# 264 +int e = (((int)sizeof(short)) * 8); +# 266 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +# 267 +} +# 269 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< ushort4> () +# 270 +{ +# 271 +int e = (((int)sizeof(unsigned short)) * 8); +# 273 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +# 274 +} +# 276 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< int> () +# 277 +{ +# 278 +int e = (((int)sizeof(int)) * 8); +# 280 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 281 +} +# 283 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< unsigned> () +# 284 +{ +# 285 +int e = (((int)sizeof(unsigned)) * 8); +# 287 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +# 288 +} +# 290 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< int1> () +# 291 +{ +# 292 +int e = (((int)sizeof(int)) * 8); +# 294 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 295 +} +# 297 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< uint1> () +# 298 +{ +# 299 +int e = (((int)sizeof(unsigned)) * 8); +# 301 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +# 302 +} +# 304 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< int2> () +# 305 +{ +# 306 +int e = (((int)sizeof(int)) * 8); +# 308 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +# 309 +} +# 311 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< uint2> () +# 312 +{ +# 313 +int e = (((int)sizeof(unsigned)) * 8); +# 315 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +# 316 +} +# 318 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< int4> () +# 319 +{ +# 320 +int e = (((int)sizeof(int)) * 8); +# 322 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +# 323 +} +# 325 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< uint4> () +# 326 +{ +# 327 +int e = (((int)sizeof(unsigned)) * 8); +# 329 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +# 330 +} +# 392 "/opt/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< float> () +# 393 +{ +# 394 +int e = (((int)sizeof(float)) * 8); +# 396 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +# 397 +} +# 399 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< float1> () +# 400 +{ +# 401 +int e = (((int)sizeof(float)) * 8); +# 403 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +# 404 +} +# 406 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< float2> () +# 407 +{ +# 408 +int e = (((int)sizeof(float)) * 8); +# 410 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindFloat); +# 411 +} +# 413 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< float4> () +# 414 +{ +# 415 +int e = (((int)sizeof(float)) * 8); +# 417 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindFloat); +# 418 +} +# 420 +static inline cudaChannelFormatDesc cudaCreateChannelDescNV12() +# 421 +{ +# 422 +int e = (((int)sizeof(char)) * 8); +# 424 +return cudaCreateChannelDesc(e, e, e, 0, cudaChannelFormatKindNV12); +# 425 +} +# 427 +template< cudaChannelFormatKind > inline cudaChannelFormatDesc cudaCreateChannelDesc() +# 428 +{ +# 429 +return cudaCreateChannelDesc(0, 0, 0, 0, cudaChannelFormatKindNone); +# 430 +} +# 433 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedNormalized8X1> () +# 434 +{ +# 435 +return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindSignedNormalized8X1); +# 436 +} +# 438 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedNormalized8X2> () +# 439 +{ +# 440 +return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindSignedNormalized8X2); +# 441 +} +# 443 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedNormalized8X4> () +# 444 +{ +# 445 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindSignedNormalized8X4); +# 446 +} +# 449 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedNormalized8X1> () +# 450 +{ +# 451 +return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindUnsignedNormalized8X1); +# 452 +} +# 454 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedNormalized8X2> () +# 455 +{ +# 456 +return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindUnsignedNormalized8X2); +# 457 +} +# 459 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedNormalized8X4> () +# 460 +{ +# 461 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedNormalized8X4); +# 462 +} +# 465 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedNormalized16X1> () +# 466 +{ +# 467 +return cudaCreateChannelDesc(16, 0, 0, 0, cudaChannelFormatKindSignedNormalized16X1); +# 468 +} +# 470 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedNormalized16X2> () +# 471 +{ +# 472 +return cudaCreateChannelDesc(16, 16, 0, 0, cudaChannelFormatKindSignedNormalized16X2); +# 473 +} +# 475 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedNormalized16X4> () +# 476 +{ +# 477 +return cudaCreateChannelDesc(16, 16, 16, 16, cudaChannelFormatKindSignedNormalized16X4); +# 478 +} +# 481 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedNormalized16X1> () +# 482 +{ +# 483 +return cudaCreateChannelDesc(16, 0, 0, 0, cudaChannelFormatKindUnsignedNormalized16X1); +# 484 +} +# 486 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedNormalized16X2> () +# 487 +{ +# 488 +return cudaCreateChannelDesc(16, 16, 0, 0, cudaChannelFormatKindUnsignedNormalized16X2); +# 489 +} +# 491 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedNormalized16X4> () +# 492 +{ +# 493 +return cudaCreateChannelDesc(16, 16, 16, 16, cudaChannelFormatKindUnsignedNormalized16X4); +# 494 +} +# 497 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindNV12> () +# 498 +{ +# 499 +return cudaCreateChannelDesc(8, 8, 8, 0, cudaChannelFormatKindNV12); +# 500 +} +# 503 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedNormalized1010102> () +# 504 +{ +# 505 +return cudaCreateChannelDesc(10, 10, 10, 2, cudaChannelFormatKindUnsignedNormalized1010102); +# 506 +} +# 509 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed1> () +# 510 +{ +# 511 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed1); +# 512 +} +# 515 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed1SRGB> () +# 516 +{ +# 517 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed1SRGB); +# 518 +} +# 521 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed2> () +# 522 +{ +# 523 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed2); +# 524 +} +# 527 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed2SRGB> () +# 528 +{ +# 529 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed2SRGB); +# 530 +} +# 533 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed3> () +# 534 +{ +# 535 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed3); +# 536 +} +# 539 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed3SRGB> () +# 540 +{ +# 541 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed3SRGB); +# 542 +} +# 545 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed4> () +# 546 +{ +# 547 +return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindUnsignedBlockCompressed4); +# 548 +} +# 551 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedBlockCompressed4> () +# 552 +{ +# 553 +return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindSignedBlockCompressed4); +# 554 +} +# 557 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed5> () +# 558 +{ +# 559 +return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindUnsignedBlockCompressed5); +# 560 +} +# 563 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedBlockCompressed5> () +# 564 +{ +# 565 +return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindSignedBlockCompressed5); +# 566 +} +# 569 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed6H> () +# 570 +{ +# 571 +return cudaCreateChannelDesc(16, 16, 16, 0, cudaChannelFormatKindUnsignedBlockCompressed6H); +# 572 +} +# 575 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedBlockCompressed6H> () +# 576 +{ +# 577 +return cudaCreateChannelDesc(16, 16, 16, 0, cudaChannelFormatKindSignedBlockCompressed6H); +# 578 +} +# 581 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed7> () +# 582 +{ +# 583 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed7); +# 584 +} +# 587 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed7SRGB> () +# 588 +{ +# 589 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed7SRGB); +# 590 +} +# 79 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static inline cudaPitchedPtr make_cudaPitchedPtr(void *d, size_t p, size_t xsz, size_t ysz) +# 80 +{ +# 81 +cudaPitchedPtr s; +# 83 +(s.ptr) = d; +# 84 +(s.pitch) = p; +# 85 +(s.xsize) = xsz; +# 86 +(s.ysize) = ysz; +# 88 +return s; +# 89 +} +# 106 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static inline cudaPos make_cudaPos(size_t x, size_t y, size_t z) +# 107 +{ +# 108 +cudaPos p; +# 110 +(p.x) = x; +# 111 +(p.y) = y; +# 112 +(p.z) = z; +# 114 +return p; +# 115 +} +# 132 "/opt/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static inline cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) +# 133 +{ +# 134 +cudaExtent e; +# 136 +(e.width) = w; +# 137 +(e.height) = h; +# 138 +(e.depth) = d; +# 140 +return e; +# 141 +} +# 77 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.h" +static inline char1 make_char1(signed char x); +# 79 +static inline uchar1 make_uchar1(unsigned char x); +# 81 +static inline char2 make_char2(signed char x, signed char y); +# 83 +static inline uchar2 make_uchar2(unsigned char x, unsigned char y); +# 85 +static inline char3 make_char3(signed char x, signed char y, signed char z); +# 87 +static inline uchar3 make_uchar3(unsigned char x, unsigned char y, unsigned char z); +# 89 +static inline char4 make_char4(signed char x, signed char y, signed char z, signed char w); +# 91 +static inline uchar4 make_uchar4(unsigned char x, unsigned char y, unsigned char z, unsigned char w); +# 93 +static inline short1 make_short1(short x); +# 95 +static inline ushort1 make_ushort1(unsigned short x); +# 97 +static inline short2 make_short2(short x, short y); +# 99 +static inline ushort2 make_ushort2(unsigned short x, unsigned short y); +# 101 +static inline short3 make_short3(short x, short y, short z); +# 103 +static inline ushort3 make_ushort3(unsigned short x, unsigned short y, unsigned short z); +# 105 +static inline short4 make_short4(short x, short y, short z, short w); +# 107 +static inline ushort4 make_ushort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w); +# 109 +static inline int1 make_int1(int x); +# 111 +static inline uint1 make_uint1(unsigned x); +# 113 +static inline int2 make_int2(int x, int y); +# 115 +static inline uint2 make_uint2(unsigned x, unsigned y); +# 117 +static inline int3 make_int3(int x, int y, int z); +# 119 +static inline uint3 make_uint3(unsigned x, unsigned y, unsigned z); +# 121 +static inline int4 make_int4(int x, int y, int z, int w); +# 123 +static inline uint4 make_uint4(unsigned x, unsigned y, unsigned z, unsigned w); +# 125 +static inline long1 make_long1(long x); +# 127 +static inline ulong1 make_ulong1(unsigned long x); +# 129 +static inline long2 make_long2(long x, long y); +# 131 +static inline ulong2 make_ulong2(unsigned long x, unsigned long y); +# 133 +static inline long3 make_long3(long x, long y, long z); +# 135 +static inline ulong3 make_ulong3(unsigned long x, unsigned long y, unsigned long z); +# 137 +static inline long4 make_long4(long x, long y, long z, long w); +# 139 +static inline ulong4 make_ulong4(unsigned long x, unsigned long y, unsigned long z, unsigned long w); +# 141 +static inline float1 make_float1(float x); +# 143 +static inline float2 make_float2(float x, float y); +# 145 +static inline float3 make_float3(float x, float y, float z); +# 147 +static inline float4 make_float4(float x, float y, float z, float w); +# 149 +static inline longlong1 make_longlong1(long long x); +# 151 +static inline ulonglong1 make_ulonglong1(unsigned long long x); +# 153 +static inline longlong2 make_longlong2(long long x, long long y); +# 155 +static inline ulonglong2 make_ulonglong2(unsigned long long x, unsigned long long y); +# 157 +static inline longlong3 make_longlong3(long long x, long long y, long long z); +# 159 +static inline ulonglong3 make_ulonglong3(unsigned long long x, unsigned long long y, unsigned long long z); +# 161 +static inline longlong4 make_longlong4(long long x, long long y, long long z, long long w); +# 163 +static inline ulonglong4 make_ulonglong4(unsigned long long x, unsigned long long y, unsigned long long z, unsigned long long w); +# 165 +static inline double1 make_double1(double x); +# 167 +static inline double2 make_double2(double x, double y); +# 169 +static inline double3 make_double3(double x, double y, double z); +# 171 +static inline double4 make_double4(double x, double y, double z, double w); +# 73 "/opt/cuda/bin/../targets/x86_64-linux/include/vector_functions.hpp" +static inline char1 make_char1(signed char x) +# 74 +{ +# 75 +char1 t; (t.x) = x; return t; +# 76 +} +# 78 +static inline uchar1 make_uchar1(unsigned char x) +# 79 +{ +# 80 +uchar1 t; (t.x) = x; return t; +# 81 +} +# 83 +static inline char2 make_char2(signed char x, signed char y) +# 84 +{ +# 85 +char2 t; (t.x) = x; (t.y) = y; return t; +# 86 +} +# 88 +static inline uchar2 make_uchar2(unsigned char x, unsigned char y) +# 89 +{ +# 90 +uchar2 t; (t.x) = x; (t.y) = y; return t; +# 91 +} +# 93 +static inline char3 make_char3(signed char x, signed char y, signed char z) +# 94 +{ +# 95 +char3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 96 +} +# 98 +static inline uchar3 make_uchar3(unsigned char x, unsigned char y, unsigned char z) +# 99 +{ +# 100 +uchar3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 101 +} +# 103 +static inline char4 make_char4(signed char x, signed char y, signed char z, signed char w) +# 104 +{ +# 105 +char4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 106 +} +# 108 +static inline uchar4 make_uchar4(unsigned char x, unsigned char y, unsigned char z, unsigned char w) +# 109 +{ +# 110 +uchar4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 111 +} +# 113 +static inline short1 make_short1(short x) +# 114 +{ +# 115 +short1 t; (t.x) = x; return t; +# 116 +} +# 118 +static inline ushort1 make_ushort1(unsigned short x) +# 119 +{ +# 120 +ushort1 t; (t.x) = x; return t; +# 121 +} +# 123 +static inline short2 make_short2(short x, short y) +# 124 +{ +# 125 +short2 t; (t.x) = x; (t.y) = y; return t; +# 126 +} +# 128 +static inline ushort2 make_ushort2(unsigned short x, unsigned short y) +# 129 +{ +# 130 +ushort2 t; (t.x) = x; (t.y) = y; return t; +# 131 +} +# 133 +static inline short3 make_short3(short x, short y, short z) +# 134 +{ +# 135 +short3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 136 +} +# 138 +static inline ushort3 make_ushort3(unsigned short x, unsigned short y, unsigned short z) +# 139 +{ +# 140 +ushort3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 141 +} +# 143 +static inline short4 make_short4(short x, short y, short z, short w) +# 144 +{ +# 145 +short4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 146 +} +# 148 +static inline ushort4 make_ushort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w) +# 149 +{ +# 150 +ushort4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 151 +} +# 153 +static inline int1 make_int1(int x) +# 154 +{ +# 155 +int1 t; (t.x) = x; return t; +# 156 +} +# 158 +static inline uint1 make_uint1(unsigned x) +# 159 +{ +# 160 +uint1 t; (t.x) = x; return t; +# 161 +} +# 163 +static inline int2 make_int2(int x, int y) +# 164 +{ +# 165 +int2 t; (t.x) = x; (t.y) = y; return t; +# 166 +} +# 168 +static inline uint2 make_uint2(unsigned x, unsigned y) +# 169 +{ +# 170 +uint2 t; (t.x) = x; (t.y) = y; return t; +# 171 +} +# 173 +static inline int3 make_int3(int x, int y, int z) +# 174 +{ +# 175 +int3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 176 +} +# 178 +static inline uint3 make_uint3(unsigned x, unsigned y, unsigned z) +# 179 +{ +# 180 +uint3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 181 +} +# 183 +static inline int4 make_int4(int x, int y, int z, int w) +# 184 +{ +# 185 +int4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 186 +} +# 188 +static inline uint4 make_uint4(unsigned x, unsigned y, unsigned z, unsigned w) +# 189 +{ +# 190 +uint4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 191 +} +# 193 +static inline long1 make_long1(long x) +# 194 +{ +# 195 +long1 t; (t.x) = x; return t; +# 196 +} +# 198 +static inline ulong1 make_ulong1(unsigned long x) +# 199 +{ +# 200 +ulong1 t; (t.x) = x; return t; +# 201 +} +# 203 +static inline long2 make_long2(long x, long y) +# 204 +{ +# 205 +long2 t; (t.x) = x; (t.y) = y; return t; +# 206 +} +# 208 +static inline ulong2 make_ulong2(unsigned long x, unsigned long y) +# 209 +{ +# 210 +ulong2 t; (t.x) = x; (t.y) = y; return t; +# 211 +} +# 213 +static inline long3 make_long3(long x, long y, long z) +# 214 +{ +# 215 +long3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 216 +} +# 218 +static inline ulong3 make_ulong3(unsigned long x, unsigned long y, unsigned long z) +# 219 +{ +# 220 +ulong3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 221 +} +# 223 +static inline long4 make_long4(long x, long y, long z, long w) +# 224 +{ +# 225 +long4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 226 +} +# 228 +static inline ulong4 make_ulong4(unsigned long x, unsigned long y, unsigned long z, unsigned long w) +# 229 +{ +# 230 +ulong4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 231 +} +# 233 +static inline float1 make_float1(float x) +# 234 +{ +# 235 +float1 t; (t.x) = x; return t; +# 236 +} +# 238 +static inline float2 make_float2(float x, float y) +# 239 +{ +# 240 +float2 t; (t.x) = x; (t.y) = y; return t; +# 241 +} +# 243 +static inline float3 make_float3(float x, float y, float z) +# 244 +{ +# 245 +float3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 246 +} +# 248 +static inline float4 make_float4(float x, float y, float z, float w) +# 249 +{ +# 250 +float4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 251 +} +# 253 +static inline longlong1 make_longlong1(long long x) +# 254 +{ +# 255 +longlong1 t; (t.x) = x; return t; +# 256 +} +# 258 +static inline ulonglong1 make_ulonglong1(unsigned long long x) +# 259 +{ +# 260 +ulonglong1 t; (t.x) = x; return t; +# 261 +} +# 263 +static inline longlong2 make_longlong2(long long x, long long y) +# 264 +{ +# 265 +longlong2 t; (t.x) = x; (t.y) = y; return t; +# 266 +} +# 268 +static inline ulonglong2 make_ulonglong2(unsigned long long x, unsigned long long y) +# 269 +{ +# 270 +ulonglong2 t; (t.x) = x; (t.y) = y; return t; +# 271 +} +# 273 +static inline longlong3 make_longlong3(long long x, long long y, long long z) +# 274 +{ +# 275 +longlong3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 276 +} +# 278 +static inline ulonglong3 make_ulonglong3(unsigned long long x, unsigned long long y, unsigned long long z) +# 279 +{ +# 280 +ulonglong3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 281 +} +# 283 +static inline longlong4 make_longlong4(long long x, long long y, long long z, long long w) +# 284 +{ +# 285 +longlong4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 286 +} +# 288 +static inline ulonglong4 make_ulonglong4(unsigned long long x, unsigned long long y, unsigned long long z, unsigned long long w) +# 289 +{ +# 290 +ulonglong4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 291 +} +# 293 +static inline double1 make_double1(double x) +# 294 +{ +# 295 +double1 t; (t.x) = x; return t; +# 296 +} +# 298 +static inline double2 make_double2(double x, double y) +# 299 +{ +# 300 +double2 t; (t.x) = x; (t.y) = y; return t; +# 301 +} +# 303 +static inline double3 make_double3(double x, double y, double z) +# 304 +{ +# 305 +double3 t; (t.x) = x; (t.y) = y; (t.z) = z; return t; +# 306 +} +# 308 +static inline double4 make_double4(double x, double y, double z, double w) +# 309 +{ +# 310 +double4 t; (t.x) = x; (t.y) = y; (t.z) = z; (t.w) = w; return t; +# 311 +} +# 28 "/usr/include/string.h" 3 +extern "C" { +# 43 "/usr/include/string.h" 3 +extern void *memcpy(void *__restrict__ __dest, const void *__restrict__ __src, size_t __n) noexcept(true) +# 44 + __attribute((__nonnull__(1, 2))); +# 47 +extern void *memmove(void * __dest, const void * __src, size_t __n) noexcept(true) +# 48 + __attribute((__nonnull__(1, 2))); +# 54 +extern void *memccpy(void *__restrict__ __dest, const void *__restrict__ __src, int __c, size_t __n) noexcept(true) +# 56 + __attribute((__nonnull__(1, 2))) __attribute((__access__(__write_only__ , 1 , 4 ))); +# 61 +extern void *memset(void * __s, int __c, size_t __n) noexcept(true) __attribute((__nonnull__(1))); +# 64 +extern int memcmp(const void * __s1, const void * __s2, size_t __n) noexcept(true) +# 65 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 80 "/usr/include/string.h" 3 +extern int __memcmpeq(const void * __s1, const void * __s2, size_t __n) noexcept(true) +# 81 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 85 +extern "C++" { +# 87 +extern void *memchr(void * __s, int __c, size_t __n) noexcept(true) __asm__("memchr") +# 88 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 89 +extern const void *memchr(const void * __s, int __c, size_t __n) noexcept(true) __asm__("memchr") +# 90 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 105 "/usr/include/string.h" 3 +} +# 115 "/usr/include/string.h" 3 +extern "C++" void *rawmemchr(void * __s, int __c) noexcept(true) __asm__("rawmemchr") +# 116 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 117 +extern "C++" const void *rawmemchr(const void * __s, int __c) noexcept(true) __asm__("rawmemchr") +# 118 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 126 +extern "C++" void *memrchr(void * __s, int __c, size_t __n) noexcept(true) __asm__("memrchr") +# 127 + __attribute((__pure__)) __attribute((__nonnull__(1))) +# 128 + __attribute((__access__(__read_only__ , 1 , 3 ))); +# 129 +extern "C++" const void *memrchr(const void * __s, int __c, size_t __n) noexcept(true) __asm__("memrchr") +# 130 + __attribute((__pure__)) __attribute((__nonnull__(1))) +# 131 + __attribute((__access__(__read_only__ , 1 , 3 ))); +# 141 "/usr/include/string.h" 3 +extern char *strcpy(char *__restrict__ __dest, const char *__restrict__ __src) noexcept(true) +# 142 + __attribute((__nonnull__(1, 2))); +# 144 +extern char *strncpy(char *__restrict__ __dest, const char *__restrict__ __src, size_t __n) noexcept(true) +# 146 + __attribute((__nonnull__(1, 2))); +# 149 +extern char *strcat(char *__restrict__ __dest, const char *__restrict__ __src) noexcept(true) +# 150 + __attribute((__nonnull__(1, 2))); +# 152 +extern char *strncat(char *__restrict__ __dest, const char *__restrict__ __src, size_t __n) noexcept(true) +# 153 + __attribute((__nonnull__(1, 2))); +# 156 +extern int strcmp(const char * __s1, const char * __s2) noexcept(true) +# 157 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 159 +extern int strncmp(const char * __s1, const char * __s2, size_t __n) noexcept(true) +# 160 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 163 +extern int strcoll(const char * __s1, const char * __s2) noexcept(true) +# 164 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 166 +extern size_t strxfrm(char *__restrict__ __dest, const char *__restrict__ __src, size_t __n) noexcept(true) +# 168 + __attribute((__nonnull__(2))) __attribute((__access__(__write_only__ , 1 , 3 ))); +# 175 +extern int strcoll_l(const char * __s1, const char * __s2, locale_t __l) noexcept(true) +# 176 + __attribute((__pure__)) __attribute((__nonnull__(1, 2, 3))); +# 179 +extern size_t strxfrm_l(char * __dest, const char * __src, size_t __n, locale_t __l) noexcept(true) +# 180 + __attribute((__nonnull__(2, 4))) +# 181 + __attribute((__access__(__write_only__ , 1 , 3 ))); +# 187 +extern char *strdup(const char * __s) noexcept(true) +# 188 + __attribute((__malloc__)) __attribute((__nonnull__(1))); +# 195 +extern char *strndup(const char * __string, size_t __n) noexcept(true) +# 196 + __attribute((__malloc__)) __attribute((__nonnull__(1))); +# 224 "/usr/include/string.h" 3 +extern "C++" { +# 226 +extern char *strchr(char * __s, int __c) noexcept(true) __asm__("strchr") +# 227 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 228 +extern const char *strchr(const char * __s, int __c) noexcept(true) __asm__("strchr") +# 229 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 244 "/usr/include/string.h" 3 +} +# 251 +extern "C++" { +# 253 +extern char *strrchr(char * __s, int __c) noexcept(true) __asm__("strrchr") +# 254 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 255 +extern const char *strrchr(const char * __s, int __c) noexcept(true) __asm__("strrchr") +# 256 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 271 "/usr/include/string.h" 3 +} +# 281 "/usr/include/string.h" 3 +extern "C++" char *strchrnul(char * __s, int __c) noexcept(true) __asm__("strchrnul") +# 282 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 283 +extern "C++" const char *strchrnul(const char * __s, int __c) noexcept(true) __asm__("strchrnul") +# 284 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 293 "/usr/include/string.h" 3 +extern size_t strcspn(const char * __s, const char * __reject) noexcept(true) +# 294 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 297 +extern size_t strspn(const char * __s, const char * __accept) noexcept(true) +# 298 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 301 +extern "C++" { +# 303 +extern char *strpbrk(char * __s, const char * __accept) noexcept(true) __asm__("strpbrk") +# 304 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 305 +extern const char *strpbrk(const char * __s, const char * __accept) noexcept(true) __asm__("strpbrk") +# 306 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 321 "/usr/include/string.h" 3 +} +# 328 +extern "C++" { +# 330 +extern char *strstr(char * __haystack, const char * __needle) noexcept(true) __asm__("strstr") +# 331 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 332 +extern const char *strstr(const char * __haystack, const char * __needle) noexcept(true) __asm__("strstr") +# 333 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 348 "/usr/include/string.h" 3 +} +# 356 +extern char *strtok(char *__restrict__ __s, const char *__restrict__ __delim) noexcept(true) +# 357 + __attribute((__nonnull__(2))); +# 361 +extern char *__strtok_r(char *__restrict__ __s, const char *__restrict__ __delim, char **__restrict__ __save_ptr) noexcept(true) +# 364 + __attribute((__nonnull__(2, 3))); +# 366 +extern char *strtok_r(char *__restrict__ __s, const char *__restrict__ __delim, char **__restrict__ __save_ptr) noexcept(true) +# 368 + __attribute((__nonnull__(2, 3))); +# 374 +extern "C++" char *strcasestr(char * __haystack, const char * __needle) noexcept(true) __asm__("strcasestr") +# 375 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 376 +extern "C++" const char *strcasestr(const char * __haystack, const char * __needle) noexcept(true) __asm__("strcasestr") +# 378 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 389 "/usr/include/string.h" 3 +extern void *memmem(const void * __haystack, size_t __haystacklen, const void * __needle, size_t __needlelen) noexcept(true) +# 391 + __attribute((__pure__)) __attribute((__nonnull__(1, 3))) +# 392 + __attribute((__access__(__read_only__ , 1 , 2 ))) +# 393 + __attribute((__access__(__read_only__ , 3 , 4 ))); +# 397 +extern void *__mempcpy(void *__restrict__ __dest, const void *__restrict__ __src, size_t __n) noexcept(true) +# 399 + __attribute((__nonnull__(1, 2))); +# 400 +extern void *mempcpy(void *__restrict__ __dest, const void *__restrict__ __src, size_t __n) noexcept(true) +# 402 + __attribute((__nonnull__(1, 2))); +# 407 +extern size_t strlen(const char * __s) noexcept(true) +# 408 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 413 +extern size_t strnlen(const char * __string, size_t __maxlen) noexcept(true) +# 414 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 419 +extern char *strerror(int __errnum) noexcept(true); +# 444 "/usr/include/string.h" 3 +extern char *strerror_r(int __errnum, char * __buf, size_t __buflen) noexcept(true) +# 445 + __attribute((__nonnull__(2))) __attribute((__access__(__write_only__ , 2 , 3 ))); +# 450 +extern const char *strerrordesc_np(int __err) noexcept(true); +# 452 +extern const char *strerrorname_np(int __err) noexcept(true); +# 458 +extern char *strerror_l(int __errnum, locale_t __l) noexcept(true); +# 30 "/usr/include/strings.h" 3 +extern "C" { +# 34 +extern int bcmp(const void * __s1, const void * __s2, size_t __n) noexcept(true) +# 35 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 38 +extern void bcopy(const void * __src, void * __dest, size_t __n) noexcept(true) +# 39 + __attribute((__nonnull__(1, 2))); +# 42 +extern void bzero(void * __s, size_t __n) noexcept(true) __attribute((__nonnull__(1))); +# 46 +extern "C++" { +# 48 +extern char *index(char * __s, int __c) noexcept(true) __asm__("index") +# 49 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 50 +extern const char *index(const char * __s, int __c) noexcept(true) __asm__("index") +# 51 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 66 "/usr/include/strings.h" 3 +} +# 74 +extern "C++" { +# 76 +extern char *rindex(char * __s, int __c) noexcept(true) __asm__("rindex") +# 77 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 78 +extern const char *rindex(const char * __s, int __c) noexcept(true) __asm__("rindex") +# 79 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 94 "/usr/include/strings.h" 3 +} +# 104 "/usr/include/strings.h" 3 +extern int ffs(int __i) noexcept(true) __attribute((const)); +# 110 +extern int ffsl(long __l) noexcept(true) __attribute((const)); +# 111 +__extension__ extern int ffsll(long long __ll) noexcept(true) +# 112 + __attribute((const)); +# 116 +extern int strcasecmp(const char * __s1, const char * __s2) noexcept(true) +# 117 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 120 +extern int strncasecmp(const char * __s1, const char * __s2, size_t __n) noexcept(true) +# 121 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 128 +extern int strcasecmp_l(const char * __s1, const char * __s2, locale_t __loc) noexcept(true) +# 129 + __attribute((__pure__)) __attribute((__nonnull__(1, 2, 3))); +# 133 +extern int strncasecmp_l(const char * __s1, const char * __s2, size_t __n, locale_t __loc) noexcept(true) +# 135 + __attribute((__pure__)) __attribute((__nonnull__(1, 2, 4))); +# 138 +} +# 466 "/usr/include/string.h" 3 +extern void explicit_bzero(void * __s, size_t __n) noexcept(true) __attribute((__nonnull__(1))) +# 467 + __attribute((__access__(__write_only__ , 1 , 2 ))); +# 471 +extern char *strsep(char **__restrict__ __stringp, const char *__restrict__ __delim) noexcept(true) +# 473 + __attribute((__nonnull__(1, 2))); +# 478 +extern char *strsignal(int __sig) noexcept(true); +# 482 +extern const char *sigabbrev_np(int __sig) noexcept(true); +# 485 +extern const char *sigdescr_np(int __sig) noexcept(true); +# 489 +extern char *__stpcpy(char *__restrict__ __dest, const char *__restrict__ __src) noexcept(true) +# 490 + __attribute((__nonnull__(1, 2))); +# 491 +extern char *stpcpy(char *__restrict__ __dest, const char *__restrict__ __src) noexcept(true) +# 492 + __attribute((__nonnull__(1, 2))); +# 496 +extern char *__stpncpy(char *__restrict__ __dest, const char *__restrict__ __src, size_t __n) noexcept(true) +# 498 + __attribute((__nonnull__(1, 2))); +# 499 +extern char *stpncpy(char *__restrict__ __dest, const char *__restrict__ __src, size_t __n) noexcept(true) +# 501 + __attribute((__nonnull__(1, 2))); +# 506 +extern size_t strlcpy(char *__restrict__ __dest, const char *__restrict__ __src, size_t __n) noexcept(true) +# 508 + __attribute((__nonnull__(1, 2))) __attribute((__access__(__write_only__ , 1 , 3 ))); +# 512 +extern size_t strlcat(char *__restrict__ __dest, const char *__restrict__ __src, size_t __n) noexcept(true) +# 514 + __attribute((__nonnull__(1, 2))) __attribute((__access__(__read_write__ , 1 , 3 ))); +# 519 +extern int strverscmp(const char * __s1, const char * __s2) noexcept(true) +# 520 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 523 +extern char *strfry(char * __string) noexcept(true) __attribute((__nonnull__(1))); +# 526 +extern void *memfrob(void * __s, size_t __n) noexcept(true) __attribute((__nonnull__(1))) +# 527 + __attribute((__access__(__read_write__ , 1 , 2 ))); +# 535 +extern "C++" char *basename(char * __filename) noexcept(true) __asm__("basename") +# 536 + __attribute((__nonnull__(1))); +# 537 +extern "C++" const char *basename(const char * __filename) noexcept(true) __asm__("basename") +# 538 + __attribute((__nonnull__(1))); +# 552 "/usr/include/string.h" 3 +} +# 26 "/usr/include/bits/timex.h" 3 +struct timex { +# 58 "/usr/include/bits/timex.h" 3 +unsigned modes; +# 59 +__syscall_slong_t offset; +# 60 +__syscall_slong_t freq; +# 61 +__syscall_slong_t maxerror; +# 62 +__syscall_slong_t esterror; +# 63 +int status; +# 64 +__syscall_slong_t constant; +# 65 +__syscall_slong_t precision; +# 66 +__syscall_slong_t tolerance; +# 67 +timeval time; +# 68 +__syscall_slong_t tick; +# 69 +__syscall_slong_t ppsfreq; +# 70 +__syscall_slong_t jitter; +# 71 +int shift; +# 72 +__syscall_slong_t stabil; +# 73 +__syscall_slong_t jitcnt; +# 74 +__syscall_slong_t calcnt; +# 75 +__syscall_slong_t errcnt; +# 76 +__syscall_slong_t stbcnt; +# 78 +int tai; +# 81 +int: 32; int: 32; int: 32; int: 32; +# 82 +int: 32; int: 32; int: 32; int: 32; +# 83 +int: 32; int: 32; int: 32; +# 85 +}; +# 75 "/usr/include/bits/time.h" 3 +extern "C" { +# 78 +extern int clock_adjtime(__clockid_t __clock_id, timex * __utx) noexcept(true) __attribute((__nonnull__(2))); +# 90 "/usr/include/bits/time.h" 3 +} +# 7 "/usr/include/bits/types/struct_tm.h" 3 +struct tm { +# 9 +int tm_sec; +# 10 +int tm_min; +# 11 +int tm_hour; +# 12 +int tm_mday; +# 13 +int tm_mon; +# 14 +int tm_year; +# 15 +int tm_wday; +# 16 +int tm_yday; +# 17 +int tm_isdst; +# 20 +long tm_gmtoff; +# 21 +const char *tm_zone; +# 26 +}; +# 8 "/usr/include/bits/types/struct_itimerspec.h" 3 +struct itimerspec { +# 10 +timespec it_interval; +# 11 +timespec it_value; +# 12 +}; +# 49 "/usr/include/time.h" 3 +struct sigevent; +# 68 "/usr/include/time.h" 3 +extern "C" { +# 72 +extern clock_t clock() noexcept(true); +# 76 +extern time_t time(time_t * __timer) noexcept(true); +# 79 +extern double difftime(time_t __time1, time_t __time0); +# 82 +extern time_t mktime(tm * __tp) noexcept(true); +# 99 "/usr/include/time.h" 3 +extern size_t strftime(char *__restrict__ __s, size_t __maxsize, const char *__restrict__ __format, const tm *__restrict__ __tp) noexcept(true) +# 102 + __attribute((__nonnull__(1, 3, 4))); +# 107 +extern char *strptime(const char *__restrict__ __s, const char *__restrict__ __fmt, tm * __tp) noexcept(true); +# 116 +extern size_t strftime_l(char *__restrict__ __s, size_t __maxsize, const char *__restrict__ __format, const tm *__restrict__ __tp, locale_t __loc) noexcept(true); +# 123 +extern char *strptime_l(const char *__restrict__ __s, const char *__restrict__ __fmt, tm * __tp, locale_t __loc) noexcept(true); +# 132 +extern tm *gmtime(const time_t * __timer) noexcept(true); +# 136 +extern tm *localtime(const time_t * __timer) noexcept(true); +# 154 "/usr/include/time.h" 3 +extern tm *gmtime_r(const time_t *__restrict__ __timer, tm *__restrict__ __tp) noexcept(true); +# 159 +extern tm *localtime_r(const time_t *__restrict__ __timer, tm *__restrict__ __tp) noexcept(true); +# 179 "/usr/include/time.h" 3 +extern char *asctime(const tm * __tp) noexcept(true); +# 183 +extern char *ctime(const time_t * __timer) noexcept(true); +# 197 "/usr/include/time.h" 3 +extern char *asctime_r(const tm *__restrict__ __tp, char *__restrict__ __buf) noexcept(true); +# 202 +extern char *ctime_r(const time_t *__restrict__ __timer, char *__restrict__ __buf) noexcept(true); +# 217 "/usr/include/time.h" 3 +extern char *__tzname[2]; +# 218 +extern int __daylight; +# 219 +extern long __timezone; +# 224 +extern char *tzname[2]; +# 228 +extern void tzset() noexcept(true); +# 232 +extern int daylight; +# 233 +extern long timezone; +# 246 "/usr/include/time.h" 3 +extern time_t timegm(tm * __tp) noexcept(true); +# 263 "/usr/include/time.h" 3 +extern time_t timelocal(tm * __tp) noexcept(true); +# 271 +extern int dysize(int __year) noexcept(true) __attribute((const)); +# 281 "/usr/include/time.h" 3 +extern int nanosleep(const timespec * __requested_time, timespec * __remaining); +# 285 +extern int clock_getres(clockid_t __clock_id, timespec * __res) noexcept(true); +# 288 +extern int clock_gettime(clockid_t __clock_id, timespec * __tp) noexcept(true) +# 289 + __attribute((__nonnull__(2))); +# 292 +extern int clock_settime(clockid_t __clock_id, const timespec * __tp) noexcept(true) +# 293 + __attribute((__nonnull__(2))); +# 323 "/usr/include/time.h" 3 +extern int clock_nanosleep(clockid_t __clock_id, int __flags, const timespec * __req, timespec * __rem); +# 338 "/usr/include/time.h" 3 +extern int clock_getcpuclockid(pid_t __pid, clockid_t * __clock_id) noexcept(true); +# 343 +extern int timer_create(clockid_t __clock_id, sigevent *__restrict__ __evp, timer_t *__restrict__ __timerid) noexcept(true); +# 348 +extern int timer_delete(timer_t __timerid) noexcept(true); +# 352 +extern int timer_settime(timer_t __timerid, int __flags, const itimerspec *__restrict__ __value, itimerspec *__restrict__ __ovalue) noexcept(true); +# 357 +extern int timer_gettime(timer_t __timerid, itimerspec * __value) noexcept(true); +# 376 "/usr/include/time.h" 3 +extern int timer_getoverrun(timer_t __timerid) noexcept(true); +# 383 +extern int timespec_get(timespec * __ts, int __base) noexcept(true) +# 384 + __attribute((__nonnull__(1))); +# 399 "/usr/include/time.h" 3 +extern int timespec_getres(timespec * __ts, int __base) noexcept(true); +# 425 "/usr/include/time.h" 3 +extern int getdate_err; +# 434 "/usr/include/time.h" 3 +extern tm *getdate(const char * __string); +# 448 "/usr/include/time.h" 3 +extern int getdate_r(const char *__restrict__ __string, tm *__restrict__ __resbufp); +# 452 +} +# 88 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern "C" { +# 91 +extern clock_t clock() noexcept(true); +# 96 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern void *memset(void *, int, size_t) noexcept(true); +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern void *memcpy(void *, const void *, size_t) noexcept(true); +# 99 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +} +# 126 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern "C" { +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int abs(int a) noexcept(true); +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern long labs(long a) noexcept(true); +# 255 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern long long llabs(long long a) noexcept(true); +# 283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double fabs(double x) noexcept(true); +# 306 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float fabsf(float x) noexcept(true); +# 317 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern inline int min(const int a, const int b); +# 324 +extern inline unsigned umin(const unsigned a, const unsigned b); +# 331 +extern inline long long llmin(const long long a, const long long b); +# 338 +extern inline unsigned long long ullmin(const unsigned long long a, const unsigned long long b); +# 359 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float fminf(float x, float y) noexcept(true); +# 379 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double fmin(double x, double y) noexcept(true); +# 392 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern inline int max(const int a, const int b); +# 400 +extern inline unsigned umax(const unsigned a, const unsigned b); +# 407 +extern inline long long llmax(const long long a, const long long b); +# 414 +extern inline unsigned long long ullmax(const unsigned long long a, const unsigned long long b); +# 435 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float fmaxf(float x, float y) noexcept(true); +# 455 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double fmax(double, double) noexcept(true); +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double sin(double x) noexcept(true); +# 495 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double cos(double x) noexcept(true); +# 511 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern void sincos(double x, double * sptr, double * cptr) noexcept(true); +# 524 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern void sincosf(float x, float * sptr, float * cptr) noexcept(true); +# 547 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double tan(double x) noexcept(true); +# 571 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double sqrt(double x) noexcept(true); +# 597 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double rsqrt(double x); +# 621 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float rsqrtf(float x); +# 648 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double log2(double x) noexcept(true); +# 677 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double exp2(double x) noexcept(true); +# 706 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float exp2f(float x) noexcept(true); +# 737 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double exp10(double x) noexcept(true); +# 764 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float exp10f(float x) noexcept(true); +# 798 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double expm1(double x) noexcept(true); +# 831 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float expm1f(float x) noexcept(true); +# 858 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float log2f(float x) noexcept(true); +# 883 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double log10(double x) noexcept(true); +# 909 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double log(double x) noexcept(true); +# 936 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double log1p(double x) noexcept(true); +# 966 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float log1pf(float x) noexcept(true); +# 992 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double floor(double x) noexcept(true); +# 1021 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double exp(double x) noexcept(true); +# 1040 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double cosh(double x) noexcept(true); +# 1060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double sinh(double x) noexcept(true); +# 1080 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double tanh(double x) noexcept(true); +# 1104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double acosh(double x) noexcept(true); +# 1131 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float acoshf(float x) noexcept(true); +# 1155 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double asinh(double x) noexcept(true); +# 1179 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float asinhf(float x) noexcept(true); +# 1204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double atanh(double x) noexcept(true); +# 1229 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float atanhf(float x) noexcept(true); +# 1247 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double ldexp(double x, int exp) noexcept(true); +# 1262 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float ldexpf(float x, int exp) noexcept(true); +# 1283 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double logb(double x) noexcept(true); +# 1307 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float logbf(float x) noexcept(true); +# 1331 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int ilogb(double x) noexcept(true); +# 1355 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int ilogbf(float x) noexcept(true); +# 1383 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double scalbn(double x, int n) noexcept(true); +# 1411 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float scalbnf(float x, int n) noexcept(true); +# 1439 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double scalbln(double x, long n) noexcept(true); +# 1467 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float scalblnf(float x, long n) noexcept(true); +# 1499 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double frexp(double x, int * nptr) noexcept(true); +# 1528 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float frexpf(float x, int * nptr) noexcept(true); +# 1551 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double round(double x) noexcept(true); +# 1577 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float roundf(float x) noexcept(true); +# 1595 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern long lround(double x) noexcept(true); +# 1613 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern long lroundf(float x) noexcept(true); +# 1631 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern long long llround(double x) noexcept(true); +# 1649 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern long long llroundf(float x) noexcept(true); +# 1719 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float rintf(float x) noexcept(true); +# 1736 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern long lrint(double x) noexcept(true); +# 1753 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern long lrintf(float x) noexcept(true); +# 1770 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern long long llrint(double x) noexcept(true); +# 1787 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern long long llrintf(float x) noexcept(true); +# 1811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double nearbyint(double x) noexcept(true); +# 1835 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float nearbyintf(float x) noexcept(true); +# 1859 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double ceil(double x) noexcept(true); +# 1882 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double trunc(double x) noexcept(true); +# 1908 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float truncf(float x) noexcept(true); +# 1930 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double fdim(double x, double y) noexcept(true); +# 1951 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float fdimf(float x, float y) noexcept(true); +# 2034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double atan2(double y, double x) noexcept(true); +# 2060 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double atan(double x) noexcept(true); +# 2077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double acos(double x) noexcept(true); +# 2099 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double asin(double x) noexcept(true); +# 2130 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double hypot(double x, double y) noexcept(true); +# 2187 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float hypotf(float x, float y) noexcept(true); +# 2459 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double cbrt(double x) noexcept(true); +# 2486 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float cbrtf(float x) noexcept(true); +# 2512 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double rcbrt(double x); +# 2533 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float rcbrtf(float x); +# 2556 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double sinpi(double x) noexcept(true); +# 2579 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float sinpif(float x) noexcept(true); +# 2601 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double cospi(double x) noexcept(true); +# 2623 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float cospif(float x) noexcept(true); +# 2636 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern void sincospi(double x, double * sptr, double * cptr); +# 2649 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern void sincospif(float x, float * sptr, float * cptr); +# 2735 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double pow(double x, double y) noexcept(true); +# 2759 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double modf(double x, double * iptr) noexcept(true); +# 2786 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double fmod(double x, double y) noexcept(true); +# 2816 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double remainder(double x, double y) noexcept(true); +# 2849 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float remainderf(float x, float y) noexcept(true); +# 2887 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double remquo(double x, double y, int * quo) noexcept(true); +# 2925 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float remquof(float x, float y, int * quo) noexcept(true); +# 2946 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double j0(double x) noexcept(true); +# 2968 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float j0f(float x) noexcept(true); +# 2995 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double j1(double x) noexcept(true); +# 3022 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float j1f(float x) noexcept(true); +# 3045 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double jn(int n, double x) noexcept(true); +# 3068 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float jnf(int n, float x) noexcept(true); +# 3095 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double y0(double x) noexcept(true); +# 3122 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float y0f(float x) noexcept(true); +# 3149 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double y1(double x) noexcept(true); +# 3176 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float y1f(float x) noexcept(true); +# 3204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double yn(int n, double x) noexcept(true); +# 3232 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float ynf(int n, float x) noexcept(true); +# 3328 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double erf(double x) noexcept(true); +# 3353 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float erff(float x) noexcept(true); +# 3383 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double erfinv(double x); +# 3406 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float erfinvf(float x); +# 3430 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double erfc(double x) noexcept(true); +# 3453 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float erfcf(float x) noexcept(true); +# 3485 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double lgamma(double x) noexcept(true); +# 3513 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double erfcinv(double x); +# 3534 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float erfcinvf(float x); +# 3556 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double normcdfinv(double x); +# 3578 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float normcdfinvf(float x); +# 3597 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double normcdf(double x); +# 3616 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float normcdff(float x); +# 3636 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double erfcx(double x); +# 3656 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float erfcxf(float x); +# 3689 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float lgammaf(float x) noexcept(true); +# 3718 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double tgamma(double x) noexcept(true); +# 3747 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float tgammaf(float x) noexcept(true); +# 3761 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double copysign(double x, double y) noexcept(true); +# 3775 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float copysignf(float x, float y) noexcept(true); +# 3794 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double nextafter(double x, double y) noexcept(true); +# 3813 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float nextafterf(float x, float y) noexcept(true); +# 3829 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double nan(const char * tagp) noexcept(true); +# 3845 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float nanf(const char * tagp) noexcept(true); +# 3852 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __isinff(float) noexcept(true); +# 3853 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __isnanf(float) noexcept(true); +# 3863 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __finite(double) noexcept(true); +# 3864 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __finitef(float) noexcept(true); +# 3865 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __signbit(double) noexcept(true); +# 3866 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __isnan(double) noexcept(true); +# 3867 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __isinf(double) noexcept(true); +# 3870 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __signbitf(float) noexcept(true); +# 3921 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern double fma(double x, double y, double z) noexcept(true); +# 3971 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float fmaf(float x, float y, float z) noexcept(true); +# 3982 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __signbitl(long double) noexcept(true); +# 3988 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __finitel(long double) noexcept(true); +# 3989 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __isinfl(long double) noexcept(true); +# 3990 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern int __isnanl(long double) noexcept(true); +# 4034 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float acosf(float x) noexcept(true); +# 4056 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float asinf(float x) noexcept(true); +# 4083 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float atanf(float x) noexcept(true); +# 4163 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float atan2f(float y, float x) noexcept(true); +# 4182 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float cosf(float x) noexcept(true); +# 4202 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float sinf(float x) noexcept(true); +# 4222 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float tanf(float x) noexcept(true); +# 4241 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float coshf(float x) noexcept(true); +# 4261 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float sinhf(float x) noexcept(true); +# 4281 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float tanhf(float x) noexcept(true); +# 4304 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float logf(float x) noexcept(true); +# 4334 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float expf(float x) noexcept(true); +# 4357 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float log10f(float x) noexcept(true); +# 4380 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float modff(float x, float * iptr) noexcept(true); +# 4463 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float powf(float x, float y) noexcept(true); +# 4487 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float sqrtf(float x) noexcept(true); +# 4510 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float ceilf(float x) noexcept(true); +# 4533 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float floorf(float x) noexcept(true); +# 4559 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern float fmodf(float x, float y) noexcept(true); +# 4574 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +} +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +extern "C++" { +# 70 +namespace std __attribute((__visibility__("default"))) { +# 74 +struct __true_type { }; +# 75 +struct __false_type { }; +# 77 +template< bool > +# 78 +struct __truth_type { +# 79 +typedef __false_type __type; }; +# 82 +template<> struct __truth_type< true> { +# 83 +typedef __true_type __type; }; +# 87 +template< class _Sp, class _Tp> +# 88 +struct __traitor { +# 90 +enum { __value = ((bool)_Sp::__value) || ((bool)_Tp::__value)}; +# 91 +typedef typename __truth_type< __value> ::__type __type; +# 92 +}; +# 95 +template< class , class > +# 96 +struct __are_same { +# 98 +enum { __value}; +# 99 +typedef __false_type __type; +# 100 +}; +# 102 +template< class _Tp> +# 103 +struct __are_same< _Tp, _Tp> { +# 105 +enum { __value = 1}; +# 106 +typedef __true_type __type; +# 107 +}; +# 110 +template< class _Tp> +# 111 +struct __is_void { +# 113 +enum { __value}; +# 114 +typedef __false_type __type; +# 115 +}; +# 118 +template<> struct __is_void< void> { +# 120 +enum { __value = 1}; +# 121 +typedef __true_type __type; +# 122 +}; +# 127 +template< class _Tp> +# 128 +struct __is_integer { +# 130 +enum { __value}; +# 131 +typedef __false_type __type; +# 132 +}; +# 139 +template<> struct __is_integer< bool> { +# 141 +enum { __value = 1}; +# 142 +typedef __true_type __type; +# 143 +}; +# 146 +template<> struct __is_integer< char> { +# 148 +enum { __value = 1}; +# 149 +typedef __true_type __type; +# 150 +}; +# 153 +template<> struct __is_integer< signed char> { +# 155 +enum { __value = 1}; +# 156 +typedef __true_type __type; +# 157 +}; +# 160 +template<> struct __is_integer< unsigned char> { +# 162 +enum { __value = 1}; +# 163 +typedef __true_type __type; +# 164 +}; +# 168 +template<> struct __is_integer< wchar_t> { +# 170 +enum { __value = 1}; +# 171 +typedef __true_type __type; +# 172 +}; +# 186 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +template<> struct __is_integer< char16_t> { +# 188 +enum { __value = 1}; +# 189 +typedef __true_type __type; +# 190 +}; +# 193 +template<> struct __is_integer< char32_t> { +# 195 +enum { __value = 1}; +# 196 +typedef __true_type __type; +# 197 +}; +# 201 +template<> struct __is_integer< short> { +# 203 +enum { __value = 1}; +# 204 +typedef __true_type __type; +# 205 +}; +# 208 +template<> struct __is_integer< unsigned short> { +# 210 +enum { __value = 1}; +# 211 +typedef __true_type __type; +# 212 +}; +# 215 +template<> struct __is_integer< int> { +# 217 +enum { __value = 1}; +# 218 +typedef __true_type __type; +# 219 +}; +# 222 +template<> struct __is_integer< unsigned> { +# 224 +enum { __value = 1}; +# 225 +typedef __true_type __type; +# 226 +}; +# 229 +template<> struct __is_integer< long> { +# 231 +enum { __value = 1}; +# 232 +typedef __true_type __type; +# 233 +}; +# 236 +template<> struct __is_integer< unsigned long> { +# 238 +enum { __value = 1}; +# 239 +typedef __true_type __type; +# 240 +}; +# 243 +template<> struct __is_integer< long long> { +# 245 +enum { __value = 1}; +# 246 +typedef __true_type __type; +# 247 +}; +# 250 +template<> struct __is_integer< unsigned long long> { +# 252 +enum { __value = 1}; +# 253 +typedef __true_type __type; +# 254 +}; +# 273 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +template<> struct __is_integer< __int128> { enum { __value = 1}; typedef __true_type __type; }; template<> struct __is_integer< unsigned __int128> { enum { __value = 1}; typedef __true_type __type; }; +# 290 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +template< class _Tp> +# 291 +struct __is_floating { +# 293 +enum { __value}; +# 294 +typedef __false_type __type; +# 295 +}; +# 299 +template<> struct __is_floating< float> { +# 301 +enum { __value = 1}; +# 302 +typedef __true_type __type; +# 303 +}; +# 306 +template<> struct __is_floating< double> { +# 308 +enum { __value = 1}; +# 309 +typedef __true_type __type; +# 310 +}; +# 313 +template<> struct __is_floating< long double> { +# 315 +enum { __value = 1}; +# 316 +typedef __true_type __type; +# 317 +}; +# 367 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +template< class _Tp> +# 368 +struct __is_pointer { +# 370 +enum { __value}; +# 371 +typedef __false_type __type; +# 372 +}; +# 374 +template< class _Tp> +# 375 +struct __is_pointer< _Tp *> { +# 377 +enum { __value = 1}; +# 378 +typedef __true_type __type; +# 379 +}; +# 384 +template< class _Tp> +# 385 +struct __is_arithmetic : public __traitor< __is_integer< _Tp> , __is_floating< _Tp> > { +# 387 +}; +# 392 +template< class _Tp> +# 393 +struct __is_scalar : public __traitor< __is_arithmetic< _Tp> , __is_pointer< _Tp> > { +# 395 +}; +# 400 +template< class _Tp> +# 401 +struct __is_char { +# 403 +enum { __value}; +# 404 +typedef __false_type __type; +# 405 +}; +# 408 +template<> struct __is_char< char> { +# 410 +enum { __value = 1}; +# 411 +typedef __true_type __type; +# 412 +}; +# 416 +template<> struct __is_char< wchar_t> { +# 418 +enum { __value = 1}; +# 419 +typedef __true_type __type; +# 420 +}; +# 423 +template< class _Tp> +# 424 +struct __is_byte { +# 426 +enum { __value}; +# 427 +typedef __false_type __type; +# 428 +}; +# 431 +template<> struct __is_byte< char> { +# 433 +enum { __value = 1}; +# 434 +typedef __true_type __type; +# 435 +}; +# 438 +template<> struct __is_byte< signed char> { +# 440 +enum { __value = 1}; +# 441 +typedef __true_type __type; +# 442 +}; +# 445 +template<> struct __is_byte< unsigned char> { +# 447 +enum { __value = 1}; +# 448 +typedef __true_type __type; +# 449 +}; +# 452 +enum class byte: unsigned char; +# 455 +template<> struct __is_byte< byte> { +# 457 +enum { __value = 1}; +# 458 +typedef __true_type __type; +# 459 +}; +# 471 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +template< class > struct iterator_traits; +# 474 +template< class _Tp> +# 475 +struct __is_nonvolatile_trivially_copyable { +# 477 +enum { __value = __is_trivially_copyable(_Tp)}; +# 478 +}; +# 483 +template< class _Tp> +# 484 +struct __is_nonvolatile_trivially_copyable< volatile _Tp> { +# 486 +enum { __value}; +# 487 +}; +# 490 +template< class _OutputIter, class _InputIter> +# 491 +struct __memcpyable { +# 493 +enum { __value}; +# 494 +}; +# 496 +template< class _Tp> +# 497 +struct __memcpyable< _Tp *, _Tp *> : public __is_nonvolatile_trivially_copyable< _Tp> { +# 499 +}; +# 501 +template< class _Tp> +# 502 +struct __memcpyable< _Tp *, const _Tp *> : public __is_nonvolatile_trivially_copyable< _Tp> { +# 504 +}; +# 511 +template< class _Iter1, class _Iter2> +# 512 +struct __memcmpable { +# 514 +enum { __value}; +# 515 +}; +# 518 +template< class _Tp> +# 519 +struct __memcmpable< _Tp *, _Tp *> : public __is_nonvolatile_trivially_copyable< _Tp> { +# 521 +}; +# 523 +template< class _Tp> +# 524 +struct __memcmpable< const _Tp *, _Tp *> : public __is_nonvolatile_trivially_copyable< _Tp> { +# 526 +}; +# 528 +template< class _Tp> +# 529 +struct __memcmpable< _Tp *, const _Tp *> : public __is_nonvolatile_trivially_copyable< _Tp> { +# 531 +}; +# 539 +template< class _Tp, bool _TreatAsBytes = __is_byte< _Tp> ::__value> +# 546 +struct __is_memcmp_ordered { +# 548 +static const bool __value = (((_Tp)(-1)) > ((_Tp)1)); +# 549 +}; +# 551 +template< class _Tp> +# 552 +struct __is_memcmp_ordered< _Tp, false> { +# 554 +static const bool __value = false; +# 555 +}; +# 558 +template< class _Tp, class _Up, bool = sizeof(_Tp) == sizeof(_Up)> +# 559 +struct __is_memcmp_ordered_with { +# 561 +static const bool __value = (__is_memcmp_ordered< _Tp> ::__value && __is_memcmp_ordered< _Up> ::__value); +# 563 +}; +# 565 +template< class _Tp, class _Up> +# 566 +struct __is_memcmp_ordered_with< _Tp, _Up, false> { +# 568 +static const bool __value = false; +# 569 +}; +# 581 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/cpp_type_traits.h" 3 +template<> struct __is_memcmp_ordered_with< byte, byte, true> { +# 582 +static constexpr inline bool __value = true; }; +# 584 +template< class _Tp, bool _SameSize> +# 585 +struct __is_memcmp_ordered_with< _Tp, byte, _SameSize> { +# 586 +static constexpr inline bool __value = false; }; +# 588 +template< class _Up, bool _SameSize> +# 589 +struct __is_memcmp_ordered_with< byte, _Up, _SameSize> { +# 590 +static constexpr inline bool __value = false; }; +# 596 +template< class _Tp> +# 597 +struct __is_move_iterator { +# 599 +enum { __value}; +# 600 +typedef __false_type __type; +# 601 +}; +# 605 +template< class _Iterator> inline _Iterator +# 608 +__miter_base(_Iterator __it) +# 609 +{ return __it; } +# 612 +} +# 613 +} +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 +extern "C++" { +# 39 +namespace __gnu_cxx __attribute((__visibility__("default"))) { +# 44 +template< bool , class > +# 45 +struct __enable_if { +# 46 +}; +# 48 +template< class _Tp> +# 49 +struct __enable_if< true, _Tp> { +# 50 +typedef _Tp __type; }; +# 54 +template< bool _Cond, class _Iftrue, class _Iffalse> +# 55 +struct __conditional_type { +# 56 +typedef _Iftrue __type; }; +# 58 +template< class _Iftrue, class _Iffalse> +# 59 +struct __conditional_type< false, _Iftrue, _Iffalse> { +# 60 +typedef _Iffalse __type; }; +# 64 +template< class _Tp> +# 65 +struct __add_unsigned { +# 68 +private: typedef __enable_if< std::__is_integer< _Tp> ::__value, _Tp> __if_type; +# 71 +public: typedef typename __enable_if< std::__is_integer< _Tp> ::__value, _Tp> ::__type __type; +# 72 +}; +# 75 +template<> struct __add_unsigned< char> { +# 76 +typedef unsigned char __type; }; +# 79 +template<> struct __add_unsigned< signed char> { +# 80 +typedef unsigned char __type; }; +# 83 +template<> struct __add_unsigned< short> { +# 84 +typedef unsigned short __type; }; +# 87 +template<> struct __add_unsigned< int> { +# 88 +typedef unsigned __type; }; +# 91 +template<> struct __add_unsigned< long> { +# 92 +typedef unsigned long __type; }; +# 95 +template<> struct __add_unsigned< long long> { +# 96 +typedef unsigned long long __type; }; +# 100 +template<> struct __add_unsigned< bool> ; +# 103 +template<> struct __add_unsigned< wchar_t> ; +# 107 +template< class _Tp> +# 108 +struct __remove_unsigned { +# 111 +private: typedef __enable_if< std::__is_integer< _Tp> ::__value, _Tp> __if_type; +# 114 +public: typedef typename __enable_if< std::__is_integer< _Tp> ::__value, _Tp> ::__type __type; +# 115 +}; +# 118 +template<> struct __remove_unsigned< char> { +# 119 +typedef signed char __type; }; +# 122 +template<> struct __remove_unsigned< unsigned char> { +# 123 +typedef signed char __type; }; +# 126 +template<> struct __remove_unsigned< unsigned short> { +# 127 +typedef short __type; }; +# 130 +template<> struct __remove_unsigned< unsigned> { +# 131 +typedef int __type; }; +# 134 +template<> struct __remove_unsigned< unsigned long> { +# 135 +typedef long __type; }; +# 138 +template<> struct __remove_unsigned< unsigned long long> { +# 139 +typedef long long __type; }; +# 143 +template<> struct __remove_unsigned< bool> ; +# 146 +template<> struct __remove_unsigned< wchar_t> ; +# 150 +template< class _Type> constexpr bool +# 153 +__is_null_pointer(_Type *__ptr) +# 154 +{ return __ptr == 0; } +# 156 +template< class _Type> constexpr bool +# 159 +__is_null_pointer(_Type) +# 160 +{ return false; } +# 164 +constexpr bool __is_null_pointer(std::nullptr_t) +# 165 +{ return true; } +# 170 +template< class _Tp, bool = std::template __is_integer< _Tp> ::__value> +# 171 +struct __promote { +# 172 +typedef double __type; }; +# 177 +template< class _Tp> +# 178 +struct __promote< _Tp, false> { +# 179 +}; +# 182 +template<> struct __promote< long double> { +# 183 +typedef long double __type; }; +# 186 +template<> struct __promote< double> { +# 187 +typedef double __type; }; +# 190 +template<> struct __promote< float> { +# 191 +typedef float __type; }; +# 225 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 +template< class ..._Tp> using __promoted_t = __decltype(((((typename __promote< _Tp> ::__type)0) + ... ))); +# 230 +template< class _Tp, class _Up> using __promote_2 = __promote< __promoted_t< _Tp, _Up> > ; +# 233 +template< class _Tp, class _Up, class _Vp> using __promote_3 = __promote< __promoted_t< _Tp, _Up, _Vp> > ; +# 236 +template< class _Tp, class _Up, class _Vp, class _Wp> using __promote_4 = __promote< __promoted_t< _Tp, _Up, _Vp, _Wp> > ; +# 270 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/type_traits.h" 3 +} +# 271 +} +# 34 "/usr/include/math.h" 3 +extern "C" { +# 167 "/usr/include/math.h" 3 +typedef float float_t; +# 168 +typedef double double_t; +# 256 "/usr/include/math.h" 3 +enum { +# 257 +FP_INT_UPWARD, +# 260 +FP_INT_DOWNWARD, +# 263 +FP_INT_TOWARDZERO, +# 266 +FP_INT_TONEARESTFROMZERO, +# 269 +FP_INT_TONEAREST +# 272 +}; +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 +extern int __fpclassify(double __value) noexcept(true) +# 21 + __attribute((const)); +# 24 +extern int __signbit(double __value) noexcept(true) +# 25 + __attribute((const)); +# 29 +extern int __isinf(double __value) noexcept(true) +# 30 + __attribute((const)); +# 33 +extern int __finite(double __value) noexcept(true) +# 34 + __attribute((const)); +# 37 +extern int __isnan(double __value) noexcept(true) +# 38 + __attribute((const)); +# 41 +extern int __iseqsig(double __x, double __y) noexcept(true); +# 44 +extern int __issignaling(double __value) noexcept(true) +# 45 + __attribute((const)); +# 53 "/usr/include/bits/mathcalls.h" 3 +extern double acos(double __x) noexcept(true); extern double __acos(double __x) noexcept(true); +# 55 +extern double asin(double __x) noexcept(true); extern double __asin(double __x) noexcept(true); +# 57 +extern double atan(double __x) noexcept(true); extern double __atan(double __x) noexcept(true); +# 59 +extern double atan2(double __y, double __x) noexcept(true); extern double __atan2(double __y, double __x) noexcept(true); +# 62 +extern double cos(double __x) noexcept(true); extern double __cos(double __x) noexcept(true); +# 64 +extern double sin(double __x) noexcept(true); extern double __sin(double __x) noexcept(true); +# 66 +extern double tan(double __x) noexcept(true); extern double __tan(double __x) noexcept(true); +# 70 +extern double acospi(double __x) noexcept(true); extern double __acospi(double __x) noexcept(true); +# 72 +extern double asinpi(double __x) noexcept(true); extern double __asinpi(double __x) noexcept(true); +# 74 +extern double atanpi(double __x) noexcept(true); extern double __atanpi(double __x) noexcept(true); +# 76 +extern double atan2pi(double __y, double __x) noexcept(true); extern double __atan2pi(double __y, double __x) noexcept(true); +# 79 +extern double cospi(double __x) noexcept(true); extern double __cospi(double __x) noexcept(true); +# 81 +extern double sinpi(double __x) noexcept(true); extern double __sinpi(double __x) noexcept(true); +# 83 +extern double tanpi(double __x) noexcept(true); extern double __tanpi(double __x) noexcept(true); +# 89 +extern double cosh(double __x) noexcept(true); extern double __cosh(double __x) noexcept(true); +# 91 +extern double sinh(double __x) noexcept(true); extern double __sinh(double __x) noexcept(true); +# 93 +extern double tanh(double __x) noexcept(true); extern double __tanh(double __x) noexcept(true); +# 97 +extern void sincos(double __x, double * __sinx, double * __cosx) noexcept(true); extern void __sincos(double __x, double * __sinx, double * __cosx) noexcept(true); +# 103 +extern double acosh(double __x) noexcept(true); extern double __acosh(double __x) noexcept(true); +# 105 +extern double asinh(double __x) noexcept(true); extern double __asinh(double __x) noexcept(true); +# 107 +extern double atanh(double __x) noexcept(true); extern double __atanh(double __x) noexcept(true); +# 113 +extern double exp(double __x) noexcept(true); extern double __exp(double __x) noexcept(true); +# 116 +extern double frexp(double __x, int * __exponent) noexcept(true); extern double __frexp(double __x, int * __exponent) noexcept(true); +# 119 +extern double ldexp(double __x, int __exponent) noexcept(true); extern double __ldexp(double __x, int __exponent) noexcept(true); +# 122 +extern double log(double __x) noexcept(true); extern double __log(double __x) noexcept(true); +# 125 +extern double log10(double __x) noexcept(true); extern double __log10(double __x) noexcept(true); +# 128 +extern double modf(double __x, double * __iptr) noexcept(true); extern double __modf(double __x, double * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 132 +extern double exp10(double __x) noexcept(true); extern double __exp10(double __x) noexcept(true); +# 135 +extern double exp2m1(double __x) noexcept(true); extern double __exp2m1(double __x) noexcept(true); +# 138 +extern double exp10m1(double __x) noexcept(true); extern double __exp10m1(double __x) noexcept(true); +# 141 +extern double log2p1(double __x) noexcept(true); extern double __log2p1(double __x) noexcept(true); +# 144 +extern double log10p1(double __x) noexcept(true); extern double __log10p1(double __x) noexcept(true); +# 147 +extern double logp1(double __x) noexcept(true); extern double __logp1(double __x) noexcept(true); +# 152 +extern double expm1(double __x) noexcept(true); extern double __expm1(double __x) noexcept(true); +# 155 +extern double log1p(double __x) noexcept(true); extern double __log1p(double __x) noexcept(true); +# 158 +extern double logb(double __x) noexcept(true); extern double __logb(double __x) noexcept(true); +# 163 +extern double exp2(double __x) noexcept(true); extern double __exp2(double __x) noexcept(true); +# 166 +extern double log2(double __x) noexcept(true); extern double __log2(double __x) noexcept(true); +# 173 +extern double pow(double __x, double __y) noexcept(true); extern double __pow(double __x, double __y) noexcept(true); +# 176 +extern double sqrt(double __x) noexcept(true); extern double __sqrt(double __x) noexcept(true); +# 180 +extern double hypot(double __x, double __y) noexcept(true); extern double __hypot(double __x, double __y) noexcept(true); +# 185 +extern double cbrt(double __x) noexcept(true); extern double __cbrt(double __x) noexcept(true); +# 192 +extern double ceil(double __x) noexcept(true) __attribute((const)); +# 195 +extern double fabs(double __x) noexcept(true) __attribute((const)); +# 198 +extern double floor(double __x) noexcept(true) __attribute((const)); +# 201 +extern double fmod(double __x, double __y) noexcept(true); extern double __fmod(double __x, double __y) noexcept(true); +# 216 "/usr/include/bits/mathcalls.h" 3 +extern int finite(double __value) noexcept(true) +# 217 + __attribute((const)); +# 220 +extern double drem(double __x, double __y) noexcept(true); extern double __drem(double __x, double __y) noexcept(true); +# 224 +extern double significand(double __x) noexcept(true); extern double __significand(double __x) noexcept(true); +# 231 +extern double copysign(double __x, double __y) noexcept(true) __attribute((const)); +# 236 +extern double nan(const char * __tagb) noexcept(true); extern double __nan(const char * __tagb) noexcept(true); +# 253 "/usr/include/bits/mathcalls.h" 3 +extern double j0(double) noexcept(true); extern double __j0(double) noexcept(true); +# 254 +extern double j1(double) noexcept(true); extern double __j1(double) noexcept(true); +# 255 +extern double jn(int, double) noexcept(true); extern double __jn(int, double) noexcept(true); +# 256 +extern double y0(double) noexcept(true); extern double __y0(double) noexcept(true); +# 257 +extern double y1(double) noexcept(true); extern double __y1(double) noexcept(true); +# 258 +extern double yn(int, double) noexcept(true); extern double __yn(int, double) noexcept(true); +# 264 +extern double erf(double) noexcept(true); extern double __erf(double) noexcept(true); +# 265 +extern double erfc(double) noexcept(true); extern double __erfc(double) noexcept(true); +# 266 +extern double lgamma(double) noexcept(true); extern double __lgamma(double) noexcept(true); +# 271 +extern double tgamma(double) noexcept(true); extern double __tgamma(double) noexcept(true); +# 277 +extern double gamma(double) noexcept(true); extern double __gamma(double) noexcept(true); +# 285 +extern double lgamma_r(double, int * __signgamp) noexcept(true); extern double __lgamma_r(double, int * __signgamp) noexcept(true); +# 292 +extern double rint(double __x) noexcept(true); extern double __rint(double __x) noexcept(true); +# 295 +extern double nextafter(double __x, double __y) noexcept(true); extern double __nextafter(double __x, double __y) noexcept(true); +# 297 +extern double nexttoward(double __x, long double __y) noexcept(true); extern double __nexttoward(double __x, long double __y) noexcept(true); +# 302 +extern double nextdown(double __x) noexcept(true); extern double __nextdown(double __x) noexcept(true); +# 304 +extern double nextup(double __x) noexcept(true); extern double __nextup(double __x) noexcept(true); +# 308 +extern double remainder(double __x, double __y) noexcept(true); extern double __remainder(double __x, double __y) noexcept(true); +# 312 +extern double scalbn(double __x, int __n) noexcept(true); extern double __scalbn(double __x, int __n) noexcept(true); +# 316 +extern int ilogb(double __x) noexcept(true); extern int __ilogb(double __x) noexcept(true); +# 321 +extern long llogb(double __x) noexcept(true); extern long __llogb(double __x) noexcept(true); +# 326 +extern double scalbln(double __x, long __n) noexcept(true); extern double __scalbln(double __x, long __n) noexcept(true); +# 330 +extern double nearbyint(double __x) noexcept(true); extern double __nearbyint(double __x) noexcept(true); +# 334 +extern double round(double __x) noexcept(true) __attribute((const)); +# 338 +extern double trunc(double __x) noexcept(true) __attribute((const)); +# 343 +extern double remquo(double __x, double __y, int * __quo) noexcept(true); extern double __remquo(double __x, double __y, int * __quo) noexcept(true); +# 350 +extern long lrint(double __x) noexcept(true); extern long __lrint(double __x) noexcept(true); +# 352 +__extension__ extern long long llrint(double __x) noexcept(true); extern long long __llrint(double __x) noexcept(true); +# 356 +extern long lround(double __x) noexcept(true); extern long __lround(double __x) noexcept(true); +# 358 +__extension__ extern long long llround(double __x) noexcept(true); extern long long __llround(double __x) noexcept(true); +# 362 +extern double fdim(double __x, double __y) noexcept(true); extern double __fdim(double __x, double __y) noexcept(true); +# 366 +extern double fmax(double __x, double __y) noexcept(true) __attribute((const)); +# 369 +extern double fmin(double __x, double __y) noexcept(true) __attribute((const)); +# 373 +extern double fma(double __x, double __y, double __z) noexcept(true); extern double __fma(double __x, double __y, double __z) noexcept(true); +# 378 +extern double roundeven(double __x) noexcept(true) __attribute((const)); +# 382 +extern __intmax_t fromfp(double __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfp(double __x, int __round, unsigned __width) noexcept(true); +# 387 +extern __uintmax_t ufromfp(double __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfp(double __x, int __round, unsigned __width) noexcept(true); +# 393 +extern __intmax_t fromfpx(double __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpx(double __x, int __round, unsigned __width) noexcept(true); +# 399 +extern __uintmax_t ufromfpx(double __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpx(double __x, int __round, unsigned __width) noexcept(true); +# 403 +extern int canonicalize(double * __cx, const double * __x) noexcept(true); +# 410 +extern double fmaxmag(double __x, double __y) noexcept(true) __attribute((const)); +# 413 +extern double fminmag(double __x, double __y) noexcept(true) __attribute((const)); +# 418 +extern double fmaximum(double __x, double __y) noexcept(true) __attribute((const)); +# 421 +extern double fminimum(double __x, double __y) noexcept(true) __attribute((const)); +# 424 +extern double fmaximum_num(double __x, double __y) noexcept(true) __attribute((const)); +# 427 +extern double fminimum_num(double __x, double __y) noexcept(true) __attribute((const)); +# 430 +extern double fmaximum_mag(double __x, double __y) noexcept(true) __attribute((const)); +# 433 +extern double fminimum_mag(double __x, double __y) noexcept(true) __attribute((const)); +# 436 +extern double fmaximum_mag_num(double __x, double __y) noexcept(true) __attribute((const)); +# 439 +extern double fminimum_mag_num(double __x, double __y) noexcept(true) __attribute((const)); +# 444 +extern int totalorder(const double * __x, const double * __y) noexcept(true) +# 446 + __attribute((__pure__)); +# 449 +extern int totalordermag(const double * __x, const double * __y) noexcept(true) +# 451 + __attribute((__pure__)); +# 454 +extern double getpayload(const double * __x) noexcept(true); extern double __getpayload(const double * __x) noexcept(true); +# 457 +extern int setpayload(double * __x, double __payload) noexcept(true); +# 460 +extern int setpayloadsig(double * __x, double __payload) noexcept(true); +# 468 +extern double scalb(double __x, double __n) noexcept(true); extern double __scalb(double __x, double __n) noexcept(true); +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 +extern int __fpclassifyf(float __value) noexcept(true) +# 21 + __attribute((const)); +# 24 +extern int __signbitf(float __value) noexcept(true) +# 25 + __attribute((const)); +# 29 +extern int __isinff(float __value) noexcept(true) +# 30 + __attribute((const)); +# 33 +extern int __finitef(float __value) noexcept(true) +# 34 + __attribute((const)); +# 37 +extern int __isnanf(float __value) noexcept(true) +# 38 + __attribute((const)); +# 41 +extern int __iseqsigf(float __x, float __y) noexcept(true); +# 44 +extern int __issignalingf(float __value) noexcept(true) +# 45 + __attribute((const)); +# 53 "/usr/include/bits/mathcalls.h" 3 +extern float acosf(float __x) noexcept(true); extern float __acosf(float __x) noexcept(true); +# 55 +extern float asinf(float __x) noexcept(true); extern float __asinf(float __x) noexcept(true); +# 57 +extern float atanf(float __x) noexcept(true); extern float __atanf(float __x) noexcept(true); +# 59 +extern float atan2f(float __y, float __x) noexcept(true); extern float __atan2f(float __y, float __x) noexcept(true); +# 62 +extern float cosf(float __x) noexcept(true); +# 64 +extern float sinf(float __x) noexcept(true); +# 66 +extern float tanf(float __x) noexcept(true); +# 70 +extern float acospif(float __x) noexcept(true); extern float __acospif(float __x) noexcept(true); +# 72 +extern float asinpif(float __x) noexcept(true); extern float __asinpif(float __x) noexcept(true); +# 74 +extern float atanpif(float __x) noexcept(true); extern float __atanpif(float __x) noexcept(true); +# 76 +extern float atan2pif(float __y, float __x) noexcept(true); extern float __atan2pif(float __y, float __x) noexcept(true); +# 79 +extern float cospif(float __x) noexcept(true); extern float __cospif(float __x) noexcept(true); +# 81 +extern float sinpif(float __x) noexcept(true); extern float __sinpif(float __x) noexcept(true); +# 83 +extern float tanpif(float __x) noexcept(true); extern float __tanpif(float __x) noexcept(true); +# 89 +extern float coshf(float __x) noexcept(true); extern float __coshf(float __x) noexcept(true); +# 91 +extern float sinhf(float __x) noexcept(true); extern float __sinhf(float __x) noexcept(true); +# 93 +extern float tanhf(float __x) noexcept(true); +# 97 +extern void sincosf(float __x, float * __sinx, float * __cosx) noexcept(true); +# 103 +extern float acoshf(float __x) noexcept(true); extern float __acoshf(float __x) noexcept(true); +# 105 +extern float asinhf(float __x) noexcept(true); extern float __asinhf(float __x) noexcept(true); +# 107 +extern float atanhf(float __x) noexcept(true); extern float __atanhf(float __x) noexcept(true); +# 113 +extern float expf(float __x) noexcept(true); +# 116 +extern float frexpf(float __x, int * __exponent) noexcept(true); extern float __frexpf(float __x, int * __exponent) noexcept(true); +# 119 +extern float ldexpf(float __x, int __exponent) noexcept(true); extern float __ldexpf(float __x, int __exponent) noexcept(true); +# 122 +extern float logf(float __x) noexcept(true); +# 125 +extern float log10f(float __x) noexcept(true); +# 128 +extern float modff(float __x, float * __iptr) noexcept(true); extern float __modff(float __x, float * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 132 +extern float exp10f(float __x) noexcept(true); +# 135 +extern float exp2m1f(float __x) noexcept(true); extern float __exp2m1f(float __x) noexcept(true); +# 138 +extern float exp10m1f(float __x) noexcept(true); extern float __exp10m1f(float __x) noexcept(true); +# 141 +extern float log2p1f(float __x) noexcept(true); extern float __log2p1f(float __x) noexcept(true); +# 144 +extern float log10p1f(float __x) noexcept(true); extern float __log10p1f(float __x) noexcept(true); +# 147 +extern float logp1f(float __x) noexcept(true); extern float __logp1f(float __x) noexcept(true); +# 152 +extern float expm1f(float __x) noexcept(true); extern float __expm1f(float __x) noexcept(true); +# 155 +extern float log1pf(float __x) noexcept(true); extern float __log1pf(float __x) noexcept(true); +# 158 +extern float logbf(float __x) noexcept(true); extern float __logbf(float __x) noexcept(true); +# 163 +extern float exp2f(float __x) noexcept(true); extern float __exp2f(float __x) noexcept(true); +# 166 +extern float log2f(float __x) noexcept(true); +# 173 +extern float powf(float __x, float __y) noexcept(true); +# 176 +extern float sqrtf(float __x) noexcept(true); extern float __sqrtf(float __x) noexcept(true); +# 180 +extern float hypotf(float __x, float __y) noexcept(true); extern float __hypotf(float __x, float __y) noexcept(true); +# 185 +extern float cbrtf(float __x) noexcept(true); extern float __cbrtf(float __x) noexcept(true); +# 192 +extern float ceilf(float __x) noexcept(true) __attribute((const)); +# 195 +extern float fabsf(float __x) noexcept(true) __attribute((const)); +# 198 +extern float floorf(float __x) noexcept(true) __attribute((const)); +# 201 +extern float fmodf(float __x, float __y) noexcept(true); extern float __fmodf(float __x, float __y) noexcept(true); +# 210 "/usr/include/bits/mathcalls.h" 3 +extern int isinff(float __value) noexcept(true) +# 211 + __attribute((const)); +# 216 +extern int finitef(float __value) noexcept(true) +# 217 + __attribute((const)); +# 220 +extern float dremf(float __x, float __y) noexcept(true); extern float __dremf(float __x, float __y) noexcept(true); +# 224 +extern float significandf(float __x) noexcept(true); extern float __significandf(float __x) noexcept(true); +# 231 +extern float copysignf(float __x, float __y) noexcept(true) __attribute((const)); +# 236 +extern float nanf(const char * __tagb) noexcept(true); extern float __nanf(const char * __tagb) noexcept(true); +# 246 "/usr/include/bits/mathcalls.h" 3 +extern int isnanf(float __value) noexcept(true) +# 247 + __attribute((const)); +# 253 +extern float j0f(float) noexcept(true); extern float __j0f(float) noexcept(true); +# 254 +extern float j1f(float) noexcept(true); extern float __j1f(float) noexcept(true); +# 255 +extern float jnf(int, float) noexcept(true); extern float __jnf(int, float) noexcept(true); +# 256 +extern float y0f(float) noexcept(true); extern float __y0f(float) noexcept(true); +# 257 +extern float y1f(float) noexcept(true); extern float __y1f(float) noexcept(true); +# 258 +extern float ynf(int, float) noexcept(true); extern float __ynf(int, float) noexcept(true); +# 264 +extern float erff(float) noexcept(true); extern float __erff(float) noexcept(true); +# 265 +extern float erfcf(float) noexcept(true); extern float __erfcf(float) noexcept(true); +# 266 +extern float lgammaf(float) noexcept(true); extern float __lgammaf(float) noexcept(true); +# 271 +extern float tgammaf(float) noexcept(true); extern float __tgammaf(float) noexcept(true); +# 277 +extern float gammaf(float) noexcept(true); extern float __gammaf(float) noexcept(true); +# 285 +extern float lgammaf_r(float, int * __signgamp) noexcept(true); extern float __lgammaf_r(float, int * __signgamp) noexcept(true); +# 292 +extern float rintf(float __x) noexcept(true); extern float __rintf(float __x) noexcept(true); +# 295 +extern float nextafterf(float __x, float __y) noexcept(true); extern float __nextafterf(float __x, float __y) noexcept(true); +# 297 +extern float nexttowardf(float __x, long double __y) noexcept(true); extern float __nexttowardf(float __x, long double __y) noexcept(true); +# 302 +extern float nextdownf(float __x) noexcept(true); extern float __nextdownf(float __x) noexcept(true); +# 304 +extern float nextupf(float __x) noexcept(true); extern float __nextupf(float __x) noexcept(true); +# 308 +extern float remainderf(float __x, float __y) noexcept(true); extern float __remainderf(float __x, float __y) noexcept(true); +# 312 +extern float scalbnf(float __x, int __n) noexcept(true); extern float __scalbnf(float __x, int __n) noexcept(true); +# 316 +extern int ilogbf(float __x) noexcept(true); extern int __ilogbf(float __x) noexcept(true); +# 321 +extern long llogbf(float __x) noexcept(true); extern long __llogbf(float __x) noexcept(true); +# 326 +extern float scalblnf(float __x, long __n) noexcept(true); extern float __scalblnf(float __x, long __n) noexcept(true); +# 330 +extern float nearbyintf(float __x) noexcept(true); extern float __nearbyintf(float __x) noexcept(true); +# 334 +extern float roundf(float __x) noexcept(true) __attribute((const)); +# 338 +extern float truncf(float __x) noexcept(true) __attribute((const)); +# 343 +extern float remquof(float __x, float __y, int * __quo) noexcept(true); extern float __remquof(float __x, float __y, int * __quo) noexcept(true); +# 350 +extern long lrintf(float __x) noexcept(true); extern long __lrintf(float __x) noexcept(true); +# 352 +__extension__ extern long long llrintf(float __x) noexcept(true); extern long long __llrintf(float __x) noexcept(true); +# 356 +extern long lroundf(float __x) noexcept(true); extern long __lroundf(float __x) noexcept(true); +# 358 +__extension__ extern long long llroundf(float __x) noexcept(true); extern long long __llroundf(float __x) noexcept(true); +# 362 +extern float fdimf(float __x, float __y) noexcept(true); extern float __fdimf(float __x, float __y) noexcept(true); +# 366 +extern float fmaxf(float __x, float __y) noexcept(true) __attribute((const)); +# 369 +extern float fminf(float __x, float __y) noexcept(true) __attribute((const)); +# 373 +extern float fmaf(float __x, float __y, float __z) noexcept(true); extern float __fmaf(float __x, float __y, float __z) noexcept(true); +# 378 +extern float roundevenf(float __x) noexcept(true) __attribute((const)); +# 382 +extern __intmax_t fromfpf(float __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpf(float __x, int __round, unsigned __width) noexcept(true); +# 387 +extern __uintmax_t ufromfpf(float __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpf(float __x, int __round, unsigned __width) noexcept(true); +# 393 +extern __intmax_t fromfpxf(float __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpxf(float __x, int __round, unsigned __width) noexcept(true); +# 399 +extern __uintmax_t ufromfpxf(float __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpxf(float __x, int __round, unsigned __width) noexcept(true); +# 403 +extern int canonicalizef(float * __cx, const float * __x) noexcept(true); +# 410 +extern float fmaxmagf(float __x, float __y) noexcept(true) __attribute((const)); +# 413 +extern float fminmagf(float __x, float __y) noexcept(true) __attribute((const)); +# 418 +extern float fmaximumf(float __x, float __y) noexcept(true) __attribute((const)); +# 421 +extern float fminimumf(float __x, float __y) noexcept(true) __attribute((const)); +# 424 +extern float fmaximum_numf(float __x, float __y) noexcept(true) __attribute((const)); +# 427 +extern float fminimum_numf(float __x, float __y) noexcept(true) __attribute((const)); +# 430 +extern float fmaximum_magf(float __x, float __y) noexcept(true) __attribute((const)); +# 433 +extern float fminimum_magf(float __x, float __y) noexcept(true) __attribute((const)); +# 436 +extern float fmaximum_mag_numf(float __x, float __y) noexcept(true) __attribute((const)); +# 439 +extern float fminimum_mag_numf(float __x, float __y) noexcept(true) __attribute((const)); +# 444 +extern int totalorderf(const float * __x, const float * __y) noexcept(true) +# 446 + __attribute((__pure__)); +# 449 +extern int totalordermagf(const float * __x, const float * __y) noexcept(true) +# 451 + __attribute((__pure__)); +# 454 +extern float getpayloadf(const float * __x) noexcept(true); extern float __getpayloadf(const float * __x) noexcept(true); +# 457 +extern int setpayloadf(float * __x, float __payload) noexcept(true); +# 460 +extern int setpayloadsigf(float * __x, float __payload) noexcept(true); +# 468 +extern float scalbf(float __x, float __n) noexcept(true); extern float __scalbf(float __x, float __n) noexcept(true); +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 +extern int __fpclassifyl(long double __value) noexcept(true) +# 21 + __attribute((const)); +# 24 +extern int __signbitl(long double __value) noexcept(true) +# 25 + __attribute((const)); +# 29 +extern int __isinfl(long double __value) noexcept(true) +# 30 + __attribute((const)); +# 33 +extern int __finitel(long double __value) noexcept(true) +# 34 + __attribute((const)); +# 37 +extern int __isnanl(long double __value) noexcept(true) +# 38 + __attribute((const)); +# 41 +extern int __iseqsigl(long double __x, long double __y) noexcept(true); +# 44 +extern int __issignalingl(long double __value) noexcept(true) +# 45 + __attribute((const)); +# 53 "/usr/include/bits/mathcalls.h" 3 +extern long double acosl(long double __x) noexcept(true); extern long double __acosl(long double __x) noexcept(true); +# 55 +extern long double asinl(long double __x) noexcept(true); extern long double __asinl(long double __x) noexcept(true); +# 57 +extern long double atanl(long double __x) noexcept(true); extern long double __atanl(long double __x) noexcept(true); +# 59 +extern long double atan2l(long double __y, long double __x) noexcept(true); extern long double __atan2l(long double __y, long double __x) noexcept(true); +# 62 +extern long double cosl(long double __x) noexcept(true); extern long double __cosl(long double __x) noexcept(true); +# 64 +extern long double sinl(long double __x) noexcept(true); extern long double __sinl(long double __x) noexcept(true); +# 66 +extern long double tanl(long double __x) noexcept(true); extern long double __tanl(long double __x) noexcept(true); +# 70 +extern long double acospil(long double __x) noexcept(true); extern long double __acospil(long double __x) noexcept(true); +# 72 +extern long double asinpil(long double __x) noexcept(true); extern long double __asinpil(long double __x) noexcept(true); +# 74 +extern long double atanpil(long double __x) noexcept(true); extern long double __atanpil(long double __x) noexcept(true); +# 76 +extern long double atan2pil(long double __y, long double __x) noexcept(true); extern long double __atan2pil(long double __y, long double __x) noexcept(true); +# 79 +extern long double cospil(long double __x) noexcept(true); extern long double __cospil(long double __x) noexcept(true); +# 81 +extern long double sinpil(long double __x) noexcept(true); extern long double __sinpil(long double __x) noexcept(true); +# 83 +extern long double tanpil(long double __x) noexcept(true); extern long double __tanpil(long double __x) noexcept(true); +# 89 +extern long double coshl(long double __x) noexcept(true); extern long double __coshl(long double __x) noexcept(true); +# 91 +extern long double sinhl(long double __x) noexcept(true); extern long double __sinhl(long double __x) noexcept(true); +# 93 +extern long double tanhl(long double __x) noexcept(true); extern long double __tanhl(long double __x) noexcept(true); +# 97 +extern void sincosl(long double __x, long double * __sinx, long double * __cosx) noexcept(true); extern void __sincosl(long double __x, long double * __sinx, long double * __cosx) noexcept(true); +# 103 +extern long double acoshl(long double __x) noexcept(true); extern long double __acoshl(long double __x) noexcept(true); +# 105 +extern long double asinhl(long double __x) noexcept(true); extern long double __asinhl(long double __x) noexcept(true); +# 107 +extern long double atanhl(long double __x) noexcept(true); extern long double __atanhl(long double __x) noexcept(true); +# 113 +extern long double expl(long double __x) noexcept(true); extern long double __expl(long double __x) noexcept(true); +# 116 +extern long double frexpl(long double __x, int * __exponent) noexcept(true); extern long double __frexpl(long double __x, int * __exponent) noexcept(true); +# 119 +extern long double ldexpl(long double __x, int __exponent) noexcept(true); extern long double __ldexpl(long double __x, int __exponent) noexcept(true); +# 122 +extern long double logl(long double __x) noexcept(true); extern long double __logl(long double __x) noexcept(true); +# 125 +extern long double log10l(long double __x) noexcept(true); extern long double __log10l(long double __x) noexcept(true); +# 128 +extern long double modfl(long double __x, long double * __iptr) noexcept(true); extern long double __modfl(long double __x, long double * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 132 +extern long double exp10l(long double __x) noexcept(true); extern long double __exp10l(long double __x) noexcept(true); +# 135 +extern long double exp2m1l(long double __x) noexcept(true); extern long double __exp2m1l(long double __x) noexcept(true); +# 138 +extern long double exp10m1l(long double __x) noexcept(true); extern long double __exp10m1l(long double __x) noexcept(true); +# 141 +extern long double log2p1l(long double __x) noexcept(true); extern long double __log2p1l(long double __x) noexcept(true); +# 144 +extern long double log10p1l(long double __x) noexcept(true); extern long double __log10p1l(long double __x) noexcept(true); +# 147 +extern long double logp1l(long double __x) noexcept(true); extern long double __logp1l(long double __x) noexcept(true); +# 152 +extern long double expm1l(long double __x) noexcept(true); extern long double __expm1l(long double __x) noexcept(true); +# 155 +extern long double log1pl(long double __x) noexcept(true); extern long double __log1pl(long double __x) noexcept(true); +# 158 +extern long double logbl(long double __x) noexcept(true); extern long double __logbl(long double __x) noexcept(true); +# 163 +extern long double exp2l(long double __x) noexcept(true); extern long double __exp2l(long double __x) noexcept(true); +# 166 +extern long double log2l(long double __x) noexcept(true); extern long double __log2l(long double __x) noexcept(true); +# 173 +extern long double powl(long double __x, long double __y) noexcept(true); extern long double __powl(long double __x, long double __y) noexcept(true); +# 176 +extern long double sqrtl(long double __x) noexcept(true); extern long double __sqrtl(long double __x) noexcept(true); +# 180 +extern long double hypotl(long double __x, long double __y) noexcept(true); extern long double __hypotl(long double __x, long double __y) noexcept(true); +# 185 +extern long double cbrtl(long double __x) noexcept(true); extern long double __cbrtl(long double __x) noexcept(true); +# 192 +extern long double ceill(long double __x) noexcept(true) __attribute((const)); +# 195 +extern long double fabsl(long double __x) noexcept(true) __attribute((const)); +# 198 +extern long double floorl(long double __x) noexcept(true) __attribute((const)); +# 201 +extern long double fmodl(long double __x, long double __y) noexcept(true); extern long double __fmodl(long double __x, long double __y) noexcept(true); +# 210 "/usr/include/bits/mathcalls.h" 3 +extern int isinfl(long double __value) noexcept(true) +# 211 + __attribute((const)); +# 216 +extern int finitel(long double __value) noexcept(true) +# 217 + __attribute((const)); +# 220 +extern long double dreml(long double __x, long double __y) noexcept(true); extern long double __dreml(long double __x, long double __y) noexcept(true); +# 224 +extern long double significandl(long double __x) noexcept(true); extern long double __significandl(long double __x) noexcept(true); +# 231 +extern long double copysignl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 236 +extern long double nanl(const char * __tagb) noexcept(true); extern long double __nanl(const char * __tagb) noexcept(true); +# 246 "/usr/include/bits/mathcalls.h" 3 +extern int isnanl(long double __value) noexcept(true) +# 247 + __attribute((const)); +# 253 +extern long double j0l(long double) noexcept(true); extern long double __j0l(long double) noexcept(true); +# 254 +extern long double j1l(long double) noexcept(true); extern long double __j1l(long double) noexcept(true); +# 255 +extern long double jnl(int, long double) noexcept(true); extern long double __jnl(int, long double) noexcept(true); +# 256 +extern long double y0l(long double) noexcept(true); extern long double __y0l(long double) noexcept(true); +# 257 +extern long double y1l(long double) noexcept(true); extern long double __y1l(long double) noexcept(true); +# 258 +extern long double ynl(int, long double) noexcept(true); extern long double __ynl(int, long double) noexcept(true); +# 264 +extern long double erfl(long double) noexcept(true); extern long double __erfl(long double) noexcept(true); +# 265 +extern long double erfcl(long double) noexcept(true); extern long double __erfcl(long double) noexcept(true); +# 266 +extern long double lgammal(long double) noexcept(true); extern long double __lgammal(long double) noexcept(true); +# 271 +extern long double tgammal(long double) noexcept(true); extern long double __tgammal(long double) noexcept(true); +# 277 +extern long double gammal(long double) noexcept(true); extern long double __gammal(long double) noexcept(true); +# 285 +extern long double lgammal_r(long double, int * __signgamp) noexcept(true); extern long double __lgammal_r(long double, int * __signgamp) noexcept(true); +# 292 +extern long double rintl(long double __x) noexcept(true); extern long double __rintl(long double __x) noexcept(true); +# 295 +extern long double nextafterl(long double __x, long double __y) noexcept(true); extern long double __nextafterl(long double __x, long double __y) noexcept(true); +# 297 +extern long double nexttowardl(long double __x, long double __y) noexcept(true); extern long double __nexttowardl(long double __x, long double __y) noexcept(true); +# 302 +extern long double nextdownl(long double __x) noexcept(true); extern long double __nextdownl(long double __x) noexcept(true); +# 304 +extern long double nextupl(long double __x) noexcept(true); extern long double __nextupl(long double __x) noexcept(true); +# 308 +extern long double remainderl(long double __x, long double __y) noexcept(true); extern long double __remainderl(long double __x, long double __y) noexcept(true); +# 312 +extern long double scalbnl(long double __x, int __n) noexcept(true); extern long double __scalbnl(long double __x, int __n) noexcept(true); +# 316 +extern int ilogbl(long double __x) noexcept(true); extern int __ilogbl(long double __x) noexcept(true); +# 321 +extern long llogbl(long double __x) noexcept(true); extern long __llogbl(long double __x) noexcept(true); +# 326 +extern long double scalblnl(long double __x, long __n) noexcept(true); extern long double __scalblnl(long double __x, long __n) noexcept(true); +# 330 +extern long double nearbyintl(long double __x) noexcept(true); extern long double __nearbyintl(long double __x) noexcept(true); +# 334 +extern long double roundl(long double __x) noexcept(true) __attribute((const)); +# 338 +extern long double truncl(long double __x) noexcept(true) __attribute((const)); +# 343 +extern long double remquol(long double __x, long double __y, int * __quo) noexcept(true); extern long double __remquol(long double __x, long double __y, int * __quo) noexcept(true); +# 350 +extern long lrintl(long double __x) noexcept(true); extern long __lrintl(long double __x) noexcept(true); +# 352 +__extension__ extern long long llrintl(long double __x) noexcept(true); extern long long __llrintl(long double __x) noexcept(true); +# 356 +extern long lroundl(long double __x) noexcept(true); extern long __lroundl(long double __x) noexcept(true); +# 358 +__extension__ extern long long llroundl(long double __x) noexcept(true); extern long long __llroundl(long double __x) noexcept(true); +# 362 +extern long double fdiml(long double __x, long double __y) noexcept(true); extern long double __fdiml(long double __x, long double __y) noexcept(true); +# 366 +extern long double fmaxl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 369 +extern long double fminl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 373 +extern long double fmal(long double __x, long double __y, long double __z) noexcept(true); extern long double __fmal(long double __x, long double __y, long double __z) noexcept(true); +# 378 +extern long double roundevenl(long double __x) noexcept(true) __attribute((const)); +# 382 +extern __intmax_t fromfpl(long double __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpl(long double __x, int __round, unsigned __width) noexcept(true); +# 387 +extern __uintmax_t ufromfpl(long double __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpl(long double __x, int __round, unsigned __width) noexcept(true); +# 393 +extern __intmax_t fromfpxl(long double __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpxl(long double __x, int __round, unsigned __width) noexcept(true); +# 399 +extern __uintmax_t ufromfpxl(long double __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpxl(long double __x, int __round, unsigned __width) noexcept(true); +# 403 +extern int canonicalizel(long double * __cx, const long double * __x) noexcept(true); +# 410 +extern long double fmaxmagl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 413 +extern long double fminmagl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 418 +extern long double fmaximuml(long double __x, long double __y) noexcept(true) __attribute((const)); +# 421 +extern long double fminimuml(long double __x, long double __y) noexcept(true) __attribute((const)); +# 424 +extern long double fmaximum_numl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 427 +extern long double fminimum_numl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 430 +extern long double fmaximum_magl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 433 +extern long double fminimum_magl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 436 +extern long double fmaximum_mag_numl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 439 +extern long double fminimum_mag_numl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 444 +extern int totalorderl(const long double * __x, const long double * __y) noexcept(true) +# 446 + __attribute((__pure__)); +# 449 +extern int totalordermagl(const long double * __x, const long double * __y) noexcept(true) +# 451 + __attribute((__pure__)); +# 454 +extern long double getpayloadl(const long double * __x) noexcept(true); extern long double __getpayloadl(const long double * __x) noexcept(true); +# 457 +extern int setpayloadl(long double * __x, long double __payload) noexcept(true); +# 460 +extern int setpayloadsigl(long double * __x, long double __payload) noexcept(true); +# 468 +extern long double scalbl(long double __x, long double __n) noexcept(true); extern long double __scalbl(long double __x, long double __n) noexcept(true); +# 53 "/usr/include/bits/mathcalls.h" 3 +extern _Float32 acosf32(_Float32 __x) noexcept(true); extern _Float32 __acosf32(_Float32 __x) noexcept(true); +# 55 +extern _Float32 asinf32(_Float32 __x) noexcept(true); extern _Float32 __asinf32(_Float32 __x) noexcept(true); +# 57 +extern _Float32 atanf32(_Float32 __x) noexcept(true); extern _Float32 __atanf32(_Float32 __x) noexcept(true); +# 59 +extern _Float32 atan2f32(_Float32 __y, _Float32 __x) noexcept(true); extern _Float32 __atan2f32(_Float32 __y, _Float32 __x) noexcept(true); +# 62 +extern _Float32 cosf32(_Float32 __x) noexcept(true); extern _Float32 __cosf32(_Float32 __x) noexcept(true); +# 64 +extern _Float32 sinf32(_Float32 __x) noexcept(true); extern _Float32 __sinf32(_Float32 __x) noexcept(true); +# 66 +extern _Float32 tanf32(_Float32 __x) noexcept(true); extern _Float32 __tanf32(_Float32 __x) noexcept(true); +# 70 +extern _Float32 acospif32(_Float32 __x) noexcept(true); extern _Float32 __acospif32(_Float32 __x) noexcept(true); +# 72 +extern _Float32 asinpif32(_Float32 __x) noexcept(true); extern _Float32 __asinpif32(_Float32 __x) noexcept(true); +# 74 +extern _Float32 atanpif32(_Float32 __x) noexcept(true); extern _Float32 __atanpif32(_Float32 __x) noexcept(true); +# 76 +extern _Float32 atan2pif32(_Float32 __y, _Float32 __x) noexcept(true); extern _Float32 __atan2pif32(_Float32 __y, _Float32 __x) noexcept(true); +# 79 +extern _Float32 cospif32(_Float32 __x) noexcept(true); extern _Float32 __cospif32(_Float32 __x) noexcept(true); +# 81 +extern _Float32 sinpif32(_Float32 __x) noexcept(true); extern _Float32 __sinpif32(_Float32 __x) noexcept(true); +# 83 +extern _Float32 tanpif32(_Float32 __x) noexcept(true); extern _Float32 __tanpif32(_Float32 __x) noexcept(true); +# 89 +extern _Float32 coshf32(_Float32 __x) noexcept(true); extern _Float32 __coshf32(_Float32 __x) noexcept(true); +# 91 +extern _Float32 sinhf32(_Float32 __x) noexcept(true); extern _Float32 __sinhf32(_Float32 __x) noexcept(true); +# 93 +extern _Float32 tanhf32(_Float32 __x) noexcept(true); extern _Float32 __tanhf32(_Float32 __x) noexcept(true); +# 97 +extern void sincosf32(_Float32 __x, _Float32 * __sinx, _Float32 * __cosx) noexcept(true); extern void __sincosf32(_Float32 __x, _Float32 * __sinx, _Float32 * __cosx) noexcept(true); +# 103 +extern _Float32 acoshf32(_Float32 __x) noexcept(true); extern _Float32 __acoshf32(_Float32 __x) noexcept(true); +# 105 +extern _Float32 asinhf32(_Float32 __x) noexcept(true); extern _Float32 __asinhf32(_Float32 __x) noexcept(true); +# 107 +extern _Float32 atanhf32(_Float32 __x) noexcept(true); extern _Float32 __atanhf32(_Float32 __x) noexcept(true); +# 113 +extern _Float32 expf32(_Float32 __x) noexcept(true); extern _Float32 __expf32(_Float32 __x) noexcept(true); +# 116 +extern _Float32 frexpf32(_Float32 __x, int * __exponent) noexcept(true); extern _Float32 __frexpf32(_Float32 __x, int * __exponent) noexcept(true); +# 119 +extern _Float32 ldexpf32(_Float32 __x, int __exponent) noexcept(true); extern _Float32 __ldexpf32(_Float32 __x, int __exponent) noexcept(true); +# 122 +extern _Float32 logf32(_Float32 __x) noexcept(true); extern _Float32 __logf32(_Float32 __x) noexcept(true); +# 125 +extern _Float32 log10f32(_Float32 __x) noexcept(true); extern _Float32 __log10f32(_Float32 __x) noexcept(true); +# 128 +extern _Float32 modff32(_Float32 __x, _Float32 * __iptr) noexcept(true); extern _Float32 __modff32(_Float32 __x, _Float32 * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 132 +extern _Float32 exp10f32(_Float32 __x) noexcept(true); extern _Float32 __exp10f32(_Float32 __x) noexcept(true); +# 135 +extern _Float32 exp2m1f32(_Float32 __x) noexcept(true); extern _Float32 __exp2m1f32(_Float32 __x) noexcept(true); +# 138 +extern _Float32 exp10m1f32(_Float32 __x) noexcept(true); extern _Float32 __exp10m1f32(_Float32 __x) noexcept(true); +# 141 +extern _Float32 log2p1f32(_Float32 __x) noexcept(true); extern _Float32 __log2p1f32(_Float32 __x) noexcept(true); +# 144 +extern _Float32 log10p1f32(_Float32 __x) noexcept(true); extern _Float32 __log10p1f32(_Float32 __x) noexcept(true); +# 147 +extern _Float32 logp1f32(_Float32 __x) noexcept(true); extern _Float32 __logp1f32(_Float32 __x) noexcept(true); +# 152 +extern _Float32 expm1f32(_Float32 __x) noexcept(true); extern _Float32 __expm1f32(_Float32 __x) noexcept(true); +# 155 +extern _Float32 log1pf32(_Float32 __x) noexcept(true); extern _Float32 __log1pf32(_Float32 __x) noexcept(true); +# 158 +extern _Float32 logbf32(_Float32 __x) noexcept(true); extern _Float32 __logbf32(_Float32 __x) noexcept(true); +# 163 +extern _Float32 exp2f32(_Float32 __x) noexcept(true); extern _Float32 __exp2f32(_Float32 __x) noexcept(true); +# 166 +extern _Float32 log2f32(_Float32 __x) noexcept(true); extern _Float32 __log2f32(_Float32 __x) noexcept(true); +# 173 +extern _Float32 powf32(_Float32 __x, _Float32 __y) noexcept(true); extern _Float32 __powf32(_Float32 __x, _Float32 __y) noexcept(true); +# 176 +extern _Float32 sqrtf32(_Float32 __x) noexcept(true); extern _Float32 __sqrtf32(_Float32 __x) noexcept(true); +# 180 +extern _Float32 hypotf32(_Float32 __x, _Float32 __y) noexcept(true); extern _Float32 __hypotf32(_Float32 __x, _Float32 __y) noexcept(true); +# 185 +extern _Float32 cbrtf32(_Float32 __x) noexcept(true); extern _Float32 __cbrtf32(_Float32 __x) noexcept(true); +# 192 +extern _Float32 ceilf32(_Float32 __x) noexcept(true) __attribute((const)); +# 195 +extern _Float32 fabsf32(_Float32 __x) noexcept(true) __attribute((const)); +# 198 +extern _Float32 floorf32(_Float32 __x) noexcept(true) __attribute((const)); +# 201 +extern _Float32 fmodf32(_Float32 __x, _Float32 __y) noexcept(true); extern _Float32 __fmodf32(_Float32 __x, _Float32 __y) noexcept(true); +# 231 "/usr/include/bits/mathcalls.h" 3 +extern _Float32 copysignf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 236 +extern _Float32 nanf32(const char * __tagb) noexcept(true); extern _Float32 __nanf32(const char * __tagb) noexcept(true); +# 253 "/usr/include/bits/mathcalls.h" 3 +extern _Float32 j0f32(_Float32) noexcept(true); extern _Float32 __j0f32(_Float32) noexcept(true); +# 254 +extern _Float32 j1f32(_Float32) noexcept(true); extern _Float32 __j1f32(_Float32) noexcept(true); +# 255 +extern _Float32 jnf32(int, _Float32) noexcept(true); extern _Float32 __jnf32(int, _Float32) noexcept(true); +# 256 +extern _Float32 y0f32(_Float32) noexcept(true); extern _Float32 __y0f32(_Float32) noexcept(true); +# 257 +extern _Float32 y1f32(_Float32) noexcept(true); extern _Float32 __y1f32(_Float32) noexcept(true); +# 258 +extern _Float32 ynf32(int, _Float32) noexcept(true); extern _Float32 __ynf32(int, _Float32) noexcept(true); +# 264 +extern _Float32 erff32(_Float32) noexcept(true); extern _Float32 __erff32(_Float32) noexcept(true); +# 265 +extern _Float32 erfcf32(_Float32) noexcept(true); extern _Float32 __erfcf32(_Float32) noexcept(true); +# 266 +extern _Float32 lgammaf32(_Float32) noexcept(true); extern _Float32 __lgammaf32(_Float32) noexcept(true); +# 271 +extern _Float32 tgammaf32(_Float32) noexcept(true); extern _Float32 __tgammaf32(_Float32) noexcept(true); +# 285 "/usr/include/bits/mathcalls.h" 3 +extern _Float32 lgammaf32_r(_Float32, int * __signgamp) noexcept(true); extern _Float32 __lgammaf32_r(_Float32, int * __signgamp) noexcept(true); +# 292 +extern _Float32 rintf32(_Float32 __x) noexcept(true); extern _Float32 __rintf32(_Float32 __x) noexcept(true); +# 295 +extern _Float32 nextafterf32(_Float32 __x, _Float32 __y) noexcept(true); extern _Float32 __nextafterf32(_Float32 __x, _Float32 __y) noexcept(true); +# 302 +extern _Float32 nextdownf32(_Float32 __x) noexcept(true); extern _Float32 __nextdownf32(_Float32 __x) noexcept(true); +# 304 +extern _Float32 nextupf32(_Float32 __x) noexcept(true); extern _Float32 __nextupf32(_Float32 __x) noexcept(true); +# 308 +extern _Float32 remainderf32(_Float32 __x, _Float32 __y) noexcept(true); extern _Float32 __remainderf32(_Float32 __x, _Float32 __y) noexcept(true); +# 312 +extern _Float32 scalbnf32(_Float32 __x, int __n) noexcept(true); extern _Float32 __scalbnf32(_Float32 __x, int __n) noexcept(true); +# 316 +extern int ilogbf32(_Float32 __x) noexcept(true); extern int __ilogbf32(_Float32 __x) noexcept(true); +# 321 +extern long llogbf32(_Float32 __x) noexcept(true); extern long __llogbf32(_Float32 __x) noexcept(true); +# 326 +extern _Float32 scalblnf32(_Float32 __x, long __n) noexcept(true); extern _Float32 __scalblnf32(_Float32 __x, long __n) noexcept(true); +# 330 +extern _Float32 nearbyintf32(_Float32 __x) noexcept(true); extern _Float32 __nearbyintf32(_Float32 __x) noexcept(true); +# 334 +extern _Float32 roundf32(_Float32 __x) noexcept(true) __attribute((const)); +# 338 +extern _Float32 truncf32(_Float32 __x) noexcept(true) __attribute((const)); +# 343 +extern _Float32 remquof32(_Float32 __x, _Float32 __y, int * __quo) noexcept(true); extern _Float32 __remquof32(_Float32 __x, _Float32 __y, int * __quo) noexcept(true); +# 350 +extern long lrintf32(_Float32 __x) noexcept(true); extern long __lrintf32(_Float32 __x) noexcept(true); +# 352 +__extension__ extern long long llrintf32(_Float32 __x) noexcept(true); extern long long __llrintf32(_Float32 __x) noexcept(true); +# 356 +extern long lroundf32(_Float32 __x) noexcept(true); extern long __lroundf32(_Float32 __x) noexcept(true); +# 358 +__extension__ extern long long llroundf32(_Float32 __x) noexcept(true); extern long long __llroundf32(_Float32 __x) noexcept(true); +# 362 +extern _Float32 fdimf32(_Float32 __x, _Float32 __y) noexcept(true); extern _Float32 __fdimf32(_Float32 __x, _Float32 __y) noexcept(true); +# 366 +extern _Float32 fmaxf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 369 +extern _Float32 fminf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 373 +extern _Float32 fmaf32(_Float32 __x, _Float32 __y, _Float32 __z) noexcept(true); extern _Float32 __fmaf32(_Float32 __x, _Float32 __y, _Float32 __z) noexcept(true); +# 378 +extern _Float32 roundevenf32(_Float32 __x) noexcept(true) __attribute((const)); +# 382 +extern __intmax_t fromfpf32(_Float32 __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpf32(_Float32 __x, int __round, unsigned __width) noexcept(true); +# 387 +extern __uintmax_t ufromfpf32(_Float32 __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpf32(_Float32 __x, int __round, unsigned __width) noexcept(true); +# 393 +extern __intmax_t fromfpxf32(_Float32 __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpxf32(_Float32 __x, int __round, unsigned __width) noexcept(true); +# 399 +extern __uintmax_t ufromfpxf32(_Float32 __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpxf32(_Float32 __x, int __round, unsigned __width) noexcept(true); +# 403 +extern int canonicalizef32(_Float32 * __cx, const _Float32 * __x) noexcept(true); +# 410 +extern _Float32 fmaxmagf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 413 +extern _Float32 fminmagf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 418 +extern _Float32 fmaximumf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 421 +extern _Float32 fminimumf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 424 +extern _Float32 fmaximum_numf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 427 +extern _Float32 fminimum_numf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 430 +extern _Float32 fmaximum_magf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 433 +extern _Float32 fminimum_magf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 436 +extern _Float32 fmaximum_mag_numf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 439 +extern _Float32 fminimum_mag_numf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 444 +extern int totalorderf32(const _Float32 * __x, const _Float32 * __y) noexcept(true) +# 446 + __attribute((__pure__)); +# 449 +extern int totalordermagf32(const _Float32 * __x, const _Float32 * __y) noexcept(true) +# 451 + __attribute((__pure__)); +# 454 +extern _Float32 getpayloadf32(const _Float32 * __x) noexcept(true); extern _Float32 __getpayloadf32(const _Float32 * __x) noexcept(true); +# 457 +extern int setpayloadf32(_Float32 * __x, _Float32 __payload) noexcept(true); +# 460 +extern int setpayloadsigf32(_Float32 * __x, _Float32 __payload) noexcept(true); +# 53 "/usr/include/bits/mathcalls.h" 3 +extern _Float64 acosf64(_Float64 __x) noexcept(true); extern _Float64 __acosf64(_Float64 __x) noexcept(true); +# 55 +extern _Float64 asinf64(_Float64 __x) noexcept(true); extern _Float64 __asinf64(_Float64 __x) noexcept(true); +# 57 +extern _Float64 atanf64(_Float64 __x) noexcept(true); extern _Float64 __atanf64(_Float64 __x) noexcept(true); +# 59 +extern _Float64 atan2f64(_Float64 __y, _Float64 __x) noexcept(true); extern _Float64 __atan2f64(_Float64 __y, _Float64 __x) noexcept(true); +# 62 +extern _Float64 cosf64(_Float64 __x) noexcept(true); extern _Float64 __cosf64(_Float64 __x) noexcept(true); +# 64 +extern _Float64 sinf64(_Float64 __x) noexcept(true); extern _Float64 __sinf64(_Float64 __x) noexcept(true); +# 66 +extern _Float64 tanf64(_Float64 __x) noexcept(true); extern _Float64 __tanf64(_Float64 __x) noexcept(true); +# 70 +extern _Float64 acospif64(_Float64 __x) noexcept(true); extern _Float64 __acospif64(_Float64 __x) noexcept(true); +# 72 +extern _Float64 asinpif64(_Float64 __x) noexcept(true); extern _Float64 __asinpif64(_Float64 __x) noexcept(true); +# 74 +extern _Float64 atanpif64(_Float64 __x) noexcept(true); extern _Float64 __atanpif64(_Float64 __x) noexcept(true); +# 76 +extern _Float64 atan2pif64(_Float64 __y, _Float64 __x) noexcept(true); extern _Float64 __atan2pif64(_Float64 __y, _Float64 __x) noexcept(true); +# 79 +extern _Float64 cospif64(_Float64 __x) noexcept(true); extern _Float64 __cospif64(_Float64 __x) noexcept(true); +# 81 +extern _Float64 sinpif64(_Float64 __x) noexcept(true); extern _Float64 __sinpif64(_Float64 __x) noexcept(true); +# 83 +extern _Float64 tanpif64(_Float64 __x) noexcept(true); extern _Float64 __tanpif64(_Float64 __x) noexcept(true); +# 89 +extern _Float64 coshf64(_Float64 __x) noexcept(true); extern _Float64 __coshf64(_Float64 __x) noexcept(true); +# 91 +extern _Float64 sinhf64(_Float64 __x) noexcept(true); extern _Float64 __sinhf64(_Float64 __x) noexcept(true); +# 93 +extern _Float64 tanhf64(_Float64 __x) noexcept(true); extern _Float64 __tanhf64(_Float64 __x) noexcept(true); +# 97 +extern void sincosf64(_Float64 __x, _Float64 * __sinx, _Float64 * __cosx) noexcept(true); extern void __sincosf64(_Float64 __x, _Float64 * __sinx, _Float64 * __cosx) noexcept(true); +# 103 +extern _Float64 acoshf64(_Float64 __x) noexcept(true); extern _Float64 __acoshf64(_Float64 __x) noexcept(true); +# 105 +extern _Float64 asinhf64(_Float64 __x) noexcept(true); extern _Float64 __asinhf64(_Float64 __x) noexcept(true); +# 107 +extern _Float64 atanhf64(_Float64 __x) noexcept(true); extern _Float64 __atanhf64(_Float64 __x) noexcept(true); +# 113 +extern _Float64 expf64(_Float64 __x) noexcept(true); extern _Float64 __expf64(_Float64 __x) noexcept(true); +# 116 +extern _Float64 frexpf64(_Float64 __x, int * __exponent) noexcept(true); extern _Float64 __frexpf64(_Float64 __x, int * __exponent) noexcept(true); +# 119 +extern _Float64 ldexpf64(_Float64 __x, int __exponent) noexcept(true); extern _Float64 __ldexpf64(_Float64 __x, int __exponent) noexcept(true); +# 122 +extern _Float64 logf64(_Float64 __x) noexcept(true); extern _Float64 __logf64(_Float64 __x) noexcept(true); +# 125 +extern _Float64 log10f64(_Float64 __x) noexcept(true); extern _Float64 __log10f64(_Float64 __x) noexcept(true); +# 128 +extern _Float64 modff64(_Float64 __x, _Float64 * __iptr) noexcept(true); extern _Float64 __modff64(_Float64 __x, _Float64 * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 132 +extern _Float64 exp10f64(_Float64 __x) noexcept(true); extern _Float64 __exp10f64(_Float64 __x) noexcept(true); +# 135 +extern _Float64 exp2m1f64(_Float64 __x) noexcept(true); extern _Float64 __exp2m1f64(_Float64 __x) noexcept(true); +# 138 +extern _Float64 exp10m1f64(_Float64 __x) noexcept(true); extern _Float64 __exp10m1f64(_Float64 __x) noexcept(true); +# 141 +extern _Float64 log2p1f64(_Float64 __x) noexcept(true); extern _Float64 __log2p1f64(_Float64 __x) noexcept(true); +# 144 +extern _Float64 log10p1f64(_Float64 __x) noexcept(true); extern _Float64 __log10p1f64(_Float64 __x) noexcept(true); +# 147 +extern _Float64 logp1f64(_Float64 __x) noexcept(true); extern _Float64 __logp1f64(_Float64 __x) noexcept(true); +# 152 +extern _Float64 expm1f64(_Float64 __x) noexcept(true); extern _Float64 __expm1f64(_Float64 __x) noexcept(true); +# 155 +extern _Float64 log1pf64(_Float64 __x) noexcept(true); extern _Float64 __log1pf64(_Float64 __x) noexcept(true); +# 158 +extern _Float64 logbf64(_Float64 __x) noexcept(true); extern _Float64 __logbf64(_Float64 __x) noexcept(true); +# 163 +extern _Float64 exp2f64(_Float64 __x) noexcept(true); extern _Float64 __exp2f64(_Float64 __x) noexcept(true); +# 166 +extern _Float64 log2f64(_Float64 __x) noexcept(true); extern _Float64 __log2f64(_Float64 __x) noexcept(true); +# 173 +extern _Float64 powf64(_Float64 __x, _Float64 __y) noexcept(true); extern _Float64 __powf64(_Float64 __x, _Float64 __y) noexcept(true); +# 176 +extern _Float64 sqrtf64(_Float64 __x) noexcept(true); extern _Float64 __sqrtf64(_Float64 __x) noexcept(true); +# 180 +extern _Float64 hypotf64(_Float64 __x, _Float64 __y) noexcept(true); extern _Float64 __hypotf64(_Float64 __x, _Float64 __y) noexcept(true); +# 185 +extern _Float64 cbrtf64(_Float64 __x) noexcept(true); extern _Float64 __cbrtf64(_Float64 __x) noexcept(true); +# 192 +extern _Float64 ceilf64(_Float64 __x) noexcept(true) __attribute((const)); +# 195 +extern _Float64 fabsf64(_Float64 __x) noexcept(true) __attribute((const)); +# 198 +extern _Float64 floorf64(_Float64 __x) noexcept(true) __attribute((const)); +# 201 +extern _Float64 fmodf64(_Float64 __x, _Float64 __y) noexcept(true); extern _Float64 __fmodf64(_Float64 __x, _Float64 __y) noexcept(true); +# 231 "/usr/include/bits/mathcalls.h" 3 +extern _Float64 copysignf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 236 +extern _Float64 nanf64(const char * __tagb) noexcept(true); extern _Float64 __nanf64(const char * __tagb) noexcept(true); +# 253 "/usr/include/bits/mathcalls.h" 3 +extern _Float64 j0f64(_Float64) noexcept(true); extern _Float64 __j0f64(_Float64) noexcept(true); +# 254 +extern _Float64 j1f64(_Float64) noexcept(true); extern _Float64 __j1f64(_Float64) noexcept(true); +# 255 +extern _Float64 jnf64(int, _Float64) noexcept(true); extern _Float64 __jnf64(int, _Float64) noexcept(true); +# 256 +extern _Float64 y0f64(_Float64) noexcept(true); extern _Float64 __y0f64(_Float64) noexcept(true); +# 257 +extern _Float64 y1f64(_Float64) noexcept(true); extern _Float64 __y1f64(_Float64) noexcept(true); +# 258 +extern _Float64 ynf64(int, _Float64) noexcept(true); extern _Float64 __ynf64(int, _Float64) noexcept(true); +# 264 +extern _Float64 erff64(_Float64) noexcept(true); extern _Float64 __erff64(_Float64) noexcept(true); +# 265 +extern _Float64 erfcf64(_Float64) noexcept(true); extern _Float64 __erfcf64(_Float64) noexcept(true); +# 266 +extern _Float64 lgammaf64(_Float64) noexcept(true); extern _Float64 __lgammaf64(_Float64) noexcept(true); +# 271 +extern _Float64 tgammaf64(_Float64) noexcept(true); extern _Float64 __tgammaf64(_Float64) noexcept(true); +# 285 "/usr/include/bits/mathcalls.h" 3 +extern _Float64 lgammaf64_r(_Float64, int * __signgamp) noexcept(true); extern _Float64 __lgammaf64_r(_Float64, int * __signgamp) noexcept(true); +# 292 +extern _Float64 rintf64(_Float64 __x) noexcept(true); extern _Float64 __rintf64(_Float64 __x) noexcept(true); +# 295 +extern _Float64 nextafterf64(_Float64 __x, _Float64 __y) noexcept(true); extern _Float64 __nextafterf64(_Float64 __x, _Float64 __y) noexcept(true); +# 302 +extern _Float64 nextdownf64(_Float64 __x) noexcept(true); extern _Float64 __nextdownf64(_Float64 __x) noexcept(true); +# 304 +extern _Float64 nextupf64(_Float64 __x) noexcept(true); extern _Float64 __nextupf64(_Float64 __x) noexcept(true); +# 308 +extern _Float64 remainderf64(_Float64 __x, _Float64 __y) noexcept(true); extern _Float64 __remainderf64(_Float64 __x, _Float64 __y) noexcept(true); +# 312 +extern _Float64 scalbnf64(_Float64 __x, int __n) noexcept(true); extern _Float64 __scalbnf64(_Float64 __x, int __n) noexcept(true); +# 316 +extern int ilogbf64(_Float64 __x) noexcept(true); extern int __ilogbf64(_Float64 __x) noexcept(true); +# 321 +extern long llogbf64(_Float64 __x) noexcept(true); extern long __llogbf64(_Float64 __x) noexcept(true); +# 326 +extern _Float64 scalblnf64(_Float64 __x, long __n) noexcept(true); extern _Float64 __scalblnf64(_Float64 __x, long __n) noexcept(true); +# 330 +extern _Float64 nearbyintf64(_Float64 __x) noexcept(true); extern _Float64 __nearbyintf64(_Float64 __x) noexcept(true); +# 334 +extern _Float64 roundf64(_Float64 __x) noexcept(true) __attribute((const)); +# 338 +extern _Float64 truncf64(_Float64 __x) noexcept(true) __attribute((const)); +# 343 +extern _Float64 remquof64(_Float64 __x, _Float64 __y, int * __quo) noexcept(true); extern _Float64 __remquof64(_Float64 __x, _Float64 __y, int * __quo) noexcept(true); +# 350 +extern long lrintf64(_Float64 __x) noexcept(true); extern long __lrintf64(_Float64 __x) noexcept(true); +# 352 +__extension__ extern long long llrintf64(_Float64 __x) noexcept(true); extern long long __llrintf64(_Float64 __x) noexcept(true); +# 356 +extern long lroundf64(_Float64 __x) noexcept(true); extern long __lroundf64(_Float64 __x) noexcept(true); +# 358 +__extension__ extern long long llroundf64(_Float64 __x) noexcept(true); extern long long __llroundf64(_Float64 __x) noexcept(true); +# 362 +extern _Float64 fdimf64(_Float64 __x, _Float64 __y) noexcept(true); extern _Float64 __fdimf64(_Float64 __x, _Float64 __y) noexcept(true); +# 366 +extern _Float64 fmaxf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 369 +extern _Float64 fminf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 373 +extern _Float64 fmaf64(_Float64 __x, _Float64 __y, _Float64 __z) noexcept(true); extern _Float64 __fmaf64(_Float64 __x, _Float64 __y, _Float64 __z) noexcept(true); +# 378 +extern _Float64 roundevenf64(_Float64 __x) noexcept(true) __attribute((const)); +# 382 +extern __intmax_t fromfpf64(_Float64 __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpf64(_Float64 __x, int __round, unsigned __width) noexcept(true); +# 387 +extern __uintmax_t ufromfpf64(_Float64 __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpf64(_Float64 __x, int __round, unsigned __width) noexcept(true); +# 393 +extern __intmax_t fromfpxf64(_Float64 __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpxf64(_Float64 __x, int __round, unsigned __width) noexcept(true); +# 399 +extern __uintmax_t ufromfpxf64(_Float64 __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpxf64(_Float64 __x, int __round, unsigned __width) noexcept(true); +# 403 +extern int canonicalizef64(_Float64 * __cx, const _Float64 * __x) noexcept(true); +# 410 +extern _Float64 fmaxmagf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 413 +extern _Float64 fminmagf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 418 +extern _Float64 fmaximumf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 421 +extern _Float64 fminimumf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 424 +extern _Float64 fmaximum_numf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 427 +extern _Float64 fminimum_numf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 430 +extern _Float64 fmaximum_magf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 433 +extern _Float64 fminimum_magf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 436 +extern _Float64 fmaximum_mag_numf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 439 +extern _Float64 fminimum_mag_numf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 444 +extern int totalorderf64(const _Float64 * __x, const _Float64 * __y) noexcept(true) +# 446 + __attribute((__pure__)); +# 449 +extern int totalordermagf64(const _Float64 * __x, const _Float64 * __y) noexcept(true) +# 451 + __attribute((__pure__)); +# 454 +extern _Float64 getpayloadf64(const _Float64 * __x) noexcept(true); extern _Float64 __getpayloadf64(const _Float64 * __x) noexcept(true); +# 457 +extern int setpayloadf64(_Float64 * __x, _Float64 __payload) noexcept(true); +# 460 +extern int setpayloadsigf64(_Float64 * __x, _Float64 __payload) noexcept(true); +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 +extern int __fpclassifyf128(_Float128 __value) noexcept(true) +# 21 + __attribute((const)); +# 24 +extern int __signbitf128(_Float128 __value) noexcept(true) +# 25 + __attribute((const)); +# 29 +extern int __isinff128(_Float128 __value) noexcept(true) +# 30 + __attribute((const)); +# 33 +extern int __finitef128(_Float128 __value) noexcept(true) +# 34 + __attribute((const)); +# 37 +extern int __isnanf128(_Float128 __value) noexcept(true) +# 38 + __attribute((const)); +# 41 +extern int __iseqsigf128(_Float128 __x, _Float128 __y) noexcept(true); +# 44 +extern int __issignalingf128(_Float128 __value) noexcept(true) +# 45 + __attribute((const)); +# 53 "/usr/include/bits/mathcalls.h" 3 +extern _Float128 acosf128(_Float128 __x) noexcept(true); extern _Float128 __acosf128(_Float128 __x) noexcept(true); +# 55 +extern _Float128 asinf128(_Float128 __x) noexcept(true); extern _Float128 __asinf128(_Float128 __x) noexcept(true); +# 57 +extern _Float128 atanf128(_Float128 __x) noexcept(true); extern _Float128 __atanf128(_Float128 __x) noexcept(true); +# 59 +extern _Float128 atan2f128(_Float128 __y, _Float128 __x) noexcept(true); extern _Float128 __atan2f128(_Float128 __y, _Float128 __x) noexcept(true); +# 62 +extern _Float128 cosf128(_Float128 __x) noexcept(true); extern _Float128 __cosf128(_Float128 __x) noexcept(true); +# 64 +extern _Float128 sinf128(_Float128 __x) noexcept(true); extern _Float128 __sinf128(_Float128 __x) noexcept(true); +# 66 +extern _Float128 tanf128(_Float128 __x) noexcept(true); extern _Float128 __tanf128(_Float128 __x) noexcept(true); +# 70 +extern _Float128 acospif128(_Float128 __x) noexcept(true); extern _Float128 __acospif128(_Float128 __x) noexcept(true); +# 72 +extern _Float128 asinpif128(_Float128 __x) noexcept(true); extern _Float128 __asinpif128(_Float128 __x) noexcept(true); +# 74 +extern _Float128 atanpif128(_Float128 __x) noexcept(true); extern _Float128 __atanpif128(_Float128 __x) noexcept(true); +# 76 +extern _Float128 atan2pif128(_Float128 __y, _Float128 __x) noexcept(true); extern _Float128 __atan2pif128(_Float128 __y, _Float128 __x) noexcept(true); +# 79 +extern _Float128 cospif128(_Float128 __x) noexcept(true); extern _Float128 __cospif128(_Float128 __x) noexcept(true); +# 81 +extern _Float128 sinpif128(_Float128 __x) noexcept(true); extern _Float128 __sinpif128(_Float128 __x) noexcept(true); +# 83 +extern _Float128 tanpif128(_Float128 __x) noexcept(true); extern _Float128 __tanpif128(_Float128 __x) noexcept(true); +# 89 +extern _Float128 coshf128(_Float128 __x) noexcept(true); extern _Float128 __coshf128(_Float128 __x) noexcept(true); +# 91 +extern _Float128 sinhf128(_Float128 __x) noexcept(true); extern _Float128 __sinhf128(_Float128 __x) noexcept(true); +# 93 +extern _Float128 tanhf128(_Float128 __x) noexcept(true); extern _Float128 __tanhf128(_Float128 __x) noexcept(true); +# 97 +extern void sincosf128(_Float128 __x, _Float128 * __sinx, _Float128 * __cosx) noexcept(true); extern void __sincosf128(_Float128 __x, _Float128 * __sinx, _Float128 * __cosx) noexcept(true); +# 103 +extern _Float128 acoshf128(_Float128 __x) noexcept(true); extern _Float128 __acoshf128(_Float128 __x) noexcept(true); +# 105 +extern _Float128 asinhf128(_Float128 __x) noexcept(true); extern _Float128 __asinhf128(_Float128 __x) noexcept(true); +# 107 +extern _Float128 atanhf128(_Float128 __x) noexcept(true); extern _Float128 __atanhf128(_Float128 __x) noexcept(true); +# 113 +extern _Float128 expf128(_Float128 __x) noexcept(true); extern _Float128 __expf128(_Float128 __x) noexcept(true); +# 116 +extern _Float128 frexpf128(_Float128 __x, int * __exponent) noexcept(true); extern _Float128 __frexpf128(_Float128 __x, int * __exponent) noexcept(true); +# 119 +extern _Float128 ldexpf128(_Float128 __x, int __exponent) noexcept(true); extern _Float128 __ldexpf128(_Float128 __x, int __exponent) noexcept(true); +# 122 +extern _Float128 logf128(_Float128 __x) noexcept(true); extern _Float128 __logf128(_Float128 __x) noexcept(true); +# 125 +extern _Float128 log10f128(_Float128 __x) noexcept(true); extern _Float128 __log10f128(_Float128 __x) noexcept(true); +# 128 +extern _Float128 modff128(_Float128 __x, _Float128 * __iptr) noexcept(true); extern _Float128 __modff128(_Float128 __x, _Float128 * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 132 +extern _Float128 exp10f128(_Float128 __x) noexcept(true); extern _Float128 __exp10f128(_Float128 __x) noexcept(true); +# 135 +extern _Float128 exp2m1f128(_Float128 __x) noexcept(true); extern _Float128 __exp2m1f128(_Float128 __x) noexcept(true); +# 138 +extern _Float128 exp10m1f128(_Float128 __x) noexcept(true); extern _Float128 __exp10m1f128(_Float128 __x) noexcept(true); +# 141 +extern _Float128 log2p1f128(_Float128 __x) noexcept(true); extern _Float128 __log2p1f128(_Float128 __x) noexcept(true); +# 144 +extern _Float128 log10p1f128(_Float128 __x) noexcept(true); extern _Float128 __log10p1f128(_Float128 __x) noexcept(true); +# 147 +extern _Float128 logp1f128(_Float128 __x) noexcept(true); extern _Float128 __logp1f128(_Float128 __x) noexcept(true); +# 152 +extern _Float128 expm1f128(_Float128 __x) noexcept(true); extern _Float128 __expm1f128(_Float128 __x) noexcept(true); +# 155 +extern _Float128 log1pf128(_Float128 __x) noexcept(true); extern _Float128 __log1pf128(_Float128 __x) noexcept(true); +# 158 +extern _Float128 logbf128(_Float128 __x) noexcept(true); extern _Float128 __logbf128(_Float128 __x) noexcept(true); +# 163 +extern _Float128 exp2f128(_Float128 __x) noexcept(true); extern _Float128 __exp2f128(_Float128 __x) noexcept(true); +# 166 +extern _Float128 log2f128(_Float128 __x) noexcept(true); extern _Float128 __log2f128(_Float128 __x) noexcept(true); +# 173 +extern _Float128 powf128(_Float128 __x, _Float128 __y) noexcept(true); extern _Float128 __powf128(_Float128 __x, _Float128 __y) noexcept(true); +# 176 +extern _Float128 sqrtf128(_Float128 __x) noexcept(true); extern _Float128 __sqrtf128(_Float128 __x) noexcept(true); +# 180 +extern _Float128 hypotf128(_Float128 __x, _Float128 __y) noexcept(true); extern _Float128 __hypotf128(_Float128 __x, _Float128 __y) noexcept(true); +# 185 +extern _Float128 cbrtf128(_Float128 __x) noexcept(true); extern _Float128 __cbrtf128(_Float128 __x) noexcept(true); +# 192 +extern _Float128 ceilf128(_Float128 __x) noexcept(true) __attribute((const)); +# 195 +extern _Float128 fabsf128(_Float128 __x) noexcept(true) __attribute((const)); +# 198 +extern _Float128 floorf128(_Float128 __x) noexcept(true) __attribute((const)); +# 201 +extern _Float128 fmodf128(_Float128 __x, _Float128 __y) noexcept(true); extern _Float128 __fmodf128(_Float128 __x, _Float128 __y) noexcept(true); +# 231 "/usr/include/bits/mathcalls.h" 3 +extern _Float128 copysignf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 236 +extern _Float128 nanf128(const char * __tagb) noexcept(true); extern _Float128 __nanf128(const char * __tagb) noexcept(true); +# 253 "/usr/include/bits/mathcalls.h" 3 +extern _Float128 j0f128(_Float128) noexcept(true); extern _Float128 __j0f128(_Float128) noexcept(true); +# 254 +extern _Float128 j1f128(_Float128) noexcept(true); extern _Float128 __j1f128(_Float128) noexcept(true); +# 255 +extern _Float128 jnf128(int, _Float128) noexcept(true); extern _Float128 __jnf128(int, _Float128) noexcept(true); +# 256 +extern _Float128 y0f128(_Float128) noexcept(true); extern _Float128 __y0f128(_Float128) noexcept(true); +# 257 +extern _Float128 y1f128(_Float128) noexcept(true); extern _Float128 __y1f128(_Float128) noexcept(true); +# 258 +extern _Float128 ynf128(int, _Float128) noexcept(true); extern _Float128 __ynf128(int, _Float128) noexcept(true); +# 264 +extern _Float128 erff128(_Float128) noexcept(true); extern _Float128 __erff128(_Float128) noexcept(true); +# 265 +extern _Float128 erfcf128(_Float128) noexcept(true); extern _Float128 __erfcf128(_Float128) noexcept(true); +# 266 +extern _Float128 lgammaf128(_Float128) noexcept(true); extern _Float128 __lgammaf128(_Float128) noexcept(true); +# 271 +extern _Float128 tgammaf128(_Float128) noexcept(true); extern _Float128 __tgammaf128(_Float128) noexcept(true); +# 285 "/usr/include/bits/mathcalls.h" 3 +extern _Float128 lgammaf128_r(_Float128, int * __signgamp) noexcept(true); extern _Float128 __lgammaf128_r(_Float128, int * __signgamp) noexcept(true); +# 292 +extern _Float128 rintf128(_Float128 __x) noexcept(true); extern _Float128 __rintf128(_Float128 __x) noexcept(true); +# 295 +extern _Float128 nextafterf128(_Float128 __x, _Float128 __y) noexcept(true); extern _Float128 __nextafterf128(_Float128 __x, _Float128 __y) noexcept(true); +# 302 +extern _Float128 nextdownf128(_Float128 __x) noexcept(true); extern _Float128 __nextdownf128(_Float128 __x) noexcept(true); +# 304 +extern _Float128 nextupf128(_Float128 __x) noexcept(true); extern _Float128 __nextupf128(_Float128 __x) noexcept(true); +# 308 +extern _Float128 remainderf128(_Float128 __x, _Float128 __y) noexcept(true); extern _Float128 __remainderf128(_Float128 __x, _Float128 __y) noexcept(true); +# 312 +extern _Float128 scalbnf128(_Float128 __x, int __n) noexcept(true); extern _Float128 __scalbnf128(_Float128 __x, int __n) noexcept(true); +# 316 +extern int ilogbf128(_Float128 __x) noexcept(true); extern int __ilogbf128(_Float128 __x) noexcept(true); +# 321 +extern long llogbf128(_Float128 __x) noexcept(true); extern long __llogbf128(_Float128 __x) noexcept(true); +# 326 +extern _Float128 scalblnf128(_Float128 __x, long __n) noexcept(true); extern _Float128 __scalblnf128(_Float128 __x, long __n) noexcept(true); +# 330 +extern _Float128 nearbyintf128(_Float128 __x) noexcept(true); extern _Float128 __nearbyintf128(_Float128 __x) noexcept(true); +# 334 +extern _Float128 roundf128(_Float128 __x) noexcept(true) __attribute((const)); +# 338 +extern _Float128 truncf128(_Float128 __x) noexcept(true) __attribute((const)); +# 343 +extern _Float128 remquof128(_Float128 __x, _Float128 __y, int * __quo) noexcept(true); extern _Float128 __remquof128(_Float128 __x, _Float128 __y, int * __quo) noexcept(true); +# 350 +extern long lrintf128(_Float128 __x) noexcept(true); extern long __lrintf128(_Float128 __x) noexcept(true); +# 352 +__extension__ extern long long llrintf128(_Float128 __x) noexcept(true); extern long long __llrintf128(_Float128 __x) noexcept(true); +# 356 +extern long lroundf128(_Float128 __x) noexcept(true); extern long __lroundf128(_Float128 __x) noexcept(true); +# 358 +__extension__ extern long long llroundf128(_Float128 __x) noexcept(true); extern long long __llroundf128(_Float128 __x) noexcept(true); +# 362 +extern _Float128 fdimf128(_Float128 __x, _Float128 __y) noexcept(true); extern _Float128 __fdimf128(_Float128 __x, _Float128 __y) noexcept(true); +# 366 +extern _Float128 fmaxf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 369 +extern _Float128 fminf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 373 +extern _Float128 fmaf128(_Float128 __x, _Float128 __y, _Float128 __z) noexcept(true); extern _Float128 __fmaf128(_Float128 __x, _Float128 __y, _Float128 __z) noexcept(true); +# 378 +extern _Float128 roundevenf128(_Float128 __x) noexcept(true) __attribute((const)); +# 382 +extern __intmax_t fromfpf128(_Float128 __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpf128(_Float128 __x, int __round, unsigned __width) noexcept(true); +# 387 +extern __uintmax_t ufromfpf128(_Float128 __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpf128(_Float128 __x, int __round, unsigned __width) noexcept(true); +# 393 +extern __intmax_t fromfpxf128(_Float128 __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpxf128(_Float128 __x, int __round, unsigned __width) noexcept(true); +# 399 +extern __uintmax_t ufromfpxf128(_Float128 __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpxf128(_Float128 __x, int __round, unsigned __width) noexcept(true); +# 403 +extern int canonicalizef128(_Float128 * __cx, const _Float128 * __x) noexcept(true); +# 410 +extern _Float128 fmaxmagf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 413 +extern _Float128 fminmagf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 418 +extern _Float128 fmaximumf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 421 +extern _Float128 fminimumf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 424 +extern _Float128 fmaximum_numf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 427 +extern _Float128 fminimum_numf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 430 +extern _Float128 fmaximum_magf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 433 +extern _Float128 fminimum_magf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 436 +extern _Float128 fmaximum_mag_numf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 439 +extern _Float128 fminimum_mag_numf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 444 +extern int totalorderf128(const _Float128 * __x, const _Float128 * __y) noexcept(true) +# 446 + __attribute((__pure__)); +# 449 +extern int totalordermagf128(const _Float128 * __x, const _Float128 * __y) noexcept(true) +# 451 + __attribute((__pure__)); +# 454 +extern _Float128 getpayloadf128(const _Float128 * __x) noexcept(true); extern _Float128 __getpayloadf128(const _Float128 * __x) noexcept(true); +# 457 +extern int setpayloadf128(_Float128 * __x, _Float128 __payload) noexcept(true); +# 460 +extern int setpayloadsigf128(_Float128 * __x, _Float128 __payload) noexcept(true); +# 53 "/usr/include/bits/mathcalls.h" 3 +extern _Float32x acosf32x(_Float32x __x) noexcept(true); extern _Float32x __acosf32x(_Float32x __x) noexcept(true); +# 55 +extern _Float32x asinf32x(_Float32x __x) noexcept(true); extern _Float32x __asinf32x(_Float32x __x) noexcept(true); +# 57 +extern _Float32x atanf32x(_Float32x __x) noexcept(true); extern _Float32x __atanf32x(_Float32x __x) noexcept(true); +# 59 +extern _Float32x atan2f32x(_Float32x __y, _Float32x __x) noexcept(true); extern _Float32x __atan2f32x(_Float32x __y, _Float32x __x) noexcept(true); +# 62 +extern _Float32x cosf32x(_Float32x __x) noexcept(true); extern _Float32x __cosf32x(_Float32x __x) noexcept(true); +# 64 +extern _Float32x sinf32x(_Float32x __x) noexcept(true); extern _Float32x __sinf32x(_Float32x __x) noexcept(true); +# 66 +extern _Float32x tanf32x(_Float32x __x) noexcept(true); extern _Float32x __tanf32x(_Float32x __x) noexcept(true); +# 70 +extern _Float32x acospif32x(_Float32x __x) noexcept(true); extern _Float32x __acospif32x(_Float32x __x) noexcept(true); +# 72 +extern _Float32x asinpif32x(_Float32x __x) noexcept(true); extern _Float32x __asinpif32x(_Float32x __x) noexcept(true); +# 74 +extern _Float32x atanpif32x(_Float32x __x) noexcept(true); extern _Float32x __atanpif32x(_Float32x __x) noexcept(true); +# 76 +extern _Float32x atan2pif32x(_Float32x __y, _Float32x __x) noexcept(true); extern _Float32x __atan2pif32x(_Float32x __y, _Float32x __x) noexcept(true); +# 79 +extern _Float32x cospif32x(_Float32x __x) noexcept(true); extern _Float32x __cospif32x(_Float32x __x) noexcept(true); +# 81 +extern _Float32x sinpif32x(_Float32x __x) noexcept(true); extern _Float32x __sinpif32x(_Float32x __x) noexcept(true); +# 83 +extern _Float32x tanpif32x(_Float32x __x) noexcept(true); extern _Float32x __tanpif32x(_Float32x __x) noexcept(true); +# 89 +extern _Float32x coshf32x(_Float32x __x) noexcept(true); extern _Float32x __coshf32x(_Float32x __x) noexcept(true); +# 91 +extern _Float32x sinhf32x(_Float32x __x) noexcept(true); extern _Float32x __sinhf32x(_Float32x __x) noexcept(true); +# 93 +extern _Float32x tanhf32x(_Float32x __x) noexcept(true); extern _Float32x __tanhf32x(_Float32x __x) noexcept(true); +# 97 +extern void sincosf32x(_Float32x __x, _Float32x * __sinx, _Float32x * __cosx) noexcept(true); extern void __sincosf32x(_Float32x __x, _Float32x * __sinx, _Float32x * __cosx) noexcept(true); +# 103 +extern _Float32x acoshf32x(_Float32x __x) noexcept(true); extern _Float32x __acoshf32x(_Float32x __x) noexcept(true); +# 105 +extern _Float32x asinhf32x(_Float32x __x) noexcept(true); extern _Float32x __asinhf32x(_Float32x __x) noexcept(true); +# 107 +extern _Float32x atanhf32x(_Float32x __x) noexcept(true); extern _Float32x __atanhf32x(_Float32x __x) noexcept(true); +# 113 +extern _Float32x expf32x(_Float32x __x) noexcept(true); extern _Float32x __expf32x(_Float32x __x) noexcept(true); +# 116 +extern _Float32x frexpf32x(_Float32x __x, int * __exponent) noexcept(true); extern _Float32x __frexpf32x(_Float32x __x, int * __exponent) noexcept(true); +# 119 +extern _Float32x ldexpf32x(_Float32x __x, int __exponent) noexcept(true); extern _Float32x __ldexpf32x(_Float32x __x, int __exponent) noexcept(true); +# 122 +extern _Float32x logf32x(_Float32x __x) noexcept(true); extern _Float32x __logf32x(_Float32x __x) noexcept(true); +# 125 +extern _Float32x log10f32x(_Float32x __x) noexcept(true); extern _Float32x __log10f32x(_Float32x __x) noexcept(true); +# 128 +extern _Float32x modff32x(_Float32x __x, _Float32x * __iptr) noexcept(true); extern _Float32x __modff32x(_Float32x __x, _Float32x * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 132 +extern _Float32x exp10f32x(_Float32x __x) noexcept(true); extern _Float32x __exp10f32x(_Float32x __x) noexcept(true); +# 135 +extern _Float32x exp2m1f32x(_Float32x __x) noexcept(true); extern _Float32x __exp2m1f32x(_Float32x __x) noexcept(true); +# 138 +extern _Float32x exp10m1f32x(_Float32x __x) noexcept(true); extern _Float32x __exp10m1f32x(_Float32x __x) noexcept(true); +# 141 +extern _Float32x log2p1f32x(_Float32x __x) noexcept(true); extern _Float32x __log2p1f32x(_Float32x __x) noexcept(true); +# 144 +extern _Float32x log10p1f32x(_Float32x __x) noexcept(true); extern _Float32x __log10p1f32x(_Float32x __x) noexcept(true); +# 147 +extern _Float32x logp1f32x(_Float32x __x) noexcept(true); extern _Float32x __logp1f32x(_Float32x __x) noexcept(true); +# 152 +extern _Float32x expm1f32x(_Float32x __x) noexcept(true); extern _Float32x __expm1f32x(_Float32x __x) noexcept(true); +# 155 +extern _Float32x log1pf32x(_Float32x __x) noexcept(true); extern _Float32x __log1pf32x(_Float32x __x) noexcept(true); +# 158 +extern _Float32x logbf32x(_Float32x __x) noexcept(true); extern _Float32x __logbf32x(_Float32x __x) noexcept(true); +# 163 +extern _Float32x exp2f32x(_Float32x __x) noexcept(true); extern _Float32x __exp2f32x(_Float32x __x) noexcept(true); +# 166 +extern _Float32x log2f32x(_Float32x __x) noexcept(true); extern _Float32x __log2f32x(_Float32x __x) noexcept(true); +# 173 +extern _Float32x powf32x(_Float32x __x, _Float32x __y) noexcept(true); extern _Float32x __powf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 176 +extern _Float32x sqrtf32x(_Float32x __x) noexcept(true); extern _Float32x __sqrtf32x(_Float32x __x) noexcept(true); +# 180 +extern _Float32x hypotf32x(_Float32x __x, _Float32x __y) noexcept(true); extern _Float32x __hypotf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 185 +extern _Float32x cbrtf32x(_Float32x __x) noexcept(true); extern _Float32x __cbrtf32x(_Float32x __x) noexcept(true); +# 192 +extern _Float32x ceilf32x(_Float32x __x) noexcept(true) __attribute((const)); +# 195 +extern _Float32x fabsf32x(_Float32x __x) noexcept(true) __attribute((const)); +# 198 +extern _Float32x floorf32x(_Float32x __x) noexcept(true) __attribute((const)); +# 201 +extern _Float32x fmodf32x(_Float32x __x, _Float32x __y) noexcept(true); extern _Float32x __fmodf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 231 "/usr/include/bits/mathcalls.h" 3 +extern _Float32x copysignf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 236 +extern _Float32x nanf32x(const char * __tagb) noexcept(true); extern _Float32x __nanf32x(const char * __tagb) noexcept(true); +# 253 "/usr/include/bits/mathcalls.h" 3 +extern _Float32x j0f32x(_Float32x) noexcept(true); extern _Float32x __j0f32x(_Float32x) noexcept(true); +# 254 +extern _Float32x j1f32x(_Float32x) noexcept(true); extern _Float32x __j1f32x(_Float32x) noexcept(true); +# 255 +extern _Float32x jnf32x(int, _Float32x) noexcept(true); extern _Float32x __jnf32x(int, _Float32x) noexcept(true); +# 256 +extern _Float32x y0f32x(_Float32x) noexcept(true); extern _Float32x __y0f32x(_Float32x) noexcept(true); +# 257 +extern _Float32x y1f32x(_Float32x) noexcept(true); extern _Float32x __y1f32x(_Float32x) noexcept(true); +# 258 +extern _Float32x ynf32x(int, _Float32x) noexcept(true); extern _Float32x __ynf32x(int, _Float32x) noexcept(true); +# 264 +extern _Float32x erff32x(_Float32x) noexcept(true); extern _Float32x __erff32x(_Float32x) noexcept(true); +# 265 +extern _Float32x erfcf32x(_Float32x) noexcept(true); extern _Float32x __erfcf32x(_Float32x) noexcept(true); +# 266 +extern _Float32x lgammaf32x(_Float32x) noexcept(true); extern _Float32x __lgammaf32x(_Float32x) noexcept(true); +# 271 +extern _Float32x tgammaf32x(_Float32x) noexcept(true); extern _Float32x __tgammaf32x(_Float32x) noexcept(true); +# 285 "/usr/include/bits/mathcalls.h" 3 +extern _Float32x lgammaf32x_r(_Float32x, int * __signgamp) noexcept(true); extern _Float32x __lgammaf32x_r(_Float32x, int * __signgamp) noexcept(true); +# 292 +extern _Float32x rintf32x(_Float32x __x) noexcept(true); extern _Float32x __rintf32x(_Float32x __x) noexcept(true); +# 295 +extern _Float32x nextafterf32x(_Float32x __x, _Float32x __y) noexcept(true); extern _Float32x __nextafterf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 302 +extern _Float32x nextdownf32x(_Float32x __x) noexcept(true); extern _Float32x __nextdownf32x(_Float32x __x) noexcept(true); +# 304 +extern _Float32x nextupf32x(_Float32x __x) noexcept(true); extern _Float32x __nextupf32x(_Float32x __x) noexcept(true); +# 308 +extern _Float32x remainderf32x(_Float32x __x, _Float32x __y) noexcept(true); extern _Float32x __remainderf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 312 +extern _Float32x scalbnf32x(_Float32x __x, int __n) noexcept(true); extern _Float32x __scalbnf32x(_Float32x __x, int __n) noexcept(true); +# 316 +extern int ilogbf32x(_Float32x __x) noexcept(true); extern int __ilogbf32x(_Float32x __x) noexcept(true); +# 321 +extern long llogbf32x(_Float32x __x) noexcept(true); extern long __llogbf32x(_Float32x __x) noexcept(true); +# 326 +extern _Float32x scalblnf32x(_Float32x __x, long __n) noexcept(true); extern _Float32x __scalblnf32x(_Float32x __x, long __n) noexcept(true); +# 330 +extern _Float32x nearbyintf32x(_Float32x __x) noexcept(true); extern _Float32x __nearbyintf32x(_Float32x __x) noexcept(true); +# 334 +extern _Float32x roundf32x(_Float32x __x) noexcept(true) __attribute((const)); +# 338 +extern _Float32x truncf32x(_Float32x __x) noexcept(true) __attribute((const)); +# 343 +extern _Float32x remquof32x(_Float32x __x, _Float32x __y, int * __quo) noexcept(true); extern _Float32x __remquof32x(_Float32x __x, _Float32x __y, int * __quo) noexcept(true); +# 350 +extern long lrintf32x(_Float32x __x) noexcept(true); extern long __lrintf32x(_Float32x __x) noexcept(true); +# 352 +__extension__ extern long long llrintf32x(_Float32x __x) noexcept(true); extern long long __llrintf32x(_Float32x __x) noexcept(true); +# 356 +extern long lroundf32x(_Float32x __x) noexcept(true); extern long __lroundf32x(_Float32x __x) noexcept(true); +# 358 +__extension__ extern long long llroundf32x(_Float32x __x) noexcept(true); extern long long __llroundf32x(_Float32x __x) noexcept(true); +# 362 +extern _Float32x fdimf32x(_Float32x __x, _Float32x __y) noexcept(true); extern _Float32x __fdimf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 366 +extern _Float32x fmaxf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 369 +extern _Float32x fminf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 373 +extern _Float32x fmaf32x(_Float32x __x, _Float32x __y, _Float32x __z) noexcept(true); extern _Float32x __fmaf32x(_Float32x __x, _Float32x __y, _Float32x __z) noexcept(true); +# 378 +extern _Float32x roundevenf32x(_Float32x __x) noexcept(true) __attribute((const)); +# 382 +extern __intmax_t fromfpf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); +# 387 +extern __uintmax_t ufromfpf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); +# 393 +extern __intmax_t fromfpxf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpxf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); +# 399 +extern __uintmax_t ufromfpxf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpxf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); +# 403 +extern int canonicalizef32x(_Float32x * __cx, const _Float32x * __x) noexcept(true); +# 410 +extern _Float32x fmaxmagf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 413 +extern _Float32x fminmagf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 418 +extern _Float32x fmaximumf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 421 +extern _Float32x fminimumf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 424 +extern _Float32x fmaximum_numf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 427 +extern _Float32x fminimum_numf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 430 +extern _Float32x fmaximum_magf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 433 +extern _Float32x fminimum_magf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 436 +extern _Float32x fmaximum_mag_numf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 439 +extern _Float32x fminimum_mag_numf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 444 +extern int totalorderf32x(const _Float32x * __x, const _Float32x * __y) noexcept(true) +# 446 + __attribute((__pure__)); +# 449 +extern int totalordermagf32x(const _Float32x * __x, const _Float32x * __y) noexcept(true) +# 451 + __attribute((__pure__)); +# 454 +extern _Float32x getpayloadf32x(const _Float32x * __x) noexcept(true); extern _Float32x __getpayloadf32x(const _Float32x * __x) noexcept(true); +# 457 +extern int setpayloadf32x(_Float32x * __x, _Float32x __payload) noexcept(true); +# 460 +extern int setpayloadsigf32x(_Float32x * __x, _Float32x __payload) noexcept(true); +# 53 "/usr/include/bits/mathcalls.h" 3 +extern _Float64x acosf64x(_Float64x __x) noexcept(true); extern _Float64x __acosf64x(_Float64x __x) noexcept(true); +# 55 +extern _Float64x asinf64x(_Float64x __x) noexcept(true); extern _Float64x __asinf64x(_Float64x __x) noexcept(true); +# 57 +extern _Float64x atanf64x(_Float64x __x) noexcept(true); extern _Float64x __atanf64x(_Float64x __x) noexcept(true); +# 59 +extern _Float64x atan2f64x(_Float64x __y, _Float64x __x) noexcept(true); extern _Float64x __atan2f64x(_Float64x __y, _Float64x __x) noexcept(true); +# 62 +extern _Float64x cosf64x(_Float64x __x) noexcept(true); extern _Float64x __cosf64x(_Float64x __x) noexcept(true); +# 64 +extern _Float64x sinf64x(_Float64x __x) noexcept(true); extern _Float64x __sinf64x(_Float64x __x) noexcept(true); +# 66 +extern _Float64x tanf64x(_Float64x __x) noexcept(true); extern _Float64x __tanf64x(_Float64x __x) noexcept(true); +# 70 +extern _Float64x acospif64x(_Float64x __x) noexcept(true); extern _Float64x __acospif64x(_Float64x __x) noexcept(true); +# 72 +extern _Float64x asinpif64x(_Float64x __x) noexcept(true); extern _Float64x __asinpif64x(_Float64x __x) noexcept(true); +# 74 +extern _Float64x atanpif64x(_Float64x __x) noexcept(true); extern _Float64x __atanpif64x(_Float64x __x) noexcept(true); +# 76 +extern _Float64x atan2pif64x(_Float64x __y, _Float64x __x) noexcept(true); extern _Float64x __atan2pif64x(_Float64x __y, _Float64x __x) noexcept(true); +# 79 +extern _Float64x cospif64x(_Float64x __x) noexcept(true); extern _Float64x __cospif64x(_Float64x __x) noexcept(true); +# 81 +extern _Float64x sinpif64x(_Float64x __x) noexcept(true); extern _Float64x __sinpif64x(_Float64x __x) noexcept(true); +# 83 +extern _Float64x tanpif64x(_Float64x __x) noexcept(true); extern _Float64x __tanpif64x(_Float64x __x) noexcept(true); +# 89 +extern _Float64x coshf64x(_Float64x __x) noexcept(true); extern _Float64x __coshf64x(_Float64x __x) noexcept(true); +# 91 +extern _Float64x sinhf64x(_Float64x __x) noexcept(true); extern _Float64x __sinhf64x(_Float64x __x) noexcept(true); +# 93 +extern _Float64x tanhf64x(_Float64x __x) noexcept(true); extern _Float64x __tanhf64x(_Float64x __x) noexcept(true); +# 97 +extern void sincosf64x(_Float64x __x, _Float64x * __sinx, _Float64x * __cosx) noexcept(true); extern void __sincosf64x(_Float64x __x, _Float64x * __sinx, _Float64x * __cosx) noexcept(true); +# 103 +extern _Float64x acoshf64x(_Float64x __x) noexcept(true); extern _Float64x __acoshf64x(_Float64x __x) noexcept(true); +# 105 +extern _Float64x asinhf64x(_Float64x __x) noexcept(true); extern _Float64x __asinhf64x(_Float64x __x) noexcept(true); +# 107 +extern _Float64x atanhf64x(_Float64x __x) noexcept(true); extern _Float64x __atanhf64x(_Float64x __x) noexcept(true); +# 113 +extern _Float64x expf64x(_Float64x __x) noexcept(true); extern _Float64x __expf64x(_Float64x __x) noexcept(true); +# 116 +extern _Float64x frexpf64x(_Float64x __x, int * __exponent) noexcept(true); extern _Float64x __frexpf64x(_Float64x __x, int * __exponent) noexcept(true); +# 119 +extern _Float64x ldexpf64x(_Float64x __x, int __exponent) noexcept(true); extern _Float64x __ldexpf64x(_Float64x __x, int __exponent) noexcept(true); +# 122 +extern _Float64x logf64x(_Float64x __x) noexcept(true); extern _Float64x __logf64x(_Float64x __x) noexcept(true); +# 125 +extern _Float64x log10f64x(_Float64x __x) noexcept(true); extern _Float64x __log10f64x(_Float64x __x) noexcept(true); +# 128 +extern _Float64x modff64x(_Float64x __x, _Float64x * __iptr) noexcept(true); extern _Float64x __modff64x(_Float64x __x, _Float64x * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 132 +extern _Float64x exp10f64x(_Float64x __x) noexcept(true); extern _Float64x __exp10f64x(_Float64x __x) noexcept(true); +# 135 +extern _Float64x exp2m1f64x(_Float64x __x) noexcept(true); extern _Float64x __exp2m1f64x(_Float64x __x) noexcept(true); +# 138 +extern _Float64x exp10m1f64x(_Float64x __x) noexcept(true); extern _Float64x __exp10m1f64x(_Float64x __x) noexcept(true); +# 141 +extern _Float64x log2p1f64x(_Float64x __x) noexcept(true); extern _Float64x __log2p1f64x(_Float64x __x) noexcept(true); +# 144 +extern _Float64x log10p1f64x(_Float64x __x) noexcept(true); extern _Float64x __log10p1f64x(_Float64x __x) noexcept(true); +# 147 +extern _Float64x logp1f64x(_Float64x __x) noexcept(true); extern _Float64x __logp1f64x(_Float64x __x) noexcept(true); +# 152 +extern _Float64x expm1f64x(_Float64x __x) noexcept(true); extern _Float64x __expm1f64x(_Float64x __x) noexcept(true); +# 155 +extern _Float64x log1pf64x(_Float64x __x) noexcept(true); extern _Float64x __log1pf64x(_Float64x __x) noexcept(true); +# 158 +extern _Float64x logbf64x(_Float64x __x) noexcept(true); extern _Float64x __logbf64x(_Float64x __x) noexcept(true); +# 163 +extern _Float64x exp2f64x(_Float64x __x) noexcept(true); extern _Float64x __exp2f64x(_Float64x __x) noexcept(true); +# 166 +extern _Float64x log2f64x(_Float64x __x) noexcept(true); extern _Float64x __log2f64x(_Float64x __x) noexcept(true); +# 173 +extern _Float64x powf64x(_Float64x __x, _Float64x __y) noexcept(true); extern _Float64x __powf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 176 +extern _Float64x sqrtf64x(_Float64x __x) noexcept(true); extern _Float64x __sqrtf64x(_Float64x __x) noexcept(true); +# 180 +extern _Float64x hypotf64x(_Float64x __x, _Float64x __y) noexcept(true); extern _Float64x __hypotf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 185 +extern _Float64x cbrtf64x(_Float64x __x) noexcept(true); extern _Float64x __cbrtf64x(_Float64x __x) noexcept(true); +# 192 +extern _Float64x ceilf64x(_Float64x __x) noexcept(true) __attribute((const)); +# 195 +extern _Float64x fabsf64x(_Float64x __x) noexcept(true) __attribute((const)); +# 198 +extern _Float64x floorf64x(_Float64x __x) noexcept(true) __attribute((const)); +# 201 +extern _Float64x fmodf64x(_Float64x __x, _Float64x __y) noexcept(true); extern _Float64x __fmodf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 231 "/usr/include/bits/mathcalls.h" 3 +extern _Float64x copysignf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 236 +extern _Float64x nanf64x(const char * __tagb) noexcept(true); extern _Float64x __nanf64x(const char * __tagb) noexcept(true); +# 253 "/usr/include/bits/mathcalls.h" 3 +extern _Float64x j0f64x(_Float64x) noexcept(true); extern _Float64x __j0f64x(_Float64x) noexcept(true); +# 254 +extern _Float64x j1f64x(_Float64x) noexcept(true); extern _Float64x __j1f64x(_Float64x) noexcept(true); +# 255 +extern _Float64x jnf64x(int, _Float64x) noexcept(true); extern _Float64x __jnf64x(int, _Float64x) noexcept(true); +# 256 +extern _Float64x y0f64x(_Float64x) noexcept(true); extern _Float64x __y0f64x(_Float64x) noexcept(true); +# 257 +extern _Float64x y1f64x(_Float64x) noexcept(true); extern _Float64x __y1f64x(_Float64x) noexcept(true); +# 258 +extern _Float64x ynf64x(int, _Float64x) noexcept(true); extern _Float64x __ynf64x(int, _Float64x) noexcept(true); +# 264 +extern _Float64x erff64x(_Float64x) noexcept(true); extern _Float64x __erff64x(_Float64x) noexcept(true); +# 265 +extern _Float64x erfcf64x(_Float64x) noexcept(true); extern _Float64x __erfcf64x(_Float64x) noexcept(true); +# 266 +extern _Float64x lgammaf64x(_Float64x) noexcept(true); extern _Float64x __lgammaf64x(_Float64x) noexcept(true); +# 271 +extern _Float64x tgammaf64x(_Float64x) noexcept(true); extern _Float64x __tgammaf64x(_Float64x) noexcept(true); +# 285 "/usr/include/bits/mathcalls.h" 3 +extern _Float64x lgammaf64x_r(_Float64x, int * __signgamp) noexcept(true); extern _Float64x __lgammaf64x_r(_Float64x, int * __signgamp) noexcept(true); +# 292 +extern _Float64x rintf64x(_Float64x __x) noexcept(true); extern _Float64x __rintf64x(_Float64x __x) noexcept(true); +# 295 +extern _Float64x nextafterf64x(_Float64x __x, _Float64x __y) noexcept(true); extern _Float64x __nextafterf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 302 +extern _Float64x nextdownf64x(_Float64x __x) noexcept(true); extern _Float64x __nextdownf64x(_Float64x __x) noexcept(true); +# 304 +extern _Float64x nextupf64x(_Float64x __x) noexcept(true); extern _Float64x __nextupf64x(_Float64x __x) noexcept(true); +# 308 +extern _Float64x remainderf64x(_Float64x __x, _Float64x __y) noexcept(true); extern _Float64x __remainderf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 312 +extern _Float64x scalbnf64x(_Float64x __x, int __n) noexcept(true); extern _Float64x __scalbnf64x(_Float64x __x, int __n) noexcept(true); +# 316 +extern int ilogbf64x(_Float64x __x) noexcept(true); extern int __ilogbf64x(_Float64x __x) noexcept(true); +# 321 +extern long llogbf64x(_Float64x __x) noexcept(true); extern long __llogbf64x(_Float64x __x) noexcept(true); +# 326 +extern _Float64x scalblnf64x(_Float64x __x, long __n) noexcept(true); extern _Float64x __scalblnf64x(_Float64x __x, long __n) noexcept(true); +# 330 +extern _Float64x nearbyintf64x(_Float64x __x) noexcept(true); extern _Float64x __nearbyintf64x(_Float64x __x) noexcept(true); +# 334 +extern _Float64x roundf64x(_Float64x __x) noexcept(true) __attribute((const)); +# 338 +extern _Float64x truncf64x(_Float64x __x) noexcept(true) __attribute((const)); +# 343 +extern _Float64x remquof64x(_Float64x __x, _Float64x __y, int * __quo) noexcept(true); extern _Float64x __remquof64x(_Float64x __x, _Float64x __y, int * __quo) noexcept(true); +# 350 +extern long lrintf64x(_Float64x __x) noexcept(true); extern long __lrintf64x(_Float64x __x) noexcept(true); +# 352 +__extension__ extern long long llrintf64x(_Float64x __x) noexcept(true); extern long long __llrintf64x(_Float64x __x) noexcept(true); +# 356 +extern long lroundf64x(_Float64x __x) noexcept(true); extern long __lroundf64x(_Float64x __x) noexcept(true); +# 358 +__extension__ extern long long llroundf64x(_Float64x __x) noexcept(true); extern long long __llroundf64x(_Float64x __x) noexcept(true); +# 362 +extern _Float64x fdimf64x(_Float64x __x, _Float64x __y) noexcept(true); extern _Float64x __fdimf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 366 +extern _Float64x fmaxf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 369 +extern _Float64x fminf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 373 +extern _Float64x fmaf64x(_Float64x __x, _Float64x __y, _Float64x __z) noexcept(true); extern _Float64x __fmaf64x(_Float64x __x, _Float64x __y, _Float64x __z) noexcept(true); +# 378 +extern _Float64x roundevenf64x(_Float64x __x) noexcept(true) __attribute((const)); +# 382 +extern __intmax_t fromfpf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); +# 387 +extern __uintmax_t ufromfpf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); +# 393 +extern __intmax_t fromfpxf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpxf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); +# 399 +extern __uintmax_t ufromfpxf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpxf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); +# 403 +extern int canonicalizef64x(_Float64x * __cx, const _Float64x * __x) noexcept(true); +# 410 +extern _Float64x fmaxmagf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 413 +extern _Float64x fminmagf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 418 +extern _Float64x fmaximumf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 421 +extern _Float64x fminimumf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 424 +extern _Float64x fmaximum_numf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 427 +extern _Float64x fminimum_numf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 430 +extern _Float64x fmaximum_magf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 433 +extern _Float64x fminimum_magf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 436 +extern _Float64x fmaximum_mag_numf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 439 +extern _Float64x fminimum_mag_numf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 444 +extern int totalorderf64x(const _Float64x * __x, const _Float64x * __y) noexcept(true) +# 446 + __attribute((__pure__)); +# 449 +extern int totalordermagf64x(const _Float64x * __x, const _Float64x * __y) noexcept(true) +# 451 + __attribute((__pure__)); +# 454 +extern _Float64x getpayloadf64x(const _Float64x * __x) noexcept(true); extern _Float64x __getpayloadf64x(const _Float64x * __x) noexcept(true); +# 457 +extern int setpayloadf64x(_Float64x * __x, _Float64x __payload) noexcept(true); +# 460 +extern int setpayloadsigf64x(_Float64x * __x, _Float64x __payload) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern float fadd(double __x, double __y) noexcept(true); +# 27 +extern float fdiv(double __x, double __y) noexcept(true); +# 30 +extern float ffma(double __x, double __y, double __z) noexcept(true); +# 33 +extern float fmul(double __x, double __y) noexcept(true); +# 36 +extern float fsqrt(double __x) noexcept(true); +# 39 +extern float fsub(double __x, double __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern float faddl(long double __x, long double __y) noexcept(true); +# 27 +extern float fdivl(long double __x, long double __y) noexcept(true); +# 30 +extern float ffmal(long double __x, long double __y, long double __z) noexcept(true); +# 33 +extern float fmull(long double __x, long double __y) noexcept(true); +# 36 +extern float fsqrtl(long double __x) noexcept(true); +# 39 +extern float fsubl(long double __x, long double __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern double daddl(long double __x, long double __y) noexcept(true); +# 27 +extern double ddivl(long double __x, long double __y) noexcept(true); +# 30 +extern double dfmal(long double __x, long double __y, long double __z) noexcept(true); +# 33 +extern double dmull(long double __x, long double __y) noexcept(true); +# 36 +extern double dsqrtl(long double __x) noexcept(true); +# 39 +extern double dsubl(long double __x, long double __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern _Float32 f32addf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 27 +extern _Float32 f32divf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 30 +extern _Float32 f32fmaf32x(_Float32x __x, _Float32x __y, _Float32x __z) noexcept(true); +# 33 +extern _Float32 f32mulf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 36 +extern _Float32 f32sqrtf32x(_Float32x __x) noexcept(true); +# 39 +extern _Float32 f32subf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern _Float32 f32addf64(_Float64 __x, _Float64 __y) noexcept(true); +# 27 +extern _Float32 f32divf64(_Float64 __x, _Float64 __y) noexcept(true); +# 30 +extern _Float32 f32fmaf64(_Float64 __x, _Float64 __y, _Float64 __z) noexcept(true); +# 33 +extern _Float32 f32mulf64(_Float64 __x, _Float64 __y) noexcept(true); +# 36 +extern _Float32 f32sqrtf64(_Float64 __x) noexcept(true); +# 39 +extern _Float32 f32subf64(_Float64 __x, _Float64 __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern _Float32 f32addf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 27 +extern _Float32 f32divf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 30 +extern _Float32 f32fmaf64x(_Float64x __x, _Float64x __y, _Float64x __z) noexcept(true); +# 33 +extern _Float32 f32mulf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 36 +extern _Float32 f32sqrtf64x(_Float64x __x) noexcept(true); +# 39 +extern _Float32 f32subf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern _Float32 f32addf128(_Float128 __x, _Float128 __y) noexcept(true); +# 27 +extern _Float32 f32divf128(_Float128 __x, _Float128 __y) noexcept(true); +# 30 +extern _Float32 f32fmaf128(_Float128 __x, _Float128 __y, _Float128 __z) noexcept(true); +# 33 +extern _Float32 f32mulf128(_Float128 __x, _Float128 __y) noexcept(true); +# 36 +extern _Float32 f32sqrtf128(_Float128 __x) noexcept(true); +# 39 +extern _Float32 f32subf128(_Float128 __x, _Float128 __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern _Float32x f32xaddf64(_Float64 __x, _Float64 __y) noexcept(true); +# 27 +extern _Float32x f32xdivf64(_Float64 __x, _Float64 __y) noexcept(true); +# 30 +extern _Float32x f32xfmaf64(_Float64 __x, _Float64 __y, _Float64 __z) noexcept(true); +# 33 +extern _Float32x f32xmulf64(_Float64 __x, _Float64 __y) noexcept(true); +# 36 +extern _Float32x f32xsqrtf64(_Float64 __x) noexcept(true); +# 39 +extern _Float32x f32xsubf64(_Float64 __x, _Float64 __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern _Float32x f32xaddf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 27 +extern _Float32x f32xdivf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 30 +extern _Float32x f32xfmaf64x(_Float64x __x, _Float64x __y, _Float64x __z) noexcept(true); +# 33 +extern _Float32x f32xmulf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 36 +extern _Float32x f32xsqrtf64x(_Float64x __x) noexcept(true); +# 39 +extern _Float32x f32xsubf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern _Float32x f32xaddf128(_Float128 __x, _Float128 __y) noexcept(true); +# 27 +extern _Float32x f32xdivf128(_Float128 __x, _Float128 __y) noexcept(true); +# 30 +extern _Float32x f32xfmaf128(_Float128 __x, _Float128 __y, _Float128 __z) noexcept(true); +# 33 +extern _Float32x f32xmulf128(_Float128 __x, _Float128 __y) noexcept(true); +# 36 +extern _Float32x f32xsqrtf128(_Float128 __x) noexcept(true); +# 39 +extern _Float32x f32xsubf128(_Float128 __x, _Float128 __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern _Float64 f64addf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 27 +extern _Float64 f64divf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 30 +extern _Float64 f64fmaf64x(_Float64x __x, _Float64x __y, _Float64x __z) noexcept(true); +# 33 +extern _Float64 f64mulf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 36 +extern _Float64 f64sqrtf64x(_Float64x __x) noexcept(true); +# 39 +extern _Float64 f64subf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern _Float64 f64addf128(_Float128 __x, _Float128 __y) noexcept(true); +# 27 +extern _Float64 f64divf128(_Float128 __x, _Float128 __y) noexcept(true); +# 30 +extern _Float64 f64fmaf128(_Float128 __x, _Float128 __y, _Float128 __z) noexcept(true); +# 33 +extern _Float64 f64mulf128(_Float128 __x, _Float128 __y) noexcept(true); +# 36 +extern _Float64 f64sqrtf128(_Float128 __x) noexcept(true); +# 39 +extern _Float64 f64subf128(_Float128 __x, _Float128 __y) noexcept(true); +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 +extern _Float64x f64xaddf128(_Float128 __x, _Float128 __y) noexcept(true); +# 27 +extern _Float64x f64xdivf128(_Float128 __x, _Float128 __y) noexcept(true); +# 30 +extern _Float64x f64xfmaf128(_Float128 __x, _Float128 __y, _Float128 __z) noexcept(true); +# 33 +extern _Float64x f64xmulf128(_Float128 __x, _Float128 __y) noexcept(true); +# 36 +extern _Float64x f64xsqrtf128(_Float128 __x) noexcept(true); +# 39 +extern _Float64x f64xsubf128(_Float128 __x, _Float128 __y) noexcept(true); +# 823 "/usr/include/math.h" 3 +extern int signgam; +# 904 "/usr/include/math.h" 3 +enum { +# 905 +FP_NAN, +# 908 +FP_INFINITE, +# 911 +FP_ZERO, +# 914 +FP_SUBNORMAL, +# 917 +FP_NORMAL +# 920 +}; +# 23 "/usr/include/bits/iscanonical.h" 3 +extern int __iscanonicall(long double __x) noexcept(true) +# 24 + __attribute((const)); +# 46 "/usr/include/bits/iscanonical.h" 3 +extern "C++" { +# 47 +inline int iscanonical(float __val) { return (((void)((__typeof__(__val))__val)), 1); } +# 48 +inline int iscanonical(double __val) { return (((void)((__typeof__(__val))__val)), 1); } +# 49 +inline int iscanonical(long double __val) { return __iscanonicall(__val); } +# 51 +inline int iscanonical(_Float128 __val) { return (((void)((__typeof__(__val))__val)), 1); } +# 53 +} +# 1036 "/usr/include/math.h" 3 +extern "C++" { +# 1037 +inline int issignaling(float __val) { return __issignalingf(__val); } +# 1038 +inline int issignaling(double __val) { return __issignaling(__val); } +# 1040 +inline int issignaling(long double __val) +# 1041 +{ +# 1045 +return __issignalingl(__val); +# 1047 +} +# 1051 +inline int issignaling(_Float128 __val) { return __issignalingf128(__val); } +# 1053 +} +# 1067 "/usr/include/math.h" 3 +extern "C++" { +# 1098 "/usr/include/math.h" 3 +template< class __T> inline bool +# 1099 +iszero(__T __val) +# 1100 +{ +# 1101 +return __val == 0; +# 1102 +} +# 1104 +} +# 1333 "/usr/include/math.h" 3 +extern "C++" { +# 1334 +template< class > struct __iseqsig_type; +# 1336 +template<> struct __iseqsig_type< float> { +# 1338 +static int __call(float __x, float __y) throw() +# 1339 +{ +# 1340 +return __iseqsigf(__x, __y); +# 1341 +} +# 1342 +}; +# 1344 +template<> struct __iseqsig_type< double> { +# 1346 +static int __call(double __x, double __y) throw() +# 1347 +{ +# 1348 +return __iseqsig(__x, __y); +# 1349 +} +# 1350 +}; +# 1352 +template<> struct __iseqsig_type< long double> { +# 1354 +static int __call(long double __x, long double __y) throw() +# 1355 +{ +# 1357 +return __iseqsigl(__x, __y); +# 1361 +} +# 1362 +}; +# 1365 +template<> struct __iseqsig_type< _Float32> { +# 1367 +static int __call(_Float32 __x, _Float32 __y) throw() +# 1368 +{ +# 1369 +return __iseqsigf(__x, __y); +# 1370 +} +# 1371 +}; +# 1375 +template<> struct __iseqsig_type< _Float64> { +# 1377 +static int __call(_Float64 __x, _Float64 __y) throw() +# 1378 +{ +# 1379 +return __iseqsig(__x, __y); +# 1380 +} +# 1381 +}; +# 1387 +template<> struct __iseqsig_type< _Float128> { +# 1389 +static int __call(_Float128 __x, _Float128 __y) throw() +# 1390 +{ +# 1392 +return __iseqsigf128(__x, __y); +# 1396 +} +# 1397 +}; +# 1401 +template<> struct __iseqsig_type< _Float32x> { +# 1403 +static int __call(_Float32x __x, _Float32x __y) throw() +# 1404 +{ +# 1405 +return __iseqsig(__x, __y); +# 1406 +} +# 1407 +}; +# 1411 +template<> struct __iseqsig_type< _Float64x> { +# 1413 +static int __call(_Float64x __x, _Float64x __y) throw() +# 1414 +{ +# 1416 +return __iseqsigl(__x, __y); +# 1420 +} +# 1421 +}; +# 1424 +template< class _T1, class _T2> inline int +# 1426 +iseqsig(_T1 __x, _T2 __y) throw() +# 1427 +{ +# 1429 +typedef __decltype(((__x + __y) + (0.0F))) _T3; +# 1433 +return __iseqsig_type< __decltype(((__x + __y) + (0.0F)))> ::__call(__x, __y); +# 1434 +} +# 1436 +} +# 1441 +} +# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +extern "C++" { +# 85 +namespace std __attribute((__visibility__("default"))) { +# 89 +using ::acos; +# 93 +constexpr float acos(float __x) +# 94 +{ return __builtin_acosf(__x); } +# 97 +constexpr long double acos(long double __x) +# 98 +{ return __builtin_acosl(__x); } +# 101 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 105 +acos(_Tp __x) +# 106 +{ return __builtin_acos(__x); } +# 108 +using ::asin; +# 112 +constexpr float asin(float __x) +# 113 +{ return __builtin_asinf(__x); } +# 116 +constexpr long double asin(long double __x) +# 117 +{ return __builtin_asinl(__x); } +# 120 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 124 +asin(_Tp __x) +# 125 +{ return __builtin_asin(__x); } +# 127 +using ::atan; +# 131 +constexpr float atan(float __x) +# 132 +{ return __builtin_atanf(__x); } +# 135 +constexpr long double atan(long double __x) +# 136 +{ return __builtin_atanl(__x); } +# 139 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 143 +atan(_Tp __x) +# 144 +{ return __builtin_atan(__x); } +# 146 +using ::atan2; +# 150 +constexpr float atan2(float __y, float __x) +# 151 +{ return __builtin_atan2f(__y, __x); } +# 154 +constexpr long double atan2(long double __y, long double __x) +# 155 +{ return __builtin_atan2l(__y, __x); } +# 158 +using ::ceil; +# 162 +constexpr float ceil(float __x) +# 163 +{ return __builtin_ceilf(__x); } +# 166 +constexpr long double ceil(long double __x) +# 167 +{ return __builtin_ceill(__x); } +# 170 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 174 +ceil(_Tp __x) +# 175 +{ return __builtin_ceil(__x); } +# 177 +using ::cos; +# 181 +constexpr float cos(float __x) +# 182 +{ return __builtin_cosf(__x); } +# 185 +constexpr long double cos(long double __x) +# 186 +{ return __builtin_cosl(__x); } +# 189 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 193 +cos(_Tp __x) +# 194 +{ return __builtin_cos(__x); } +# 196 +using ::cosh; +# 200 +constexpr float cosh(float __x) +# 201 +{ return __builtin_coshf(__x); } +# 204 +constexpr long double cosh(long double __x) +# 205 +{ return __builtin_coshl(__x); } +# 208 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 212 +cosh(_Tp __x) +# 213 +{ return __builtin_cosh(__x); } +# 215 +using ::exp; +# 219 +constexpr float exp(float __x) +# 220 +{ return __builtin_expf(__x); } +# 223 +constexpr long double exp(long double __x) +# 224 +{ return __builtin_expl(__x); } +# 227 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 231 +exp(_Tp __x) +# 232 +{ return __builtin_exp(__x); } +# 234 +using ::fabs; +# 238 +constexpr float fabs(float __x) +# 239 +{ return __builtin_fabsf(__x); } +# 242 +constexpr long double fabs(long double __x) +# 243 +{ return __builtin_fabsl(__x); } +# 246 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 250 +fabs(_Tp __x) +# 251 +{ return __builtin_fabs(__x); } +# 253 +using ::floor; +# 257 +constexpr float floor(float __x) +# 258 +{ return __builtin_floorf(__x); } +# 261 +constexpr long double floor(long double __x) +# 262 +{ return __builtin_floorl(__x); } +# 265 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 269 +floor(_Tp __x) +# 270 +{ return __builtin_floor(__x); } +# 272 +using ::fmod; +# 276 +constexpr float fmod(float __x, float __y) +# 277 +{ return __builtin_fmodf(__x, __y); } +# 280 +constexpr long double fmod(long double __x, long double __y) +# 281 +{ return __builtin_fmodl(__x, __y); } +# 284 +using ::frexp; +# 288 +inline float frexp(float __x, int *__exp) +# 289 +{ return __builtin_frexpf(__x, __exp); } +# 292 +inline long double frexp(long double __x, int *__exp) +# 293 +{ return __builtin_frexpl(__x, __exp); } +# 296 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 300 +frexp(_Tp __x, int *__exp) +# 301 +{ return __builtin_frexp(__x, __exp); } +# 303 +using ::ldexp; +# 307 +constexpr float ldexp(float __x, int __exp) +# 308 +{ return __builtin_ldexpf(__x, __exp); } +# 311 +constexpr long double ldexp(long double __x, int __exp) +# 312 +{ return __builtin_ldexpl(__x, __exp); } +# 315 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 319 +ldexp(_Tp __x, int __exp) +# 320 +{ return __builtin_ldexp(__x, __exp); } +# 322 +using ::log; +# 326 +constexpr float log(float __x) +# 327 +{ return __builtin_logf(__x); } +# 330 +constexpr long double log(long double __x) +# 331 +{ return __builtin_logl(__x); } +# 334 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 338 +log(_Tp __x) +# 339 +{ return __builtin_log(__x); } +# 341 +using ::log10; +# 345 +constexpr float log10(float __x) +# 346 +{ return __builtin_log10f(__x); } +# 349 +constexpr long double log10(long double __x) +# 350 +{ return __builtin_log10l(__x); } +# 353 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 357 +log10(_Tp __x) +# 358 +{ return __builtin_log10(__x); } +# 360 +using ::modf; +# 364 +inline float modf(float __x, float *__iptr) +# 365 +{ return __builtin_modff(__x, __iptr); } +# 368 +inline long double modf(long double __x, long double *__iptr) +# 369 +{ return __builtin_modfl(__x, __iptr); } +# 372 +using ::pow; +# 376 +constexpr float pow(float __x, float __y) +# 377 +{ return __builtin_powf(__x, __y); } +# 380 +constexpr long double pow(long double __x, long double __y) +# 381 +{ return __builtin_powl(__x, __y); } +# 400 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +using ::sin; +# 404 +constexpr float sin(float __x) +# 405 +{ return __builtin_sinf(__x); } +# 408 +constexpr long double sin(long double __x) +# 409 +{ return __builtin_sinl(__x); } +# 412 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 416 +sin(_Tp __x) +# 417 +{ return __builtin_sin(__x); } +# 419 +using ::sinh; +# 423 +constexpr float sinh(float __x) +# 424 +{ return __builtin_sinhf(__x); } +# 427 +constexpr long double sinh(long double __x) +# 428 +{ return __builtin_sinhl(__x); } +# 431 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 435 +sinh(_Tp __x) +# 436 +{ return __builtin_sinh(__x); } +# 438 +using ::sqrt; +# 442 +constexpr float sqrt(float __x) +# 443 +{ return __builtin_sqrtf(__x); } +# 446 +constexpr long double sqrt(long double __x) +# 447 +{ return __builtin_sqrtl(__x); } +# 450 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 454 +sqrt(_Tp __x) +# 455 +{ return __builtin_sqrt(__x); } +# 457 +using ::tan; +# 461 +constexpr float tan(float __x) +# 462 +{ return __builtin_tanf(__x); } +# 465 +constexpr long double tan(long double __x) +# 466 +{ return __builtin_tanl(__x); } +# 469 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 473 +tan(_Tp __x) +# 474 +{ return __builtin_tan(__x); } +# 476 +using ::tanh; +# 480 +constexpr float tanh(float __x) +# 481 +{ return __builtin_tanhf(__x); } +# 484 +constexpr long double tanh(long double __x) +# 485 +{ return __builtin_tanhl(__x); } +# 488 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 492 +tanh(_Tp __x) +# 493 +{ return __builtin_tanh(__x); } +# 1053 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 1056 +atan2(_Tp __y, _Up __x) +# 1057 +{ +# 1058 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1059 +return atan2((__type)__y, (__type)__x); +# 1060 +} +# 1062 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 1065 +fmod(_Tp __x, _Up __y) +# 1066 +{ +# 1067 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1068 +return fmod((__type)__x, (__type)__y); +# 1069 +} +# 1071 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 1074 +pow(_Tp __x, _Up __y) +# 1075 +{ +# 1076 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1077 +return pow((__type)__x, (__type)__y); +# 1078 +} +# 1101 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +constexpr int fpclassify(float __x) +# 1102 +{ return __builtin_fpclassify(0, 1, 4, 3, 2, __x); +# 1103 +} +# 1106 +constexpr int fpclassify(double __x) +# 1107 +{ return __builtin_fpclassify(0, 1, 4, 3, 2, __x); +# 1108 +} +# 1111 +constexpr int fpclassify(long double __x) +# 1112 +{ return __builtin_fpclassify(0, 1, 4, 3, 2, __x); +# 1113 +} +# 1117 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, int> ::__type +# 1120 +fpclassify(_Tp __x) +# 1121 +{ return (__x != 0) ? 4 : 2; } +# 1126 +constexpr bool isfinite(float __x) +# 1127 +{ return __builtin_isfinite(__x); } +# 1130 +constexpr bool isfinite(double __x) +# 1131 +{ return __builtin_isfinite(__x); } +# 1134 +constexpr bool isfinite(long double __x) +# 1135 +{ return __builtin_isfinite(__x); } +# 1139 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, bool> ::__type +# 1142 +isfinite(_Tp) +# 1143 +{ return true; } +# 1148 +constexpr bool isinf(float __x) +# 1149 +{ return __builtin_isinf(__x); } +# 1156 +constexpr bool isinf(double __x) +# 1157 +{ return __builtin_isinf(__x); } +# 1161 +constexpr bool isinf(long double __x) +# 1162 +{ return __builtin_isinf(__x); } +# 1166 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, bool> ::__type +# 1169 +isinf(_Tp) +# 1170 +{ return false; } +# 1175 +constexpr bool isnan(float __x) +# 1176 +{ return __builtin_isnan(__x); } +# 1183 +constexpr bool isnan(double __x) +# 1184 +{ return __builtin_isnan(__x); } +# 1188 +constexpr bool isnan(long double __x) +# 1189 +{ return __builtin_isnan(__x); } +# 1193 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, bool> ::__type +# 1196 +isnan(_Tp) +# 1197 +{ return false; } +# 1202 +constexpr bool isnormal(float __x) +# 1203 +{ return __builtin_isnormal(__x); } +# 1206 +constexpr bool isnormal(double __x) +# 1207 +{ return __builtin_isnormal(__x); } +# 1210 +constexpr bool isnormal(long double __x) +# 1211 +{ return __builtin_isnormal(__x); } +# 1215 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, bool> ::__type +# 1218 +isnormal(_Tp __x) +# 1219 +{ return (__x != 0) ? true : false; } +# 1225 +constexpr bool signbit(float __x) +# 1226 +{ return __builtin_signbit(__x); } +# 1229 +constexpr bool signbit(double __x) +# 1230 +{ return __builtin_signbit(__x); } +# 1233 +constexpr bool signbit(long double __x) +# 1234 +{ return __builtin_signbit(__x); } +# 1238 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, bool> ::__type +# 1241 +signbit(_Tp __x) +# 1242 +{ return (__x < 0) ? true : false; } +# 1247 +constexpr bool isgreater(float __x, float __y) +# 1248 +{ return __builtin_isgreater(__x, __y); } +# 1251 +constexpr bool isgreater(double __x, double __y) +# 1252 +{ return __builtin_isgreater(__x, __y); } +# 1255 +constexpr bool isgreater(long double __x, long double __y) +# 1256 +{ return __builtin_isgreater(__x, __y); } +# 1260 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__enable_if< __is_arithmetic< _Tp> ::__value && __is_arithmetic< _Up> ::__value, bool> ::__type +# 1264 +isgreater(_Tp __x, _Up __y) +# 1265 +{ +# 1266 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1267 +return __builtin_isgreater((__type)__x, (__type)__y); +# 1268 +} +# 1273 +constexpr bool isgreaterequal(float __x, float __y) +# 1274 +{ return __builtin_isgreaterequal(__x, __y); } +# 1277 +constexpr bool isgreaterequal(double __x, double __y) +# 1278 +{ return __builtin_isgreaterequal(__x, __y); } +# 1281 +constexpr bool isgreaterequal(long double __x, long double __y) +# 1282 +{ return __builtin_isgreaterequal(__x, __y); } +# 1286 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__enable_if< __is_arithmetic< _Tp> ::__value && __is_arithmetic< _Up> ::__value, bool> ::__type +# 1290 +isgreaterequal(_Tp __x, _Up __y) +# 1291 +{ +# 1292 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1293 +return __builtin_isgreaterequal((__type)__x, (__type)__y); +# 1294 +} +# 1299 +constexpr bool isless(float __x, float __y) +# 1300 +{ return __builtin_isless(__x, __y); } +# 1303 +constexpr bool isless(double __x, double __y) +# 1304 +{ return __builtin_isless(__x, __y); } +# 1307 +constexpr bool isless(long double __x, long double __y) +# 1308 +{ return __builtin_isless(__x, __y); } +# 1312 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__enable_if< __is_arithmetic< _Tp> ::__value && __is_arithmetic< _Up> ::__value, bool> ::__type +# 1316 +isless(_Tp __x, _Up __y) +# 1317 +{ +# 1318 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1319 +return __builtin_isless((__type)__x, (__type)__y); +# 1320 +} +# 1325 +constexpr bool islessequal(float __x, float __y) +# 1326 +{ return __builtin_islessequal(__x, __y); } +# 1329 +constexpr bool islessequal(double __x, double __y) +# 1330 +{ return __builtin_islessequal(__x, __y); } +# 1333 +constexpr bool islessequal(long double __x, long double __y) +# 1334 +{ return __builtin_islessequal(__x, __y); } +# 1338 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__enable_if< __is_arithmetic< _Tp> ::__value && __is_arithmetic< _Up> ::__value, bool> ::__type +# 1342 +islessequal(_Tp __x, _Up __y) +# 1343 +{ +# 1344 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1345 +return __builtin_islessequal((__type)__x, (__type)__y); +# 1346 +} +# 1351 +constexpr bool islessgreater(float __x, float __y) +# 1352 +{ return __builtin_islessgreater(__x, __y); } +# 1355 +constexpr bool islessgreater(double __x, double __y) +# 1356 +{ return __builtin_islessgreater(__x, __y); } +# 1359 +constexpr bool islessgreater(long double __x, long double __y) +# 1360 +{ return __builtin_islessgreater(__x, __y); } +# 1364 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__enable_if< __is_arithmetic< _Tp> ::__value && __is_arithmetic< _Up> ::__value, bool> ::__type +# 1368 +islessgreater(_Tp __x, _Up __y) +# 1369 +{ +# 1370 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1371 +return __builtin_islessgreater((__type)__x, (__type)__y); +# 1372 +} +# 1377 +constexpr bool isunordered(float __x, float __y) +# 1378 +{ return __builtin_isunordered(__x, __y); } +# 1381 +constexpr bool isunordered(double __x, double __y) +# 1382 +{ return __builtin_isunordered(__x, __y); } +# 1385 +constexpr bool isunordered(long double __x, long double __y) +# 1386 +{ return __builtin_isunordered(__x, __y); } +# 1390 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__enable_if< __is_arithmetic< _Tp> ::__value && __is_arithmetic< _Up> ::__value, bool> ::__type +# 1394 +isunordered(_Tp __x, _Up __y) +# 1395 +{ +# 1396 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1397 +return __builtin_isunordered((__type)__x, (__type)__y); +# 1398 +} +# 1820 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +using ::acosf; +# 1823 +using ::acosl; +# 1827 +using ::asinf; +# 1830 +using ::asinl; +# 1834 +using ::atanf; +# 1837 +using ::atanl; +# 1841 +using ::atan2f; +# 1844 +using ::atan2l; +# 1848 +using ::ceilf; +# 1851 +using ::ceill; +# 1855 +using ::cosf; +# 1858 +using ::cosl; +# 1862 +using ::coshf; +# 1865 +using ::coshl; +# 1869 +using ::expf; +# 1872 +using ::expl; +# 1876 +using ::fabsf; +# 1879 +using ::fabsl; +# 1883 +using ::floorf; +# 1886 +using ::floorl; +# 1890 +using ::fmodf; +# 1893 +using ::fmodl; +# 1897 +using ::frexpf; +# 1900 +using ::frexpl; +# 1904 +using ::ldexpf; +# 1907 +using ::ldexpl; +# 1911 +using ::logf; +# 1914 +using ::logl; +# 1918 +using ::log10f; +# 1921 +using ::log10l; +# 1925 +using ::modff; +# 1928 +using ::modfl; +# 1932 +using ::powf; +# 1935 +using ::powl; +# 1939 +using ::sinf; +# 1942 +using ::sinl; +# 1946 +using ::sinhf; +# 1949 +using ::sinhl; +# 1953 +using ::sqrtf; +# 1956 +using ::sqrtl; +# 1960 +using ::tanf; +# 1963 +using ::tanl; +# 1967 +using ::tanhf; +# 1970 +using ::tanhl; +# 2085 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +using ::double_t; +# 2086 +using ::float_t; +# 2090 +using ::acosh; +# 2091 +using ::acoshf; +# 2092 +using ::acoshl; +# 2094 +using ::asinh; +# 2095 +using ::asinhf; +# 2096 +using ::asinhl; +# 2098 +using ::atanh; +# 2099 +using ::atanhf; +# 2100 +using ::atanhl; +# 2102 +using ::cbrt; +# 2103 +using ::cbrtf; +# 2104 +using ::cbrtl; +# 2106 +using ::copysign; +# 2107 +using ::copysignf; +# 2108 +using ::copysignl; +# 2110 +using ::erf; +# 2111 +using ::erff; +# 2112 +using ::erfl; +# 2114 +using ::erfc; +# 2115 +using ::erfcf; +# 2116 +using ::erfcl; +# 2118 +using ::exp2; +# 2119 +using ::exp2f; +# 2120 +using ::exp2l; +# 2122 +using ::expm1; +# 2123 +using ::expm1f; +# 2124 +using ::expm1l; +# 2126 +using ::fdim; +# 2127 +using ::fdimf; +# 2128 +using ::fdiml; +# 2130 +using ::fma; +# 2131 +using ::fmaf; +# 2132 +using ::fmal; +# 2134 +using ::fmax; +# 2135 +using ::fmaxf; +# 2136 +using ::fmaxl; +# 2138 +using ::fmin; +# 2139 +using ::fminf; +# 2140 +using ::fminl; +# 2142 +using ::hypot; +# 2143 +using ::hypotf; +# 2144 +using ::hypotl; +# 2146 +using ::ilogb; +# 2147 +using ::ilogbf; +# 2148 +using ::ilogbl; +# 2150 +using ::lgamma; +# 2151 +using ::lgammaf; +# 2152 +using ::lgammal; +# 2155 +using ::llrint; +# 2156 +using ::llrintf; +# 2157 +using ::llrintl; +# 2159 +using ::llround; +# 2160 +using ::llroundf; +# 2161 +using ::llroundl; +# 2164 +using ::log1p; +# 2165 +using ::log1pf; +# 2166 +using ::log1pl; +# 2168 +using ::log2; +# 2169 +using ::log2f; +# 2170 +using ::log2l; +# 2172 +using ::logb; +# 2173 +using ::logbf; +# 2174 +using ::logbl; +# 2176 +using ::lrint; +# 2177 +using ::lrintf; +# 2178 +using ::lrintl; +# 2180 +using ::lround; +# 2181 +using ::lroundf; +# 2182 +using ::lroundl; +# 2184 +using ::nan; +# 2185 +using ::nanf; +# 2186 +using ::nanl; +# 2188 +using ::nearbyint; +# 2189 +using ::nearbyintf; +# 2190 +using ::nearbyintl; +# 2192 +using ::nextafter; +# 2193 +using ::nextafterf; +# 2194 +using ::nextafterl; +# 2196 +using ::nexttoward; +# 2197 +using ::nexttowardf; +# 2198 +using ::nexttowardl; +# 2200 +using ::remainder; +# 2201 +using ::remainderf; +# 2202 +using ::remainderl; +# 2204 +using ::remquo; +# 2205 +using ::remquof; +# 2206 +using ::remquol; +# 2208 +using ::rint; +# 2209 +using ::rintf; +# 2210 +using ::rintl; +# 2212 +using ::round; +# 2213 +using ::roundf; +# 2214 +using ::roundl; +# 2216 +using ::scalbln; +# 2217 +using ::scalblnf; +# 2218 +using ::scalblnl; +# 2220 +using ::scalbn; +# 2221 +using ::scalbnf; +# 2222 +using ::scalbnl; +# 2224 +using ::tgamma; +# 2225 +using ::tgammaf; +# 2226 +using ::tgammal; +# 2228 +using ::trunc; +# 2229 +using ::truncf; +# 2230 +using ::truncl; +# 2235 +constexpr float acosh(float __x) +# 2236 +{ return __builtin_acoshf(__x); } +# 2239 +constexpr long double acosh(long double __x) +# 2240 +{ return __builtin_acoshl(__x); } +# 2244 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2247 +acosh(_Tp __x) +# 2248 +{ return __builtin_acosh(__x); } +# 2253 +constexpr float asinh(float __x) +# 2254 +{ return __builtin_asinhf(__x); } +# 2257 +constexpr long double asinh(long double __x) +# 2258 +{ return __builtin_asinhl(__x); } +# 2262 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2265 +asinh(_Tp __x) +# 2266 +{ return __builtin_asinh(__x); } +# 2271 +constexpr float atanh(float __x) +# 2272 +{ return __builtin_atanhf(__x); } +# 2275 +constexpr long double atanh(long double __x) +# 2276 +{ return __builtin_atanhl(__x); } +# 2280 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2283 +atanh(_Tp __x) +# 2284 +{ return __builtin_atanh(__x); } +# 2289 +constexpr float cbrt(float __x) +# 2290 +{ return __builtin_cbrtf(__x); } +# 2293 +constexpr long double cbrt(long double __x) +# 2294 +{ return __builtin_cbrtl(__x); } +# 2298 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2301 +cbrt(_Tp __x) +# 2302 +{ return __builtin_cbrt(__x); } +# 2307 +constexpr float copysign(float __x, float __y) +# 2308 +{ return __builtin_copysignf(__x, __y); } +# 2311 +constexpr long double copysign(long double __x, long double __y) +# 2312 +{ return __builtin_copysignl(__x, __y); } +# 2317 +constexpr float erf(float __x) +# 2318 +{ return __builtin_erff(__x); } +# 2321 +constexpr long double erf(long double __x) +# 2322 +{ return __builtin_erfl(__x); } +# 2326 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2329 +erf(_Tp __x) +# 2330 +{ return __builtin_erf(__x); } +# 2335 +constexpr float erfc(float __x) +# 2336 +{ return __builtin_erfcf(__x); } +# 2339 +constexpr long double erfc(long double __x) +# 2340 +{ return __builtin_erfcl(__x); } +# 2344 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2347 +erfc(_Tp __x) +# 2348 +{ return __builtin_erfc(__x); } +# 2353 +constexpr float exp2(float __x) +# 2354 +{ return __builtin_exp2f(__x); } +# 2357 +constexpr long double exp2(long double __x) +# 2358 +{ return __builtin_exp2l(__x); } +# 2362 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2365 +exp2(_Tp __x) +# 2366 +{ return __builtin_exp2(__x); } +# 2371 +constexpr float expm1(float __x) +# 2372 +{ return __builtin_expm1f(__x); } +# 2375 +constexpr long double expm1(long double __x) +# 2376 +{ return __builtin_expm1l(__x); } +# 2380 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2383 +expm1(_Tp __x) +# 2384 +{ return __builtin_expm1(__x); } +# 2389 +constexpr float fdim(float __x, float __y) +# 2390 +{ return __builtin_fdimf(__x, __y); } +# 2393 +constexpr long double fdim(long double __x, long double __y) +# 2394 +{ return __builtin_fdiml(__x, __y); } +# 2399 +constexpr float fma(float __x, float __y, float __z) +# 2400 +{ return __builtin_fmaf(__x, __y, __z); } +# 2403 +constexpr long double fma(long double __x, long double __y, long double __z) +# 2404 +{ return __builtin_fmal(__x, __y, __z); } +# 2409 +constexpr float fmax(float __x, float __y) +# 2410 +{ return __builtin_fmaxf(__x, __y); } +# 2413 +constexpr long double fmax(long double __x, long double __y) +# 2414 +{ return __builtin_fmaxl(__x, __y); } +# 2419 +constexpr float fmin(float __x, float __y) +# 2420 +{ return __builtin_fminf(__x, __y); } +# 2423 +constexpr long double fmin(long double __x, long double __y) +# 2424 +{ return __builtin_fminl(__x, __y); } +# 2429 +constexpr float hypot(float __x, float __y) +# 2430 +{ return __builtin_hypotf(__x, __y); } +# 2433 +constexpr long double hypot(long double __x, long double __y) +# 2434 +{ return __builtin_hypotl(__x, __y); } +# 2439 +constexpr int ilogb(float __x) +# 2440 +{ return __builtin_ilogbf(__x); } +# 2443 +constexpr int ilogb(long double __x) +# 2444 +{ return __builtin_ilogbl(__x); } +# 2448 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, int> ::__type +# 2452 +ilogb(_Tp __x) +# 2453 +{ return __builtin_ilogb(__x); } +# 2458 +constexpr float lgamma(float __x) +# 2459 +{ return __builtin_lgammaf(__x); } +# 2462 +constexpr long double lgamma(long double __x) +# 2463 +{ return __builtin_lgammal(__x); } +# 2467 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2470 +lgamma(_Tp __x) +# 2471 +{ return __builtin_lgamma(__x); } +# 2476 +constexpr long long llrint(float __x) +# 2477 +{ return __builtin_llrintf(__x); } +# 2480 +constexpr long long llrint(long double __x) +# 2481 +{ return __builtin_llrintl(__x); } +# 2485 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, long long> ::__type +# 2488 +llrint(_Tp __x) +# 2489 +{ return __builtin_llrint(__x); } +# 2494 +constexpr long long llround(float __x) +# 2495 +{ return __builtin_llroundf(__x); } +# 2498 +constexpr long long llround(long double __x) +# 2499 +{ return __builtin_llroundl(__x); } +# 2503 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, long long> ::__type +# 2506 +llround(_Tp __x) +# 2507 +{ return __builtin_llround(__x); } +# 2512 +constexpr float log1p(float __x) +# 2513 +{ return __builtin_log1pf(__x); } +# 2516 +constexpr long double log1p(long double __x) +# 2517 +{ return __builtin_log1pl(__x); } +# 2521 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2524 +log1p(_Tp __x) +# 2525 +{ return __builtin_log1p(__x); } +# 2531 +constexpr float log2(float __x) +# 2532 +{ return __builtin_log2f(__x); } +# 2535 +constexpr long double log2(long double __x) +# 2536 +{ return __builtin_log2l(__x); } +# 2540 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2543 +log2(_Tp __x) +# 2544 +{ return __builtin_log2(__x); } +# 2549 +constexpr float logb(float __x) +# 2550 +{ return __builtin_logbf(__x); } +# 2553 +constexpr long double logb(long double __x) +# 2554 +{ return __builtin_logbl(__x); } +# 2558 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2561 +logb(_Tp __x) +# 2562 +{ return __builtin_logb(__x); } +# 2567 +constexpr long lrint(float __x) +# 2568 +{ return __builtin_lrintf(__x); } +# 2571 +constexpr long lrint(long double __x) +# 2572 +{ return __builtin_lrintl(__x); } +# 2576 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, long> ::__type +# 2579 +lrint(_Tp __x) +# 2580 +{ return __builtin_lrint(__x); } +# 2585 +constexpr long lround(float __x) +# 2586 +{ return __builtin_lroundf(__x); } +# 2589 +constexpr long lround(long double __x) +# 2590 +{ return __builtin_lroundl(__x); } +# 2594 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, long> ::__type +# 2597 +lround(_Tp __x) +# 2598 +{ return __builtin_lround(__x); } +# 2603 +constexpr float nearbyint(float __x) +# 2604 +{ return __builtin_nearbyintf(__x); } +# 2607 +constexpr long double nearbyint(long double __x) +# 2608 +{ return __builtin_nearbyintl(__x); } +# 2612 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2615 +nearbyint(_Tp __x) +# 2616 +{ return __builtin_nearbyint(__x); } +# 2621 +constexpr float nextafter(float __x, float __y) +# 2622 +{ return __builtin_nextafterf(__x, __y); } +# 2625 +constexpr long double nextafter(long double __x, long double __y) +# 2626 +{ return __builtin_nextafterl(__x, __y); } +# 2631 +constexpr float nexttoward(float __x, long double __y) +# 2632 +{ return __builtin_nexttowardf(__x, __y); } +# 2635 +constexpr long double nexttoward(long double __x, long double __y) +# 2636 +{ return __builtin_nexttowardl(__x, __y); } +# 2640 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2643 +nexttoward(_Tp __x, long double __y) +# 2644 +{ return __builtin_nexttoward(__x, __y); } +# 2649 +constexpr float remainder(float __x, float __y) +# 2650 +{ return __builtin_remainderf(__x, __y); } +# 2653 +constexpr long double remainder(long double __x, long double __y) +# 2654 +{ return __builtin_remainderl(__x, __y); } +# 2659 +inline float remquo(float __x, float __y, int *__pquo) +# 2660 +{ return __builtin_remquof(__x, __y, __pquo); } +# 2663 +inline long double remquo(long double __x, long double __y, int *__pquo) +# 2664 +{ return __builtin_remquol(__x, __y, __pquo); } +# 2669 +constexpr float rint(float __x) +# 2670 +{ return __builtin_rintf(__x); } +# 2673 +constexpr long double rint(long double __x) +# 2674 +{ return __builtin_rintl(__x); } +# 2678 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2681 +rint(_Tp __x) +# 2682 +{ return __builtin_rint(__x); } +# 2687 +constexpr float round(float __x) +# 2688 +{ return __builtin_roundf(__x); } +# 2691 +constexpr long double round(long double __x) +# 2692 +{ return __builtin_roundl(__x); } +# 2696 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2699 +round(_Tp __x) +# 2700 +{ return __builtin_round(__x); } +# 2705 +constexpr float scalbln(float __x, long __ex) +# 2706 +{ return __builtin_scalblnf(__x, __ex); } +# 2709 +constexpr long double scalbln(long double __x, long __ex) +# 2710 +{ return __builtin_scalblnl(__x, __ex); } +# 2714 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2717 +scalbln(_Tp __x, long __ex) +# 2718 +{ return __builtin_scalbln(__x, __ex); } +# 2723 +constexpr float scalbn(float __x, int __ex) +# 2724 +{ return __builtin_scalbnf(__x, __ex); } +# 2727 +constexpr long double scalbn(long double __x, int __ex) +# 2728 +{ return __builtin_scalbnl(__x, __ex); } +# 2732 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2735 +scalbn(_Tp __x, int __ex) +# 2736 +{ return __builtin_scalbn(__x, __ex); } +# 2741 +constexpr float tgamma(float __x) +# 2742 +{ return __builtin_tgammaf(__x); } +# 2745 +constexpr long double tgamma(long double __x) +# 2746 +{ return __builtin_tgammal(__x); } +# 2750 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2753 +tgamma(_Tp __x) +# 2754 +{ return __builtin_tgamma(__x); } +# 2759 +constexpr float trunc(float __x) +# 2760 +{ return __builtin_truncf(__x); } +# 2763 +constexpr long double trunc(long double __x) +# 2764 +{ return __builtin_truncl(__x); } +# 2768 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 2771 +trunc(_Tp __x) +# 2772 +{ return __builtin_trunc(__x); } +# 3682 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 3684 +copysign(_Tp __x, _Up __y) +# 3685 +{ +# 3686 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 3687 +return copysign((__type)__x, (__type)__y); +# 3688 +} +# 3690 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 3692 +fdim(_Tp __x, _Up __y) +# 3693 +{ +# 3694 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 3695 +return fdim((__type)__x, (__type)__y); +# 3696 +} +# 3698 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 3700 +fmax(_Tp __x, _Up __y) +# 3701 +{ +# 3702 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 3703 +return fmax((__type)__x, (__type)__y); +# 3704 +} +# 3706 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 3708 +fmin(_Tp __x, _Up __y) +# 3709 +{ +# 3710 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 3711 +return fmin((__type)__x, (__type)__y); +# 3712 +} +# 3714 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 3716 +hypot(_Tp __x, _Up __y) +# 3717 +{ +# 3718 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 3719 +return hypot((__type)__x, (__type)__y); +# 3720 +} +# 3722 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 3724 +nextafter(_Tp __x, _Up __y) +# 3725 +{ +# 3726 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 3727 +return nextafter((__type)__x, (__type)__y); +# 3728 +} +# 3730 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 3732 +remainder(_Tp __x, _Up __y) +# 3733 +{ +# 3734 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 3735 +return remainder((__type)__x, (__type)__y); +# 3736 +} +# 3738 +template< class _Tp, class _Up> inline typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 3740 +remquo(_Tp __x, _Up __y, int *__pquo) +# 3741 +{ +# 3742 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 3743 +return remquo((__type)__x, (__type)__y, __pquo); +# 3744 +} +# 3746 +template< class _Tp, class _Up, class _Vp> constexpr typename __gnu_cxx::__promote_3< _Tp, _Up, _Vp> ::__type +# 3748 +fma(_Tp __x, _Up __y, _Vp __z) +# 3749 +{ +# 3750 +typedef typename __gnu_cxx::__promote_3< _Tp, _Up, _Vp> ::__type __type; +# 3751 +return fma((__type)__x, (__type)__y, (__type)__z); +# 3752 +} +# 3760 +template< class _Tp> inline _Tp +# 3762 +__hypot3(_Tp __x, _Tp __y, _Tp __z) +# 3763 +{ +# 3764 +__x = std::abs(__x); +# 3765 +__y = std::abs(__y); +# 3766 +__z = std::abs(__z); +# 3767 +if (_Tp __a = (__x < __y) ? (__y < __z) ? __z : __y : ((__x < __z) ? __z : __x)) { +# 3768 +return __a * std::sqrt((((__x / __a) * (__x / __a)) + ((__y / __a) * (__y / __a))) + ((__z / __a) * (__z / __a))); } else { +# 3772 +return {}; } +# 3773 +} +# 3776 +inline float hypot(float __x, float __y, float __z) +# 3777 +{ return std::__hypot3< float> (__x, __y, __z); } +# 3780 +inline double hypot(double __x, double __y, double __z) +# 3781 +{ return std::__hypot3< double> (__x, __y, __z); } +# 3784 +inline long double hypot(long double __x, long double __y, long double __z) +# 3785 +{ return std::__hypot3< long double> (__x, __y, __z); } +# 3787 +template< class _Tp, class _Up, class _Vp> __gnu_cxx::__promoted_t< _Tp, _Up, _Vp> +# 3789 +hypot(_Tp __x, _Up __y, _Vp __z) +# 3790 +{ +# 3791 +using __type = __gnu_cxx::__promoted_t< _Tp, _Up, _Vp> ; +# 3792 +return std::__hypot3< __gnu_cxx::__promoted_t< _Tp, _Up, _Vp> > (__x, __y, __z); +# 3793 +} +# 3903 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +} +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 49 +void __throw_bad_exception() __attribute((__noreturn__)); +# 53 +void __throw_bad_alloc() __attribute((__noreturn__)); +# 56 +void __throw_bad_array_new_length() __attribute((__noreturn__)); +# 60 +void __throw_bad_cast() __attribute((__noreturn__, __cold__)); +# 63 +void __throw_bad_typeid() __attribute((__noreturn__, __cold__)); +# 67 +void __throw_logic_error(const char *) __attribute((__noreturn__, __cold__)); +# 70 +void __throw_domain_error(const char *) __attribute((__noreturn__, __cold__)); +# 73 +void __throw_invalid_argument(const char *) __attribute((__noreturn__, __cold__)); +# 76 +void __throw_length_error(const char *) __attribute((__noreturn__, __cold__)); +# 79 +void __throw_out_of_range(const char *) __attribute((__noreturn__, __cold__)); +# 82 +void __throw_out_of_range_fmt(const char *, ...) __attribute((__noreturn__, __cold__)) +# 83 + __attribute((__format__(__gnu_printf__, 1, 2))); +# 86 +void __throw_runtime_error(const char *) __attribute((__noreturn__, __cold__)); +# 89 +void __throw_range_error(const char *) __attribute((__noreturn__, __cold__)); +# 92 +void __throw_overflow_error(const char *) __attribute((__noreturn__, __cold__)); +# 95 +void __throw_underflow_error(const char *) __attribute((__noreturn__, __cold__)); +# 99 +void __throw_ios_failure(const char *) __attribute((__noreturn__, __cold__)); +# 102 +void __throw_ios_failure(const char *, int) __attribute((__noreturn__, __cold__)); +# 106 +void __throw_system_error(int) __attribute((__noreturn__, __cold__)); +# 110 +void __throw_future_error(int) __attribute((__noreturn__, __cold__)); +# 114 +void __throw_bad_function_call() __attribute((__noreturn__, __cold__)); +# 141 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/functexcept.h" 3 +} +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 +namespace __gnu_cxx __attribute((__visibility__("default"))) { +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 +template< class _Tp> +# 51 +struct __is_integer_nonstrict : public std::__is_integer< _Tp> { +# 54 +using std::__is_integer< _Tp> ::__value; +# 57 +enum { __width = (__value) ? sizeof(_Tp) * (8) : (0)}; +# 58 +}; +# 60 +template< class _Value> +# 61 +struct __numeric_traits_integer { +# 64 +static_assert((__is_integer_nonstrict< _Value> ::__value), "invalid specialization"); +# 70 +static const bool __is_signed = (((_Value)(-1)) < 0); +# 71 +static const int __digits = (__is_integer_nonstrict< _Value> ::__width - __is_signed); +# 75 +static const _Value __max = (__is_signed ? (((((_Value)1) << (__digits - 1)) - 1) << 1) + 1 : (~((_Value)0))); +# 78 +static const _Value __min = (__is_signed ? (-__max) - 1 : ((_Value)0)); +# 79 +}; +# 81 +template< class _Value> const _Value __numeric_traits_integer< _Value> ::__min; +# 84 +template< class _Value> const _Value __numeric_traits_integer< _Value> ::__max; +# 87 +template< class _Value> const bool __numeric_traits_integer< _Value> ::__is_signed; +# 90 +template< class _Value> const int __numeric_traits_integer< _Value> ::__digits; +# 137 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 +template< class _Tp> using __int_traits = __numeric_traits_integer< _Tp> ; +# 157 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 +template< class _Value> +# 158 +struct __numeric_traits_floating { +# 161 +static const int __max_digits10 = ((2) + ((((std::template __are_same< _Value, float> ::__value) ? 24 : ((std::template __are_same< _Value, double> ::__value) ? 53 : 64)) * 643L) / (2136))); +# 164 +static const bool __is_signed = true; +# 165 +static const int __digits10 = ((std::template __are_same< _Value, float> ::__value) ? 6 : ((std::template __are_same< _Value, double> ::__value) ? 15 : 18)); +# 166 +static const int __max_exponent10 = ((std::template __are_same< _Value, float> ::__value) ? 38 : ((std::template __are_same< _Value, double> ::__value) ? 308 : 4932)); +# 167 +}; +# 169 +template< class _Value> const int __numeric_traits_floating< _Value> ::__max_digits10; +# 172 +template< class _Value> const bool __numeric_traits_floating< _Value> ::__is_signed; +# 175 +template< class _Value> const int __numeric_traits_floating< _Value> ::__digits10; +# 178 +template< class _Value> const int __numeric_traits_floating< _Value> ::__max_exponent10; +# 186 +template< class _Value> +# 187 +struct __numeric_traits : public __numeric_traits_integer< _Value> { +# 189 +}; +# 192 +template<> struct __numeric_traits< float> : public __numeric_traits_floating< float> { +# 194 +}; +# 197 +template<> struct __numeric_traits< double> : public __numeric_traits_floating< double> { +# 199 +}; +# 202 +template<> struct __numeric_traits< long double> : public __numeric_traits_floating< long double> { +# 204 +}; +# 239 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/ext/numeric_traits.h" 3 +} +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +namespace std __attribute((__visibility__("default"))) { +# 69 +template< class _Tp> class reference_wrapper; +# 86 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp, _Tp __v> +# 87 +struct integral_constant { +# 89 +static constexpr inline _Tp value = (__v); +# 90 +using value_type = _Tp; +# 91 +using type = integral_constant; +# 92 +constexpr operator value_type() const noexcept { return value; } +# 95 +constexpr value_type operator()() const noexcept { return value; } +# 97 +}; +# 106 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< bool __v> using __bool_constant = integral_constant< bool, __v> ; +# 111 +using true_type = __bool_constant< true> ; +# 114 +using false_type = __bool_constant< false> ; +# 119 +template< bool __v> using bool_constant = __bool_constant< __v> ; +# 127 +template< bool , class _Tp = void> +# 128 +struct enable_if { +# 129 +}; +# 132 +template< class _Tp> +# 133 +struct enable_if< true, _Tp> { +# 134 +using type = _Tp; }; +# 137 +template< bool _Cond, class _Tp = void> using __enable_if_t = typename enable_if< _Cond, _Tp> ::type; +# 140 +template< bool > +# 141 +struct __conditional { +# 143 +template< class _Tp, class > using type = _Tp; +# 145 +}; +# 148 +template<> struct __conditional< false> { +# 150 +template< class , class _Up> using type = _Up; +# 152 +}; +# 155 +template< bool _Cond, class _If, class _Else> using __conditional_t = typename __conditional< _Cond> ::template type< _If, _Else> ; +# 160 +template< class _Type> +# 161 +struct __type_identity { +# 162 +using type = _Type; }; +# 164 +template< class _Tp> using __type_identity_t = typename __type_identity< _Tp> ::type; +# 167 +namespace __detail { +# 170 +template< class _Tp, class ...> using __first_t = _Tp; +# 174 +template< class ..._Bn> auto __or_fn(int)->__first_t< integral_constant< bool, false> , __enable_if_t< !((bool)_Bn::value)> ...> ; +# 178 +template< class ..._Bn> auto __or_fn(...)->true_type; +# 181 +template< class ..._Bn> auto __and_fn(int)->__first_t< integral_constant< bool, true> , __enable_if_t< (bool)_Bn::value> ...> ; +# 185 +template< class ..._Bn> auto __and_fn(...)->false_type; +# 187 +} +# 192 +template< class ..._Bn> +# 193 +struct __or_ : public __decltype((__detail::__or_fn< _Bn...> (0))) { +# 195 +}; +# 197 +template< class ..._Bn> +# 198 +struct __and_ : public __decltype((__detail::__and_fn< _Bn...> (0))) { +# 200 +}; +# 202 +template< class _Pp> +# 203 +struct __not_ : public __bool_constant< !((bool)_Pp::value)> { +# 205 +}; +# 211 +template< class ..._Bn> constexpr inline bool +# 212 +__or_v = (__or_< _Bn...> ::value); +# 213 +template< class ..._Bn> constexpr inline bool +# 214 +__and_v = (__and_< _Bn...> ::value); +# 216 +namespace __detail { +# 218 +template< class , class _B1, class ..._Bn> +# 219 +struct __disjunction_impl { +# 220 +using type = _B1; }; +# 222 +template< class _B1, class _B2, class ..._Bn> +# 223 +struct __disjunction_impl< __enable_if_t< !((bool)_B1::value)> , _B1, _B2, _Bn...> { +# 224 +using type = typename __detail::__disjunction_impl< void, _B2, _Bn...> ::type; }; +# 226 +template< class , class _B1, class ..._Bn> +# 227 +struct __conjunction_impl { +# 228 +using type = _B1; }; +# 230 +template< class _B1, class _B2, class ..._Bn> +# 231 +struct __conjunction_impl< __enable_if_t< (bool)_B1::value> , _B1, _B2, _Bn...> { +# 232 +using type = typename __detail::__conjunction_impl< void, _B2, _Bn...> ::type; }; +# 233 +} +# 236 +template< class ..._Bn> +# 237 +struct conjunction : public __detail::__conjunction_impl< void, _Bn...> ::type { +# 239 +}; +# 242 +template<> struct conjunction< > : public true_type { +# 244 +}; +# 246 +template< class ..._Bn> +# 247 +struct disjunction : public __detail::__disjunction_impl< void, _Bn...> ::type { +# 249 +}; +# 252 +template<> struct disjunction< > : public false_type { +# 254 +}; +# 256 +template< class _Pp> +# 257 +struct negation : public __not_< _Pp> ::type { +# 259 +}; +# 264 +template< class ..._Bn> constexpr inline bool +# 265 +conjunction_v = (conjunction< _Bn...> ::value); +# 267 +template< class ..._Bn> constexpr inline bool +# 268 +disjunction_v = (disjunction< _Bn...> ::value); +# 270 +template< class _Pp> constexpr inline bool +# 271 +negation_v = (negation< _Pp> ::value); +# 277 +template< class > struct is_reference; +# 279 +template< class > struct is_function; +# 281 +template< class > struct is_void; +# 283 +template< class > struct remove_cv; +# 285 +template< class > struct is_const; +# 289 +template< class > struct __is_array_unknown_bounds; +# 295 +template< class _Tp, size_t = sizeof(_Tp)> constexpr true_type +# 296 +__is_complete_or_unbounded(__type_identity< _Tp> ) +# 297 +{ return {}; } +# 299 +template< class _TypeIdentity, class +# 300 +_NestedType = typename _TypeIdentity::type> constexpr typename __or_< is_reference< _NestedType> , is_function< _NestedType> , is_void< _NestedType> , __is_array_unknown_bounds< _NestedType> > ::type +# 306 +__is_complete_or_unbounded(_TypeIdentity) +# 307 +{ return {}; } +# 310 +template< class _Tp> using __remove_cv_t = typename remove_cv< _Tp> ::type; +# 317 +template< class _Tp> +# 318 +struct is_void : public false_type { +# 319 +}; +# 322 +template<> struct is_void< void> : public true_type { +# 323 +}; +# 326 +template<> struct is_void< const void> : public true_type { +# 327 +}; +# 330 +template<> struct is_void< volatile void> : public true_type { +# 331 +}; +# 334 +template<> struct is_void< const volatile void> : public true_type { +# 335 +}; +# 338 +template< class > +# 339 +struct __is_integral_helper : public false_type { +# 340 +}; +# 343 +template<> struct __is_integral_helper< bool> : public true_type { +# 344 +}; +# 347 +template<> struct __is_integral_helper< char> : public true_type { +# 348 +}; +# 351 +template<> struct __is_integral_helper< signed char> : public true_type { +# 352 +}; +# 355 +template<> struct __is_integral_helper< unsigned char> : public true_type { +# 356 +}; +# 362 +template<> struct __is_integral_helper< wchar_t> : public true_type { +# 363 +}; +# 372 +template<> struct __is_integral_helper< char16_t> : public true_type { +# 373 +}; +# 376 +template<> struct __is_integral_helper< char32_t> : public true_type { +# 377 +}; +# 380 +template<> struct __is_integral_helper< short> : public true_type { +# 381 +}; +# 384 +template<> struct __is_integral_helper< unsigned short> : public true_type { +# 385 +}; +# 388 +template<> struct __is_integral_helper< int> : public true_type { +# 389 +}; +# 392 +template<> struct __is_integral_helper< unsigned> : public true_type { +# 393 +}; +# 396 +template<> struct __is_integral_helper< long> : public true_type { +# 397 +}; +# 400 +template<> struct __is_integral_helper< unsigned long> : public true_type { +# 401 +}; +# 404 +template<> struct __is_integral_helper< long long> : public true_type { +# 405 +}; +# 408 +template<> struct __is_integral_helper< unsigned long long> : public true_type { +# 409 +}; +# 416 +template<> struct __is_integral_helper< __int128> : public true_type { +# 417 +}; +# 421 +template<> struct __is_integral_helper< unsigned __int128> : public true_type { +# 422 +}; +# 460 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> +# 461 +struct is_integral : public __is_integral_helper< __remove_cv_t< _Tp> > ::type { +# 463 +}; +# 466 +template< class > +# 467 +struct __is_floating_point_helper : public false_type { +# 468 +}; +# 471 +template<> struct __is_floating_point_helper< float> : public true_type { +# 472 +}; +# 475 +template<> struct __is_floating_point_helper< double> : public true_type { +# 476 +}; +# 479 +template<> struct __is_floating_point_helper< long double> : public true_type { +# 480 +}; +# 514 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template<> struct __is_floating_point_helper< __float128> : public true_type { +# 515 +}; +# 520 +template< class _Tp> +# 521 +struct is_floating_point : public __is_floating_point_helper< __remove_cv_t< _Tp> > ::type { +# 523 +}; +# 527 +template< class _Tp> +# 528 +struct is_array : public __bool_constant< __is_array(_Tp)> { +# 530 +}; +# 545 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class > +# 546 +struct __is_pointer_helper : public false_type { +# 547 +}; +# 549 +template< class _Tp> +# 550 +struct __is_pointer_helper< _Tp *> : public true_type { +# 551 +}; +# 554 +template< class _Tp> +# 555 +struct is_pointer : public __is_pointer_helper< __remove_cv_t< _Tp> > ::type { +# 557 +}; +# 560 +template< class > +# 561 +struct is_lvalue_reference : public false_type { +# 562 +}; +# 564 +template< class _Tp> +# 565 +struct is_lvalue_reference< _Tp &> : public true_type { +# 566 +}; +# 569 +template< class > +# 570 +struct is_rvalue_reference : public false_type { +# 571 +}; +# 573 +template< class _Tp> +# 574 +struct is_rvalue_reference< _Tp &&> : public true_type { +# 575 +}; +# 579 +template< class _Tp> +# 580 +struct is_member_object_pointer : public __bool_constant< __is_member_object_pointer(_Tp)> { +# 582 +}; +# 601 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> +# 602 +struct is_member_function_pointer : public __bool_constant< __is_member_function_pointer(_Tp)> { +# 604 +}; +# 622 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> +# 623 +struct is_enum : public __bool_constant< __is_enum(_Tp)> { +# 625 +}; +# 628 +template< class _Tp> +# 629 +struct is_union : public __bool_constant< __is_union(_Tp)> { +# 631 +}; +# 634 +template< class _Tp> +# 635 +struct is_class : public __bool_constant< __is_class(_Tp)> { +# 637 +}; +# 641 +template< class _Tp> +# 642 +struct is_function : public __bool_constant< __is_function(_Tp)> { +# 644 +}; +# 661 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> +# 662 +struct is_null_pointer : public false_type { +# 663 +}; +# 666 +template<> struct is_null_pointer< __decltype((nullptr))> : public true_type { +# 667 +}; +# 670 +template<> struct is_null_pointer< const __decltype((nullptr))> : public true_type { +# 671 +}; +# 674 +template<> struct is_null_pointer< volatile __decltype((nullptr))> : public true_type { +# 675 +}; +# 678 +template<> struct is_null_pointer< const volatile __decltype((nullptr))> : public true_type { +# 679 +}; +# 683 +template< class _Tp> +# 684 +struct __is_nullptr_t : public is_null_pointer< _Tp> { +# 686 +} __attribute((__deprecated__("use \'std::is_null_pointer\' instead"))); +# 693 +template< class _Tp> +# 694 +struct is_reference : public __bool_constant< __is_reference(_Tp)> { +# 696 +}; +# 715 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> +# 716 +struct is_arithmetic : public __or_< is_integral< _Tp> , is_floating_point< _Tp> > ::type { +# 718 +}; +# 721 +template< class _Tp> +# 722 +struct is_fundamental : public __or_< is_arithmetic< _Tp> , is_void< _Tp> , is_null_pointer< _Tp> > ::type { +# 725 +}; +# 729 +template< class _Tp> +# 730 +struct is_object : public __bool_constant< __is_object(_Tp)> { +# 732 +}; +# 741 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class > struct is_member_pointer; +# 745 +template< class _Tp> +# 746 +struct is_scalar : public __or_< is_arithmetic< _Tp> , is_enum< _Tp> , is_pointer< _Tp> , is_member_pointer< _Tp> , is_null_pointer< _Tp> > ::type { +# 749 +}; +# 752 +template< class _Tp> +# 753 +struct is_compound : public __bool_constant< !is_fundamental< _Tp> ::value> { +# 754 +}; +# 758 +template< class _Tp> +# 759 +struct is_member_pointer : public __bool_constant< __is_member_pointer(_Tp)> { +# 761 +}; +# 779 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class , class > struct is_same; +# 783 +template< class _Tp, class ..._Types> using __is_one_of = __or_< is_same< _Tp, _Types> ...> ; +# 788 +template< class _Tp> using __is_signed_integer = __is_one_of< __remove_cv_t< _Tp> , signed char, signed short, signed int, signed long, signed long long, signed __int128> ; +# 808 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> using __is_unsigned_integer = __is_one_of< __remove_cv_t< _Tp> , unsigned char, unsigned short, unsigned, unsigned long, unsigned long long, unsigned __int128> ; +# 827 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> using __is_standard_integer = __or_< __is_signed_integer< _Tp> , __is_unsigned_integer< _Tp> > ; +# 832 +template< class ...> using __void_t = void; +# 838 +template< class > +# 839 +struct is_const : public false_type { +# 840 +}; +# 842 +template< class _Tp> +# 843 +struct is_const< const _Tp> : public true_type { +# 844 +}; +# 847 +template< class > +# 848 +struct is_volatile : public false_type { +# 849 +}; +# 851 +template< class _Tp> +# 852 +struct is_volatile< volatile _Tp> : public true_type { +# 853 +}; +# 856 +template< class _Tp> +# 857 +struct is_trivial : public __bool_constant< __is_trivial(_Tp)> { +# 860 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 862 +}; +# 865 +template< class _Tp> +# 866 +struct is_trivially_copyable : public __bool_constant< __is_trivially_copyable(_Tp)> { +# 869 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 871 +}; +# 874 +template< class _Tp> +# 875 +struct is_standard_layout : public __bool_constant< __is_standard_layout(_Tp)> { +# 878 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 880 +}; +# 887 +template< class _Tp> +# 890 +struct is_pod : public __bool_constant< __is_pod(_Tp)> { +# 893 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 895 +}; +# 901 +template< class _Tp> +# 904 +struct +# 903 + [[__deprecated__]] is_literal_type : public __bool_constant< __is_literal_type(_Tp)> { +# 907 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 909 +}; +# 912 +template< class _Tp> +# 913 +struct is_empty : public __bool_constant< __is_empty(_Tp)> { +# 915 +}; +# 918 +template< class _Tp> +# 919 +struct is_polymorphic : public __bool_constant< __is_polymorphic(_Tp)> { +# 921 +}; +# 926 +template< class _Tp> +# 927 +struct is_final : public __bool_constant< __is_final(_Tp)> { +# 929 +}; +# 933 +template< class _Tp> +# 934 +struct is_abstract : public __bool_constant< __is_abstract(_Tp)> { +# 936 +}; +# 939 +template< class _Tp, bool +# 940 + = is_arithmetic< _Tp> ::value> +# 941 +struct __is_signed_helper : public false_type { +# 942 +}; +# 944 +template< class _Tp> +# 945 +struct __is_signed_helper< _Tp, true> : public __bool_constant< ((_Tp)(-1)) < ((_Tp)0)> { +# 947 +}; +# 951 +template< class _Tp> +# 952 +struct is_signed : public __is_signed_helper< _Tp> ::type { +# 954 +}; +# 957 +template< class _Tp> +# 958 +struct is_unsigned : public __and_< is_arithmetic< _Tp> , __not_< is_signed< _Tp> > > ::type { +# 960 +}; +# 963 +template< class _Tp, class _Up = _Tp &&> _Up __declval(int); +# 967 +template< class _Tp> _Tp __declval(long); +# 972 +template< class _Tp> auto declval() noexcept->__decltype((__declval< _Tp> (0))); +# 975 +template< class > struct remove_all_extents; +# 979 +template< class _Tp> +# 980 +struct __is_array_known_bounds : public false_type { +# 982 +}; +# 984 +template< class _Tp, size_t _Size> +# 985 +struct __is_array_known_bounds< _Tp [_Size]> : public true_type { +# 987 +}; +# 989 +template< class _Tp> +# 990 +struct __is_array_unknown_bounds : public false_type { +# 992 +}; +# 994 +template< class _Tp> +# 995 +struct __is_array_unknown_bounds< _Tp []> : public true_type { +# 997 +}; +# 1006 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +struct __do_is_destructible_impl { +# 1008 +template< class _Tp, class = __decltype((declval< _Tp &> ().~_Tp()))> static true_type __test(int); +# 1011 +template< class > static false_type __test(...); +# 1013 +}; +# 1015 +template< class _Tp> +# 1016 +struct __is_destructible_impl : public __do_is_destructible_impl { +# 1019 +using type = __decltype((__test< _Tp> (0))); +# 1020 +}; +# 1022 +template< class _Tp, bool +# 1023 + = __or_< is_void< _Tp> , __is_array_unknown_bounds< _Tp> , is_function< _Tp> > ::value, bool +# 1026 + = __or_< is_reference< _Tp> , is_scalar< _Tp> > ::value> struct __is_destructible_safe; +# 1029 +template< class _Tp> +# 1030 +struct __is_destructible_safe< _Tp, false, false> : public __is_destructible_impl< typename remove_all_extents< _Tp> ::type> ::type { +# 1033 +}; +# 1035 +template< class _Tp> +# 1036 +struct __is_destructible_safe< _Tp, true, false> : public false_type { +# 1037 +}; +# 1039 +template< class _Tp> +# 1040 +struct __is_destructible_safe< _Tp, false, true> : public true_type { +# 1041 +}; +# 1045 +template< class _Tp> +# 1046 +struct is_destructible : public __is_destructible_safe< _Tp> ::type { +# 1049 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1051 +}; +# 1059 +struct __do_is_nt_destructible_impl { +# 1061 +template< class _Tp> static __bool_constant< noexcept(declval< _Tp &> ().~_Tp())> __test(int); +# 1065 +template< class > static false_type __test(...); +# 1067 +}; +# 1069 +template< class _Tp> +# 1070 +struct __is_nt_destructible_impl : public __do_is_nt_destructible_impl { +# 1073 +using type = __decltype((__test< _Tp> (0))); +# 1074 +}; +# 1076 +template< class _Tp, bool +# 1077 + = __or_< is_void< _Tp> , __is_array_unknown_bounds< _Tp> , is_function< _Tp> > ::value, bool +# 1080 + = __or_< is_reference< _Tp> , is_scalar< _Tp> > ::value> struct __is_nt_destructible_safe; +# 1083 +template< class _Tp> +# 1084 +struct __is_nt_destructible_safe< _Tp, false, false> : public __is_nt_destructible_impl< typename remove_all_extents< _Tp> ::type> ::type { +# 1087 +}; +# 1089 +template< class _Tp> +# 1090 +struct __is_nt_destructible_safe< _Tp, true, false> : public false_type { +# 1091 +}; +# 1093 +template< class _Tp> +# 1094 +struct __is_nt_destructible_safe< _Tp, false, true> : public true_type { +# 1095 +}; +# 1099 +template< class _Tp> +# 1100 +struct is_nothrow_destructible : public __is_nt_destructible_safe< _Tp> ::type { +# 1103 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1105 +}; +# 1108 +template< class _Tp, class ..._Args> using __is_constructible_impl = __bool_constant< __is_constructible(_Tp, _Args...)> ; +# 1114 +template< class _Tp, class ..._Args> +# 1115 +struct is_constructible : public __is_constructible_impl< _Tp, _Args...> { +# 1118 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1120 +}; +# 1123 +template< class _Tp> +# 1124 +struct is_default_constructible : public __is_constructible_impl< _Tp> { +# 1127 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1129 +}; +# 1132 +template< class _Tp, class = void> +# 1133 +struct __add_lvalue_reference_helper { +# 1134 +using type = _Tp; }; +# 1136 +template< class _Tp> +# 1137 +struct __add_lvalue_reference_helper< _Tp, __void_t< _Tp &> > { +# 1138 +using type = _Tp &; }; +# 1140 +template< class _Tp> using __add_lval_ref_t = typename __add_lvalue_reference_helper< _Tp> ::type; +# 1145 +template< class _Tp> +# 1146 +struct is_copy_constructible : public __is_constructible_impl< _Tp, __add_lval_ref_t< const _Tp> > { +# 1149 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1151 +}; +# 1154 +template< class _Tp, class = void> +# 1155 +struct __add_rvalue_reference_helper { +# 1156 +using type = _Tp; }; +# 1158 +template< class _Tp> +# 1159 +struct __add_rvalue_reference_helper< _Tp, __void_t< _Tp &&> > { +# 1160 +using type = _Tp &&; }; +# 1162 +template< class _Tp> using __add_rval_ref_t = typename __add_rvalue_reference_helper< _Tp> ::type; +# 1167 +template< class _Tp> +# 1168 +struct is_move_constructible : public __is_constructible_impl< _Tp, __add_rval_ref_t< _Tp> > { +# 1171 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1173 +}; +# 1176 +template< class _Tp, class ..._Args> using __is_nothrow_constructible_impl = __bool_constant< __is_nothrow_constructible(_Tp, _Args...)> ; +# 1182 +template< class _Tp, class ..._Args> +# 1183 +struct is_nothrow_constructible : public __is_nothrow_constructible_impl< _Tp, _Args...> { +# 1186 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1188 +}; +# 1191 +template< class _Tp> +# 1192 +struct is_nothrow_default_constructible : public __is_nothrow_constructible_impl< _Tp> { +# 1195 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1197 +}; +# 1200 +template< class _Tp> +# 1201 +struct is_nothrow_copy_constructible : public __is_nothrow_constructible_impl< _Tp, __add_lval_ref_t< const _Tp> > { +# 1204 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1206 +}; +# 1209 +template< class _Tp> +# 1210 +struct is_nothrow_move_constructible : public __is_nothrow_constructible_impl< _Tp, __add_rval_ref_t< _Tp> > { +# 1213 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1215 +}; +# 1218 +template< class _Tp, class _Up> using __is_assignable_impl = __bool_constant< __is_assignable(_Tp, _Up)> ; +# 1223 +template< class _Tp, class _Up> +# 1224 +struct is_assignable : public __is_assignable_impl< _Tp, _Up> { +# 1227 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1229 +}; +# 1232 +template< class _Tp> +# 1233 +struct is_copy_assignable : public __is_assignable_impl< __add_lval_ref_t< _Tp> , __add_lval_ref_t< const _Tp> > { +# 1237 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1239 +}; +# 1242 +template< class _Tp> +# 1243 +struct is_move_assignable : public __is_assignable_impl< __add_lval_ref_t< _Tp> , __add_rval_ref_t< _Tp> > { +# 1246 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1248 +}; +# 1251 +template< class _Tp, class _Up> using __is_nothrow_assignable_impl = __bool_constant< __is_nothrow_assignable(_Tp, _Up)> ; +# 1257 +template< class _Tp, class _Up> +# 1258 +struct is_nothrow_assignable : public __is_nothrow_assignable_impl< _Tp, _Up> { +# 1261 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1263 +}; +# 1266 +template< class _Tp> +# 1267 +struct is_nothrow_copy_assignable : public __is_nothrow_assignable_impl< __add_lval_ref_t< _Tp> , __add_lval_ref_t< const _Tp> > { +# 1271 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1273 +}; +# 1276 +template< class _Tp> +# 1277 +struct is_nothrow_move_assignable : public __is_nothrow_assignable_impl< __add_lval_ref_t< _Tp> , __add_rval_ref_t< _Tp> > { +# 1281 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1283 +}; +# 1286 +template< class _Tp, class ..._Args> using __is_trivially_constructible_impl = __bool_constant< __is_trivially_constructible(_Tp, _Args...)> ; +# 1292 +template< class _Tp, class ..._Args> +# 1293 +struct is_trivially_constructible : public __is_trivially_constructible_impl< _Tp, _Args...> { +# 1296 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1298 +}; +# 1301 +template< class _Tp> +# 1302 +struct is_trivially_default_constructible : public __is_trivially_constructible_impl< _Tp> { +# 1305 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1307 +}; +# 1319 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +struct __do_is_implicitly_default_constructible_impl { +# 1321 +template< class _Tp> static void __helper(const _Tp &); +# 1324 +template< class _Tp> static true_type __test(const _Tp &, __decltype((__helper< const _Tp &> ({}))) * = 0); +# 1328 +static false_type __test(...); +# 1329 +}; +# 1331 +template< class _Tp> +# 1332 +struct __is_implicitly_default_constructible_impl : public __do_is_implicitly_default_constructible_impl { +# 1335 +using type = __decltype((__test(declval< _Tp> ()))); +# 1336 +}; +# 1338 +template< class _Tp> +# 1339 +struct __is_implicitly_default_constructible_safe : public __is_implicitly_default_constructible_impl< _Tp> ::type { +# 1341 +}; +# 1343 +template< class _Tp> +# 1344 +struct __is_implicitly_default_constructible : public __and_< __is_constructible_impl< _Tp> , __is_implicitly_default_constructible_safe< _Tp> > ::type { +# 1347 +}; +# 1351 +template< class _Tp> +# 1352 +struct is_trivially_copy_constructible : public __is_trivially_constructible_impl< _Tp, __add_lval_ref_t< const _Tp> > { +# 1355 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1357 +}; +# 1360 +template< class _Tp> +# 1361 +struct is_trivially_move_constructible : public __is_trivially_constructible_impl< _Tp, __add_rval_ref_t< _Tp> > { +# 1364 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1366 +}; +# 1369 +template< class _Tp, class _Up> using __is_trivially_assignable_impl = __bool_constant< __is_trivially_assignable(_Tp, _Up)> ; +# 1375 +template< class _Tp, class _Up> +# 1376 +struct is_trivially_assignable : public __is_trivially_assignable_impl< _Tp, _Up> { +# 1379 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1381 +}; +# 1384 +template< class _Tp> +# 1385 +struct is_trivially_copy_assignable : public __is_trivially_assignable_impl< __add_lval_ref_t< _Tp> , __add_lval_ref_t< const _Tp> > { +# 1389 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1391 +}; +# 1394 +template< class _Tp> +# 1395 +struct is_trivially_move_assignable : public __is_trivially_assignable_impl< __add_lval_ref_t< _Tp> , __add_rval_ref_t< _Tp> > { +# 1399 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1401 +}; +# 1404 +template< class _Tp> +# 1405 +struct is_trivially_destructible : public __and_< __is_destructible_safe< _Tp> , __bool_constant< __has_trivial_destructor(_Tp)> > ::type { +# 1409 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1411 +}; +# 1415 +template< class _Tp> +# 1416 +struct has_virtual_destructor : public __bool_constant< __has_virtual_destructor(_Tp)> { +# 1419 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1421 +}; +# 1427 +template< class _Tp> +# 1428 +struct alignment_of : public integral_constant< unsigned long, __alignof__(_Tp)> { +# 1431 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1433 +}; +# 1436 +template< class > +# 1437 +struct rank : public integral_constant< unsigned long, 0UL> { +# 1438 +}; +# 1440 +template< class _Tp, size_t _Size> +# 1441 +struct rank< _Tp [_Size]> : public integral_constant< unsigned long, 1 + std::rank< _Tp> ::value> { +# 1442 +}; +# 1444 +template< class _Tp> +# 1445 +struct rank< _Tp []> : public integral_constant< unsigned long, 1 + std::rank< _Tp> ::value> { +# 1446 +}; +# 1449 +template< class , unsigned _Uint = 0U> +# 1450 +struct extent : public integral_constant< unsigned long, 0UL> { +# 1451 +}; +# 1453 +template< class _Tp, size_t _Size> +# 1454 +struct extent< _Tp [_Size], 0> : public integral_constant< unsigned long, _Size> { +# 1455 +}; +# 1457 +template< class _Tp, unsigned _Uint, size_t _Size> +# 1458 +struct extent< _Tp [_Size], _Uint> : public std::extent< _Tp, _Uint - (1)> ::type { +# 1459 +}; +# 1461 +template< class _Tp> +# 1462 +struct extent< _Tp [], 0> : public integral_constant< unsigned long, 0UL> { +# 1463 +}; +# 1465 +template< class _Tp, unsigned _Uint> +# 1466 +struct extent< _Tp [], _Uint> : public std::extent< _Tp, _Uint - (1)> ::type { +# 1467 +}; +# 1474 +template< class _Tp, class _Up> +# 1475 +struct is_same : public __bool_constant< __is_same(_Tp, _Up)> { +# 1477 +}; +# 1491 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Base, class _Derived> +# 1492 +struct is_base_of : public __bool_constant< __is_base_of(_Base, _Derived)> { +# 1494 +}; +# 1497 +template< class _From, class _To> +# 1498 +struct is_convertible : public __bool_constant< __is_convertible(_From, _To)> { +# 1500 +}; +# 1540 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _ToElementType, class _FromElementType> using __is_array_convertible = is_convertible< _FromElementType (*)[], _ToElementType (*)[]> ; +# 1600 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++14-extensions" +template< class _Tp, class ..._Args> +# 1603 +struct __is_nothrow_new_constructible_impl : public __bool_constant< noexcept((::new (std::declval< void *> ()) _Tp(std::declval< _Args> ()...)))> { +# 1607 +}; +# 1609 +template< class _Tp, class ..._Args> constexpr inline bool +# 1610 +__is_nothrow_new_constructible = (__and_< is_constructible< _Tp, _Args...> , __is_nothrow_new_constructible_impl< _Tp, _Args...> > ::value); +# 1613 +#pragma GCC diagnostic pop +# 1618 +template< class _Tp> +# 1619 +struct remove_const { +# 1620 +using type = _Tp; }; +# 1622 +template< class _Tp> +# 1623 +struct remove_const< const _Tp> { +# 1624 +using type = _Tp; }; +# 1627 +template< class _Tp> +# 1628 +struct remove_volatile { +# 1629 +using type = _Tp; }; +# 1631 +template< class _Tp> +# 1632 +struct remove_volatile< volatile _Tp> { +# 1633 +using type = _Tp; }; +# 1637 +template< class _Tp> +# 1638 +struct remove_cv { +# 1639 +using type = __remove_cv(_Tp); }; +# 1659 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> +# 1660 +struct add_const { +# 1661 +using type = const _Tp; }; +# 1664 +template< class _Tp> +# 1665 +struct add_volatile { +# 1666 +using type = volatile _Tp; }; +# 1669 +template< class _Tp> +# 1670 +struct add_cv { +# 1671 +using type = const volatile _Tp; }; +# 1675 +template< class _Tp> using remove_const_t = typename remove_const< _Tp> ::type; +# 1679 +template< class _Tp> using remove_volatile_t = typename remove_volatile< _Tp> ::type; +# 1683 +template< class _Tp> using remove_cv_t = typename remove_cv< _Tp> ::type; +# 1687 +template< class _Tp> using add_const_t = typename add_const< _Tp> ::type; +# 1691 +template< class _Tp> using add_volatile_t = typename add_volatile< _Tp> ::type; +# 1695 +template< class _Tp> using add_cv_t = typename add_cv< _Tp> ::type; +# 1703 +template< class _Tp> +# 1704 +struct remove_reference { +# 1705 +using type = __remove_reference(_Tp); }; +# 1721 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> +# 1722 +struct add_lvalue_reference { +# 1723 +using type = __add_lval_ref_t< _Tp> ; }; +# 1726 +template< class _Tp> +# 1727 +struct add_rvalue_reference { +# 1728 +using type = __add_rval_ref_t< _Tp> ; }; +# 1732 +template< class _Tp> using remove_reference_t = typename remove_reference< _Tp> ::type; +# 1736 +template< class _Tp> using add_lvalue_reference_t = typename add_lvalue_reference< _Tp> ::type; +# 1740 +template< class _Tp> using add_rvalue_reference_t = typename add_rvalue_reference< _Tp> ::type; +# 1749 +template< class _Unqualified, bool _IsConst, bool _IsVol> struct __cv_selector; +# 1752 +template< class _Unqualified> +# 1753 +struct __cv_selector< _Unqualified, false, false> { +# 1754 +using __type = _Unqualified; }; +# 1756 +template< class _Unqualified> +# 1757 +struct __cv_selector< _Unqualified, false, true> { +# 1758 +using __type = volatile _Unqualified; }; +# 1760 +template< class _Unqualified> +# 1761 +struct __cv_selector< _Unqualified, true, false> { +# 1762 +using __type = const _Unqualified; }; +# 1764 +template< class _Unqualified> +# 1765 +struct __cv_selector< _Unqualified, true, true> { +# 1766 +using __type = const volatile _Unqualified; }; +# 1768 +template< class _Qualified, class _Unqualified, bool +# 1769 +_IsConst = is_const< _Qualified> ::value, bool +# 1770 +_IsVol = is_volatile< _Qualified> ::value> +# 1771 +class __match_cv_qualifiers { +# 1773 +using __match = __cv_selector< _Unqualified, _IsConst, _IsVol> ; +# 1776 +public: using __type = typename __cv_selector< _Unqualified, _IsConst, _IsVol> ::__type; +# 1777 +}; +# 1780 +template< class _Tp> +# 1781 +struct __make_unsigned { +# 1782 +using __type = _Tp; }; +# 1785 +template<> struct __make_unsigned< char> { +# 1786 +using __type = unsigned char; }; +# 1789 +template<> struct __make_unsigned< signed char> { +# 1790 +using __type = unsigned char; }; +# 1793 +template<> struct __make_unsigned< short> { +# 1794 +using __type = unsigned short; }; +# 1797 +template<> struct __make_unsigned< int> { +# 1798 +using __type = unsigned; }; +# 1801 +template<> struct __make_unsigned< long> { +# 1802 +using __type = unsigned long; }; +# 1805 +template<> struct __make_unsigned< long long> { +# 1806 +using __type = unsigned long long; }; +# 1811 +template<> struct __make_unsigned< __int128> { +# 1812 +using __type = unsigned __int128; }; +# 1834 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp, bool +# 1835 +_IsInt = is_integral< _Tp> ::value, bool +# 1836 +_IsEnum = __is_enum(_Tp)> class __make_unsigned_selector; +# 1839 +template< class _Tp> +# 1840 +class __make_unsigned_selector< _Tp, true, false> { +# 1842 +using __unsigned_type = typename __make_unsigned< __remove_cv_t< _Tp> > ::__type; +# 1846 +public: using __type = typename __match_cv_qualifiers< _Tp, __unsigned_type> ::__type; +# 1848 +}; +# 1850 +class __make_unsigned_selector_base { +# 1853 +protected: template< class ...> struct _List { }; +# 1855 +template< class _Tp, class ..._Up> +# 1856 +struct _List< _Tp, _Up...> : public __make_unsigned_selector_base::template _List< _Up...> { +# 1857 +static constexpr inline std::size_t __size = sizeof(_Tp); }; +# 1859 +template< size_t _Sz, class _Tp, bool = _Sz <= _Tp::__size> struct __select; +# 1862 +template< size_t _Sz, class _Uint, class ..._UInts> +# 1863 +struct __select< _Sz, _List< _Uint, _UInts...> , true> { +# 1864 +using __type = _Uint; }; +# 1866 +template< size_t _Sz, class _Uint, class ..._UInts> +# 1867 +struct __select< _Sz, _List< _Uint, _UInts...> , false> : public __make_unsigned_selector_base::template __select< _Sz, _List< _UInts...> > { +# 1869 +}; +# 1870 +}; +# 1873 +template< class _Tp> +# 1874 +class __make_unsigned_selector< _Tp, false, true> : private __make_unsigned_selector_base { +# 1878 +using _UInts = _List< unsigned char, unsigned short, unsigned, unsigned long, unsigned long long> ; +# 1881 +using __unsigned_type = typename __select< sizeof(_Tp), _List< unsigned char, unsigned short, unsigned, unsigned long, unsigned long long> > ::__type; +# 1884 +public: using __type = typename __match_cv_qualifiers< _Tp, __unsigned_type> ::__type; +# 1886 +}; +# 1893 +template<> struct __make_unsigned< wchar_t> { +# 1895 +using __type = __make_unsigned_selector< wchar_t, false, true> ::__type; +# 1897 +}; +# 1909 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template<> struct __make_unsigned< char16_t> { +# 1911 +using __type = __make_unsigned_selector< char16_t, false, true> ::__type; +# 1913 +}; +# 1916 +template<> struct __make_unsigned< char32_t> { +# 1918 +using __type = __make_unsigned_selector< char32_t, false, true> ::__type; +# 1920 +}; +# 1927 +template< class _Tp> +# 1928 +struct make_unsigned { +# 1929 +using type = typename __make_unsigned_selector< _Tp> ::__type; }; +# 1932 +template<> struct make_unsigned< bool> ; +# 1933 +template<> struct make_unsigned< const bool> ; +# 1934 +template<> struct make_unsigned< volatile bool> ; +# 1935 +template<> struct make_unsigned< const volatile bool> ; +# 1940 +template< class _Tp> +# 1941 +struct __make_signed { +# 1942 +using __type = _Tp; }; +# 1945 +template<> struct __make_signed< char> { +# 1946 +using __type = signed char; }; +# 1949 +template<> struct __make_signed< unsigned char> { +# 1950 +using __type = signed char; }; +# 1953 +template<> struct __make_signed< unsigned short> { +# 1954 +using __type = signed short; }; +# 1957 +template<> struct __make_signed< unsigned> { +# 1958 +using __type = signed int; }; +# 1961 +template<> struct __make_signed< unsigned long> { +# 1962 +using __type = signed long; }; +# 1965 +template<> struct __make_signed< unsigned long long> { +# 1966 +using __type = signed long long; }; +# 1971 +template<> struct __make_signed< unsigned __int128> { +# 1972 +using __type = __int128; }; +# 1994 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp, bool +# 1995 +_IsInt = is_integral< _Tp> ::value, bool +# 1996 +_IsEnum = __is_enum(_Tp)> class __make_signed_selector; +# 1999 +template< class _Tp> +# 2000 +class __make_signed_selector< _Tp, true, false> { +# 2002 +using __signed_type = typename __make_signed< __remove_cv_t< _Tp> > ::__type; +# 2006 +public: using __type = typename __match_cv_qualifiers< _Tp, __signed_type> ::__type; +# 2008 +}; +# 2011 +template< class _Tp> +# 2012 +class __make_signed_selector< _Tp, false, true> { +# 2014 +using __unsigned_type = typename __make_unsigned_selector< _Tp> ::__type; +# 2017 +public: using __type = typename std::__make_signed_selector< __unsigned_type> ::__type; +# 2018 +}; +# 2025 +template<> struct __make_signed< wchar_t> { +# 2027 +using __type = __make_signed_selector< wchar_t, false, true> ::__type; +# 2029 +}; +# 2041 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template<> struct __make_signed< char16_t> { +# 2043 +using __type = __make_signed_selector< char16_t, false, true> ::__type; +# 2045 +}; +# 2048 +template<> struct __make_signed< char32_t> { +# 2050 +using __type = __make_signed_selector< char32_t, false, true> ::__type; +# 2052 +}; +# 2059 +template< class _Tp> +# 2060 +struct make_signed { +# 2061 +using type = typename __make_signed_selector< _Tp> ::__type; }; +# 2064 +template<> struct make_signed< bool> ; +# 2065 +template<> struct make_signed< const bool> ; +# 2066 +template<> struct make_signed< volatile bool> ; +# 2067 +template<> struct make_signed< const volatile bool> ; +# 2071 +template< class _Tp> using make_signed_t = typename make_signed< _Tp> ::type; +# 2075 +template< class _Tp> using make_unsigned_t = typename make_unsigned< _Tp> ::type; +# 2082 +template< class _Tp> +# 2083 +struct remove_extent { +# 2084 +using type = _Tp; }; +# 2086 +template< class _Tp, size_t _Size> +# 2087 +struct remove_extent< _Tp [_Size]> { +# 2088 +using type = _Tp; }; +# 2090 +template< class _Tp> +# 2091 +struct remove_extent< _Tp []> { +# 2092 +using type = _Tp; }; +# 2095 +template< class _Tp> +# 2096 +struct remove_all_extents { +# 2097 +using type = _Tp; }; +# 2099 +template< class _Tp, size_t _Size> +# 2100 +struct remove_all_extents< _Tp [_Size]> { +# 2101 +using type = typename std::remove_all_extents< _Tp> ::type; }; +# 2103 +template< class _Tp> +# 2104 +struct remove_all_extents< _Tp []> { +# 2105 +using type = typename std::remove_all_extents< _Tp> ::type; }; +# 2109 +template< class _Tp> using remove_extent_t = typename remove_extent< _Tp> ::type; +# 2113 +template< class _Tp> using remove_all_extents_t = typename remove_all_extents< _Tp> ::type; +# 2121 +template< class _Tp> +# 2122 +struct remove_pointer { +# 2123 +using type = __remove_pointer(_Tp); }; +# 2139 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp, class = void> +# 2140 +struct __add_pointer_helper { +# 2141 +using type = _Tp; }; +# 2143 +template< class _Tp> +# 2144 +struct __add_pointer_helper< _Tp, __void_t< _Tp *> > { +# 2145 +using type = _Tp *; }; +# 2148 +template< class _Tp> +# 2149 +struct add_pointer : public __add_pointer_helper< _Tp> { +# 2151 +}; +# 2153 +template< class _Tp> +# 2154 +struct add_pointer< _Tp &> { +# 2155 +using type = _Tp *; }; +# 2157 +template< class _Tp> +# 2158 +struct add_pointer< _Tp &&> { +# 2159 +using type = _Tp *; }; +# 2163 +template< class _Tp> using remove_pointer_t = typename remove_pointer< _Tp> ::type; +# 2167 +template< class _Tp> using add_pointer_t = typename add_pointer< _Tp> ::type; +# 2171 +template< size_t _Len> +# 2172 +struct __aligned_storage_msa { +# 2174 +union __type { +# 2176 +unsigned char __data[_Len]; +# 2177 +struct __attribute((__aligned__)) { } __align; +# 2178 +}; +# 2179 +}; +# 2194 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< size_t _Len, size_t _Align = __alignof__(typename __aligned_storage_msa< _Len> ::__type)> +# 2198 +struct aligned_storage { +# 2200 +union type { +# 2202 +unsigned char __data[_Len]; +# 2203 +struct __attribute((__aligned__(_Align))) { } __align; +# 2204 +}; +# 2205 +}; +# 2207 +template< class ..._Types> +# 2208 +struct __strictest_alignment { +# 2210 +static const size_t _S_alignment = (0); +# 2211 +static const size_t _S_size = (0); +# 2212 +}; +# 2214 +template< class _Tp, class ..._Types> +# 2215 +struct __strictest_alignment< _Tp, _Types...> { +# 2217 +static const size_t _S_alignment = ((__alignof__(_Tp) > __strictest_alignment< _Types...> ::_S_alignment) ? __alignof__(_Tp) : __strictest_alignment< _Types...> ::_S_alignment); +# 2220 +static const size_t _S_size = ((sizeof(_Tp) > __strictest_alignment< _Types...> ::_S_size) ? sizeof(_Tp) : __strictest_alignment< _Types...> ::_S_size); +# 2223 +}; +# 2225 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 2240 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< size_t _Len, class ..._Types> +# 2243 +struct aligned_union { +# 2246 +static_assert((sizeof...(_Types) != (0)), "At least one type is required"); +# 2248 +private: using __strictest = __strictest_alignment< _Types...> ; +# 2249 +static const size_t _S_len = ((_Len > __strictest::_S_size) ? _Len : __strictest::_S_size); +# 2253 +public: static const size_t alignment_value = (__strictest::_S_alignment); +# 2255 +using type = typename aligned_storage< _S_len, alignment_value> ::type; +# 2256 +}; +# 2258 +template< size_t _Len, class ..._Types> const size_t aligned_union< _Len, _Types...> ::alignment_value; +# 2260 +#pragma GCC diagnostic pop +# 2266 +template< class _Up> +# 2267 +struct __decay_selector : public __conditional_t< is_const< const _Up> ::value, remove_cv< _Up> , add_pointer< _Up> > { +# 2271 +}; +# 2273 +template< class _Up, size_t _Nm> +# 2274 +struct __decay_selector< _Up [_Nm]> { +# 2275 +using type = _Up *; }; +# 2277 +template< class _Up> +# 2278 +struct __decay_selector< _Up []> { +# 2279 +using type = _Up *; }; +# 2284 +template< class _Tp> +# 2285 +struct decay { +# 2286 +using type = typename __decay_selector< _Tp> ::type; }; +# 2288 +template< class _Tp> +# 2289 +struct decay< _Tp &> { +# 2290 +using type = typename __decay_selector< _Tp> ::type; }; +# 2292 +template< class _Tp> +# 2293 +struct decay< _Tp &&> { +# 2294 +using type = typename __decay_selector< _Tp> ::type; }; +# 2299 +template< class _Tp> +# 2300 +struct __strip_reference_wrapper { +# 2302 +using __type = _Tp; +# 2303 +}; +# 2305 +template< class _Tp> +# 2306 +struct __strip_reference_wrapper< reference_wrapper< _Tp> > { +# 2308 +using __type = _Tp &; +# 2309 +}; +# 2312 +template< class _Tp> using __decay_t = typename decay< _Tp> ::type; +# 2315 +template< class _Tp> using __decay_and_strip = __strip_reference_wrapper< __decay_t< _Tp> > ; +# 2322 +template< class ..._Cond> using _Require = __enable_if_t< __and_< _Cond...> ::value> ; +# 2326 +template< class _Tp> using __remove_cvref_t = typename remove_cv< typename remove_reference< _Tp> ::type> ::type; +# 2333 +template< bool _Cond, class _Iftrue, class _Iffalse> +# 2334 +struct conditional { +# 2335 +using type = _Iftrue; }; +# 2338 +template< class _Iftrue, class _Iffalse> +# 2339 +struct conditional< false, _Iftrue, _Iffalse> { +# 2340 +using type = _Iffalse; }; +# 2343 +template< class ..._Tp> struct common_type; +# 2355 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> +# 2356 +struct __success_type { +# 2357 +using type = _Tp; }; +# 2359 +struct __failure_type { +# 2360 +}; +# 2362 +struct __do_common_type_impl { +# 2364 +template< class _Tp, class _Up> using __cond_t = __decltype((true ? std::declval< _Tp> () : std::declval< _Up> ())); +# 2370 +template< class _Tp, class _Up> static __success_type< __decay_t< __cond_t< _Tp, _Up> > > _S_test(int); +# 2382 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class , class > static __failure_type _S_test_2(...); +# 2386 +template< class _Tp, class _Up> static __decltype((_S_test_2< _Tp, _Up> (0))) _S_test(...); +# 2389 +}; +# 2393 +template<> struct common_type< > { +# 2394 +}; +# 2397 +template< class _Tp0> +# 2398 +struct common_type< _Tp0> : public std::common_type< _Tp0, _Tp0> { +# 2400 +}; +# 2403 +template< class _Tp1, class _Tp2, class +# 2404 +_Dp1 = __decay_t< _Tp1> , class _Dp2 = __decay_t< _Tp2> > +# 2405 +struct __common_type_impl { +# 2409 +using type = common_type< _Dp1, _Dp2> ; +# 2410 +}; +# 2412 +template< class _Tp1, class _Tp2> +# 2413 +struct __common_type_impl< _Tp1, _Tp2, _Tp1, _Tp2> : private __do_common_type_impl { +# 2418 +using type = __decltype((_S_test< _Tp1, _Tp2> (0))); +# 2419 +}; +# 2422 +template< class _Tp1, class _Tp2> +# 2423 +struct common_type< _Tp1, _Tp2> : public __common_type_impl< _Tp1, _Tp2> ::type { +# 2425 +}; +# 2427 +template< class ...> +# 2428 +struct __common_type_pack { +# 2429 +}; +# 2431 +template< class , class , class = void> struct __common_type_fold; +# 2435 +template< class _Tp1, class _Tp2, class ..._Rp> +# 2436 +struct common_type< _Tp1, _Tp2, _Rp...> : public __common_type_fold< std::common_type< _Tp1, _Tp2> , __common_type_pack< _Rp...> > { +# 2439 +}; +# 2444 +template< class _CTp, class ..._Rp> +# 2445 +struct __common_type_fold< _CTp, __common_type_pack< _Rp...> , __void_t< typename _CTp::type> > : public common_type< typename _CTp::type, _Rp...> { +# 2448 +}; +# 2451 +template< class _CTp, class _Rp> +# 2452 +struct __common_type_fold< _CTp, _Rp, void> { +# 2453 +}; +# 2455 +template< class _Tp, bool = __is_enum(_Tp)> +# 2456 +struct __underlying_type_impl { +# 2458 +using type = __underlying_type(_Tp); +# 2459 +}; +# 2461 +template< class _Tp> +# 2462 +struct __underlying_type_impl< _Tp, false> { +# 2463 +}; +# 2467 +template< class _Tp> +# 2468 +struct underlying_type : public __underlying_type_impl< _Tp> { +# 2470 +}; +# 2473 +template< class _Tp> +# 2474 +struct __declval_protector { +# 2476 +static const bool __stop = false; +# 2477 +}; +# 2484 +template< class _Tp> auto +# 2485 +declval() noexcept->__decltype((__declval< _Tp> (0))) +# 2486 +{ +# 2487 +static_assert((__declval_protector< _Tp> ::__stop), "declval() must not be used!"); +# 2489 +return __declval< _Tp> (0); +# 2490 +} +# 2493 +template< class _Signature> struct result_of; +# 2499 +struct __invoke_memfun_ref { }; +# 2500 +struct __invoke_memfun_deref { }; +# 2501 +struct __invoke_memobj_ref { }; +# 2502 +struct __invoke_memobj_deref { }; +# 2503 +struct __invoke_other { }; +# 2506 +template< class _Tp, class _Tag> +# 2507 +struct __result_of_success : public __success_type< _Tp> { +# 2508 +using __invoke_type = _Tag; }; +# 2511 +struct __result_of_memfun_ref_impl { +# 2513 +template< class _Fp, class _Tp1, class ..._Args> static __result_of_success< __decltype(((std::declval< _Tp1> ().*std::declval< _Fp> ())(std::declval< _Args> ()...))), __invoke_memfun_ref> _S_test(int); +# 2518 +template< class ...> static __failure_type _S_test(...); +# 2520 +}; +# 2522 +template< class _MemPtr, class _Arg, class ..._Args> +# 2523 +struct __result_of_memfun_ref : private __result_of_memfun_ref_impl { +# 2526 +using type = __decltype((_S_test< _MemPtr, _Arg, _Args...> (0))); +# 2527 +}; +# 2530 +struct __result_of_memfun_deref_impl { +# 2532 +template< class _Fp, class _Tp1, class ..._Args> static __result_of_success< __decltype((((*std::declval< _Tp1> ()).*std::declval< _Fp> ())(std::declval< _Args> ()...))), __invoke_memfun_deref> _S_test(int); +# 2537 +template< class ...> static __failure_type _S_test(...); +# 2539 +}; +# 2541 +template< class _MemPtr, class _Arg, class ..._Args> +# 2542 +struct __result_of_memfun_deref : private __result_of_memfun_deref_impl { +# 2545 +using type = __decltype((_S_test< _MemPtr, _Arg, _Args...> (0))); +# 2546 +}; +# 2549 +struct __result_of_memobj_ref_impl { +# 2551 +template< class _Fp, class _Tp1> static __result_of_success< __decltype((std::declval< _Tp1> ().*std::declval< _Fp> ())), __invoke_memobj_ref> _S_test(int); +# 2556 +template< class , class > static __failure_type _S_test(...); +# 2558 +}; +# 2560 +template< class _MemPtr, class _Arg> +# 2561 +struct __result_of_memobj_ref : private __result_of_memobj_ref_impl { +# 2564 +using type = __decltype((_S_test< _MemPtr, _Arg> (0))); +# 2565 +}; +# 2568 +struct __result_of_memobj_deref_impl { +# 2570 +template< class _Fp, class _Tp1> static __result_of_success< __decltype(((*std::declval< _Tp1> ()).*std::declval< _Fp> ())), __invoke_memobj_deref> _S_test(int); +# 2575 +template< class , class > static __failure_type _S_test(...); +# 2577 +}; +# 2579 +template< class _MemPtr, class _Arg> +# 2580 +struct __result_of_memobj_deref : private __result_of_memobj_deref_impl { +# 2583 +using type = __decltype((_S_test< _MemPtr, _Arg> (0))); +# 2584 +}; +# 2586 +template< class _MemPtr, class _Arg> struct __result_of_memobj; +# 2589 +template< class _Res, class _Class, class _Arg> +# 2590 +struct __result_of_memobj< _Res (_Class::*), _Arg> { +# 2592 +using _Argval = __remove_cvref_t< _Arg> ; +# 2593 +using _MemPtr = _Res (_Class::*); +# 2594 +using type = typename __conditional_t< __or_< is_same< _Argval, _Class> , is_base_of< _Class, _Argval> > ::value, __result_of_memobj_ref< _MemPtr, _Arg> , __result_of_memobj_deref< _MemPtr, _Arg> > ::type; +# 2599 +}; +# 2601 +template< class _MemPtr, class _Arg, class ..._Args> struct __result_of_memfun; +# 2604 +template< class _Res, class _Class, class _Arg, class ..._Args> +# 2605 +struct __result_of_memfun< _Res (_Class::*), _Arg, _Args...> { +# 2607 +using _Argval = typename remove_reference< _Arg> ::type; +# 2608 +using _MemPtr = _Res (_Class::*); +# 2609 +using type = typename __conditional_t< is_base_of< _Class, _Argval> ::value, __result_of_memfun_ref< _MemPtr, _Arg, _Args...> , __result_of_memfun_deref< _MemPtr, _Arg, _Args...> > ::type; +# 2613 +}; +# 2620 +template< class _Tp, class _Up = __remove_cvref_t< _Tp> > +# 2621 +struct __inv_unwrap { +# 2623 +using type = _Tp; +# 2624 +}; +# 2626 +template< class _Tp, class _Up> +# 2627 +struct __inv_unwrap< _Tp, reference_wrapper< _Up> > { +# 2629 +using type = _Up &; +# 2630 +}; +# 2632 +template< bool , bool , class _Functor, class ..._ArgTypes> +# 2633 +struct __result_of_impl { +# 2635 +using type = __failure_type; +# 2636 +}; +# 2638 +template< class _MemPtr, class _Arg> +# 2639 +struct __result_of_impl< true, false, _MemPtr, _Arg> : public __result_of_memobj< __decay_t< _MemPtr> , typename __inv_unwrap< _Arg> ::type> { +# 2642 +}; +# 2644 +template< class _MemPtr, class _Arg, class ..._Args> +# 2645 +struct __result_of_impl< false, true, _MemPtr, _Arg, _Args...> : public __result_of_memfun< __decay_t< _MemPtr> , typename __inv_unwrap< _Arg> ::type, _Args...> { +# 2648 +}; +# 2651 +struct __result_of_other_impl { +# 2653 +template< class _Fn, class ..._Args> static __result_of_success< __decltype((std::declval< _Fn> ()(std::declval< _Args> ()...))), __invoke_other> _S_test(int); +# 2658 +template< class ...> static __failure_type _S_test(...); +# 2660 +}; +# 2662 +template< class _Functor, class ..._ArgTypes> +# 2663 +struct __result_of_impl< false, false, _Functor, _ArgTypes...> : private __result_of_other_impl { +# 2666 +using type = __decltype((_S_test< _Functor, _ArgTypes...> (0))); +# 2667 +}; +# 2670 +template< class _Functor, class ..._ArgTypes> +# 2671 +struct __invoke_result : public __result_of_impl< is_member_object_pointer< typename remove_reference< _Functor> ::type> ::value, is_member_function_pointer< typename remove_reference< _Functor> ::type> ::value, _Functor, _ArgTypes...> ::type { +# 2681 +}; +# 2684 +template< class _Fn, class ..._Args> using __invoke_result_t = typename __invoke_result< _Fn, _Args...> ::type; +# 2688 +template< class _Functor, class ..._ArgTypes> +# 2689 +struct result_of< _Functor (_ArgTypes ...)> : public __invoke_result< _Functor, _ArgTypes...> { +# 2691 +} __attribute((__deprecated__("use \'std::invoke_result\' instead"))); +# 2694 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 2697 +template< size_t _Len, size_t _Align = __alignof__(typename __aligned_storage_msa< _Len> ::__type)> using aligned_storage_t = typename aligned_storage< _Len, _Align> ::type; +# 2701 +template< size_t _Len, class ..._Types> using aligned_union_t = typename aligned_union< _Len, _Types...> ::type; +# 2703 +#pragma GCC diagnostic pop +# 2706 +template< class _Tp> using decay_t = typename decay< _Tp> ::type; +# 2710 +template< bool _Cond, class _Tp = void> using enable_if_t = typename enable_if< _Cond, _Tp> ::type; +# 2714 +template< bool _Cond, class _Iftrue, class _Iffalse> using conditional_t = typename conditional< _Cond, _Iftrue, _Iffalse> ::type; +# 2718 +template< class ..._Tp> using common_type_t = typename common_type< _Tp...> ::type; +# 2722 +template< class _Tp> using underlying_type_t = typename underlying_type< _Tp> ::type; +# 2726 +template< class _Tp> using result_of_t = typename result_of< _Tp> ::type; +# 2732 +template< class ...> using void_t = void; +# 2759 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Default, class _AlwaysVoid, +# 2760 +template< class ...> class _Op, class ..._Args> +# 2761 +struct __detector { +# 2763 +using type = _Default; +# 2764 +using __is_detected = false_type; +# 2765 +}; +# 2768 +template< class _Default, template< class ...> class _Op, class ... +# 2769 +_Args> +# 2770 +struct __detector< _Default, __void_t< _Op< _Args...> > , _Op, _Args...> { +# 2772 +using type = _Op< _Args...> ; +# 2773 +using __is_detected = true_type; +# 2774 +}; +# 2776 +template< class _Default, template< class ...> class _Op, class ... +# 2777 +_Args> using __detected_or = __detector< _Default, void, _Op, _Args...> ; +# 2782 +template< class _Default, template< class ...> class _Op, class ... +# 2783 +_Args> using __detected_or_t = typename __detected_or< _Default, _Op, _Args...> ::type; +# 2801 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> struct __is_swappable; +# 2804 +template< class _Tp> struct __is_nothrow_swappable; +# 2807 +template< class > +# 2808 +struct __is_tuple_like_impl : public false_type { +# 2809 +}; +# 2812 +template< class _Tp> +# 2813 +struct __is_tuple_like : public __is_tuple_like_impl< __remove_cvref_t< _Tp> > ::type { +# 2815 +}; +# 2818 +template< class _Tp> inline _Require< __not_< __is_tuple_like< _Tp> > , is_move_constructible< _Tp> , is_move_assignable< _Tp> > swap(_Tp &, _Tp &) noexcept(__and_< is_nothrow_move_constructible< _Tp> , is_nothrow_move_assignable< _Tp> > ::value); +# 2828 +template< class _Tp, size_t _Nm> inline __enable_if_t< __is_swappable< _Tp> ::value> swap(_Tp (& __a)[_Nm], _Tp (& __b)[_Nm]) noexcept(__is_nothrow_swappable< _Tp> ::value); +# 2836 +namespace __swappable_details { +# 2837 +using std::swap; +# 2839 +struct __do_is_swappable_impl { +# 2841 +template< class _Tp, class +# 2842 + = __decltype((swap(std::declval< _Tp &> (), std::declval< _Tp &> ())))> static true_type +# 2841 +__test(int); +# 2845 +template< class > static false_type __test(...); +# 2847 +}; +# 2849 +struct __do_is_nothrow_swappable_impl { +# 2851 +template< class _Tp> static __bool_constant< noexcept(swap(std::declval< _Tp &> (), std::declval< _Tp &> ()))> __test(int); +# 2856 +template< class > static false_type __test(...); +# 2858 +}; +# 2860 +} +# 2862 +template< class _Tp> +# 2863 +struct __is_swappable_impl : public __swappable_details::__do_is_swappable_impl { +# 2866 +using type = __decltype((__test< _Tp> (0))); +# 2867 +}; +# 2869 +template< class _Tp> +# 2870 +struct __is_nothrow_swappable_impl : public __swappable_details::__do_is_nothrow_swappable_impl { +# 2873 +using type = __decltype((__test< _Tp> (0))); +# 2874 +}; +# 2876 +template< class _Tp> +# 2877 +struct __is_swappable : public __is_swappable_impl< _Tp> ::type { +# 2879 +}; +# 2881 +template< class _Tp> +# 2882 +struct __is_nothrow_swappable : public __is_nothrow_swappable_impl< _Tp> ::type { +# 2884 +}; +# 2891 +template< class _Tp> +# 2892 +struct is_swappable : public __is_swappable_impl< _Tp> ::type { +# 2895 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 2897 +}; +# 2900 +template< class _Tp> +# 2901 +struct is_nothrow_swappable : public __is_nothrow_swappable_impl< _Tp> ::type { +# 2904 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 2906 +}; +# 2910 +template< class _Tp> constexpr inline bool +# 2911 +is_swappable_v = (is_swappable< _Tp> ::value); +# 2915 +template< class _Tp> constexpr inline bool +# 2916 +is_nothrow_swappable_v = (is_nothrow_swappable< _Tp> ::value); +# 2921 +namespace __swappable_with_details { +# 2922 +using std::swap; +# 2924 +struct __do_is_swappable_with_impl { +# 2926 +template< class _Tp, class _Up, class +# 2927 + = __decltype((swap(std::declval< _Tp> (), std::declval< _Up> ()))), class +# 2929 + = __decltype((swap(std::declval< _Up> (), std::declval< _Tp> ())))> static true_type +# 2926 +__test(int); +# 2932 +template< class , class > static false_type __test(...); +# 2934 +}; +# 2936 +struct __do_is_nothrow_swappable_with_impl { +# 2938 +template< class _Tp, class _Up> static __bool_constant< noexcept(swap(std::declval< _Tp> (), std::declval< _Up> ())) && noexcept(swap(std::declval< _Up> (), std::declval< _Tp> ()))> __test(int); +# 2945 +template< class , class > static false_type __test(...); +# 2947 +}; +# 2949 +} +# 2951 +template< class _Tp, class _Up> +# 2952 +struct __is_swappable_with_impl : public __swappable_with_details::__do_is_swappable_with_impl { +# 2955 +using type = __decltype((__test< _Tp, _Up> (0))); +# 2956 +}; +# 2959 +template< class _Tp> +# 2960 +struct __is_swappable_with_impl< _Tp &, _Tp &> : public __swappable_details::__do_is_swappable_impl { +# 2963 +using type = __decltype((__test< _Tp &> (0))); +# 2964 +}; +# 2966 +template< class _Tp, class _Up> +# 2967 +struct __is_nothrow_swappable_with_impl : public __swappable_with_details::__do_is_nothrow_swappable_with_impl { +# 2970 +using type = __decltype((__test< _Tp, _Up> (0))); +# 2971 +}; +# 2974 +template< class _Tp> +# 2975 +struct __is_nothrow_swappable_with_impl< _Tp &, _Tp &> : public __swappable_details::__do_is_nothrow_swappable_impl { +# 2978 +using type = __decltype((__test< _Tp &> (0))); +# 2979 +}; +# 2983 +template< class _Tp, class _Up> +# 2984 +struct is_swappable_with : public __is_swappable_with_impl< _Tp, _Up> ::type { +# 2987 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "first template argument must be a complete class or an unbounded array"); +# 2989 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Up> {})), "second template argument must be a complete class or an unbounded array"); +# 2991 +}; +# 2994 +template< class _Tp, class _Up> +# 2995 +struct is_nothrow_swappable_with : public __is_nothrow_swappable_with_impl< _Tp, _Up> ::type { +# 2998 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "first template argument must be a complete class or an unbounded array"); +# 3000 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Up> {})), "second template argument must be a complete class or an unbounded array"); +# 3002 +}; +# 3006 +template< class _Tp, class _Up> constexpr inline bool +# 3007 +is_swappable_with_v = (is_swappable_with< _Tp, _Up> ::value); +# 3011 +template< class _Tp, class _Up> constexpr inline bool +# 3012 +is_nothrow_swappable_with_v = (is_nothrow_swappable_with< _Tp, _Up> ::value); +# 3023 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Result, class _Ret, bool +# 3024 + = is_void< _Ret> ::value, class = void> +# 3025 +struct __is_invocable_impl : public false_type { +# 3028 +using __nothrow_conv = false_type; +# 3029 +}; +# 3032 +template< class _Result, class _Ret> +# 3033 +struct __is_invocable_impl< _Result, _Ret, true, __void_t< typename _Result::type> > : public true_type { +# 3038 +using __nothrow_conv = true_type; +# 3039 +}; +# 3041 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" +# 3044 +template< class _Result, class _Ret> +# 3045 +struct __is_invocable_impl< _Result, _Ret, false, __void_t< typename _Result::type> > { +# 3051 +private: using _Res_t = typename _Result::type; +# 3055 +static _Res_t _S_get() noexcept; +# 3058 +template< class _Tp> static void _S_conv(__type_identity_t< _Tp> ) noexcept; +# 3062 +template< class _Tp, bool +# 3063 +_Nothrow = noexcept(_S_conv< _Tp> ((_S_get)())), class +# 3064 + = __decltype((_S_conv< _Tp> ((_S_get)()))), bool +# 3066 +_Dangle = __reference_converts_from_temporary(_Tp, _Res_t)> static __bool_constant< _Nothrow && (!_Dangle)> +# 3062 +_S_test(int); +# 3074 +template< class _Tp, bool = false> static false_type _S_test(...); +# 3080 +public: using type = __decltype((_S_test< _Ret, true> (1))); +# 3083 +using __nothrow_conv = __decltype((_S_test< _Ret> (1))); +# 3084 +}; +#pragma GCC diagnostic pop +# 3087 +template< class _Fn, class ..._ArgTypes> +# 3088 +struct __is_invocable : public __is_invocable_impl< __invoke_result< _Fn, _ArgTypes...> , void> ::type { +# 3090 +}; +# 3092 +template< class _Fn, class _Tp, class ..._Args> constexpr bool +# 3093 +__call_is_nt(__invoke_memfun_ref) +# 3094 +{ +# 3095 +using _Up = typename __inv_unwrap< _Tp> ::type; +# 3096 +return noexcept((std::declval< typename __inv_unwrap< _Tp> ::type> ().*std::declval< _Fn> ())(std::declval< _Args> ()...)); +# 3098 +} +# 3100 +template< class _Fn, class _Tp, class ..._Args> constexpr bool +# 3101 +__call_is_nt(__invoke_memfun_deref) +# 3102 +{ +# 3103 +return noexcept(((*std::declval< _Tp> ()).*std::declval< _Fn> ())(std::declval< _Args> ()...)); +# 3105 +} +# 3107 +template< class _Fn, class _Tp> constexpr bool +# 3108 +__call_is_nt(__invoke_memobj_ref) +# 3109 +{ +# 3110 +using _Up = typename __inv_unwrap< _Tp> ::type; +# 3111 +return noexcept((std::declval< typename __inv_unwrap< _Tp> ::type> ().*std::declval< _Fn> ())); +# 3112 +} +# 3114 +template< class _Fn, class _Tp> constexpr bool +# 3115 +__call_is_nt(__invoke_memobj_deref) +# 3116 +{ +# 3117 +return noexcept(((*std::declval< _Tp> ()).*std::declval< _Fn> ())); +# 3118 +} +# 3120 +template< class _Fn, class ..._Args> constexpr bool +# 3121 +__call_is_nt(__invoke_other) +# 3122 +{ +# 3123 +return noexcept(std::declval< _Fn> ()(std::declval< _Args> ()...)); +# 3124 +} +# 3126 +template< class _Result, class _Fn, class ..._Args> +# 3127 +struct __call_is_nothrow : public __bool_constant< std::__call_is_nt< _Fn, _Args...> (typename _Result::__invoke_type{})> { +# 3131 +}; +# 3133 +template< class _Fn, class ..._Args> using __call_is_nothrow_ = __call_is_nothrow< __invoke_result< _Fn, _Args...> , _Fn, _Args...> ; +# 3138 +template< class _Fn, class ..._Args> +# 3139 +struct __is_nothrow_invocable : public __and_< __is_invocable< _Fn, _Args...> , __call_is_nothrow_< _Fn, _Args...> > ::type { +# 3142 +}; +# 3144 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" +struct __nonesuchbase { }; +# 3147 +struct __nonesuch : private __nonesuchbase { +# 3148 +~__nonesuch() = delete; +# 3149 +__nonesuch(const __nonesuch &) = delete; +# 3150 +void operator=(const __nonesuch &) = delete; +# 3151 +}; +#pragma GCC diagnostic pop +# 3157 +template< class _Functor, class ..._ArgTypes> +# 3158 +struct invoke_result : public __invoke_result< _Functor, _ArgTypes...> { +# 3161 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Functor> {})), "_Functor must be a complete class or an unbounded array"); +# 3163 +static_assert(((std::__is_complete_or_unbounded(__type_identity< _ArgTypes> {}) && ... )), "each argument type must be a complete class or an unbounded array"); +# 3166 +}; +# 3169 +template< class _Fn, class ..._Args> using invoke_result_t = typename invoke_result< _Fn, _Args...> ::type; +# 3173 +template< class _Fn, class ..._ArgTypes> +# 3174 +struct is_invocable : public __is_invocable_impl< __invoke_result< _Fn, _ArgTypes...> , void> ::type { +# 3177 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Fn> {})), "_Fn must be a complete class or an unbounded array"); +# 3179 +static_assert(((std::__is_complete_or_unbounded(__type_identity< _ArgTypes> {}) && ... )), "each argument type must be a complete class or an unbounded array"); +# 3182 +}; +# 3185 +template< class _Ret, class _Fn, class ..._ArgTypes> +# 3186 +struct is_invocable_r : public __is_invocable_impl< __invoke_result< _Fn, _ArgTypes...> , _Ret> ::type { +# 3189 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Fn> {})), "_Fn must be a complete class or an unbounded array"); +# 3191 +static_assert(((std::__is_complete_or_unbounded(__type_identity< _ArgTypes> {}) && ... )), "each argument type must be a complete class or an unbounded array"); +# 3194 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Ret> {})), "_Ret must be a complete class or an unbounded array"); +# 3196 +}; +# 3199 +template< class _Fn, class ..._ArgTypes> +# 3200 +struct is_nothrow_invocable : public __and_< __is_invocable_impl< __invoke_result< _Fn, _ArgTypes...> , void> , __call_is_nothrow_< _Fn, _ArgTypes...> > ::type { +# 3204 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Fn> {})), "_Fn must be a complete class or an unbounded array"); +# 3206 +static_assert(((std::__is_complete_or_unbounded(__type_identity< _ArgTypes> {}) && ... )), "each argument type must be a complete class or an unbounded array"); +# 3209 +}; +# 3215 +template< class _Result, class _Ret> using __is_nt_invocable_impl = typename __is_invocable_impl< _Result, _Ret> ::__nothrow_conv; +# 3221 +template< class _Ret, class _Fn, class ..._ArgTypes> +# 3222 +struct is_nothrow_invocable_r : public __and_< __is_nt_invocable_impl< __invoke_result< _Fn, _ArgTypes...> , _Ret> , __call_is_nothrow_< _Fn, _ArgTypes...> > ::type { +# 3226 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Fn> {})), "_Fn must be a complete class or an unbounded array"); +# 3228 +static_assert(((std::__is_complete_or_unbounded(__type_identity< _ArgTypes> {}) && ... )), "each argument type must be a complete class or an unbounded array"); +# 3231 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Ret> {})), "_Ret must be a complete class or an unbounded array"); +# 3233 +}; +# 3251 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> constexpr inline bool +# 3252 +is_void_v = (is_void< _Tp> ::value); +# 3253 +template< class _Tp> constexpr inline bool +# 3254 +is_null_pointer_v = (is_null_pointer< _Tp> ::value); +# 3255 +template< class _Tp> constexpr inline bool +# 3256 +is_integral_v = (is_integral< _Tp> ::value); +# 3257 +template< class _Tp> constexpr inline bool +# 3258 +is_floating_point_v = (is_floating_point< _Tp> ::value); +# 3261 +template< class _Tp> constexpr inline bool +# 3262 +is_array_v = __is_array(_Tp); +# 3272 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> constexpr inline bool +# 3273 +is_pointer_v = (is_pointer< _Tp> ::value); +# 3274 +template< class _Tp> constexpr inline bool +# 3275 +is_lvalue_reference_v = false; +# 3276 +template< class _Tp> constexpr inline bool +# 3277 +is_lvalue_reference_v< _Tp &> = true; +# 3278 +template< class _Tp> constexpr inline bool +# 3279 +is_rvalue_reference_v = false; +# 3280 +template< class _Tp> constexpr inline bool +# 3281 +is_rvalue_reference_v< _Tp &&> = true; +# 3284 +template< class _Tp> constexpr inline bool +# 3285 +is_member_object_pointer_v = __is_member_object_pointer(_Tp); +# 3294 +template< class _Tp> constexpr inline bool +# 3295 +is_member_function_pointer_v = __is_member_function_pointer(_Tp); +# 3303 +template< class _Tp> constexpr inline bool +# 3304 +is_enum_v = __is_enum(_Tp); +# 3305 +template< class _Tp> constexpr inline bool +# 3306 +is_union_v = __is_union(_Tp); +# 3307 +template< class _Tp> constexpr inline bool +# 3308 +is_class_v = __is_class(_Tp); +# 3312 +template< class _Tp> constexpr inline bool +# 3313 +is_reference_v = __is_reference(_Tp); +# 3323 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> constexpr inline bool +# 3324 +is_arithmetic_v = (is_arithmetic< _Tp> ::value); +# 3325 +template< class _Tp> constexpr inline bool +# 3326 +is_fundamental_v = (is_fundamental< _Tp> ::value); +# 3329 +template< class _Tp> constexpr inline bool +# 3330 +is_object_v = __is_object(_Tp); +# 3336 +template< class _Tp> constexpr inline bool +# 3337 +is_scalar_v = (is_scalar< _Tp> ::value); +# 3338 +template< class _Tp> constexpr inline bool +# 3339 +is_compound_v = (!is_fundamental_v< _Tp> ); +# 3342 +template< class _Tp> constexpr inline bool +# 3343 +is_member_pointer_v = __is_member_pointer(_Tp); +# 3349 +template< class _Tp> constexpr inline bool +# 3350 +is_const_v = false; +# 3351 +template< class _Tp> constexpr inline bool +# 3352 +is_const_v< const _Tp> = true; +# 3355 +template< class _Tp> constexpr inline bool +# 3356 +is_function_v = __is_function(_Tp); +# 3366 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> constexpr inline bool +# 3367 +is_volatile_v = false; +# 3368 +template< class _Tp> constexpr inline bool +# 3369 +is_volatile_v< volatile _Tp> = true; +# 3371 +template< class _Tp> constexpr inline bool +# 3372 +is_trivial_v = __is_trivial(_Tp); +# 3373 +template< class _Tp> constexpr inline bool +# 3374 +is_trivially_copyable_v = __is_trivially_copyable(_Tp); +# 3375 +template< class _Tp> constexpr inline bool +# 3376 +is_standard_layout_v = __is_standard_layout(_Tp); +# 3377 +template< class _Tp> constexpr inline bool +# 3379 +is_pod_v = __is_pod(_Tp); +# 3380 +template< class _Tp> +# 3381 +[[__deprecated__]] constexpr inline bool +# 3382 +is_literal_type_v = __is_literal_type(_Tp); +# 3383 +template< class _Tp> constexpr inline bool +# 3384 +is_empty_v = __is_empty(_Tp); +# 3385 +template< class _Tp> constexpr inline bool +# 3386 +is_polymorphic_v = __is_polymorphic(_Tp); +# 3387 +template< class _Tp> constexpr inline bool +# 3388 +is_abstract_v = __is_abstract(_Tp); +# 3389 +template< class _Tp> constexpr inline bool +# 3390 +is_final_v = __is_final(_Tp); +# 3392 +template< class _Tp> constexpr inline bool +# 3393 +is_signed_v = (is_signed< _Tp> ::value); +# 3394 +template< class _Tp> constexpr inline bool +# 3395 +is_unsigned_v = (is_unsigned< _Tp> ::value); +# 3397 +template< class _Tp, class ..._Args> constexpr inline bool +# 3398 +is_constructible_v = __is_constructible(_Tp, _Args...); +# 3399 +template< class _Tp> constexpr inline bool +# 3400 +is_default_constructible_v = __is_constructible(_Tp); +# 3401 +template< class _Tp> constexpr inline bool +# 3402 +is_copy_constructible_v = __is_constructible(_Tp, __add_lval_ref_t< const _Tp> ); +# 3404 +template< class _Tp> constexpr inline bool +# 3405 +is_move_constructible_v = __is_constructible(_Tp, __add_rval_ref_t< _Tp> ); +# 3408 +template< class _Tp, class _Up> constexpr inline bool +# 3409 +is_assignable_v = __is_assignable(_Tp, _Up); +# 3410 +template< class _Tp> constexpr inline bool +# 3411 +is_copy_assignable_v = __is_assignable(__add_lval_ref_t< _Tp> , __add_lval_ref_t< const _Tp> ); +# 3413 +template< class _Tp> constexpr inline bool +# 3414 +is_move_assignable_v = __is_assignable(__add_lval_ref_t< _Tp> , __add_rval_ref_t< _Tp> ); +# 3417 +template< class _Tp> constexpr inline bool +# 3418 +is_destructible_v = (is_destructible< _Tp> ::value); +# 3420 +template< class _Tp, class ..._Args> constexpr inline bool +# 3421 +is_trivially_constructible_v = __is_trivially_constructible(_Tp, _Args...); +# 3423 +template< class _Tp> constexpr inline bool +# 3424 +is_trivially_default_constructible_v = __is_trivially_constructible(_Tp); +# 3426 +template< class _Tp> constexpr inline bool +# 3427 +is_trivially_copy_constructible_v = __is_trivially_constructible(_Tp, __add_lval_ref_t< const _Tp> ); +# 3429 +template< class _Tp> constexpr inline bool +# 3430 +is_trivially_move_constructible_v = __is_trivially_constructible(_Tp, __add_rval_ref_t< _Tp> ); +# 3433 +template< class _Tp, class _Up> constexpr inline bool +# 3434 +is_trivially_assignable_v = __is_trivially_assignable(_Tp, _Up); +# 3436 +template< class _Tp> constexpr inline bool +# 3437 +is_trivially_copy_assignable_v = __is_trivially_assignable(__add_lval_ref_t< _Tp> , __add_lval_ref_t< const _Tp> ); +# 3440 +template< class _Tp> constexpr inline bool +# 3441 +is_trivially_move_assignable_v = __is_trivially_assignable(__add_lval_ref_t< _Tp> , __add_rval_ref_t< _Tp> ); +# 3461 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +template< class _Tp> constexpr inline bool +# 3462 +is_trivially_destructible_v = (is_trivially_destructible< _Tp> ::value); +# 3466 +template< class _Tp, class ..._Args> constexpr inline bool +# 3467 +is_nothrow_constructible_v = __is_nothrow_constructible(_Tp, _Args...); +# 3469 +template< class _Tp> constexpr inline bool +# 3470 +is_nothrow_default_constructible_v = __is_nothrow_constructible(_Tp); +# 3472 +template< class _Tp> constexpr inline bool +# 3473 +is_nothrow_copy_constructible_v = __is_nothrow_constructible(_Tp, __add_lval_ref_t< const _Tp> ); +# 3475 +template< class _Tp> constexpr inline bool +# 3476 +is_nothrow_move_constructible_v = __is_nothrow_constructible(_Tp, __add_rval_ref_t< _Tp> ); +# 3479 +template< class _Tp, class _Up> constexpr inline bool +# 3480 +is_nothrow_assignable_v = __is_nothrow_assignable(_Tp, _Up); +# 3482 +template< class _Tp> constexpr inline bool +# 3483 +is_nothrow_copy_assignable_v = __is_nothrow_assignable(__add_lval_ref_t< _Tp> , __add_lval_ref_t< const _Tp> ); +# 3486 +template< class _Tp> constexpr inline bool +# 3487 +is_nothrow_move_assignable_v = __is_nothrow_assignable(__add_lval_ref_t< _Tp> , __add_rval_ref_t< _Tp> ); +# 3490 +template< class _Tp> constexpr inline bool +# 3491 +is_nothrow_destructible_v = (is_nothrow_destructible< _Tp> ::value); +# 3494 +template< class _Tp> constexpr inline bool +# 3495 +has_virtual_destructor_v = __has_virtual_destructor(_Tp); +# 3498 +template< class _Tp> constexpr inline size_t +# 3499 +alignment_of_v = (alignment_of< _Tp> ::value); +# 3501 +template< class _Tp> constexpr inline size_t +# 3502 +rank_v = (0); +# 3503 +template< class _Tp, size_t _Size> constexpr inline size_t +# 3504 +rank_v< _Tp [_Size]> = 1 + rank_v< _Tp> ; +# 3505 +template< class _Tp> constexpr inline size_t +# 3506 +rank_v< _Tp []> = 1 + rank_v< _Tp> ; +# 3508 +template< class _Tp, unsigned _Idx = 0U> constexpr inline size_t +# 3509 +extent_v = (0); +# 3510 +template< class _Tp, size_t _Size> constexpr inline size_t +# 3511 +extent_v< _Tp [_Size], 0> = _Size; +# 3512 +template< class _Tp, unsigned _Idx, size_t _Size> constexpr inline size_t +# 3513 +extent_v< _Tp [_Size], _Idx> = extent_v< _Tp, _Idx - (1)> ; +# 3514 +template< class _Tp> constexpr inline size_t +# 3515 +extent_v< _Tp [], 0> = (0); +# 3516 +template< class _Tp, unsigned _Idx> constexpr inline size_t +# 3517 +extent_v< _Tp [], _Idx> = extent_v< _Tp, _Idx - (1)> ; +# 3520 +template< class _Tp, class _Up> constexpr inline bool +# 3521 +is_same_v = __is_same(_Tp, _Up); +# 3528 +template< class _Base, class _Derived> constexpr inline bool +# 3529 +is_base_of_v = __is_base_of(_Base, _Derived); +# 3531 +template< class _From, class _To> constexpr inline bool +# 3532 +is_convertible_v = __is_convertible(_From, _To); +# 3537 +template< class _Fn, class ..._Args> constexpr inline bool +# 3538 +is_invocable_v = (is_invocable< _Fn, _Args...> ::value); +# 3539 +template< class _Fn, class ..._Args> constexpr inline bool +# 3540 +is_nothrow_invocable_v = (is_nothrow_invocable< _Fn, _Args...> ::value); +# 3542 +template< class _Ret, class _Fn, class ..._Args> constexpr inline bool +# 3543 +is_invocable_r_v = (is_invocable_r< _Ret, _Fn, _Args...> ::value); +# 3545 +template< class _Ret, class _Fn, class ..._Args> constexpr inline bool +# 3546 +is_nothrow_invocable_r_v = (is_nothrow_invocable_r< _Ret, _Fn, _Args...> ::value); +# 3554 +template< class _Tp> +# 3555 +struct has_unique_object_representations : public bool_constant< __has_unique_object_representations(remove_cv_t< remove_all_extents_t< _Tp> > )> { +# 3560 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 3562 +}; +# 3566 +template< class _Tp> constexpr inline bool +# 3567 +has_unique_object_representations_v = (has_unique_object_representations< _Tp> ::value); +# 3575 +template< class _Tp> +# 3576 +struct is_aggregate : public bool_constant< __is_aggregate(remove_cv_t< _Tp> )> { +# 3578 +}; +# 3585 +template< class _Tp> constexpr inline bool +# 3586 +is_aggregate_v = __is_aggregate(remove_cv_t< _Tp> ); +# 4018 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/type_traits" 3 +} +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 49 +template< class _Tp> constexpr _Tp * +# 51 +__addressof(_Tp &__r) noexcept +# 52 +{ return __builtin_addressof(__r); } +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 +template< class _Tp> +# 69 +[[__nodiscard__]] constexpr _Tp && +# 71 +forward(typename remove_reference< _Tp> ::type &__t) noexcept +# 72 +{ return static_cast< _Tp &&>(__t); } +# 81 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 +template< class _Tp> +# 82 +[[__nodiscard__]] constexpr _Tp && +# 84 +forward(typename remove_reference< _Tp> ::type &&__t) noexcept +# 85 +{ +# 86 +static_assert((!std::template is_lvalue_reference< _Tp> ::value), "std::forward must not be used to convert an rvalue to an lvalue"); +# 88 +return static_cast< _Tp &&>(__t); +# 89 +} +# 134 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 +template< class _Tp> +# 135 +[[__nodiscard__]] constexpr typename remove_reference< _Tp> ::type && +# 137 +move(_Tp &&__t) noexcept +# 138 +{ return static_cast< typename remove_reference< _Tp> ::type &&>(__t); } +# 141 +template< class _Tp> +# 142 +struct __move_if_noexcept_cond : public __and_< __not_< is_nothrow_move_constructible< _Tp> > , is_copy_constructible< _Tp> > ::type { +# 144 +}; +# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 +template< class _Tp> +# 156 +[[__nodiscard__]] constexpr __conditional_t< __move_if_noexcept_cond< _Tp> ::value, const _Tp &, _Tp &&> +# 159 +move_if_noexcept(_Tp &__x) noexcept +# 160 +{ return std::move(__x); } +# 172 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 +template< class _Tp> +# 173 +[[__nodiscard__]] constexpr _Tp * +# 175 +addressof(_Tp &__r) noexcept +# 176 +{ return std::__addressof(__r); } +# 180 +template < typename _Tp > + const _Tp * addressof ( const _Tp && ) = delete; +# 184 +template< class _Tp, class _Up = _Tp> inline _Tp +# 187 +__exchange(_Tp &__obj, _Up &&__new_val) +# 188 +{ +# 189 +_Tp __old_val = std::move(__obj); +# 190 +__obj = std::forward< _Up> (__new_val); +# 191 +return __old_val; +# 192 +} +# 216 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/move.h" 3 +template< class _Tp> inline typename enable_if< __and_< __not_< __is_tuple_like< _Tp> > , is_move_constructible< _Tp> , is_move_assignable< _Tp> > ::value> ::type +# 226 +swap(_Tp &__a, _Tp &__b) noexcept(__and_< is_nothrow_move_constructible< _Tp> , is_nothrow_move_assignable< _Tp> > ::value) +# 229 +{ +# 234 +_Tp __tmp = std::move(__a); +# 235 +__a = std::move(__b); +# 236 +__b = std::move(__tmp); +# 237 +} +# 242 +template< class _Tp, size_t _Nm> inline typename enable_if< __is_swappable< _Tp> ::value> ::type +# 250 +swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) noexcept(__is_nothrow_swappable< _Tp> ::value) +# 252 +{ +# 253 +for (size_t __n = (0); __n < _Nm; ++__n) { +# 254 +swap(__a[__n], __b[__n]); } +# 255 +} +# 259 +} +# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 48 +template< class _Tp> struct tuple_size; +# 55 +template< class _Tp, class +# 56 +_Up = typename remove_cv< _Tp> ::type, class +# 57 + = typename enable_if< is_same< _Tp, _Up> ::value> ::type, size_t +# 58 + = tuple_size< _Tp> ::value> using __enable_if_has_tuple_size = _Tp; +# 61 +template< class _Tp> +# 62 +struct tuple_size< const __enable_if_has_tuple_size< _Tp> > : public std::tuple_size< _Tp> { +# 63 +}; +# 65 +template< class _Tp> +# 66 +struct tuple_size< volatile __enable_if_has_tuple_size< _Tp> > : public std::tuple_size< _Tp> { +# 67 +}; +# 69 +template< class _Tp> +# 70 +struct tuple_size< const volatile __enable_if_has_tuple_size< _Tp> > : public std::tuple_size< _Tp> { +# 71 +}; +# 74 +template< class _Tp> constexpr inline size_t +# 75 +tuple_size_v = (tuple_size< _Tp> ::value); +# 79 +template< size_t __i, class _Tp> struct tuple_element; +# 83 +template< size_t __i, class _Tp> using __tuple_element_t = typename tuple_element< __i, _Tp> ::type; +# 86 +template< size_t __i, class _Tp> +# 87 +struct tuple_element< __i, const _Tp> { +# 89 +using type = const __tuple_element_t< __i, _Tp> ; +# 90 +}; +# 92 +template< size_t __i, class _Tp> +# 93 +struct tuple_element< __i, volatile _Tp> { +# 95 +using type = volatile __tuple_element_t< __i, _Tp> ; +# 96 +}; +# 98 +template< size_t __i, class _Tp> +# 99 +struct tuple_element< __i, const volatile _Tp> { +# 101 +using type = const volatile __tuple_element_t< __i, _Tp> ; +# 102 +}; +# 108 +template< class _Tp, class ..._Types> constexpr size_t +# 110 +__find_uniq_type_in_pack() +# 111 +{ +# 112 +constexpr size_t __sz = sizeof...(_Types); +# 113 +constexpr bool __found[__sz] = {__is_same(_Tp, _Types)...}; +# 114 +size_t __n = __sz; +# 115 +for (size_t __i = (0); __i < __sz; ++__i) +# 116 +{ +# 117 +if (__found[__i]) +# 118 +{ +# 119 +if (__n < __sz) { +# 120 +return __sz; } +# 121 +__n = __i; +# 122 +} +# 123 +} +# 124 +return __n; +# 125 +} +# 134 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 +template< size_t __i, class _Tp> using tuple_element_t = typename tuple_element< __i, _Tp> ::type; +# 140 +template< size_t ..._Indexes> struct _Index_tuple { }; +# 143 +template< size_t _Num> +# 144 +struct _Build_index_tuple { +# 154 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 +using __type = _Index_tuple< __integer_pack(_Num)...> ; +# 156 +}; +# 161 +template< class _Tp, _Tp ..._Idx> +# 162 +struct integer_sequence { +# 167 +typedef _Tp value_type; +# 168 +static constexpr size_t size() noexcept { return sizeof...(_Idx); } +# 169 +}; +# 172 +template< class _Tp, _Tp _Num> using make_integer_sequence = integer_sequence< _Tp, __integer_pack(_Num)...> ; +# 181 +template< size_t ..._Idx> using index_sequence = integer_sequence< unsigned long, _Idx...> ; +# 185 +template< size_t _Num> using make_index_sequence = make_integer_sequence< unsigned long, _Num> ; +# 189 +template< class ..._Types> using index_sequence_for = make_index_sequence< sizeof...(_Types)> ; +# 195 +struct in_place_t { +# 196 +explicit in_place_t() = default; +# 197 +}; +# 199 +constexpr inline in_place_t in_place{}; +# 201 +template< class _Tp> struct in_place_type_t { +# 203 +explicit in_place_type_t() = default; +# 204 +}; +# 206 +template< class _Tp> constexpr inline in_place_type_t< _Tp> +# 207 +in_place_type{}; +# 209 +template< size_t _Idx> struct in_place_index_t { +# 211 +explicit in_place_index_t() = default; +# 212 +}; +# 214 +template< size_t _Idx> constexpr inline in_place_index_t< _Idx> +# 215 +in_place_index{}; +# 217 +template< class > constexpr inline bool +# 218 +__is_in_place_type_v = false; +# 220 +template< class _Tp> constexpr inline bool +# 221 +__is_in_place_type_v< in_place_type_t< _Tp> > = true; +# 223 +template< class _Tp> using __is_in_place_type = bool_constant< __is_in_place_type_v< _Tp> > ; +# 226 +template< class > constexpr inline bool +# 227 +__is_in_place_index_v = false; +# 229 +template< size_t _Nm> constexpr inline bool +# 230 +__is_in_place_index_v< in_place_index_t< _Nm> > = true; +# 235 +template< size_t _Np, class ..._Types> +# 236 +struct _Nth_type { +# 237 +using type = __type_pack_element< _Np, _Types...> ; }; +# 284 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/utility.h" 3 +} +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +struct piecewise_construct_t { explicit piecewise_construct_t() = default;}; +# 82 +constexpr inline piecewise_construct_t piecewise_construct = piecewise_construct_t(); +# 88 +template< class _T1, class _T2> struct pair; +# 91 +template< class ...> class tuple; +# 98 +template< class _Tp, size_t _Nm> struct array; +# 101 +template< size_t ...> struct _Index_tuple; +# 104 +template< size_t _Int, class _Tp1, class _Tp2> constexpr typename tuple_element< _Int, pair< _Tp1, _Tp2> > ::type &get(pair< _Tp1, _Tp2> & __in) noexcept; +# 108 +template< size_t _Int, class _Tp1, class _Tp2> constexpr typename tuple_element< _Int, pair< _Tp1, _Tp2> > ::type &&get(pair< _Tp1, _Tp2> && __in) noexcept; +# 112 +template< size_t _Int, class _Tp1, class _Tp2> constexpr const typename tuple_element< _Int, pair< _Tp1, _Tp2> > ::type &get(const pair< _Tp1, _Tp2> & __in) noexcept; +# 116 +template< size_t _Int, class _Tp1, class _Tp2> constexpr const typename tuple_element< _Int, pair< _Tp1, _Tp2> > ::type &&get(const pair< _Tp1, _Tp2> && __in) noexcept; +# 120 +template< size_t __i, class ..._Elements> constexpr __tuple_element_t< __i, tuple< _Elements...> > &get(tuple< _Elements...> & __t) noexcept; +# 124 +template< size_t __i, class ..._Elements> constexpr const __tuple_element_t< __i, tuple< _Elements...> > &get(const tuple< _Elements...> & __t) noexcept; +# 128 +template< size_t __i, class ..._Elements> constexpr __tuple_element_t< __i, tuple< _Elements...> > &&get(tuple< _Elements...> && __t) noexcept; +# 132 +template< size_t __i, class ..._Elements> constexpr const __tuple_element_t< __i, tuple< _Elements...> > &&get(const tuple< _Elements...> && __t) noexcept; +# 136 +template< size_t _Int, class _Tp, size_t _Nm> constexpr _Tp &get(array< _Tp, _Nm> &) noexcept; +# 140 +template< size_t _Int, class _Tp, size_t _Nm> constexpr _Tp &&get(array< _Tp, _Nm> &&) noexcept; +# 144 +template< size_t _Int, class _Tp, size_t _Nm> constexpr const _Tp &get(const array< _Tp, _Nm> &) noexcept; +# 148 +template< size_t _Int, class _Tp, size_t _Nm> constexpr const _Tp &&get(const array< _Tp, _Nm> &&) noexcept; +# 158 +template< bool , class _T1, class _T2> +# 159 +struct _PCC { +# 161 +template< class _U1, class _U2> static constexpr bool +# 162 +_ConstructiblePair() +# 163 +{ +# 164 +return __and_< is_constructible< _T1, const _U1 &> , is_constructible< _T2, const _U2 &> > ::value; +# 166 +} +# 168 +template< class _U1, class _U2> static constexpr bool +# 169 +_ImplicitlyConvertiblePair() +# 170 +{ +# 171 +return __and_< is_convertible< const _U1 &, _T1> , is_convertible< const _U2 &, _T2> > ::value; +# 173 +} +# 175 +template< class _U1, class _U2> static constexpr bool +# 176 +_MoveConstructiblePair() +# 177 +{ +# 178 +return __and_< is_constructible< _T1, _U1 &&> , is_constructible< _T2, _U2 &&> > ::value; +# 180 +} +# 182 +template< class _U1, class _U2> static constexpr bool +# 183 +_ImplicitlyMoveConvertiblePair() +# 184 +{ +# 185 +return __and_< is_convertible< _U1 &&, _T1> , is_convertible< _U2 &&, _T2> > ::value; +# 187 +} +# 188 +}; +# 190 +template< class _T1, class _T2> +# 191 +struct _PCC< false, _T1, _T2> { +# 193 +template< class _U1, class _U2> static constexpr bool +# 194 +_ConstructiblePair() +# 195 +{ +# 196 +return false; +# 197 +} +# 199 +template< class _U1, class _U2> static constexpr bool +# 200 +_ImplicitlyConvertiblePair() +# 201 +{ +# 202 +return false; +# 203 +} +# 205 +template< class _U1, class _U2> static constexpr bool +# 206 +_MoveConstructiblePair() +# 207 +{ +# 208 +return false; +# 209 +} +# 211 +template< class _U1, class _U2> static constexpr bool +# 212 +_ImplicitlyMoveConvertiblePair() +# 213 +{ +# 214 +return false; +# 215 +} +# 216 +}; +# 260 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +template< class _U1, class _U2> class __pair_base { +# 263 +template< class _T1, class _T2> friend struct pair; +# 264 +__pair_base() = default; +# 265 +~__pair_base() = default; +# 266 +__pair_base(const __pair_base &) = default; +# 267 +__pair_base &operator=(const __pair_base &) = delete; +# 269 +}; +# 283 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +template< class _T1, class _T2> +# 284 +struct pair : public __pair_base< _T1, _T2> { +# 287 +typedef _T1 first_type; +# 288 +typedef _T2 second_type; +# 290 +_T1 first; +# 291 +_T2 second; +# 294 +constexpr pair(const pair &) = default; +# 295 +constexpr pair(pair &&) = default; +# 297 +template< class ..._Args1, class ..._Args2> pair(std::piecewise_construct_t, tuple< _Args1...> , tuple< _Args2...> ); +# 303 +void swap(pair &__p) noexcept(__and_< __is_nothrow_swappable< _T1> , __is_nothrow_swappable< _T2> > ::value) +# 306 +{ +# 307 +using std::swap; +# 308 +swap(first, __p.first); +# 309 +swap(second, __p.second); +# 310 +} +# 332 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +private: template< class ..._Args1, std::size_t ..._Indexes1, class ... +# 333 +_Args2, std::size_t ..._Indexes2> +# 332 +pair(tuple< _Args1...> &, tuple< _Args2...> &, _Index_tuple< _Indexes1...> , _Index_tuple< _Indexes2...> ); +# 725 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +public: +# 719 +template< class _U1 = _T1, class +# 720 +_U2 = _T2, typename enable_if< __and_< __is_implicitly_default_constructible< _U1> , __is_implicitly_default_constructible< _U2> > ::value, bool> ::type +# 724 + = true> constexpr +# 725 +pair() : first(), second() +# 726 +{ } +# 728 +template< class _U1 = _T1, class +# 729 +_U2 = _T2, typename enable_if< __and_< is_default_constructible< _U1> , is_default_constructible< _U2> , __not_< __and_< __is_implicitly_default_constructible< _U1> , __is_implicitly_default_constructible< _U2> > > > ::value, bool> ::type +# 736 + = false> constexpr explicit +# 737 +pair() : first(), second() +# 738 +{ } +# 742 +using _PCCP = _PCC< true, _T1, _T2> ; +# 746 +template< class _U1 = _T1, class _U2 = _T2, typename enable_if< _PCC< true, _T1, _T2> ::template _ConstructiblePair< _U1, _U2> () && _PCC< true, _T1, _T2> ::template _ImplicitlyConvertiblePair< _U1, _U2> (), bool> ::type +# 751 + = true> constexpr +# 752 +pair(const _T1 &__a, const _T2 &__b) : first(__a), second(__b) +# 753 +{ } +# 756 +template< class _U1 = _T1, class _U2 = _T2, typename enable_if< _PCC< true, _T1, _T2> ::template _ConstructiblePair< _U1, _U2> () && (!_PCC< true, _T1, _T2> ::template _ImplicitlyConvertiblePair< _U1, _U2> ()), bool> ::type +# 761 + = false> constexpr explicit +# 762 +pair(const _T1 &__a, const _T2 &__b) : first(__a), second(__b) +# 763 +{ } +# 767 +template< class _U1, class _U2> using _PCCFP = _PCC< (!is_same< _T1, _U1> ::value) || (!is_same< _T2, _U2> ::value), _T1, _T2> ; +# 773 +template< class _U1, class _U2, typename enable_if< _PCC< (!is_same< _T1, _U1> ::value) || (!is_same< _T2, _U2> ::value), _T1, _T2> ::template _ConstructiblePair< _U1, _U2> () && _PCC< (!is_same< _T1, _U1> ::value) || (!is_same< _T2, _U2> ::value), _T1, _T2> ::template _ImplicitlyConvertiblePair< _U1, _U2> (), bool> ::type +# 778 + = true> constexpr +# 779 +pair(const pair< _U1, _U2> &__p) : first((__p.first)), second((__p.second)) +# 781 +{ ; } +# 783 +template< class _U1, class _U2, typename enable_if< _PCC< (!is_same< _T1, _U1> ::value) || (!is_same< _T2, _U2> ::value), _T1, _T2> ::template _ConstructiblePair< _U1, _U2> () && (!_PCC< (!is_same< _T1, _U1> ::value) || (!is_same< _T2, _U2> ::value), _T1, _T2> ::template _ImplicitlyConvertiblePair< _U1, _U2> ()), bool> ::type +# 788 + = false> constexpr explicit +# 789 +pair(const pair< _U1, _U2> &__p) : first((__p.first)), second((__p.second)) +# 791 +{ ; } +# 807 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +private: struct __zero_as_null_pointer_constant { +# 809 +__zero_as_null_pointer_constant(int (__zero_as_null_pointer_constant::*)) +# 810 +{ } +# 811 +template < typename _Tp, + typename = __enable_if_t < is_null_pointer < _Tp > :: value > > + __zero_as_null_pointer_constant ( _Tp ) = delete; +# 814 +}; +# 830 +public: +# 821 +template< class _U1, std::__enable_if_t< __and_< __not_< is_reference< _U1> > , is_pointer< _T2> , is_constructible< _T1, _U1> , __not_< is_constructible< _T1, const _U1 &> > , is_convertible< _U1, _T1> > ::value, bool> +# 827 + = true> +# 828 +__attribute((__deprecated__("use \'nullptr\' instead of \'0\' to initialize std::pair of move-only type and pointer"))) constexpr +# 830 +pair(_U1 &&__x, __zero_as_null_pointer_constant, ...) : first(std::forward< _U1> (__x)), second(nullptr) +# 832 +{ ; } +# 834 +template< class _U1, std::__enable_if_t< __and_< __not_< is_reference< _U1> > , is_pointer< _T2> , is_constructible< _T1, _U1> , __not_< is_constructible< _T1, const _U1 &> > , __not_< is_convertible< _U1, _T1> > > ::value, bool> +# 840 + = false> +# 841 +__attribute((__deprecated__("use \'nullptr\' instead of \'0\' to initialize std::pair of move-only type and pointer"))) constexpr explicit +# 843 +pair(_U1 &&__x, __zero_as_null_pointer_constant, ...) : first(std::forward< _U1> (__x)), second(nullptr) +# 845 +{ ; } +# 847 +template< class _U2, std::__enable_if_t< __and_< is_pointer< _T1> , __not_< is_reference< _U2> > , is_constructible< _T2, _U2> , __not_< is_constructible< _T2, const _U2 &> > , is_convertible< _U2, _T2> > ::value, bool> +# 853 + = true> +# 854 +__attribute((__deprecated__("use \'nullptr\' instead of \'0\' to initialize std::pair of move-only type and pointer"))) constexpr +# 856 +pair(__zero_as_null_pointer_constant, _U2 &&__y, ...) : first(nullptr), second(std::forward< _U2> (__y)) +# 858 +{ ; } +# 860 +template< class _U2, std::__enable_if_t< __and_< is_pointer< _T1> , __not_< is_reference< _U2> > , is_constructible< _T2, _U2> , __not_< is_constructible< _T2, const _U2 &> > , __not_< is_convertible< _U2, _T2> > > ::value, bool> +# 866 + = false> +# 867 +__attribute((__deprecated__("use \'nullptr\' instead of \'0\' to initialize std::pair of move-only type and pointer"))) constexpr explicit +# 869 +pair(__zero_as_null_pointer_constant, _U2 &&__y, ...) : first(nullptr), second(std::forward< _U2> (__y)) +# 871 +{ ; } +# 875 +template< class _U1, class _U2, typename enable_if< _PCC< true, _T1, _T2> ::template _MoveConstructiblePair< _U1, _U2> () && _PCC< true, _T1, _T2> ::template _ImplicitlyMoveConvertiblePair< _U1, _U2> (), bool> ::type +# 880 + = true> constexpr +# 881 +pair(_U1 &&__x, _U2 &&__y) : first(std::forward< _U1> (__x)), second(std::forward< _U2> (__y)) +# 883 +{ ; } +# 885 +template< class _U1, class _U2, typename enable_if< _PCC< true, _T1, _T2> ::template _MoveConstructiblePair< _U1, _U2> () && (!_PCC< true, _T1, _T2> ::template _ImplicitlyMoveConvertiblePair< _U1, _U2> ()), bool> ::type +# 890 + = false> constexpr explicit +# 891 +pair(_U1 &&__x, _U2 &&__y) : first(std::forward< _U1> (__x)), second(std::forward< _U2> (__y)) +# 893 +{ ; } +# 896 +template< class _U1, class _U2, typename enable_if< _PCC< (!is_same< _T1, _U1> ::value) || (!is_same< _T2, _U2> ::value), _T1, _T2> ::template _MoveConstructiblePair< _U1, _U2> () && _PCC< (!is_same< _T1, _U1> ::value) || (!is_same< _T2, _U2> ::value), _T1, _T2> ::template _ImplicitlyMoveConvertiblePair< _U1, _U2> (), bool> ::type +# 901 + = true> constexpr +# 902 +pair(pair< _U1, _U2> &&__p) : first(std::forward< _U1> ((__p.first))), second(std::forward< _U2> ((__p.second))) +# 905 +{ ; } +# 907 +template< class _U1, class _U2, typename enable_if< _PCC< (!is_same< _T1, _U1> ::value) || (!is_same< _T2, _U2> ::value), _T1, _T2> ::template _MoveConstructiblePair< _U1, _U2> () && (!_PCC< (!is_same< _T1, _U1> ::value) || (!is_same< _T2, _U2> ::value), _T1, _T2> ::template _ImplicitlyMoveConvertiblePair< _U1, _U2> ()), bool> ::type +# 912 + = false> constexpr explicit +# 913 +pair(pair< _U1, _U2> &&__p) : first(std::forward< _U1> ((__p.first))), second(std::forward< _U2> ((__p.second))) +# 916 +{ ; } +# 921 +pair &operator=(std::__conditional_t< __and_< is_copy_assignable< _T1> , is_copy_assignable< _T2> > ::value, const pair &, const std::__nonesuch &> +# 923 +__p) +# 924 +{ +# 925 +(first) = (__p.first); +# 926 +(second) = (__p.second); +# 927 +return *this; +# 928 +} +# 931 +pair &operator=(std::__conditional_t< __and_< is_move_assignable< _T1> , is_move_assignable< _T2> > ::value, pair &&, std::__nonesuch &&> +# 933 +__p) noexcept(__and_< is_nothrow_move_assignable< _T1> , is_nothrow_move_assignable< _T2> > ::value) +# 936 +{ +# 937 +(first) = std::forward< first_type> ((__p.first)); +# 938 +(second) = std::forward< second_type> ((__p.second)); +# 939 +return *this; +# 940 +} +# 942 +template< class _U1, class _U2> typename enable_if< __and_< is_assignable< _T1 &, const _U1 &> , is_assignable< _T2 &, const _U2 &> > ::value, pair &> ::type +# 946 +operator=(const pair< _U1, _U2> &__p) +# 947 +{ +# 948 +(first) = (__p.first); +# 949 +(second) = (__p.second); +# 950 +return *this; +# 951 +} +# 953 +template< class _U1, class _U2> typename enable_if< __and_< is_assignable< _T1 &, _U1 &&> , is_assignable< _T2 &, _U2 &&> > ::value, pair &> ::type +# 957 +operator=(pair< _U1, _U2> &&__p) +# 958 +{ +# 959 +(first) = std::forward< _U1> ((__p.first)); +# 960 +(second) = std::forward< _U2> ((__p.second)); +# 961 +return *this; +# 962 +} +# 995 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +}; +# 1000 +template< class _T1, class _T2> pair(_T1, _T2)->pair< _T1, _T2> ; +# 1031 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +template< class _T1, class _T2> constexpr bool +# 1033 +operator==(const pair< _T1, _T2> &__x, const pair< _T1, _T2> &__y) +# 1034 +{ return ((__x.first) == (__y.first)) && ((__x.second) == (__y.second)); } +# 1043 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +template< class _T1, class _T2> constexpr bool +# 1045 +operator<(const pair< _T1, _T2> &__x, const pair< _T1, _T2> &__y) +# 1046 +{ return ((__x.first) < (__y.first)) || ((!((__y.first) < (__x.first))) && ((__x.second) < (__y.second))); +# 1047 +} +# 1050 +template< class _T1, class _T2> constexpr bool +# 1052 +operator!=(const pair< _T1, _T2> &__x, const pair< _T1, _T2> &__y) +# 1053 +{ return !(__x == __y); } +# 1056 +template< class _T1, class _T2> constexpr bool +# 1058 +operator>(const pair< _T1, _T2> &__x, const pair< _T1, _T2> &__y) +# 1059 +{ return __y < __x; } +# 1062 +template< class _T1, class _T2> constexpr bool +# 1064 +operator<=(const pair< _T1, _T2> &__x, const pair< _T1, _T2> &__y) +# 1065 +{ return !(__y < __x); } +# 1068 +template< class _T1, class _T2> constexpr bool +# 1070 +operator>=(const pair< _T1, _T2> &__x, const pair< _T1, _T2> &__y) +# 1071 +{ return !(__x < __y); } +# 1080 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +template< class _T1, class _T2> inline typename enable_if< __and_< __is_swappable< _T1> , __is_swappable< _T2> > ::value> ::type +# 1089 +swap(pair< _T1, _T2> &__x, pair< _T1, _T2> &__y) noexcept(noexcept(__x.swap(__y))) +# 1091 +{ __x.swap(__y); } +# 1103 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +template < typename _T1, typename _T2 > + typename enable_if < ! __and_ < __is_swappable < _T1 >, + __is_swappable < _T2 > > :: value > :: type + swap ( pair < _T1, _T2 > &, pair < _T1, _T2 > & ) = delete; +# 1129 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +template< class _T1, class _T2> constexpr pair< typename __decay_and_strip< _T1> ::__type, typename __decay_and_strip< _T2> ::__type> +# 1132 +make_pair(_T1 &&__x, _T2 &&__y) +# 1133 +{ +# 1134 +typedef typename __decay_and_strip< _T1> ::__type __ds_type1; +# 1135 +typedef typename __decay_and_strip< _T2> ::__type __ds_type2; +# 1136 +typedef pair< typename __decay_and_strip< _T1> ::__type, typename __decay_and_strip< _T2> ::__type> __pair_type; +# 1137 +return __pair_type(std::forward< _T1> (__x), std::forward< _T2> (__y)); +# 1138 +} +# 1152 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +template< class _T1, class _T2> +# 1153 +struct __is_tuple_like_impl< pair< _T1, _T2> > : public true_type { +# 1154 +}; +# 1158 +template< class _Tp1, class _Tp2> +# 1159 +struct tuple_size< pair< _Tp1, _Tp2> > : public integral_constant< unsigned long, 2UL> { +# 1160 +}; +# 1163 +template< class _Tp1, class _Tp2> +# 1164 +struct tuple_element< 0, pair< _Tp1, _Tp2> > { +# 1165 +typedef _Tp1 type; }; +# 1168 +template< class _Tp1, class _Tp2> +# 1169 +struct tuple_element< 1, pair< _Tp1, _Tp2> > { +# 1170 +typedef _Tp2 type; }; +# 1174 +template< size_t __i, class ..._Types> struct tuple_element< __i, tuple< _Types...> > ; +# 1178 +template< class _Tp1, class _Tp2> constexpr inline size_t +# 1179 +tuple_size_v< pair< _Tp1, _Tp2> > = (2); +# 1181 +template< class _Tp1, class _Tp2> constexpr inline size_t +# 1182 +tuple_size_v< const pair< _Tp1, _Tp2> > = (2); +# 1184 +template< class _Tp> constexpr inline bool +# 1185 +__is_pair = false; +# 1187 +template< class _Tp, class _Up> constexpr inline bool +# 1188 +__is_pair< pair< _Tp, _Up> > = true; +# 1192 +template< size_t _Int> struct __pair_get; +# 1196 +template<> struct __pair_get< 0UL> { +# 1198 +template< class _Tp1, class _Tp2> static constexpr _Tp1 & +# 1200 +__get(pair< _Tp1, _Tp2> &__pair) noexcept +# 1201 +{ return __pair.first; } +# 1203 +template< class _Tp1, class _Tp2> static constexpr _Tp1 && +# 1205 +__move_get(pair< _Tp1, _Tp2> &&__pair) noexcept +# 1206 +{ return std::forward< _Tp1> ((__pair.first)); } +# 1208 +template< class _Tp1, class _Tp2> static constexpr const _Tp1 & +# 1210 +__const_get(const pair< _Tp1, _Tp2> &__pair) noexcept +# 1211 +{ return __pair.first; } +# 1213 +template< class _Tp1, class _Tp2> static constexpr const _Tp1 && +# 1215 +__const_move_get(const pair< _Tp1, _Tp2> &&__pair) noexcept +# 1216 +{ return std::forward< const _Tp1> ((__pair.first)); } +# 1217 +}; +# 1220 +template<> struct __pair_get< 1UL> { +# 1222 +template< class _Tp1, class _Tp2> static constexpr _Tp2 & +# 1224 +__get(pair< _Tp1, _Tp2> &__pair) noexcept +# 1225 +{ return __pair.second; } +# 1227 +template< class _Tp1, class _Tp2> static constexpr _Tp2 && +# 1229 +__move_get(pair< _Tp1, _Tp2> &&__pair) noexcept +# 1230 +{ return std::forward< _Tp2> ((__pair.second)); } +# 1232 +template< class _Tp1, class _Tp2> static constexpr const _Tp2 & +# 1234 +__const_get(const pair< _Tp1, _Tp2> &__pair) noexcept +# 1235 +{ return __pair.second; } +# 1237 +template< class _Tp1, class _Tp2> static constexpr const _Tp2 && +# 1239 +__const_move_get(const pair< _Tp1, _Tp2> &&__pair) noexcept +# 1240 +{ return std::forward< const _Tp2> ((__pair.second)); } +# 1241 +}; +# 1248 +template< size_t _Int, class _Tp1, class _Tp2> constexpr typename tuple_element< _Int, pair< _Tp1, _Tp2> > ::type & +# 1250 +get(pair< _Tp1, _Tp2> &__in) noexcept +# 1251 +{ return __pair_get< _Int> ::__get(__in); } +# 1253 +template< size_t _Int, class _Tp1, class _Tp2> constexpr typename tuple_element< _Int, pair< _Tp1, _Tp2> > ::type && +# 1255 +get(pair< _Tp1, _Tp2> &&__in) noexcept +# 1256 +{ return __pair_get< _Int> ::__move_get(std::move(__in)); } +# 1258 +template< size_t _Int, class _Tp1, class _Tp2> constexpr const typename tuple_element< _Int, pair< _Tp1, _Tp2> > ::type & +# 1260 +get(const pair< _Tp1, _Tp2> &__in) noexcept +# 1261 +{ return __pair_get< _Int> ::__const_get(__in); } +# 1263 +template< size_t _Int, class _Tp1, class _Tp2> constexpr const typename tuple_element< _Int, pair< _Tp1, _Tp2> > ::type && +# 1265 +get(const pair< _Tp1, _Tp2> &&__in) noexcept +# 1266 +{ return __pair_get< _Int> ::__const_move_get(std::move(__in)); } +# 1270 +template< class _Tp, class _Up> constexpr _Tp & +# 1272 +get(pair< _Tp, _Up> &__p) noexcept +# 1273 +{ return __p.first; } +# 1275 +template< class _Tp, class _Up> constexpr const _Tp & +# 1277 +get(const pair< _Tp, _Up> &__p) noexcept +# 1278 +{ return __p.first; } +# 1280 +template< class _Tp, class _Up> constexpr _Tp && +# 1282 +get(pair< _Tp, _Up> &&__p) noexcept +# 1283 +{ return std::move((__p.first)); } +# 1285 +template< class _Tp, class _Up> constexpr const _Tp && +# 1287 +get(const pair< _Tp, _Up> &&__p) noexcept +# 1288 +{ return std::move((__p.first)); } +# 1290 +template< class _Tp, class _Up> constexpr _Tp & +# 1292 +get(pair< _Up, _Tp> &__p) noexcept +# 1293 +{ return __p.second; } +# 1295 +template< class _Tp, class _Up> constexpr const _Tp & +# 1297 +get(const pair< _Up, _Tp> &__p) noexcept +# 1298 +{ return __p.second; } +# 1300 +template< class _Tp, class _Up> constexpr _Tp && +# 1302 +get(pair< _Up, _Tp> &&__p) noexcept +# 1303 +{ return std::move((__p.second)); } +# 1305 +template< class _Tp, class _Up> constexpr const _Tp && +# 1307 +get(const pair< _Up, _Tp> &&__p) noexcept +# 1308 +{ return std::move((__p.second)); } +# 1333 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_pair.h" 3 +} +# 74 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 93 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 +struct input_iterator_tag { }; +# 96 +struct output_iterator_tag { }; +# 99 +struct forward_iterator_tag : public input_iterator_tag { }; +# 103 +struct bidirectional_iterator_tag : public forward_iterator_tag { }; +# 107 +struct random_access_iterator_tag : public bidirectional_iterator_tag { }; +# 125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 +template< class _Category, class _Tp, class _Distance = ptrdiff_t, class +# 126 +_Pointer = _Tp *, class _Reference = _Tp &> +# 127 +struct [[__deprecated__]] iterator { +# 130 +typedef _Category iterator_category; +# 132 +typedef _Tp value_type; +# 134 +typedef _Distance difference_type; +# 136 +typedef _Pointer pointer; +# 138 +typedef _Reference reference; +# 139 +}; +# 149 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 +template< class _Iterator> struct iterator_traits; +# 155 +template< class _Iterator, class = __void_t< > > +# 156 +struct __iterator_traits { }; +# 160 +template< class _Iterator> +# 161 +struct __iterator_traits< _Iterator, __void_t< typename _Iterator::iterator_category, typename _Iterator::value_type, typename _Iterator::difference_type, typename _Iterator::pointer, typename _Iterator::reference> > { +# 168 +typedef typename _Iterator::iterator_category iterator_category; +# 169 +typedef typename _Iterator::value_type value_type; +# 170 +typedef typename _Iterator::difference_type difference_type; +# 171 +typedef typename _Iterator::pointer pointer; +# 172 +typedef typename _Iterator::reference reference; +# 173 +}; +# 176 +template< class _Iterator> +# 177 +struct iterator_traits : public __iterator_traits< _Iterator> { +# 178 +}; +# 209 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_types.h" 3 +template< class _Tp> +# 210 +struct iterator_traits< _Tp *> { +# 212 +typedef random_access_iterator_tag iterator_category; +# 213 +typedef _Tp value_type; +# 214 +typedef ptrdiff_t difference_type; +# 215 +typedef _Tp *pointer; +# 216 +typedef _Tp &reference; +# 217 +}; +# 220 +template< class _Tp> +# 221 +struct iterator_traits< const _Tp *> { +# 223 +typedef random_access_iterator_tag iterator_category; +# 224 +typedef _Tp value_type; +# 225 +typedef ptrdiff_t difference_type; +# 226 +typedef const _Tp *pointer; +# 227 +typedef const _Tp &reference; +# 228 +}; +# 235 +template< class _Iter> +# 236 +__attribute((__always_inline__)) constexpr typename iterator_traits< _Iter> ::iterator_category +# 239 +__iterator_category(const _Iter &) +# 240 +{ return typename iterator_traits< _Iter> ::iterator_category(); } +# 245 +template< class _Iter> using __iter_category_t = typename iterator_traits< _Iter> ::iterator_category; +# 249 +template< class _InIter> using _RequireInputIter = __enable_if_t< is_convertible< __iter_category_t< _InIter> , input_iterator_tag> ::value> ; +# 254 +template< class _It, class +# 255 +_Cat = __iter_category_t< _It> > +# 256 +struct __is_random_access_iter : public is_base_of< random_access_iterator_tag, _Cat> { +# 259 +typedef is_base_of< std::random_access_iterator_tag, _Cat> _Base; +# 260 +enum { __value = is_base_of< std::random_access_iterator_tag, _Cat> ::value}; +# 261 +}; +# 270 +} +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 74 +template< class > struct _List_iterator; +# 75 +template< class > struct _List_const_iterator; +# 78 +template< class _InputIterator> constexpr typename iterator_traits< _InputIterator> ::difference_type +# 81 +__distance(_InputIterator __first, _InputIterator __last, input_iterator_tag) +# 83 +{ +# 87 +typename iterator_traits< _InputIterator> ::difference_type __n = (0); +# 88 +while (__first != __last) +# 89 +{ +# 90 +++__first; +# 91 +++__n; +# 92 +} +# 93 +return __n; +# 94 +} +# 96 +template< class _RandomAccessIterator> +# 97 +__attribute((__always_inline__)) constexpr typename iterator_traits< _RandomAccessIterator> ::difference_type +# 100 +__distance(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag) +# 102 +{ +# 106 +return __last - __first; +# 107 +} +# 111 +template< class _Tp> ptrdiff_t __distance(_List_iterator< _Tp> , _List_iterator< _Tp> , input_iterator_tag); +# 117 +template< class _Tp> ptrdiff_t __distance(_List_const_iterator< _Tp> , _List_const_iterator< _Tp> , input_iterator_tag); +# 126 +template < typename _OutputIterator > + void + __distance ( _OutputIterator, _OutputIterator, output_iterator_tag ) = delete; +# 144 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 +template< class _InputIterator> +# 145 +[[__nodiscard__]] __attribute((__always_inline__)) constexpr typename iterator_traits< _InputIterator> ::difference_type +# 148 +distance(_InputIterator __first, _InputIterator __last) +# 149 +{ +# 151 +return std::__distance(__first, __last, std::__iterator_category(__first)); +# 153 +} +# 155 +template< class _InputIterator, class _Distance> constexpr void +# 157 +__advance(_InputIterator &__i, _Distance __n, input_iterator_tag) +# 158 +{ +# 161 +do { if (std::__is_constant_evaluated() && (!((bool)(__n >= 0)))) { std::__glibcxx_assert_fail(); } } while (false); +# 162 +while (__n--) { +# 163 +++__i; } +# 164 +} +# 166 +template< class _BidirectionalIterator, class _Distance> constexpr void +# 168 +__advance(_BidirectionalIterator &__i, _Distance __n, bidirectional_iterator_tag) +# 170 +{ +# 174 +if (__n > 0) { +# 175 +while (__n--) { +# 176 +++__i; } } else { +# 178 +while (__n++) { +# 179 +--__i; } } +# 180 +} +# 182 +template< class _RandomAccessIterator, class _Distance> constexpr void +# 184 +__advance(_RandomAccessIterator &__i, _Distance __n, random_access_iterator_tag) +# 186 +{ +# 190 +if (__builtin_constant_p(__n) && (__n == 1)) { +# 191 +++__i; } else { +# 192 +if (__builtin_constant_p(__n) && (__n == (-1))) { +# 193 +--__i; } else { +# 195 +__i += __n; } } +# 196 +} +# 200 +template < typename _OutputIterator, typename _Distance > + void + __advance ( _OutputIterator &, _Distance, output_iterator_tag ) = delete; +# 217 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator_base_funcs.h" 3 +template< class _InputIterator, class _Distance> +# 218 +__attribute((__always_inline__)) constexpr void +# 220 +advance(_InputIterator &__i, _Distance __n) +# 221 +{ +# 223 +typename iterator_traits< _InputIterator> ::difference_type __d = __n; +# 224 +std::__advance(__i, __d, std::__iterator_category(__i)); +# 225 +} +# 229 +template< class _InputIterator> +# 230 +[[__nodiscard__]] [[__gnu__::__always_inline__]] constexpr _InputIterator +# 232 +next(_InputIterator __x, typename iterator_traits< _InputIterator> ::difference_type +# 233 +__n = 1) +# 234 +{ +# 237 +std::advance(__x, __n); +# 238 +return __x; +# 239 +} +# 241 +template< class _BidirectionalIterator> +# 242 +[[__nodiscard__]] [[__gnu__::__always_inline__]] constexpr _BidirectionalIterator +# 244 +prev(_BidirectionalIterator __x, typename iterator_traits< _BidirectionalIterator> ::difference_type +# 245 +__n = 1) +# 246 +{ +# 250 +std::advance(__x, -__n); +# 251 +return __x; +# 252 +} +# 257 +} +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/ptr_traits.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 48 +class __undefined; +# 52 +template< class _Tp> +# 53 +struct __get_first_arg { +# 54 +using type = __undefined; }; +# 56 +template< template< class , class ...> class _SomeTemplate, class _Tp, class ... +# 57 +_Types> +# 58 +struct __get_first_arg< _SomeTemplate< _Tp, _Types...> > { +# 59 +using type = _Tp; }; +# 63 +template< class _Tp, class _Up> +# 64 +struct __replace_first_arg { +# 65 +}; +# 67 +template< template< class , class ...> class _SomeTemplate, class _Up, class +# 68 +_Tp, class ..._Types> +# 69 +struct __replace_first_arg< _SomeTemplate< _Tp, _Types...> , _Up> { +# 70 +using type = _SomeTemplate< _Up, _Types...> ; }; +# 73 +template< class _Ptr, class = void> +# 74 +struct __ptr_traits_elem : public __get_first_arg< _Ptr> { +# 75 +}; +# 83 +template< class _Ptr> +# 84 +struct __ptr_traits_elem< _Ptr, __void_t< typename _Ptr::element_type> > { +# 85 +using type = typename _Ptr::element_type; }; +# 88 +template< class _Ptr> using __ptr_traits_elem_t = typename __ptr_traits_elem< _Ptr> ::type; +# 94 +template< class _Ptr, class _Elt, bool = is_void< _Elt> ::value> +# 95 +struct __ptr_traits_ptr_to { +# 97 +using pointer = _Ptr; +# 98 +using element_type = _Elt; +# 107 +static pointer pointer_to(element_type &__r) +# 113 +{ return pointer::pointer_to(__r); } +# 114 +}; +# 117 +template< class _Ptr, class _Elt> +# 118 +struct __ptr_traits_ptr_to< _Ptr, _Elt, true> { +# 119 +}; +# 122 +template< class _Tp> +# 123 +struct __ptr_traits_ptr_to< _Tp *, _Tp, false> { +# 125 +using pointer = _Tp *; +# 126 +using element_type = _Tp; +# 134 +static pointer pointer_to(element_type &__r) noexcept +# 135 +{ return std::addressof(__r); } +# 136 +}; +# 138 +template< class _Ptr, class _Elt> +# 139 +struct __ptr_traits_impl : public __ptr_traits_ptr_to< _Ptr, _Elt> { +# 143 +private: +# 142 +template< class _Tp> using __diff_t = typename _Tp::difference_type; +# 145 +template< class _Tp, class _Up> using __rebind = __type_identity< typename _Tp::template rebind< _Up> > ; +# 150 +public: using pointer = _Ptr; +# 153 +using element_type = _Elt; +# 156 +using difference_type = std::__detected_or_t< std::ptrdiff_t, __diff_t, _Ptr> ; +# 159 +template< class _Up> using rebind = typename std::__detected_or_t< __replace_first_arg< _Ptr, _Up> , __rebind, _Ptr, _Up> ::type; +# 162 +}; +# 166 +template< class _Ptr> +# 167 +struct __ptr_traits_impl< _Ptr, __undefined> { +# 168 +}; +# 176 +template< class _Ptr> +# 177 +struct pointer_traits : public __ptr_traits_impl< _Ptr, __ptr_traits_elem_t< _Ptr> > { +# 178 +}; +# 186 +template< class _Tp> +# 187 +struct pointer_traits< _Tp *> : public __ptr_traits_ptr_to< _Tp *, _Tp> { +# 190 +typedef _Tp *pointer; +# 192 +typedef _Tp element_type; +# 194 +typedef std::ptrdiff_t difference_type; +# 196 +template< class _Up> using rebind = _Up *; +# 197 +}; +# 200 +template< class _Ptr, class _Tp> using __ptr_rebind = typename pointer_traits< _Ptr> ::template rebind< _Tp> ; +# 203 +template< class _Tp> constexpr _Tp * +# 205 +__to_address(_Tp *__ptr) noexcept +# 206 +{ +# 207 +static_assert((!std::template is_function< _Tp> ::value), "not a function pointer"); +# 208 +return __ptr; +# 209 +} +# 212 +template< class _Ptr> constexpr typename pointer_traits< _Ptr> ::element_type * +# 214 +__to_address(const _Ptr &__ptr) +# 215 +{ return std::__to_address(__ptr.operator->()); } +# 258 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/ptr_traits.h" 3 +} +# 85 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 106 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 128 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Iterator> +# 129 +class reverse_iterator : public iterator< typename iterator_traits< _Iterator> ::iterator_category, typename iterator_traits< _Iterator> ::value_type, typename iterator_traits< _Iterator> ::difference_type, typename iterator_traits< _Iterator> ::pointer, typename iterator_traits< _Iterator> ::reference> { +# 136 +template< class _Iter> friend class reverse_iterator; +# 148 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +protected: _Iterator current; +# 150 +typedef iterator_traits< _Iterator> __traits_type; +# 153 +public: typedef _Iterator iterator_type; +# 154 +typedef typename iterator_traits< _Iterator> ::pointer pointer; +# 156 +typedef typename iterator_traits< _Iterator> ::difference_type difference_type; +# 157 +typedef typename iterator_traits< _Iterator> ::reference reference; +# 179 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +constexpr reverse_iterator() noexcept(noexcept((_Iterator()))) : current() +# 182 +{ } +# 188 +constexpr explicit reverse_iterator(iterator_type __x) noexcept(noexcept(((_Iterator)__x))) : current(__x) +# 191 +{ } +# 197 +constexpr reverse_iterator(const reverse_iterator &__x) noexcept(noexcept(((_Iterator)(__x.current)))) : current(__x.current) +# 200 +{ } +# 203 +reverse_iterator &operator=(const reverse_iterator &) = default; +# 210 +template< class _Iter> constexpr +# 215 +reverse_iterator(const reverse_iterator< _Iter> &__x) noexcept(noexcept(((_Iterator)(__x.current)))) : current((__x.current)) +# 218 +{ } +# 221 +template< class _Iter> constexpr reverse_iterator & +# 228 +operator=(const reverse_iterator< _Iter> &__x) noexcept(noexcept(((current) = (__x.current)))) +# 230 +{ +# 231 +(current) = (__x.current); +# 232 +return *this; +# 233 +} +# 239 +[[__nodiscard__]] constexpr iterator_type +# 241 +base() const noexcept(noexcept(((_Iterator)(current)))) +# 243 +{ return current; } +# 255 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +[[__nodiscard__]] constexpr reference +# 257 +operator*() const +# 258 +{ +# 259 +_Iterator __tmp = current; +# 260 +return *(--__tmp); +# 261 +} +# 268 +[[__nodiscard__]] constexpr pointer +# 270 +operator->() const +# 275 +{ +# 278 +_Iterator __tmp = current; +# 279 +--__tmp; +# 280 +return _S_to_pointer(__tmp); +# 281 +} +# 289 +constexpr reverse_iterator &operator++() +# 290 +{ +# 291 +--(current); +# 292 +return *this; +# 293 +} +# 301 +constexpr reverse_iterator operator++(int) +# 302 +{ +# 303 +reverse_iterator __tmp = *this; +# 304 +--(current); +# 305 +return __tmp; +# 306 +} +# 314 +constexpr reverse_iterator &operator--() +# 315 +{ +# 316 +++(current); +# 317 +return *this; +# 318 +} +# 326 +constexpr reverse_iterator operator--(int) +# 327 +{ +# 328 +reverse_iterator __tmp = *this; +# 329 +++(current); +# 330 +return __tmp; +# 331 +} +# 338 +[[__nodiscard__]] constexpr reverse_iterator +# 340 +operator+(difference_type __n) const +# 341 +{ return ((reverse_iterator)((current) - __n)); } +# 350 +constexpr reverse_iterator &operator+=(difference_type __n) +# 351 +{ +# 352 +(current) -= __n; +# 353 +return *this; +# 354 +} +# 361 +[[__nodiscard__]] constexpr reverse_iterator +# 363 +operator-(difference_type __n) const +# 364 +{ return ((reverse_iterator)((current) + __n)); } +# 373 +constexpr reverse_iterator &operator-=(difference_type __n) +# 374 +{ +# 375 +(current) += __n; +# 376 +return *this; +# 377 +} +# 384 +[[__nodiscard__]] constexpr reference +# 386 +operator[](difference_type __n) const +# 387 +{ return *((*this) + __n); } +# 418 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +private: +# 416 +template< class _Tp> static constexpr _Tp * +# 418 +_S_to_pointer(_Tp *__p) +# 419 +{ return __p; } +# 421 +template< class _Tp> static constexpr pointer +# 423 +_S_to_pointer(_Tp __t) +# 424 +{ return __t.operator->(); } +# 425 +}; +# 438 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Iterator> +# 439 +[[__nodiscard__]] constexpr bool +# 441 +operator==(const reverse_iterator< _Iterator> &__x, const reverse_iterator< _Iterator> & +# 442 +__y) +# 443 +{ return __x.base() == __y.base(); } +# 445 +template< class _Iterator> +# 446 +[[__nodiscard__]] constexpr bool +# 448 +operator<(const reverse_iterator< _Iterator> &__x, const reverse_iterator< _Iterator> & +# 449 +__y) +# 450 +{ return __y.base() < __x.base(); } +# 452 +template< class _Iterator> +# 453 +[[__nodiscard__]] constexpr bool +# 455 +operator!=(const reverse_iterator< _Iterator> &__x, const reverse_iterator< _Iterator> & +# 456 +__y) +# 457 +{ return !(__x == __y); } +# 459 +template< class _Iterator> +# 460 +[[__nodiscard__]] constexpr bool +# 462 +operator>(const reverse_iterator< _Iterator> &__x, const reverse_iterator< _Iterator> & +# 463 +__y) +# 464 +{ return __y < __x; } +# 466 +template< class _Iterator> +# 467 +[[__nodiscard__]] constexpr bool +# 469 +operator<=(const reverse_iterator< _Iterator> &__x, const reverse_iterator< _Iterator> & +# 470 +__y) +# 471 +{ return !(__y < __x); } +# 473 +template< class _Iterator> +# 474 +[[__nodiscard__]] constexpr bool +# 476 +operator>=(const reverse_iterator< _Iterator> &__x, const reverse_iterator< _Iterator> & +# 477 +__y) +# 478 +{ return !(__x < __y); } +# 483 +template< class _IteratorL, class _IteratorR> +# 484 +[[__nodiscard__]] constexpr bool +# 486 +operator==(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 487 +__y) +# 488 +{ return __x.base() == __y.base(); } +# 490 +template< class _IteratorL, class _IteratorR> +# 491 +[[__nodiscard__]] constexpr bool +# 493 +operator<(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 494 +__y) +# 495 +{ return __x.base() > __y.base(); } +# 497 +template< class _IteratorL, class _IteratorR> +# 498 +[[__nodiscard__]] constexpr bool +# 500 +operator!=(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 501 +__y) +# 502 +{ return __x.base() != __y.base(); } +# 504 +template< class _IteratorL, class _IteratorR> +# 505 +[[__nodiscard__]] constexpr bool +# 507 +operator>(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 508 +__y) +# 509 +{ return __x.base() < __y.base(); } +# 511 +template< class _IteratorL, class _IteratorR> constexpr bool +# 513 +operator<=(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 514 +__y) +# 515 +{ return __x.base() >= __y.base(); } +# 517 +template< class _IteratorL, class _IteratorR> +# 518 +[[__nodiscard__]] constexpr bool +# 520 +operator>=(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 521 +__y) +# 522 +{ return __x.base() <= __y.base(); } +# 615 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _IteratorL, class _IteratorR> +# 616 +[[__nodiscard__]] constexpr auto +# 618 +operator-(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 619 +__y)->__decltype((__y.base() - __x.base())) +# 621 +{ return __y.base() - __x.base(); } +# 624 +template< class _Iterator> +# 625 +[[__nodiscard__]] constexpr reverse_iterator< _Iterator> +# 627 +operator+(typename reverse_iterator< _Iterator> ::difference_type __n, const reverse_iterator< _Iterator> & +# 628 +__x) +# 629 +{ return ((reverse_iterator< _Iterator> )(__x.base() - __n)); } +# 633 +template< class _Iterator> constexpr reverse_iterator< _Iterator> +# 635 +__make_reverse_iterator(_Iterator __i) +# 636 +{ return ((reverse_iterator< _Iterator> )(__i)); } +# 642 +template< class _Iterator> +# 643 +[[__nodiscard__]] constexpr reverse_iterator< _Iterator> +# 645 +make_reverse_iterator(_Iterator __i) +# 646 +{ return ((reverse_iterator< _Iterator> )(__i)); } +# 657 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Iterator> auto +# 660 +__niter_base(reverse_iterator< _Iterator> __it)->__decltype((__make_reverse_iterator(__niter_base(__it.base())))) +# 662 +{ return __make_reverse_iterator(__niter_base(__it.base())); } +# 664 +template< class _Iterator> +# 665 +struct __is_move_iterator< reverse_iterator< _Iterator> > : public std::__is_move_iterator< _Iterator> { +# 667 +}; +# 669 +template< class _Iterator> auto +# 672 +__miter_base(reverse_iterator< _Iterator> __it)->__decltype((__make_reverse_iterator(__miter_base(__it.base())))) +# 674 +{ return __make_reverse_iterator(__miter_base(__it.base())); } +# 688 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Container> +# 689 +class back_insert_iterator : public iterator< output_iterator_tag, void, void, void, void> { +# 693 +protected: _Container *container; +# 697 +public: typedef _Container container_type; +# 704 +explicit back_insert_iterator(_Container &__x) : container(std::__addressof(__x)) +# 705 +{ } +# 728 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +back_insert_iterator &operator=(const typename _Container::value_type &__value) +# 729 +{ +# 730 +(container)->push_back(__value); +# 731 +return *this; +# 732 +} +# 736 +back_insert_iterator &operator=(typename _Container::value_type &&__value) +# 737 +{ +# 738 +(container)->push_back(std::move(__value)); +# 739 +return *this; +# 740 +} +# 744 +[[__nodiscard__]] back_insert_iterator & +# 746 +operator*() +# 747 +{ return *this; } +# 752 +back_insert_iterator &operator++() +# 753 +{ return *this; } +# 758 +back_insert_iterator operator++(int) +# 759 +{ return *this; } +# 760 +}; +# 773 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Container> +# 774 +[[__nodiscard__]] inline back_insert_iterator< _Container> +# 776 +back_inserter(_Container &__x) +# 777 +{ return ((back_insert_iterator< _Container> )(__x)); } +# 789 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Container> +# 790 +class front_insert_iterator : public iterator< output_iterator_tag, void, void, void, void> { +# 794 +protected: _Container *container; +# 798 +public: typedef _Container container_type; +# 805 +explicit front_insert_iterator(_Container &__x) : container(std::__addressof(__x)) +# 806 +{ } +# 829 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +front_insert_iterator &operator=(const typename _Container::value_type &__value) +# 830 +{ +# 831 +(container)->push_front(__value); +# 832 +return *this; +# 833 +} +# 837 +front_insert_iterator &operator=(typename _Container::value_type &&__value) +# 838 +{ +# 839 +(container)->push_front(std::move(__value)); +# 840 +return *this; +# 841 +} +# 845 +[[__nodiscard__]] front_insert_iterator & +# 847 +operator*() +# 848 +{ return *this; } +# 853 +front_insert_iterator &operator++() +# 854 +{ return *this; } +# 859 +front_insert_iterator operator++(int) +# 860 +{ return *this; } +# 861 +}; +# 874 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Container> +# 875 +[[__nodiscard__]] inline front_insert_iterator< _Container> +# 877 +front_inserter(_Container &__x) +# 878 +{ return ((front_insert_iterator< _Container> )(__x)); } +# 894 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Container> +# 895 +class insert_iterator : public iterator< output_iterator_tag, void, void, void, void> { +# 901 +typedef typename _Container::iterator _Iter; +# 904 +protected: _Container *container; +# 905 +_Iter iter; +# 909 +public: typedef _Container container_type; +# 920 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +insert_iterator(_Container &__x, _Iter __i) : container(std::__addressof(__x)), iter(__i) +# 921 +{ } +# 957 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +insert_iterator &operator=(const typename _Container::value_type &__value) +# 958 +{ +# 959 +(iter) = (container)->insert(iter, __value); +# 960 +++(iter); +# 961 +return *this; +# 962 +} +# 966 +insert_iterator &operator=(typename _Container::value_type &&__value) +# 967 +{ +# 968 +(iter) = (container)->insert(iter, std::move(__value)); +# 969 +++(iter); +# 970 +return *this; +# 971 +} +# 975 +[[__nodiscard__]] insert_iterator & +# 977 +operator*() +# 978 +{ return *this; } +# 983 +insert_iterator &operator++() +# 984 +{ return *this; } +# 989 +insert_iterator &operator++(int) +# 990 +{ return *this; } +# 991 +}; +# 993 +#pragma GCC diagnostic pop +# 1014 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Container> +# 1015 +[[__nodiscard__]] inline insert_iterator< _Container> +# 1017 +inserter(_Container &__x, typename _Container::iterator __i) +# 1018 +{ return insert_iterator< _Container> (__x, __i); } +# 1024 +} +# 1026 +namespace __gnu_cxx __attribute((__visibility__("default"))) { +# 1037 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Iterator, class _Container> +# 1038 +class __normal_iterator { +# 1041 +protected: _Iterator _M_current; +# 1043 +typedef std::iterator_traits< _Iterator> __traits_type; +# 1046 +template< class _Iter> using __convertible_from = std::__enable_if_t< std::is_convertible< _Iter, _Iterator> ::value> ; +# 1052 +public: typedef _Iterator iterator_type; +# 1053 +typedef typename std::iterator_traits< _Iterator> ::iterator_category iterator_category; +# 1054 +typedef typename std::iterator_traits< _Iterator> ::value_type value_type; +# 1055 +typedef typename std::iterator_traits< _Iterator> ::difference_type difference_type; +# 1056 +typedef typename std::iterator_traits< _Iterator> ::reference reference; +# 1057 +typedef typename std::iterator_traits< _Iterator> ::pointer pointer; +# 1063 +constexpr __normal_iterator() noexcept : _M_current(_Iterator()) +# 1064 +{ } +# 1067 +explicit __normal_iterator(const _Iterator &__i) noexcept : _M_current(__i) +# 1068 +{ } +# 1072 +template< class _Iter, class = __convertible_from< _Iter> > +# 1074 +__normal_iterator(const __normal_iterator< _Iter, _Container> &__i) noexcept : _M_current(__i.base()) +# 1085 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +{ } +# 1090 +reference operator*() const noexcept +# 1091 +{ return *(_M_current); } +# 1095 +pointer operator->() const noexcept +# 1096 +{ return _M_current; } +# 1100 +__normal_iterator &operator++() noexcept +# 1101 +{ +# 1102 +++(_M_current); +# 1103 +return *this; +# 1104 +} +# 1108 +__normal_iterator operator++(int) noexcept +# 1109 +{ return ((__normal_iterator)((_M_current)++)); } +# 1114 +__normal_iterator &operator--() noexcept +# 1115 +{ +# 1116 +--(_M_current); +# 1117 +return *this; +# 1118 +} +# 1122 +__normal_iterator operator--(int) noexcept +# 1123 +{ return ((__normal_iterator)((_M_current)--)); } +# 1128 +reference operator[](difference_type __n) const noexcept +# 1129 +{ return (_M_current)[__n]; } +# 1133 +__normal_iterator &operator+=(difference_type __n) noexcept +# 1134 +{ (_M_current) += __n; return *this; } +# 1138 +__normal_iterator operator+(difference_type __n) const noexcept +# 1139 +{ return ((__normal_iterator)((_M_current) + __n)); } +# 1143 +__normal_iterator &operator-=(difference_type __n) noexcept +# 1144 +{ (_M_current) -= __n; return *this; } +# 1148 +__normal_iterator operator-(difference_type __n) const noexcept +# 1149 +{ return ((__normal_iterator)((_M_current) - __n)); } +# 1153 +const _Iterator &base() const noexcept +# 1154 +{ return _M_current; } +# 1155 +}; +# 1205 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _IteratorL, class _IteratorR, class _Container> +# 1206 +[[__nodiscard__]] inline bool +# 1208 +operator==(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1209 +__rhs) noexcept +# 1211 +{ return __lhs.base() == __rhs.base(); } +# 1213 +template< class _Iterator, class _Container> +# 1214 +[[__nodiscard__]] inline bool +# 1216 +operator==(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1217 +__rhs) noexcept +# 1219 +{ return __lhs.base() == __rhs.base(); } +# 1221 +template< class _IteratorL, class _IteratorR, class _Container> +# 1222 +[[__nodiscard__]] inline bool +# 1224 +operator!=(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1225 +__rhs) noexcept +# 1227 +{ return __lhs.base() != __rhs.base(); } +# 1229 +template< class _Iterator, class _Container> +# 1230 +[[__nodiscard__]] inline bool +# 1232 +operator!=(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1233 +__rhs) noexcept +# 1235 +{ return __lhs.base() != __rhs.base(); } +# 1238 +template< class _IteratorL, class _IteratorR, class _Container> +# 1239 +[[__nodiscard__]] inline bool +# 1241 +operator<(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1242 +__rhs) noexcept +# 1244 +{ return __lhs.base() < __rhs.base(); } +# 1246 +template< class _Iterator, class _Container> +# 1247 +[[__nodiscard__]] inline bool +# 1249 +operator<(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1250 +__rhs) noexcept +# 1252 +{ return __lhs.base() < __rhs.base(); } +# 1254 +template< class _IteratorL, class _IteratorR, class _Container> +# 1255 +[[__nodiscard__]] inline bool +# 1257 +operator>(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1258 +__rhs) noexcept +# 1260 +{ return __lhs.base() > __rhs.base(); } +# 1262 +template< class _Iterator, class _Container> +# 1263 +[[__nodiscard__]] inline bool +# 1265 +operator>(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1266 +__rhs) noexcept +# 1268 +{ return __lhs.base() > __rhs.base(); } +# 1270 +template< class _IteratorL, class _IteratorR, class _Container> +# 1271 +[[__nodiscard__]] inline bool +# 1273 +operator<=(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1274 +__rhs) noexcept +# 1276 +{ return __lhs.base() <= __rhs.base(); } +# 1278 +template< class _Iterator, class _Container> +# 1279 +[[__nodiscard__]] inline bool +# 1281 +operator<=(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1282 +__rhs) noexcept +# 1284 +{ return __lhs.base() <= __rhs.base(); } +# 1286 +template< class _IteratorL, class _IteratorR, class _Container> +# 1287 +[[__nodiscard__]] inline bool +# 1289 +operator>=(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1290 +__rhs) noexcept +# 1292 +{ return __lhs.base() >= __rhs.base(); } +# 1294 +template< class _Iterator, class _Container> +# 1295 +[[__nodiscard__]] inline bool +# 1297 +operator>=(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1298 +__rhs) noexcept +# 1300 +{ return __lhs.base() >= __rhs.base(); } +# 1307 +template< class _IteratorL, class _IteratorR, class _Container> +# 1310 +[[__nodiscard__]] inline auto +# 1312 +operator-(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1313 +__rhs) noexcept->__decltype((__lhs.base() - __rhs.base())) +# 1320 +{ return __lhs.base() - __rhs.base(); } +# 1322 +template< class _Iterator, class _Container> +# 1323 +[[__nodiscard__]] inline typename __normal_iterator< _Iterator, _Container> ::difference_type +# 1325 +operator-(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1326 +__rhs) noexcept +# 1328 +{ return __lhs.base() - __rhs.base(); } +# 1330 +template< class _Iterator, class _Container> +# 1331 +[[__nodiscard__]] inline __normal_iterator< _Iterator, _Container> +# 1333 +operator+(typename __normal_iterator< _Iterator, _Container> ::difference_type +# 1334 +__n, const __normal_iterator< _Iterator, _Container> &__i) noexcept +# 1336 +{ return ((__normal_iterator< _Iterator, _Container> )(__i.base() + __n)); } +# 1339 +} +# 1341 +namespace std __attribute((__visibility__("default"))) { +# 1345 +template< class _Iterator, class _Container> _Iterator +# 1348 +__niter_base(__gnu_cxx::__normal_iterator< _Iterator, _Container> __it) noexcept(std::template is_nothrow_copy_constructible< _Iterator> ::value) +# 1350 +{ return __it.base(); } +# 1357 +template< class _Iterator, class _Container> constexpr auto +# 1359 +__to_address(const __gnu_cxx::__normal_iterator< _Iterator, _Container> & +# 1360 +__it) noexcept->__decltype((std::__to_address(__it.base()))) +# 1362 +{ return std::__to_address(__it.base()); } +# 1412 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +namespace __detail { +# 1428 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +} +# 1439 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Iterator> +# 1440 +class move_iterator { +# 1445 +_Iterator _M_current; +# 1447 +using __traits_type = iterator_traits< _Iterator> ; +# 1449 +using __base_ref = typename iterator_traits< _Iterator> ::reference; +# 1452 +template< class _Iter2> friend class move_iterator; +# 1479 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +public: using iterator_type = _Iterator; +# 1490 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +typedef typename iterator_traits< _Iterator> ::iterator_category iterator_category; +# 1491 +typedef typename iterator_traits< _Iterator> ::value_type value_type; +# 1492 +typedef typename iterator_traits< _Iterator> ::difference_type difference_type; +# 1494 +typedef _Iterator pointer; +# 1497 +using reference = __conditional_t< is_reference< __base_ref> ::value, typename remove_reference< __base_ref> ::type &&, __base_ref> ; +# 1504 +constexpr move_iterator() : _M_current() +# 1505 +{ } +# 1508 +constexpr explicit move_iterator(iterator_type __i) : _M_current(std::move(__i)) +# 1509 +{ } +# 1511 +template< class _Iter> constexpr +# 1516 +move_iterator(const move_iterator< _Iter> &__i) : _M_current((__i._M_current)) +# 1517 +{ } +# 1519 +template< class _Iter> constexpr move_iterator & +# 1525 +operator=(const move_iterator< _Iter> &__i) +# 1526 +{ +# 1527 +(_M_current) = (__i._M_current); +# 1528 +return *this; +# 1529 +} +# 1532 +[[__nodiscard__]] constexpr iterator_type +# 1534 +base() const +# 1535 +{ return _M_current; } +# 1548 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +[[__nodiscard__]] constexpr reference +# 1550 +operator*() const +# 1554 +{ return static_cast< reference>(*(_M_current)); } +# 1557 +[[__nodiscard__]] constexpr pointer +# 1559 +operator->() const +# 1560 +{ return _M_current; } +# 1563 +constexpr move_iterator &operator++() +# 1564 +{ +# 1565 +++(_M_current); +# 1566 +return *this; +# 1567 +} +# 1570 +constexpr move_iterator operator++(int) +# 1571 +{ +# 1572 +move_iterator __tmp = *this; +# 1573 +++(_M_current); +# 1574 +return __tmp; +# 1575 +} +# 1584 +constexpr move_iterator &operator--() +# 1585 +{ +# 1586 +--(_M_current); +# 1587 +return *this; +# 1588 +} +# 1591 +constexpr move_iterator operator--(int) +# 1592 +{ +# 1593 +move_iterator __tmp = *this; +# 1594 +--(_M_current); +# 1595 +return __tmp; +# 1596 +} +# 1598 +[[__nodiscard__]] constexpr move_iterator +# 1600 +operator+(difference_type __n) const +# 1601 +{ return ((move_iterator)((_M_current) + __n)); } +# 1604 +constexpr move_iterator &operator+=(difference_type __n) +# 1605 +{ +# 1606 +(_M_current) += __n; +# 1607 +return *this; +# 1608 +} +# 1610 +[[__nodiscard__]] constexpr move_iterator +# 1612 +operator-(difference_type __n) const +# 1613 +{ return ((move_iterator)((_M_current) - __n)); } +# 1616 +constexpr move_iterator &operator-=(difference_type __n) +# 1617 +{ +# 1618 +(_M_current) -= __n; +# 1619 +return *this; +# 1620 +} +# 1622 +[[__nodiscard__]] constexpr reference +# 1624 +operator[](difference_type __n) const +# 1628 +{ return std::move((_M_current)[__n]); } +# 1662 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +}; +# 1664 +template< class _IteratorL, class _IteratorR> +# 1665 +[[__nodiscard__]] constexpr bool +# 1667 +operator==(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1668 +__y) +# 1672 +{ return __x.base() == __y.base(); } +# 1683 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _IteratorL, class _IteratorR> +# 1684 +[[__nodiscard__]] constexpr bool +# 1686 +operator!=(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1687 +__y) +# 1688 +{ return !(__x == __y); } +# 1691 +template< class _IteratorL, class _IteratorR> +# 1692 +[[__nodiscard__]] constexpr bool +# 1694 +operator<(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1695 +__y) +# 1699 +{ return __x.base() < __y.base(); } +# 1701 +template< class _IteratorL, class _IteratorR> +# 1702 +[[__nodiscard__]] constexpr bool +# 1704 +operator<=(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1705 +__y) +# 1709 +{ return !(__y < __x); } +# 1711 +template< class _IteratorL, class _IteratorR> +# 1712 +[[__nodiscard__]] constexpr bool +# 1714 +operator>(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1715 +__y) +# 1719 +{ return __y < __x; } +# 1721 +template< class _IteratorL, class _IteratorR> +# 1722 +[[__nodiscard__]] constexpr bool +# 1724 +operator>=(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1725 +__y) +# 1729 +{ return !(__x < __y); } +# 1734 +template< class _Iterator> +# 1735 +[[__nodiscard__]] constexpr bool +# 1737 +operator==(const move_iterator< _Iterator> &__x, const move_iterator< _Iterator> & +# 1738 +__y) +# 1740 +{ return __x.base() == __y.base(); } +# 1750 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Iterator> +# 1751 +[[__nodiscard__]] constexpr bool +# 1753 +operator!=(const move_iterator< _Iterator> &__x, const move_iterator< _Iterator> & +# 1754 +__y) +# 1755 +{ return !(__x == __y); } +# 1757 +template< class _Iterator> +# 1758 +[[__nodiscard__]] constexpr bool +# 1760 +operator<(const move_iterator< _Iterator> &__x, const move_iterator< _Iterator> & +# 1761 +__y) +# 1762 +{ return __x.base() < __y.base(); } +# 1764 +template< class _Iterator> +# 1765 +[[__nodiscard__]] constexpr bool +# 1767 +operator<=(const move_iterator< _Iterator> &__x, const move_iterator< _Iterator> & +# 1768 +__y) +# 1769 +{ return !(__y < __x); } +# 1771 +template< class _Iterator> +# 1772 +[[__nodiscard__]] constexpr bool +# 1774 +operator>(const move_iterator< _Iterator> &__x, const move_iterator< _Iterator> & +# 1775 +__y) +# 1776 +{ return __y < __x; } +# 1778 +template< class _Iterator> +# 1779 +[[__nodiscard__]] constexpr bool +# 1781 +operator>=(const move_iterator< _Iterator> &__x, const move_iterator< _Iterator> & +# 1782 +__y) +# 1783 +{ return !(__x < __y); } +# 1787 +template< class _IteratorL, class _IteratorR> +# 1788 +[[__nodiscard__]] constexpr auto +# 1790 +operator-(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1791 +__y)->__decltype((__x.base() - __y.base())) +# 1793 +{ return __x.base() - __y.base(); } +# 1795 +template< class _Iterator> +# 1796 +[[__nodiscard__]] constexpr move_iterator< _Iterator> +# 1798 +operator+(typename move_iterator< _Iterator> ::difference_type __n, const move_iterator< _Iterator> & +# 1799 +__x) +# 1803 +{ return __x + __n; } +# 1805 +template< class _Iterator> +# 1806 +[[__nodiscard__]] constexpr move_iterator< _Iterator> +# 1808 +make_move_iterator(_Iterator __i) +# 1809 +{ return ((move_iterator< _Iterator> )(std::move(__i))); } +# 1811 +template< class _Iterator, class _ReturnType = __conditional_t< __move_if_noexcept_cond< typename iterator_traits< _Iterator> ::value_type> ::value, _Iterator, move_iterator< _Iterator> > > constexpr _ReturnType +# 1816 +__make_move_if_noexcept_iterator(_Iterator __i) +# 1817 +{ return (_ReturnType)__i; } +# 1821 +template< class _Tp, class _ReturnType = __conditional_t< __move_if_noexcept_cond< _Tp> ::value, const _Tp *, move_iterator< _Tp *> > > constexpr _ReturnType +# 1825 +__make_move_if_noexcept_iterator(_Tp *__i) +# 1826 +{ return (_ReturnType)__i; } +# 2964 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _Iterator> auto +# 2967 +__niter_base(move_iterator< _Iterator> __it)->__decltype((make_move_iterator(__niter_base(__it.base())))) +# 2969 +{ return make_move_iterator(__niter_base(__it.base())); } +# 2971 +template< class _Iterator> +# 2972 +struct __is_move_iterator< move_iterator< _Iterator> > { +# 2974 +enum { __value = 1}; +# 2975 +typedef __true_type __type; +# 2976 +}; +# 2978 +template< class _Iterator> auto +# 2981 +__miter_base(move_iterator< _Iterator> __it)->__decltype((__miter_base(__it.base()))) +# 2983 +{ return __miter_base(__it.base()); } +# 2996 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_iterator.h" 3 +template< class _InputIterator> using __iter_key_t = remove_const_t< typename iterator_traits< _InputIterator> ::value_type::first_type> ; +# 3004 +template< class _InputIterator> using __iter_val_t = typename iterator_traits< _InputIterator> ::value_type::second_type; +# 3012 +template< class _T1, class _T2> struct pair; +# 3015 +template< class _InputIterator> using __iter_to_alloc_t = pair< const __iter_key_t< _InputIterator> , __iter_val_t< _InputIterator> > ; +# 3021 +} +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/debug/debug.h" 3 +namespace std { +# 50 +namespace __debug { } +# 51 +} +# 56 +namespace __gnu_debug { +# 58 +using namespace std::__debug; +# 60 +template< class _Ite, class _Seq, class _Cat> struct _Safe_iterator; +# 62 +} +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/predefined_ops.h" 3 +namespace __gnu_cxx { +# 37 +namespace __ops { +# 39 +struct _Iter_less_iter { +# 41 +template< class _Iterator1, class _Iterator2> constexpr bool +# 44 +operator()(_Iterator1 __it1, _Iterator2 __it2) const +# 45 +{ return (*__it1) < (*__it2); } +# 46 +}; +# 50 +constexpr _Iter_less_iter __iter_less_iter() +# 51 +{ return _Iter_less_iter(); } +# 53 +struct _Iter_less_val { +# 56 +constexpr _Iter_less_val() = default; +# 63 +explicit _Iter_less_val(_Iter_less_iter) { } +# 65 +template< class _Iterator, class _Value> bool +# 68 +operator()(_Iterator __it, _Value &__val) const +# 69 +{ return (*__it) < __val; } +# 70 +}; +# 74 +inline _Iter_less_val __iter_less_val() +# 75 +{ return _Iter_less_val(); } +# 79 +inline _Iter_less_val __iter_comp_val(_Iter_less_iter) +# 80 +{ return _Iter_less_val(); } +# 82 +struct _Val_less_iter { +# 85 +constexpr _Val_less_iter() = default; +# 92 +explicit _Val_less_iter(_Iter_less_iter) { } +# 94 +template< class _Value, class _Iterator> bool +# 97 +operator()(_Value &__val, _Iterator __it) const +# 98 +{ return __val < (*__it); } +# 99 +}; +# 103 +inline _Val_less_iter __val_less_iter() +# 104 +{ return _Val_less_iter(); } +# 108 +inline _Val_less_iter __val_comp_iter(_Iter_less_iter) +# 109 +{ return _Val_less_iter(); } +# 111 +struct _Iter_equal_to_iter { +# 113 +template< class _Iterator1, class _Iterator2> bool +# 116 +operator()(_Iterator1 __it1, _Iterator2 __it2) const +# 117 +{ return (*__it1) == (*__it2); } +# 118 +}; +# 122 +inline _Iter_equal_to_iter __iter_equal_to_iter() +# 123 +{ return _Iter_equal_to_iter(); } +# 125 +struct _Iter_equal_to_val { +# 127 +template< class _Iterator, class _Value> bool +# 130 +operator()(_Iterator __it, _Value &__val) const +# 131 +{ return (*__it) == __val; } +# 132 +}; +# 136 +inline _Iter_equal_to_val __iter_equal_to_val() +# 137 +{ return _Iter_equal_to_val(); } +# 141 +inline _Iter_equal_to_val __iter_comp_val(_Iter_equal_to_iter) +# 142 +{ return _Iter_equal_to_val(); } +# 144 +template< class _Compare> +# 145 +struct _Iter_comp_iter { +# 147 +_Compare _M_comp; +# 150 +constexpr explicit _Iter_comp_iter(_Compare __comp) : _M_comp(std::move(__comp)) +# 152 +{ } +# 154 +template< class _Iterator1, class _Iterator2> constexpr bool +# 157 +operator()(_Iterator1 __it1, _Iterator2 __it2) +# 158 +{ return (bool)(_M_comp)(*__it1, *__it2); } +# 159 +}; +# 161 +template< class _Compare> constexpr _Iter_comp_iter< _Compare> +# 164 +__iter_comp_iter(_Compare __comp) +# 165 +{ return ((_Iter_comp_iter< _Compare> )(std::move(__comp))); } +# 167 +template< class _Compare> +# 168 +struct _Iter_comp_val { +# 170 +_Compare _M_comp; +# 174 +explicit _Iter_comp_val(_Compare __comp) : _M_comp(std::move(__comp)) +# 176 +{ } +# 180 +explicit _Iter_comp_val(const _Iter_comp_iter< _Compare> &__comp) : _M_comp((__comp._M_comp)) +# 182 +{ } +# 187 +explicit _Iter_comp_val(_Iter_comp_iter< _Compare> &&__comp) : _M_comp(std::move((__comp._M_comp))) +# 189 +{ } +# 192 +template< class _Iterator, class _Value> bool +# 195 +operator()(_Iterator __it, _Value &__val) +# 196 +{ return (bool)(_M_comp)(*__it, __val); } +# 197 +}; +# 199 +template< class _Compare> inline _Iter_comp_val< _Compare> +# 202 +__iter_comp_val(_Compare __comp) +# 203 +{ return ((_Iter_comp_val< _Compare> )(std::move(__comp))); } +# 205 +template< class _Compare> inline _Iter_comp_val< _Compare> +# 208 +__iter_comp_val(_Iter_comp_iter< _Compare> __comp) +# 209 +{ return ((_Iter_comp_val< _Compare> )(std::move(__comp))); } +# 211 +template< class _Compare> +# 212 +struct _Val_comp_iter { +# 214 +_Compare _M_comp; +# 218 +explicit _Val_comp_iter(_Compare __comp) : _M_comp(std::move(__comp)) +# 220 +{ } +# 224 +explicit _Val_comp_iter(const _Iter_comp_iter< _Compare> &__comp) : _M_comp((__comp._M_comp)) +# 226 +{ } +# 231 +explicit _Val_comp_iter(_Iter_comp_iter< _Compare> &&__comp) : _M_comp(std::move((__comp._M_comp))) +# 233 +{ } +# 236 +template< class _Value, class _Iterator> bool +# 239 +operator()(_Value &__val, _Iterator __it) +# 240 +{ return (bool)(_M_comp)(__val, *__it); } +# 241 +}; +# 243 +template< class _Compare> inline _Val_comp_iter< _Compare> +# 246 +__val_comp_iter(_Compare __comp) +# 247 +{ return ((_Val_comp_iter< _Compare> )(std::move(__comp))); } +# 249 +template< class _Compare> inline _Val_comp_iter< _Compare> +# 252 +__val_comp_iter(_Iter_comp_iter< _Compare> __comp) +# 253 +{ return ((_Val_comp_iter< _Compare> )(std::move(__comp))); } +# 255 +template< class _Value> +# 256 +struct _Iter_equals_val { +# 258 +_Value &_M_value; +# 262 +explicit _Iter_equals_val(_Value &__value) : _M_value(__value) +# 264 +{ } +# 266 +template< class _Iterator> bool +# 269 +operator()(_Iterator __it) +# 270 +{ return (*__it) == (_M_value); } +# 271 +}; +# 273 +template< class _Value> inline _Iter_equals_val< _Value> +# 276 +__iter_equals_val(_Value &__val) +# 277 +{ return ((_Iter_equals_val< _Value> )(__val)); } +# 279 +template< class _Iterator1> +# 280 +struct _Iter_equals_iter { +# 282 +_Iterator1 _M_it1; +# 286 +explicit _Iter_equals_iter(_Iterator1 __it1) : _M_it1(__it1) +# 288 +{ } +# 290 +template< class _Iterator2> bool +# 293 +operator()(_Iterator2 __it2) +# 294 +{ return (*__it2) == (*(_M_it1)); } +# 295 +}; +# 297 +template< class _Iterator> inline _Iter_equals_iter< _Iterator> +# 300 +__iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) +# 301 +{ return ((_Iter_equals_iter< _Iterator> )(__it)); } +# 303 +template< class _Predicate> +# 304 +struct _Iter_pred { +# 306 +_Predicate _M_pred; +# 310 +explicit _Iter_pred(_Predicate __pred) : _M_pred(std::move(__pred)) +# 312 +{ } +# 314 +template< class _Iterator> bool +# 317 +operator()(_Iterator __it) +# 318 +{ return (bool)(_M_pred)(*__it); } +# 319 +}; +# 321 +template< class _Predicate> inline _Iter_pred< _Predicate> +# 324 +__pred_iter(_Predicate __pred) +# 325 +{ return ((_Iter_pred< _Predicate> )(std::move(__pred))); } +# 327 +template< class _Compare, class _Value> +# 328 +struct _Iter_comp_to_val { +# 330 +_Compare _M_comp; +# 331 +_Value &_M_value; +# 334 +_Iter_comp_to_val(_Compare __comp, _Value &__value) : _M_comp(std::move(__comp)), _M_value(__value) +# 336 +{ } +# 338 +template< class _Iterator> bool +# 341 +operator()(_Iterator __it) +# 342 +{ return (bool)(_M_comp)(*__it, _M_value); } +# 343 +}; +# 345 +template< class _Compare, class _Value> _Iter_comp_to_val< _Compare, _Value> +# 348 +__iter_comp_val(_Compare __comp, _Value &__val) +# 349 +{ +# 350 +return _Iter_comp_to_val< _Compare, _Value> (std::move(__comp), __val); +# 351 +} +# 353 +template< class _Compare, class _Iterator1> +# 354 +struct _Iter_comp_to_iter { +# 356 +_Compare _M_comp; +# 357 +_Iterator1 _M_it1; +# 360 +_Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) : _M_comp(std::move(__comp)), _M_it1(__it1) +# 362 +{ } +# 364 +template< class _Iterator2> bool +# 367 +operator()(_Iterator2 __it2) +# 368 +{ return (bool)(_M_comp)(*__it2, *(_M_it1)); } +# 369 +}; +# 371 +template< class _Compare, class _Iterator> inline _Iter_comp_to_iter< _Compare, _Iterator> +# 374 +__iter_comp_iter(_Iter_comp_iter< _Compare> __comp, _Iterator __it) +# 375 +{ +# 376 +return _Iter_comp_to_iter< _Compare, _Iterator> (std::move((__comp._M_comp)), __it); +# 378 +} +# 380 +template< class _Predicate> +# 381 +struct _Iter_negate { +# 383 +_Predicate _M_pred; +# 387 +explicit _Iter_negate(_Predicate __pred) : _M_pred(std::move(__pred)) +# 389 +{ } +# 391 +template< class _Iterator> bool +# 394 +operator()(_Iterator __it) +# 395 +{ return !((bool)(_M_pred)(*__it)); } +# 396 +}; +# 398 +template< class _Predicate> inline _Iter_negate< _Predicate> +# 401 +__negate(_Iter_pred< _Predicate> __pred) +# 402 +{ return ((_Iter_negate< _Predicate> )(std::move((__pred._M_pred)))); } +# 404 +} +# 405 +} +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 +namespace std __attribute((__visibility__("default"))) { +# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 +template< class _Tp> constexpr _Tp +# 157 +__rotl(_Tp __x, int __s) noexcept +# 158 +{ +# 159 +constexpr auto _Nd = (__gnu_cxx::__int_traits< _Tp> ::__digits); +# 160 +if constexpr ((_Nd & (_Nd - 1)) == 0) +# 161 +{ +# 164 +constexpr unsigned __uNd = (_Nd); +# 165 +const unsigned __r = __s; +# 166 +return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd)); +# 167 +} +# 168 +const int __r = __s % _Nd; +# 169 +if (__r == 0) { +# 170 +return __x; } else { +# 171 +if (__r > 0) { +# 172 +return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); } else { +# 174 +return (__x >> (-__r)) | (__x << ((_Nd + __r) % _Nd)); } } +# 175 +} +# 177 +template< class _Tp> constexpr _Tp +# 179 +__rotr(_Tp __x, int __s) noexcept +# 180 +{ +# 181 +constexpr auto _Nd = (__gnu_cxx::__int_traits< _Tp> ::__digits); +# 182 +if constexpr ((_Nd & (_Nd - 1)) == 0) +# 183 +{ +# 186 +constexpr unsigned __uNd = (_Nd); +# 187 +const unsigned __r = __s; +# 188 +return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd)); +# 189 +} +# 190 +const int __r = __s % _Nd; +# 191 +if (__r == 0) { +# 192 +return __x; } else { +# 193 +if (__r > 0) { +# 194 +return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); } else { +# 196 +return (__x << (-__r)) | (__x >> ((_Nd + __r) % _Nd)); } } +# 197 +} +# 199 +template< class _Tp> constexpr int +# 201 +__countl_zero(_Tp __x) noexcept +# 202 +{ +# 203 +using __gnu_cxx::__int_traits; +# 204 +constexpr auto _Nd = (__int_traits< _Tp> ::__digits); +# 206 +if (__x == 0) { +# 207 +return _Nd; } +# 209 +constexpr auto _Nd_ull = __int_traits< unsigned long long> ::__digits; +# 210 +constexpr auto _Nd_ul = __int_traits< unsigned long> ::__digits; +# 211 +constexpr auto _Nd_u = __int_traits< unsigned> ::__digits; +# 213 +if constexpr (_Nd <= _Nd_u) +# 214 +{ +# 215 +constexpr int __diff = (_Nd_u - _Nd); +# 216 +return __builtin_clz(__x) - __diff; +# 217 +} else { +# 218 +if constexpr (_Nd <= _Nd_ul) +# 219 +{ +# 220 +constexpr int __diff = (_Nd_ul - _Nd); +# 221 +return __builtin_clzl(__x) - __diff; +# 222 +} else { +# 223 +if constexpr (_Nd <= _Nd_ull) +# 224 +{ +# 225 +constexpr int __diff = (_Nd_ull - _Nd); +# 226 +return __builtin_clzll(__x) - __diff; +# 227 +} else +# 229 +{ +# 230 +static_assert((_Nd <= (2 * _Nd_ull)), "Maximum supported integer size is 128-bit"); +# 233 +unsigned long long __high = __x >> _Nd_ull; +# 234 +if (__high != (0)) +# 235 +{ +# 236 +constexpr int __diff = ((2 * _Nd_ull) - _Nd); +# 237 +return __builtin_clzll(__high) - __diff; +# 238 +} +# 239 +constexpr auto __max_ull = __int_traits< unsigned long long> ::__max; +# 240 +unsigned long long __low = __x & __max_ull; +# 241 +return (_Nd - _Nd_ull) + __builtin_clzll(__low); +# 242 +} } } +# 243 +} +# 245 +template< class _Tp> constexpr int +# 247 +__countl_one(_Tp __x) noexcept +# 248 +{ +# 249 +return std::__countl_zero< _Tp> ((_Tp)(~__x)); +# 250 +} +# 252 +template< class _Tp> constexpr int +# 254 +__countr_zero(_Tp __x) noexcept +# 255 +{ +# 256 +using __gnu_cxx::__int_traits; +# 257 +constexpr auto _Nd = (__int_traits< _Tp> ::__digits); +# 259 +if (__x == 0) { +# 260 +return _Nd; } +# 262 +constexpr auto _Nd_ull = __int_traits< unsigned long long> ::__digits; +# 263 +constexpr auto _Nd_ul = __int_traits< unsigned long> ::__digits; +# 264 +constexpr auto _Nd_u = __int_traits< unsigned> ::__digits; +# 266 +if constexpr (_Nd <= _Nd_u) { +# 267 +return __builtin_ctz(__x); } else { +# 268 +if constexpr (_Nd <= _Nd_ul) { +# 269 +return __builtin_ctzl(__x); } else { +# 270 +if constexpr (_Nd <= _Nd_ull) { +# 271 +return __builtin_ctzll(__x); } else +# 273 +{ +# 274 +static_assert((_Nd <= (2 * _Nd_ull)), "Maximum supported integer size is 128-bit"); +# 277 +constexpr auto __max_ull = __int_traits< unsigned long long> ::__max; +# 278 +unsigned long long __low = __x & __max_ull; +# 279 +if (__low != (0)) { +# 280 +return __builtin_ctzll(__low); } +# 281 +unsigned long long __high = __x >> _Nd_ull; +# 282 +return __builtin_ctzll(__high) + _Nd_ull; +# 283 +} } } +# 284 +} +# 286 +template< class _Tp> constexpr int +# 288 +__countr_one(_Tp __x) noexcept +# 289 +{ +# 290 +return std::__countr_zero((_Tp)(~__x)); +# 291 +} +# 293 +template< class _Tp> constexpr int +# 295 +__popcount(_Tp __x) noexcept +# 296 +{ +# 297 +using __gnu_cxx::__int_traits; +# 298 +constexpr auto _Nd = (__int_traits< _Tp> ::__digits); +# 300 +constexpr auto _Nd_ull = __int_traits< unsigned long long> ::__digits; +# 301 +constexpr auto _Nd_ul = __int_traits< unsigned long> ::__digits; +# 302 +constexpr auto _Nd_u = __int_traits< unsigned> ::__digits; +# 304 +if constexpr (_Nd <= _Nd_u) { +# 305 +return __builtin_popcount(__x); } else { +# 306 +if constexpr (_Nd <= _Nd_ul) { +# 307 +return __builtin_popcountl(__x); } else { +# 308 +if constexpr (_Nd <= _Nd_ull) { +# 309 +return __builtin_popcountll(__x); } else +# 311 +{ +# 312 +static_assert((_Nd <= (2 * _Nd_ull)), "Maximum supported integer size is 128-bit"); +# 315 +constexpr auto __max_ull = __int_traits< unsigned long long> ::__max; +# 316 +unsigned long long __low = __x & __max_ull; +# 317 +unsigned long long __high = __x >> _Nd_ull; +# 318 +return __builtin_popcountll(__low) + __builtin_popcountll(__high); +# 319 +} } } +# 320 +} +# 322 +template< class _Tp> constexpr bool +# 324 +__has_single_bit(_Tp __x) noexcept +# 325 +{ return std::__popcount(__x) == 1; } +# 327 +template< class _Tp> constexpr _Tp +# 329 +__bit_ceil(_Tp __x) noexcept +# 330 +{ +# 331 +using __gnu_cxx::__int_traits; +# 332 +constexpr auto _Nd = (__int_traits< _Tp> ::__digits); +# 333 +if ((__x == 0) || (__x == 1)) { +# 334 +return 1; } +# 335 +auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1U)); +# 340 +if (!std::__is_constant_evaluated()) +# 341 +{ +# 342 +do { if (std::__is_constant_evaluated() && (!((bool)(__shift_exponent != __int_traits< _Tp> ::__digits)))) { std::__glibcxx_assert_fail(); } } while (false); +# 343 +} +# 345 +using __promoted_type = __decltype((__x << 1)); +# 346 +if constexpr (!is_same< __decltype((__x << 1)), _Tp> ::value) +# 347 +{ +# 353 +const int __extra_exp = ((sizeof(__promoted_type) / sizeof(_Tp)) / (2)); +# 354 +__shift_exponent |= ((__shift_exponent & _Nd) << __extra_exp); +# 355 +} +# 356 +return ((_Tp)1U) << __shift_exponent; +# 357 +} +# 359 +template< class _Tp> constexpr _Tp +# 361 +__bit_floor(_Tp __x) noexcept +# 362 +{ +# 363 +constexpr auto _Nd = (__gnu_cxx::__int_traits< _Tp> ::__digits); +# 364 +if (__x == 0) { +# 365 +return 0; } +# 366 +return ((_Tp)1U) << (_Nd - std::__countl_zero((_Tp)(__x >> 1))); +# 367 +} +# 369 +template< class _Tp> constexpr int +# 371 +__bit_width(_Tp __x) noexcept +# 372 +{ +# 373 +constexpr auto _Nd = (__gnu_cxx::__int_traits< _Tp> ::__digits); +# 374 +return _Nd - std::__countl_zero(__x); +# 375 +} +# 483 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bit" 3 +} +# 82 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 90 +template< class _Tp, class _Up> constexpr int +# 93 +__memcmp(const _Tp *__first1, const _Up *__first2, size_t __num) +# 94 +{ +# 96 +static_assert((sizeof(_Tp) == sizeof(_Up)), "can be compared with memcmp"); +# 108 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); +# 109 +} +# 152 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _ForwardIterator1, class _ForwardIterator2> inline void +# 155 +iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) +# 156 +{ +# 185 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +swap(*__a, *__b); +# 187 +} +# 201 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _ForwardIterator1, class _ForwardIterator2> _ForwardIterator2 +# 204 +swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 +# 205 +__first2) +# 206 +{ +# 212 +; +# 214 +for (; __first1 != __last1; (++__first1), ((void)(++__first2))) { +# 215 +std::iter_swap(__first1, __first2); } +# 216 +return __first2; +# 217 +} +# 230 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _Tp> +# 231 +[[__nodiscard__]] constexpr const _Tp & +# 233 +min(const _Tp &__a, const _Tp &__b) +# 234 +{ +# 238 +if (__b < __a) { +# 239 +return __b; } +# 240 +return __a; +# 241 +} +# 254 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _Tp> +# 255 +[[__nodiscard__]] constexpr const _Tp & +# 257 +max(const _Tp &__a, const _Tp &__b) +# 258 +{ +# 262 +if (__a < __b) { +# 263 +return __b; } +# 264 +return __a; +# 265 +} +# 278 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _Tp, class _Compare> +# 279 +[[__nodiscard__]] constexpr const _Tp & +# 281 +min(const _Tp &__a, const _Tp &__b, _Compare __comp) +# 282 +{ +# 284 +if (__comp(__b, __a)) { +# 285 +return __b; } +# 286 +return __a; +# 287 +} +# 300 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _Tp, class _Compare> +# 301 +[[__nodiscard__]] constexpr const _Tp & +# 303 +max(const _Tp &__a, const _Tp &__b, _Compare __comp) +# 304 +{ +# 306 +if (__comp(__a, __b)) { +# 307 +return __b; } +# 308 +return __a; +# 309 +} +# 313 +template< class _Iterator> inline _Iterator +# 316 +__niter_base(_Iterator __it) noexcept(std::template is_nothrow_copy_constructible< _Iterator> ::value) +# 318 +{ return __it; } +# 332 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _Ite, class _Seq> __decltype((std::__niter_base(std::declval< _Ite> ()))) __niter_base(const __gnu_debug::_Safe_iterator< _Ite, _Seq, random_access_iterator_tag> &) noexcept(std::template is_nothrow_copy_constructible< _Ite> ::value); +# 343 +template< class _From, class _To> inline _From +# 346 +__niter_wrap(_From __from, _To __res) +# 347 +{ return __from + (std::__niter_base(__res) - std::__niter_base(__from)); } +# 350 +template< class _Iterator> inline _Iterator +# 353 +__niter_wrap(const _Iterator &, _Iterator __res) +# 354 +{ return __res; } +# 362 +template< bool _IsMove, bool _IsSimple, class _Category> +# 363 +struct __copy_move { +# 365 +template< class _II, class _OI> static _OI +# 368 +__copy_m(_II __first, _II __last, _OI __result) +# 369 +{ +# 370 +for (; __first != __last; (++__result), ((void)(++__first))) { +# 371 +(*__result) = (*__first); } +# 372 +return __result; +# 373 +} +# 374 +}; +# 377 +template< class _Category> +# 378 +struct __copy_move< true, false, _Category> { +# 380 +template< class _II, class _OI> static _OI +# 383 +__copy_m(_II __first, _II __last, _OI __result) +# 384 +{ +# 385 +for (; __first != __last; (++__result), ((void)(++__first))) { +# 386 +(*__result) = std::move(*__first); } +# 387 +return __result; +# 388 +} +# 389 +}; +# 393 +template<> struct __copy_move< false, false, random_access_iterator_tag> { +# 395 +template< class _II, class _OI> static _OI +# 398 +__copy_m(_II __first, _II __last, _OI __result) +# 399 +{ +# 400 +typedef typename iterator_traits< _II> ::difference_type _Distance; +# 401 +for (_Distance __n = __last - __first; __n > 0; --__n) +# 402 +{ +# 403 +(*__result) = (*__first); +# 404 +++__first; +# 405 +++__result; +# 406 +} +# 407 +return __result; +# 408 +} +# 410 +template< class _Tp, class _Up> static void +# 412 +__assign_one(_Tp *__to, _Up *__from) +# 413 +{ (*__to) = (*__from); } +# 414 +}; +# 418 +template<> struct __copy_move< true, false, random_access_iterator_tag> { +# 420 +template< class _II, class _OI> static _OI +# 423 +__copy_m(_II __first, _II __last, _OI __result) +# 424 +{ +# 425 +typedef typename iterator_traits< _II> ::difference_type _Distance; +# 426 +for (_Distance __n = __last - __first; __n > 0; --__n) +# 427 +{ +# 428 +(*__result) = std::move(*__first); +# 429 +++__first; +# 430 +++__result; +# 431 +} +# 432 +return __result; +# 433 +} +# 435 +template< class _Tp, class _Up> static void +# 437 +__assign_one(_Tp *__to, _Up *__from) +# 438 +{ (*__to) = std::move(*__from); } +# 439 +}; +# 442 +template< bool _IsMove> +# 443 +struct __copy_move< _IsMove, true, random_access_iterator_tag> { +# 445 +template< class _Tp, class _Up> static _Up * +# 448 +__copy_m(_Tp *__first, _Tp *__last, _Up *__result) +# 449 +{ +# 450 +const ptrdiff_t _Num = __last - __first; +# 451 +if (__builtin_expect(_Num > (1), true)) { +# 452 +__builtin_memmove(__result, __first, sizeof(_Tp) * _Num); } else { +# 453 +if (_Num == (1)) { +# 454 +std::template __copy_move< _IsMove, false, random_access_iterator_tag> ::__assign_one(__result, __first); } } +# 456 +return __result + _Num; +# 457 +} +# 458 +}; +# 462 +template< class _Tp, class _Ref, class _Ptr> struct _Deque_iterator; +# 465 +struct _Bit_iterator; +# 472 +template< class _CharT> struct char_traits; +# 475 +template< class _CharT, class _Traits> class istreambuf_iterator; +# 478 +template< class _CharT, class _Traits> class ostreambuf_iterator; +# 481 +template< bool _IsMove, class _CharT> typename __gnu_cxx::__enable_if< __is_char< _CharT> ::__value, ostreambuf_iterator< _CharT, char_traits< _CharT> > > ::__type __copy_move_a2(_CharT *, _CharT *, ostreambuf_iterator< _CharT, char_traits< _CharT> > ); +# 487 +template< bool _IsMove, class _CharT> typename __gnu_cxx::__enable_if< __is_char< _CharT> ::__value, ostreambuf_iterator< _CharT, char_traits< _CharT> > > ::__type __copy_move_a2(const _CharT *, const _CharT *, ostreambuf_iterator< _CharT, char_traits< _CharT> > ); +# 493 +template< bool _IsMove, class _CharT> typename __gnu_cxx::__enable_if< __is_char< _CharT> ::__value, _CharT *> ::__type __copy_move_a2(istreambuf_iterator< _CharT, char_traits< _CharT> > , istreambuf_iterator< _CharT, char_traits< _CharT> > , _CharT *); +# 499 +template< bool _IsMove, class _CharT> typename __gnu_cxx::__enable_if< __is_char< _CharT> ::__value, _Deque_iterator< _CharT, _CharT &, _CharT *> > ::__type __copy_move_a2(istreambuf_iterator< _CharT, char_traits< _CharT> > , istreambuf_iterator< _CharT, char_traits< _CharT> > , _Deque_iterator< _CharT, _CharT &, _CharT *> ); +# 509 +template< bool _IsMove, class _II, class _OI> inline _OI +# 512 +__copy_move_a2(_II __first, _II __last, _OI __result) +# 513 +{ +# 514 +typedef typename iterator_traits< _II> ::iterator_category _Category; +# 520 +return std::template __copy_move< _IsMove, __memcpyable< _OI, _II> ::__value, typename iterator_traits< _II> ::iterator_category> ::__copy_m(__first, __last, __result); +# 522 +} +# 524 +template< bool _IsMove, class +# 525 +_Tp, class _Ref, class _Ptr, class _OI> _OI +# 524 +__copy_move_a1(_Deque_iterator< _Tp, _Ref, _Ptr> , _Deque_iterator< _Tp, _Ref, _Ptr> , _OI); +# 531 +template< bool _IsMove, class +# 532 +_ITp, class _IRef, class _IPtr, class _OTp> _Deque_iterator< _OTp, _OTp &, _OTp *> +# 531 +__copy_move_a1(_Deque_iterator< _ITp, _IRef, _IPtr> , _Deque_iterator< _ITp, _IRef, _IPtr> , _Deque_iterator< _OTp, _OTp &, _OTp *> ); +# 538 +template< bool _IsMove, class _II, class _Tp> typename __gnu_cxx::__enable_if< __is_random_access_iter< _II> ::__value, _Deque_iterator< _Tp, _Tp &, _Tp *> > ::__type __copy_move_a1(_II, _II, _Deque_iterator< _Tp, _Tp &, _Tp *> ); +# 544 +template< bool _IsMove, class _II, class _OI> inline _OI +# 547 +__copy_move_a1(_II __first, _II __last, _OI __result) +# 548 +{ return std::__copy_move_a2< _IsMove> (__first, __last, __result); } +# 550 +template< bool _IsMove, class _II, class _OI> inline _OI +# 553 +__copy_move_a(_II __first, _II __last, _OI __result) +# 554 +{ +# 555 +return std::__niter_wrap(__result, std::__copy_move_a1< _IsMove> (std::__niter_base(__first), std::__niter_base(__last), std::__niter_base(__result))); +# 559 +} +# 561 +template< bool _IsMove, class +# 562 +_Ite, class _Seq, class _Cat, class _OI> _OI +# 561 +__copy_move_a(const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &, const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &, _OI); +# 569 +template< bool _IsMove, class +# 570 +_II, class _Ite, class _Seq, class _Cat> __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> +# 569 +__copy_move_a(_II, _II, const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &); +# 576 +template< bool _IsMove, class +# 577 +_IIte, class _ISeq, class _ICat, class +# 578 +_OIte, class _OSeq, class _OCat> __gnu_debug::_Safe_iterator< _OIte, _OSeq, _OCat> +# 576 +__copy_move_a(const __gnu_debug::_Safe_iterator< _IIte, _ISeq, _ICat> &, const __gnu_debug::_Safe_iterator< _IIte, _ISeq, _ICat> &, const __gnu_debug::_Safe_iterator< _OIte, _OSeq, _OCat> &); +# 585 +template< class _InputIterator, class _Size, class _OutputIterator> _OutputIterator +# 588 +__copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, bool) +# 590 +{ +# 591 +if (__n > 0) +# 592 +{ +# 593 +while (true) +# 594 +{ +# 595 +(*__result) = (*__first); +# 596 +++__result; +# 597 +if ((--__n) > 0) { +# 598 +++__first; } else { +# 600 +break; } +# 601 +} +# 602 +} +# 603 +return __result; +# 604 +} +# 607 +template< class _CharT, class _Size> typename __gnu_cxx::__enable_if< __is_char< _CharT> ::__value, _CharT *> ::__type __copy_n_a(istreambuf_iterator< _CharT, char_traits< _CharT> > , _Size, _CharT *, bool); +# 613 +template< class _CharT, class _Size> typename __gnu_cxx::__enable_if< __is_char< _CharT> ::__value, _Deque_iterator< _CharT, _CharT &, _CharT *> > ::__type __copy_n_a(istreambuf_iterator< _CharT, char_traits< _CharT> > , _Size, _Deque_iterator< _CharT, _CharT &, _CharT *> , bool); +# 639 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _II, class _OI> inline _OI +# 642 +copy(_II __first, _II __last, _OI __result) +# 643 +{ +# 648 +; +# 650 +return std::__copy_move_a< __is_move_iterator< _II> ::__value> (std::__miter_base(__first), std::__miter_base(__last), __result); +# 652 +} +# 672 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _II, class _OI> inline _OI +# 675 +move(_II __first, _II __last, _OI __result) +# 676 +{ +# 681 +; +# 683 +return std::__copy_move_a< true> (std::__miter_base(__first), std::__miter_base(__last), __result); +# 685 +} +# 692 +template< bool _IsMove, bool _IsSimple, class _Category> +# 693 +struct __copy_move_backward { +# 695 +template< class _BI1, class _BI2> static _BI2 +# 698 +__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) +# 699 +{ +# 700 +while (__first != __last) { +# 701 +(*(--__result)) = (*(--__last)); } +# 702 +return __result; +# 703 +} +# 704 +}; +# 707 +template< class _Category> +# 708 +struct __copy_move_backward< true, false, _Category> { +# 710 +template< class _BI1, class _BI2> static _BI2 +# 713 +__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) +# 714 +{ +# 715 +while (__first != __last) { +# 716 +(*(--__result)) = std::move(*(--__last)); } +# 717 +return __result; +# 718 +} +# 719 +}; +# 723 +template<> struct __copy_move_backward< false, false, random_access_iterator_tag> { +# 725 +template< class _BI1, class _BI2> static _BI2 +# 728 +__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) +# 729 +{ +# 731 +typename iterator_traits< _BI1> ::difference_type __n = __last - __first; +# 732 +for (; __n > 0; --__n) { +# 733 +(*(--__result)) = (*(--__last)); } +# 734 +return __result; +# 735 +} +# 736 +}; +# 740 +template<> struct __copy_move_backward< true, false, random_access_iterator_tag> { +# 742 +template< class _BI1, class _BI2> static _BI2 +# 745 +__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) +# 746 +{ +# 748 +typename iterator_traits< _BI1> ::difference_type __n = __last - __first; +# 749 +for (; __n > 0; --__n) { +# 750 +(*(--__result)) = std::move(*(--__last)); } +# 751 +return __result; +# 752 +} +# 753 +}; +# 756 +template< bool _IsMove> +# 757 +struct __copy_move_backward< _IsMove, true, random_access_iterator_tag> { +# 759 +template< class _Tp, class _Up> static _Up * +# 762 +__copy_move_b(_Tp *__first, _Tp *__last, _Up *__result) +# 763 +{ +# 764 +const ptrdiff_t _Num = __last - __first; +# 765 +if (__builtin_expect(_Num > (1), true)) { +# 766 +__builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); } else { +# 767 +if (_Num == (1)) { +# 768 +std::template __copy_move< _IsMove, false, random_access_iterator_tag> ::__assign_one(__result - 1, __first); } } +# 770 +return __result - _Num; +# 771 +} +# 772 +}; +# 774 +template< bool _IsMove, class _BI1, class _BI2> inline _BI2 +# 777 +__copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) +# 778 +{ +# 779 +typedef typename iterator_traits< _BI1> ::iterator_category _Category; +# 785 +return std::template __copy_move_backward< _IsMove, __memcpyable< _BI2, _BI1> ::__value, typename iterator_traits< _BI1> ::iterator_category> ::__copy_move_b(__first, __last, __result); +# 790 +} +# 792 +template< bool _IsMove, class _BI1, class _BI2> inline _BI2 +# 795 +__copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) +# 796 +{ return std::__copy_move_backward_a2< _IsMove> (__first, __last, __result); } +# 798 +template< bool _IsMove, class +# 799 +_Tp, class _Ref, class _Ptr, class _OI> _OI +# 798 +__copy_move_backward_a1(_Deque_iterator< _Tp, _Ref, _Ptr> , _Deque_iterator< _Tp, _Ref, _Ptr> , _OI); +# 805 +template< bool _IsMove, class +# 806 +_ITp, class _IRef, class _IPtr, class _OTp> _Deque_iterator< _OTp, _OTp &, _OTp *> +# 805 +__copy_move_backward_a1(_Deque_iterator< _ITp, _IRef, _IPtr> , _Deque_iterator< _ITp, _IRef, _IPtr> , _Deque_iterator< _OTp, _OTp &, _OTp *> ); +# 813 +template< bool _IsMove, class _II, class _Tp> typename __gnu_cxx::__enable_if< __is_random_access_iter< _II> ::__value, _Deque_iterator< _Tp, _Tp &, _Tp *> > ::__type __copy_move_backward_a1(_II, _II, _Deque_iterator< _Tp, _Tp &, _Tp *> ); +# 820 +template< bool _IsMove, class _II, class _OI> inline _OI +# 823 +__copy_move_backward_a(_II __first, _II __last, _OI __result) +# 824 +{ +# 825 +return std::__niter_wrap(__result, std::__copy_move_backward_a1< _IsMove> (std::__niter_base(__first), std::__niter_base(__last), std::__niter_base(__result))); +# 829 +} +# 831 +template< bool _IsMove, class +# 832 +_Ite, class _Seq, class _Cat, class _OI> _OI +# 831 +__copy_move_backward_a(const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &, const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &, _OI); +# 840 +template< bool _IsMove, class +# 841 +_II, class _Ite, class _Seq, class _Cat> __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> +# 840 +__copy_move_backward_a(_II, _II, const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &); +# 847 +template< bool _IsMove, class +# 848 +_IIte, class _ISeq, class _ICat, class +# 849 +_OIte, class _OSeq, class _OCat> __gnu_debug::_Safe_iterator< _OIte, _OSeq, _OCat> +# 847 +__copy_move_backward_a(const __gnu_debug::_Safe_iterator< _IIte, _ISeq, _ICat> &, const __gnu_debug::_Safe_iterator< _IIte, _ISeq, _ICat> &, const __gnu_debug::_Safe_iterator< _OIte, _OSeq, _OCat> &); +# 875 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _BI1, class _BI2> inline _BI2 +# 878 +copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) +# 879 +{ +# 885 +; +# 887 +return std::__copy_move_backward_a< __is_move_iterator< _BI1> ::__value> (std::__miter_base(__first), std::__miter_base(__last), __result); +# 889 +} +# 910 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _BI1, class _BI2> inline _BI2 +# 913 +move_backward(_BI1 __first, _BI1 __last, _BI2 __result) +# 914 +{ +# 920 +; +# 922 +return std::__copy_move_backward_a< true> (std::__miter_base(__first), std::__miter_base(__last), __result); +# 925 +} +# 932 +template< class _ForwardIterator, class _Tp> inline typename __gnu_cxx::__enable_if< !__is_scalar< _Tp> ::__value, void> ::__type +# 936 +__fill_a1(_ForwardIterator __first, _ForwardIterator __last, const _Tp & +# 937 +__value) +# 938 +{ +# 939 +for (; __first != __last; ++__first) { +# 940 +(*__first) = __value; } +# 941 +} +# 943 +template< class _ForwardIterator, class _Tp> inline typename __gnu_cxx::__enable_if< __is_scalar< _Tp> ::__value, void> ::__type +# 947 +__fill_a1(_ForwardIterator __first, _ForwardIterator __last, const _Tp & +# 948 +__value) +# 949 +{ +# 950 +const _Tp __tmp = __value; +# 951 +for (; __first != __last; ++__first) { +# 952 +(*__first) = __tmp; } +# 953 +} +# 956 +template< class _Tp> inline typename __gnu_cxx::__enable_if< __is_byte< _Tp> ::__value, void> ::__type +# 960 +__fill_a1(_Tp *__first, _Tp *__last, const _Tp &__c) +# 961 +{ +# 962 +const _Tp __tmp = __c; +# 971 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +if (const size_t __len = __last - __first) { +# 972 +__builtin_memset(__first, static_cast< unsigned char>(__tmp), __len); } +# 973 +} +# 975 +template< class _Ite, class _Cont, class _Tp> inline void +# 978 +__fill_a1(__gnu_cxx::__normal_iterator< _Ite, _Cont> __first, __gnu_cxx::__normal_iterator< _Ite, _Cont> +# 979 +__last, const _Tp & +# 980 +__value) +# 981 +{ std::__fill_a1(__first.base(), __last.base(), __value); } +# 983 +template< class _Tp, class _VTp> void __fill_a1(const _Deque_iterator< _Tp, _Tp &, _Tp *> &, const _Deque_iterator< _Tp, _Tp &, _Tp *> &, const _VTp &); +# 991 +void __fill_a1(_Bit_iterator, _Bit_iterator, const bool &); +# 994 +template< class _FIte, class _Tp> inline void +# 997 +__fill_a(_FIte __first, _FIte __last, const _Tp &__value) +# 998 +{ std::__fill_a1(__first, __last, __value); } +# 1000 +template< class _Ite, class _Seq, class _Cat, class _Tp> void __fill_a(const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &, const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &, const _Tp &); +# 1019 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _ForwardIterator, class _Tp> inline void +# 1022 +fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp &__value) +# 1023 +{ +# 1027 +; +# 1029 +std::__fill_a(__first, __last, __value); +# 1030 +} +# 1032 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wlong-long" +# 1036 +constexpr int __size_to_integer(int __n) { return __n; } +# 1038 +constexpr unsigned __size_to_integer(unsigned __n) { return __n; } +# 1040 +constexpr long __size_to_integer(long __n) { return __n; } +# 1042 +constexpr unsigned long __size_to_integer(unsigned long __n) { return __n; } +# 1044 +constexpr long long __size_to_integer(long long __n) { return __n; } +# 1046 +constexpr unsigned long long __size_to_integer(unsigned long long __n) { return __n; } +# 1050 +__extension__ constexpr __int128 __size_to_integer(__int128 __n) { return __n; } +# 1052 +__extension__ constexpr unsigned __int128 __size_to_integer(unsigned __int128 __n) { return __n; } +# 1074 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +constexpr long long __size_to_integer(float __n) { return (long long)__n; } +# 1076 +constexpr long long __size_to_integer(double __n) { return (long long)__n; } +# 1078 +constexpr long long __size_to_integer(long double __n) { return (long long)__n; } +# 1081 +__extension__ constexpr long long __size_to_integer(__float128 __n) { return (long long)__n; } +# 1083 +#pragma GCC diagnostic pop +# 1085 +template< class _OutputIterator, class _Size, class _Tp> inline typename __gnu_cxx::__enable_if< !__is_scalar< _Tp> ::__value, _OutputIterator> ::__type +# 1089 +__fill_n_a1(_OutputIterator __first, _Size __n, const _Tp &__value) +# 1090 +{ +# 1091 +for (; __n > 0; (--__n), ((void)(++__first))) { +# 1092 +(*__first) = __value; } +# 1093 +return __first; +# 1094 +} +# 1096 +template< class _OutputIterator, class _Size, class _Tp> inline typename __gnu_cxx::__enable_if< __is_scalar< _Tp> ::__value, _OutputIterator> ::__type +# 1100 +__fill_n_a1(_OutputIterator __first, _Size __n, const _Tp &__value) +# 1101 +{ +# 1102 +const _Tp __tmp = __value; +# 1103 +for (; __n > 0; (--__n), ((void)(++__first))) { +# 1104 +(*__first) = __tmp; } +# 1105 +return __first; +# 1106 +} +# 1108 +template< class _Ite, class _Seq, class _Cat, class _Size, class +# 1109 +_Tp> __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> +# 1108 +__fill_n_a(const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> & __first, _Size __n, const _Tp & __value, input_iterator_tag); +# 1116 +template< class _OutputIterator, class _Size, class _Tp> inline _OutputIterator +# 1119 +__fill_n_a(_OutputIterator __first, _Size __n, const _Tp &__value, output_iterator_tag) +# 1121 +{ +# 1123 +static_assert((is_integral< _Size> {}), "fill_n must pass integral size"); +# 1125 +return __fill_n_a1(__first, __n, __value); +# 1126 +} +# 1128 +template< class _OutputIterator, class _Size, class _Tp> inline _OutputIterator +# 1131 +__fill_n_a(_OutputIterator __first, _Size __n, const _Tp &__value, input_iterator_tag) +# 1133 +{ +# 1135 +static_assert((is_integral< _Size> {}), "fill_n must pass integral size"); +# 1137 +return __fill_n_a1(__first, __n, __value); +# 1138 +} +# 1140 +template< class _OutputIterator, class _Size, class _Tp> inline _OutputIterator +# 1143 +__fill_n_a(_OutputIterator __first, _Size __n, const _Tp &__value, random_access_iterator_tag) +# 1145 +{ +# 1147 +static_assert((is_integral< _Size> {}), "fill_n must pass integral size"); +# 1149 +if (__n <= 0) { +# 1150 +return __first; } +# 1152 +; +# 1154 +std::__fill_a(__first, __first + __n, __value); +# 1155 +return __first + __n; +# 1156 +} +# 1175 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _OI, class _Size, class _Tp> inline _OI +# 1178 +fill_n(_OI __first, _Size __n, const _Tp &__value) +# 1179 +{ +# 1183 +return std::__fill_n_a(__first, std::__size_to_integer(__n), __value, std::__iterator_category(__first)); +# 1185 +} +# 1187 +template< bool _BoolType> +# 1188 +struct __equal { +# 1190 +template< class _II1, class _II2> static bool +# 1193 +equal(_II1 __first1, _II1 __last1, _II2 __first2) +# 1194 +{ +# 1195 +for (; __first1 != __last1; (++__first1), ((void)(++__first2))) { +# 1196 +if (!((*__first1) == (*__first2))) { +# 1197 +return false; } } +# 1198 +return true; +# 1199 +} +# 1200 +}; +# 1203 +template<> struct __equal< true> { +# 1205 +template< class _Tp> static bool +# 1208 +equal(const _Tp *__first1, const _Tp *__last1, const _Tp *__first2) +# 1209 +{ +# 1210 +if (const size_t __len = __last1 - __first1) { +# 1211 +return !std::__memcmp(__first1, __first2, __len); } +# 1212 +return true; +# 1213 +} +# 1214 +}; +# 1216 +template< class _Tp, class _Ref, class _Ptr, class _II> typename __gnu_cxx::__enable_if< __is_random_access_iter< _II> ::__value, bool> ::__type __equal_aux1(_Deque_iterator< _Tp, _Ref, _Ptr> , _Deque_iterator< _Tp, _Ref, _Ptr> , _II); +# 1223 +template< class _Tp1, class _Ref1, class _Ptr1, class +# 1224 +_Tp2, class _Ref2, class _Ptr2> bool +# 1223 +__equal_aux1(_Deque_iterator< _Tp1, _Ref1, _Ptr1> , _Deque_iterator< _Tp1, _Ref1, _Ptr1> , _Deque_iterator< _Tp2, _Ref2, _Ptr2> ); +# 1230 +template< class _II, class _Tp, class _Ref, class _Ptr> typename __gnu_cxx::__enable_if< __is_random_access_iter< _II> ::__value, bool> ::__type __equal_aux1(_II, _II, _Deque_iterator< _Tp, _Ref, _Ptr> ); +# 1236 +template< class _II1, class _II2> inline bool +# 1239 +__equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2) +# 1240 +{ +# 1241 +typedef typename iterator_traits< _II1> ::value_type _ValueType1; +# 1242 +const bool __simple = ((__is_integer< typename iterator_traits< _II1> ::value_type> ::__value || __is_pointer< typename iterator_traits< _II1> ::value_type> ::__value) && __memcmpable< _II1, _II2> ::__value); +# 1245 +return std::template __equal< __simple> ::equal(__first1, __last1, __first2); +# 1246 +} +# 1248 +template< class _II1, class _II2> inline bool +# 1251 +__equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) +# 1252 +{ +# 1253 +return std::__equal_aux1(std::__niter_base(__first1), std::__niter_base(__last1), std::__niter_base(__first2)); +# 1256 +} +# 1258 +template< class _II1, class _Seq1, class _Cat1, class _II2> bool __equal_aux(const __gnu_debug::_Safe_iterator< _II1, _Seq1, _Cat1> &, const __gnu_debug::_Safe_iterator< _II1, _Seq1, _Cat1> &, _II2); +# 1265 +template< class _II1, class _II2, class _Seq2, class _Cat2> bool __equal_aux(_II1, _II1, const __gnu_debug::_Safe_iterator< _II2, _Seq2, _Cat2> &); +# 1271 +template< class _II1, class _Seq1, class _Cat1, class +# 1272 +_II2, class _Seq2, class _Cat2> bool +# 1271 +__equal_aux(const __gnu_debug::_Safe_iterator< _II1, _Seq1, _Cat1> &, const __gnu_debug::_Safe_iterator< _II1, _Seq1, _Cat1> &, const __gnu_debug::_Safe_iterator< _II2, _Seq2, _Cat2> &); +# 1279 +template< class , class > +# 1280 +struct __lc_rai { +# 1282 +template< class _II1, class _II2> static _II1 +# 1285 +__newlast1(_II1, _II1 __last1, _II2, _II2) +# 1286 +{ return __last1; } +# 1288 +template< class _II> static bool +# 1291 +__cnd2(_II __first, _II __last) +# 1292 +{ return __first != __last; } +# 1293 +}; +# 1296 +template<> struct __lc_rai< random_access_iterator_tag, random_access_iterator_tag> { +# 1298 +template< class _RAI1, class _RAI2> static _RAI1 +# 1301 +__newlast1(_RAI1 __first1, _RAI1 __last1, _RAI2 +# 1302 +__first2, _RAI2 __last2) +# 1303 +{ +# 1305 +const typename iterator_traits< _RAI1> ::difference_type __diff1 = __last1 - __first1; +# 1307 +const typename iterator_traits< _RAI2> ::difference_type __diff2 = __last2 - __first2; +# 1308 +return (__diff2 < __diff1) ? __first1 + __diff2 : __last1; +# 1309 +} +# 1311 +template< class _RAI> static bool +# 1313 +__cnd2(_RAI, _RAI) +# 1314 +{ return true; } +# 1315 +}; +# 1317 +template< class _II1, class _II2, class _Compare> bool +# 1320 +__lexicographical_compare_impl(_II1 __first1, _II1 __last1, _II2 +# 1321 +__first2, _II2 __last2, _Compare +# 1322 +__comp) +# 1323 +{ +# 1324 +typedef typename iterator_traits< _II1> ::iterator_category _Category1; +# 1325 +typedef typename iterator_traits< _II2> ::iterator_category _Category2; +# 1326 +typedef __lc_rai< typename iterator_traits< _II1> ::iterator_category, typename iterator_traits< _II2> ::iterator_category> __rai_type; +# 1328 +__last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); +# 1329 +for (; (__first1 != __last1) && __rai_type::__cnd2(__first2, __last2); (++__first1), ((void)(++__first2))) +# 1331 +{ +# 1332 +if (__comp(__first1, __first2)) { +# 1333 +return true; } +# 1334 +if (__comp(__first2, __first1)) { +# 1335 +return false; } +# 1336 +} +# 1337 +return (__first1 == __last1) && (__first2 != __last2); +# 1338 +} +# 1340 +template< bool _BoolType> +# 1341 +struct __lexicographical_compare { +# 1343 +template< class _II1, class _II2> static bool +# 1346 +__lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) +# 1347 +{ +# 1348 +using __gnu_cxx::__ops::__iter_less_iter; +# 1349 +return std::__lexicographical_compare_impl(__first1, __last1, __first2, __last2, __iter_less_iter()); +# 1352 +} +# 1354 +template< class _II1, class _II2> static int +# 1357 +__3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) +# 1358 +{ +# 1359 +while (__first1 != __last1) +# 1360 +{ +# 1361 +if (__first2 == __last2) { +# 1362 +return +1; } +# 1363 +if ((*__first1) < (*__first2)) { +# 1364 +return -1; } +# 1365 +if ((*__first2) < (*__first1)) { +# 1366 +return +1; } +# 1367 +++__first1; +# 1368 +++__first2; +# 1369 +} +# 1370 +return ((int)(__first2 == __last2)) - 1; +# 1371 +} +# 1372 +}; +# 1375 +template<> struct __lexicographical_compare< true> { +# 1377 +template< class _Tp, class _Up> static bool +# 1380 +__lc(const _Tp *__first1, const _Tp *__last1, const _Up * +# 1381 +__first2, const _Up *__last2) +# 1382 +{ return __3way(__first1, __last1, __first2, __last2) < 0; } +# 1384 +template< class _Tp, class _Up> static ptrdiff_t +# 1387 +__3way(const _Tp *__first1, const _Tp *__last1, const _Up * +# 1388 +__first2, const _Up *__last2) +# 1389 +{ +# 1390 +const size_t __len1 = __last1 - __first1; +# 1391 +const size_t __len2 = __last2 - __first2; +# 1392 +if (const size_t __len = std::min(__len1, __len2)) { +# 1393 +if (int __result = std::__memcmp(__first1, __first2, __len)) { +# 1394 +return __result; } } +# 1395 +return (ptrdiff_t)(__len1 - __len2); +# 1396 +} +# 1397 +}; +# 1399 +template< class _II1, class _II2> inline bool +# 1402 +__lexicographical_compare_aux1(_II1 __first1, _II1 __last1, _II2 +# 1403 +__first2, _II2 __last2) +# 1404 +{ +# 1405 +typedef typename iterator_traits< _II1> ::value_type _ValueType1; +# 1406 +typedef typename iterator_traits< _II2> ::value_type _ValueType2; +# 1407 +const bool __simple = (__is_memcmp_ordered_with< typename iterator_traits< _II1> ::value_type, typename iterator_traits< _II2> ::value_type> ::__value && __is_pointer< _II1> ::__value && __is_pointer< _II2> ::__value); +# 1420 +return std::template __lexicographical_compare< __simple> ::__lc(__first1, __last1, __first2, __last2); +# 1422 +} +# 1424 +template< class _Tp1, class _Ref1, class _Ptr1, class +# 1425 +_Tp2> bool +# 1424 +__lexicographical_compare_aux1(_Deque_iterator< _Tp1, _Ref1, _Ptr1> , _Deque_iterator< _Tp1, _Ref1, _Ptr1> , _Tp2 *, _Tp2 *); +# 1432 +template< class _Tp1, class +# 1433 +_Tp2, class _Ref2, class _Ptr2> bool +# 1432 +__lexicographical_compare_aux1(_Tp1 *, _Tp1 *, _Deque_iterator< _Tp2, _Ref2, _Ptr2> , _Deque_iterator< _Tp2, _Ref2, _Ptr2> ); +# 1439 +template< class _Tp1, class _Ref1, class _Ptr1, class +# 1440 +_Tp2, class _Ref2, class _Ptr2> bool +# 1439 +__lexicographical_compare_aux1(_Deque_iterator< _Tp1, _Ref1, _Ptr1> , _Deque_iterator< _Tp1, _Ref1, _Ptr1> , _Deque_iterator< _Tp2, _Ref2, _Ptr2> , _Deque_iterator< _Tp2, _Ref2, _Ptr2> ); +# 1448 +template< class _II1, class _II2> inline bool +# 1451 +__lexicographical_compare_aux(_II1 __first1, _II1 __last1, _II2 +# 1452 +__first2, _II2 __last2) +# 1453 +{ +# 1454 +return std::__lexicographical_compare_aux1(std::__niter_base(__first1), std::__niter_base(__last1), std::__niter_base(__first2), std::__niter_base(__last2)); +# 1458 +} +# 1460 +template< class _Iter1, class _Seq1, class _Cat1, class +# 1461 +_II2> bool +# 1460 +__lexicographical_compare_aux(const __gnu_debug::_Safe_iterator< _Iter1, _Seq1, _Cat1> &, const __gnu_debug::_Safe_iterator< _Iter1, _Seq1, _Cat1> &, _II2, _II2); +# 1469 +template< class _II1, class +# 1470 +_Iter2, class _Seq2, class _Cat2> bool +# 1469 +__lexicographical_compare_aux(_II1, _II1, const __gnu_debug::_Safe_iterator< _Iter2, _Seq2, _Cat2> &, const __gnu_debug::_Safe_iterator< _Iter2, _Seq2, _Cat2> &); +# 1478 +template< class _Iter1, class _Seq1, class _Cat1, class +# 1479 +_Iter2, class _Seq2, class _Cat2> bool +# 1478 +__lexicographical_compare_aux(const __gnu_debug::_Safe_iterator< _Iter1, _Seq1, _Cat1> &, const __gnu_debug::_Safe_iterator< _Iter1, _Seq1, _Cat1> &, const __gnu_debug::_Safe_iterator< _Iter2, _Seq2, _Cat2> &, const __gnu_debug::_Safe_iterator< _Iter2, _Seq2, _Cat2> &); +# 1488 +template< class _ForwardIterator, class _Tp, class _Compare> _ForwardIterator +# 1491 +__lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp & +# 1492 +__val, _Compare __comp) +# 1493 +{ +# 1495 +typedef typename iterator_traits< _ForwardIterator> ::difference_type _DistanceType; +# 1497 +_DistanceType __len = std::distance(__first, __last); +# 1499 +while (__len > 0) +# 1500 +{ +# 1501 +_DistanceType __half = __len >> 1; +# 1502 +_ForwardIterator __middle = __first; +# 1503 +std::advance(__middle, __half); +# 1504 +if (__comp(__middle, __val)) +# 1505 +{ +# 1506 +__first = __middle; +# 1507 +++__first; +# 1508 +__len = ((__len - __half) - 1); +# 1509 +} else { +# 1511 +__len = __half; } +# 1512 +} +# 1513 +return __first; +# 1514 +} +# 1527 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _ForwardIterator, class _Tp> +# 1528 +[[__nodiscard__]] inline _ForwardIterator +# 1530 +lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp & +# 1531 +__val) +# 1532 +{ +# 1537 +; +# 1539 +return std::__lower_bound(__first, __last, __val, __gnu_cxx::__ops::__iter_less_val()); +# 1541 +} +# 1545 +template< class _Tp> constexpr _Tp +# 1547 +__lg(_Tp __n) +# 1548 +{ +# 1550 +return std::__bit_width((make_unsigned_t< _Tp> )__n) - 1; +# 1563 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +} +# 1579 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _II1, class _II2> +# 1580 +[[__nodiscard__]] inline bool +# 1582 +equal(_II1 __first1, _II1 __last1, _II2 __first2) +# 1583 +{ +# 1590 +; +# 1592 +return std::__equal_aux(__first1, __last1, __first2); +# 1593 +} +# 1610 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _IIter1, class _IIter2, class _BinaryPredicate> +# 1611 +[[__nodiscard__]] inline bool +# 1613 +equal(_IIter1 __first1, _IIter1 __last1, _IIter2 +# 1614 +__first2, _BinaryPredicate __binary_pred) +# 1615 +{ +# 1619 +; +# 1621 +for (; __first1 != __last1; (++__first1), ((void)(++__first2))) { +# 1622 +if (!((bool)__binary_pred(*__first1, *__first2))) { +# 1623 +return false; } } +# 1624 +return true; +# 1625 +} +# 1628 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++17-extensions" +# 1632 +template< class _II1, class _II2> inline bool +# 1635 +__equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) +# 1636 +{ +# 1637 +using _RATag = random_access_iterator_tag; +# 1638 +using _Cat1 = typename iterator_traits< _II1> ::iterator_category; +# 1639 +using _Cat2 = typename iterator_traits< _II2> ::iterator_category; +# 1640 +using _RAIters = __and_< is_same< typename iterator_traits< _II1> ::iterator_category, random_access_iterator_tag> , is_same< typename iterator_traits< _II2> ::iterator_category, random_access_iterator_tag> > ; +# 1641 +if constexpr (_RAIters::value) +# 1642 +{ +# 1643 +if ((__last1 - __first1) != (__last2 - __first2)) { +# 1644 +return false; } +# 1645 +return std::equal(__first1, __last1, __first2); +# 1646 +} else +# 1648 +{ +# 1649 +for (; (__first1 != __last1) && (__first2 != __last2); (++__first1), ((void)(++__first2))) { +# 1651 +if (!((*__first1) == (*__first2))) { +# 1652 +return false; } } +# 1653 +return (__first1 == __last1) && (__first2 == __last2); +# 1654 +} +# 1655 +} +# 1658 +template< class _II1, class _II2, class _BinaryPredicate> inline bool +# 1661 +__equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, _BinaryPredicate +# 1662 +__binary_pred) +# 1663 +{ +# 1664 +using _RATag = random_access_iterator_tag; +# 1665 +using _Cat1 = typename iterator_traits< _II1> ::iterator_category; +# 1666 +using _Cat2 = typename iterator_traits< _II2> ::iterator_category; +# 1667 +using _RAIters = __and_< is_same< typename iterator_traits< _II1> ::iterator_category, random_access_iterator_tag> , is_same< typename iterator_traits< _II2> ::iterator_category, random_access_iterator_tag> > ; +# 1668 +if constexpr (_RAIters::value) +# 1669 +{ +# 1670 +if ((__last1 - __first1) != (__last2 - __first2)) { +# 1671 +return false; } +# 1672 +return std::equal(__first1, __last1, __first2, __binary_pred); +# 1674 +} else +# 1676 +{ +# 1677 +for (; (__first1 != __last1) && (__first2 != __last2); (++__first1), ((void)(++__first2))) { +# 1679 +if (!((bool)__binary_pred(*__first1, *__first2))) { +# 1680 +return false; } } +# 1681 +return (__first1 == __last1) && (__first2 == __last2); +# 1682 +} +# 1683 +} +#pragma GCC diagnostic pop +# 1701 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _II1, class _II2> +# 1702 +[[__nodiscard__]] inline bool +# 1704 +equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) +# 1705 +{ +# 1712 +; +# 1713 +; +# 1715 +return std::__equal4(__first1, __last1, __first2, __last2); +# 1716 +} +# 1734 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _IIter1, class _IIter2, class _BinaryPredicate> +# 1735 +[[__nodiscard__]] inline bool +# 1737 +equal(_IIter1 __first1, _IIter1 __last1, _IIter2 +# 1738 +__first2, _IIter2 __last2, _BinaryPredicate __binary_pred) +# 1739 +{ +# 1743 +; +# 1744 +; +# 1746 +return std::__equal4(__first1, __last1, __first2, __last2, __binary_pred); +# 1748 +} +# 1766 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _II1, class _II2> +# 1767 +[[__nodiscard__]] inline bool +# 1769 +lexicographical_compare(_II1 __first1, _II1 __last1, _II2 +# 1770 +__first2, _II2 __last2) +# 1771 +{ +# 1781 +; +# 1782 +; +# 1784 +return std::__lexicographical_compare_aux(__first1, __last1, __first2, __last2); +# 1786 +} +# 1801 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _II1, class _II2, class _Compare> +# 1802 +[[__nodiscard__]] inline bool +# 1804 +lexicographical_compare(_II1 __first1, _II1 __last1, _II2 +# 1805 +__first2, _II2 __last2, _Compare __comp) +# 1806 +{ +# 1810 +; +# 1811 +; +# 1813 +return std::__lexicographical_compare_impl(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__comp)); +# 1816 +} +# 1916 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _InputIterator1, class _InputIterator2, class +# 1917 +_BinaryPredicate> pair< _InputIterator1, _InputIterator2> +# 1920 +__mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 +# 1921 +__first2, _BinaryPredicate __binary_pred) +# 1922 +{ +# 1923 +while ((__first1 != __last1) && __binary_pred(__first1, __first2)) +# 1924 +{ +# 1925 +++__first1; +# 1926 +++__first2; +# 1927 +} +# 1928 +return pair< _InputIterator1, _InputIterator2> (__first1, __first2); +# 1929 +} +# 1944 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _InputIterator1, class _InputIterator2> +# 1945 +[[__nodiscard__]] inline pair< _InputIterator1, _InputIterator2> +# 1947 +mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 +# 1948 +__first2) +# 1949 +{ +# 1956 +; +# 1958 +return std::__mismatch(__first1, __last1, __first2, __gnu_cxx::__ops::__iter_equal_to_iter()); +# 1960 +} +# 1978 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _InputIterator1, class _InputIterator2, class +# 1979 +_BinaryPredicate> +# 1980 +[[__nodiscard__]] inline pair< _InputIterator1, _InputIterator2> +# 1982 +mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 +# 1983 +__first2, _BinaryPredicate __binary_pred) +# 1984 +{ +# 1988 +; +# 1990 +return std::__mismatch(__first1, __last1, __first2, __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); +# 1992 +} +# 1995 +template< class _InputIterator1, class _InputIterator2, class +# 1996 +_BinaryPredicate> pair< _InputIterator1, _InputIterator2> +# 1999 +__mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 +# 2000 +__first2, _InputIterator2 __last2, _BinaryPredicate +# 2001 +__binary_pred) +# 2002 +{ +# 2003 +while ((__first1 != __last1) && (__first2 != __last2) && __binary_pred(__first1, __first2)) +# 2005 +{ +# 2006 +++__first1; +# 2007 +++__first2; +# 2008 +} +# 2009 +return pair< _InputIterator1, _InputIterator2> (__first1, __first2); +# 2010 +} +# 2026 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _InputIterator1, class _InputIterator2> +# 2027 +[[__nodiscard__]] inline pair< _InputIterator1, _InputIterator2> +# 2029 +mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 +# 2030 +__first2, _InputIterator2 __last2) +# 2031 +{ +# 2038 +; +# 2039 +; +# 2041 +return std::__mismatch(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_equal_to_iter()); +# 2043 +} +# 2062 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _InputIterator1, class _InputIterator2, class +# 2063 +_BinaryPredicate> +# 2064 +[[__nodiscard__]] inline pair< _InputIterator1, _InputIterator2> +# 2066 +mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 +# 2067 +__first2, _InputIterator2 __last2, _BinaryPredicate +# 2068 +__binary_pred) +# 2069 +{ +# 2073 +; +# 2074 +; +# 2076 +return std::__mismatch(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); +# 2078 +} +# 2084 +template< class _InputIterator, class _Predicate> inline _InputIterator +# 2087 +__find_if(_InputIterator __first, _InputIterator __last, _Predicate +# 2088 +__pred, input_iterator_tag) +# 2089 +{ +# 2090 +while ((__first != __last) && (!__pred(__first))) { +# 2091 +++__first; } +# 2092 +return __first; +# 2093 +} +# 2096 +template< class _RandomAccessIterator, class _Predicate> _RandomAccessIterator +# 2099 +__find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, _Predicate +# 2100 +__pred, random_access_iterator_tag) +# 2101 +{ +# 2103 +typename iterator_traits< _RandomAccessIterator> ::difference_type __trip_count = (__last - __first) >> 2; +# 2105 +for (; __trip_count > 0; --__trip_count) +# 2106 +{ +# 2107 +if (__pred(__first)) { +# 2108 +return __first; } +# 2109 +++__first; +# 2111 +if (__pred(__first)) { +# 2112 +return __first; } +# 2113 +++__first; +# 2115 +if (__pred(__first)) { +# 2116 +return __first; } +# 2117 +++__first; +# 2119 +if (__pred(__first)) { +# 2120 +return __first; } +# 2121 +++__first; +# 2122 +} +# 2124 +switch (__last - __first) +# 2125 +{ +# 2126 +case 3: +# 2127 +if (__pred(__first)) { +# 2128 +return __first; } +# 2129 +++__first; +# 2131 +case 2: +# 2132 +if (__pred(__first)) { +# 2133 +return __first; } +# 2134 +++__first; +# 2136 +case 1: +# 2137 +if (__pred(__first)) { +# 2138 +return __first; } +# 2139 +++__first; +# 2141 +case 0: +# 2142 +default: +# 2143 +return __last; +# 2144 +} +# 2145 +} +# 2147 +template< class _Iterator, class _Predicate> inline _Iterator +# 2150 +__find_if(_Iterator __first, _Iterator __last, _Predicate __pred) +# 2151 +{ +# 2152 +return __find_if(__first, __last, __pred, std::__iterator_category(__first)); +# 2154 +} +# 2156 +template< class _InputIterator, class _Predicate> typename iterator_traits< _InputIterator> ::difference_type +# 2159 +__count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) +# 2160 +{ +# 2161 +typename iterator_traits< _InputIterator> ::difference_type __n = (0); +# 2162 +for (; __first != __last; ++__first) { +# 2163 +if (__pred(__first)) { +# 2164 +++__n; } } +# 2165 +return __n; +# 2166 +} +# 2168 +template< class _ForwardIterator, class _Predicate> _ForwardIterator +# 2171 +__remove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate +# 2172 +__pred) +# 2173 +{ +# 2174 +__first = std::__find_if(__first, __last, __pred); +# 2175 +if (__first == __last) { +# 2176 +return __first; } +# 2177 +_ForwardIterator __result = __first; +# 2178 +++__first; +# 2179 +for (; __first != __last; ++__first) { +# 2180 +if (!__pred(__first)) +# 2181 +{ +# 2182 +(*__result) = std::move(*__first); +# 2183 +++__result; +# 2184 +} } +# 2185 +return __result; +# 2186 +} +# 2188 +template< class _ForwardIterator1, class _ForwardIterator2, class +# 2189 +_BinaryPredicate> _ForwardIterator1 +# 2192 +__search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 +# 2193 +__first2, _ForwardIterator2 __last2, _BinaryPredicate +# 2194 +__predicate) +# 2195 +{ +# 2197 +if ((__first1 == __last1) || (__first2 == __last2)) { +# 2198 +return __first1; } +# 2201 +_ForwardIterator2 __p1(__first2); +# 2202 +if ((++__p1) == __last2) { +# 2203 +return std::__find_if(__first1, __last1, __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); } +# 2207 +_ForwardIterator1 __current = __first1; +# 2209 +for (; ;) +# 2210 +{ +# 2211 +__first1 = std::__find_if(__first1, __last1, __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); +# 2215 +if (__first1 == __last1) { +# 2216 +return __last1; } +# 2218 +_ForwardIterator2 __p = __p1; +# 2219 +__current = __first1; +# 2220 +if ((++__current) == __last1) { +# 2221 +return __last1; } +# 2223 +while (__predicate(__current, __p)) +# 2224 +{ +# 2225 +if ((++__p) == __last2) { +# 2226 +return __first1; } +# 2227 +if ((++__current) == __last1) { +# 2228 +return __last1; } +# 2229 +} +# 2230 +++__first1; +# 2231 +} +# 2232 +return __first1; +# 2233 +} +# 2236 +template< class _ForwardIterator1, class _ForwardIterator2, class +# 2237 +_BinaryPredicate> bool +# 2240 +__is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 +# 2241 +__first2, _BinaryPredicate __pred) +# 2242 +{ +# 2245 +for (; __first1 != __last1; (++__first1), ((void)(++__first2))) { +# 2246 +if (!__pred(__first1, __first2)) { +# 2247 +break; } } +# 2249 +if (__first1 == __last1) { +# 2250 +return true; } +# 2254 +_ForwardIterator2 __last2 = __first2; +# 2255 +std::advance(__last2, std::distance(__first1, __last1)); +# 2256 +for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) +# 2257 +{ +# 2258 +if (__scan != std::__find_if(__first1, __scan, __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) { +# 2260 +continue; } +# 2262 +auto __matches = std::__count_if(__first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); +# 2265 +if ((0 == __matches) || (std::__count_if(__scan, __last1, __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) != __matches)) { +# 2269 +return false; } +# 2270 +} +# 2271 +return true; +# 2272 +} +# 2286 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _ForwardIterator1, class _ForwardIterator2> inline bool +# 2289 +is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 +# 2290 +__first2) +# 2291 +{ +# 2298 +; +# 2300 +return std::__is_permutation(__first1, __last1, __first2, __gnu_cxx::__ops::__iter_equal_to_iter()); +# 2302 +} +# 2328 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_algobase.h" 3 +template< class _ForwardIterator1, class _ForwardIterator2, class +# 2329 +_BinaryPredicate> inline _ForwardIterator1 +# 2332 +search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 +# 2333 +__first2, _ForwardIterator2 __last2, _BinaryPredicate +# 2334 +__predicate) +# 2335 +{ +# 2342 +; +# 2343 +; +# 2345 +return std::__search(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__predicate)); +# 2347 +} +# 2351 +} +# 158 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +namespace std __attribute((__visibility__("default"))) { +# 167 +enum float_round_style { +# 169 +round_indeterminate = (-1), +# 170 +round_toward_zero = 0, +# 171 +round_to_nearest, +# 172 +round_toward_infinity, +# 173 +round_toward_neg_infinity +# 174 +}; +# 182 +enum float_denorm_style { +# 185 +denorm_indeterminate = (-1), +# 187 +denorm_absent = 0, +# 189 +denorm_present +# 190 +}; +# 202 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +struct __numeric_limits_base { +# 206 +static constexpr inline bool is_specialized = false; +# 211 +static constexpr inline int digits = 0; +# 214 +static constexpr inline int digits10 = 0; +# 219 +static constexpr inline int max_digits10 = 0; +# 223 +static constexpr inline bool is_signed = false; +# 226 +static constexpr inline bool is_integer = false; +# 231 +static constexpr inline bool is_exact = false; +# 235 +static constexpr inline int radix = 0; +# 239 +static constexpr inline int min_exponent = 0; +# 243 +static constexpr inline int min_exponent10 = 0; +# 248 +static constexpr inline int max_exponent = 0; +# 252 +static constexpr inline int max_exponent10 = 0; +# 255 +static constexpr inline bool has_infinity = false; +# 259 +static constexpr inline bool has_quiet_NaN = false; +# 263 +static constexpr inline bool has_signaling_NaN = false; +# 266 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 270 +static constexpr inline bool has_denorm_loss = false; +# 274 +static constexpr inline bool is_iec559 = false; +# 279 +static constexpr inline bool is_bounded = false; +# 288 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +static constexpr inline bool is_modulo = false; +# 291 +static constexpr inline bool traps = false; +# 294 +static constexpr inline bool tinyness_before = false; +# 299 +static constexpr inline float_round_style round_style = round_toward_zero; +# 301 +}; +# 311 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +template< class _Tp> +# 312 +struct numeric_limits : public __numeric_limits_base { +# 317 +static constexpr _Tp min() noexcept { return _Tp(); } +# 321 +static constexpr _Tp max() noexcept { return _Tp(); } +# 327 +static constexpr _Tp lowest() noexcept { return _Tp(); } +# 333 +static constexpr _Tp epsilon() noexcept { return _Tp(); } +# 337 +static constexpr _Tp round_error() noexcept { return _Tp(); } +# 341 +static constexpr _Tp infinity() noexcept { return _Tp(); } +# 346 +static constexpr _Tp quiet_NaN() noexcept { return _Tp(); } +# 351 +static constexpr _Tp signaling_NaN() noexcept { return _Tp(); } +# 357 +static constexpr _Tp denorm_min() noexcept { return _Tp(); } +# 358 +}; +# 363 +template< class _Tp> +# 364 +struct numeric_limits< const _Tp> : public std::numeric_limits< _Tp> { +# 365 +}; +# 367 +template< class _Tp> +# 368 +struct numeric_limits< volatile _Tp> : public std::numeric_limits< _Tp> { +# 369 +}; +# 371 +template< class _Tp> +# 372 +struct numeric_limits< const volatile _Tp> : public std::numeric_limits< _Tp> { +# 373 +}; +# 384 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +template<> struct numeric_limits< bool> { +# 386 +static constexpr inline bool is_specialized = true; +# 389 +static constexpr bool min() noexcept { return false; } +# 392 +static constexpr bool max() noexcept { return true; } +# 396 +static constexpr bool lowest() noexcept { return min(); } +# 398 +static constexpr inline int digits = 1; +# 399 +static constexpr inline int digits10 = 0; +# 401 +static constexpr inline int max_digits10 = 0; +# 403 +static constexpr inline bool is_signed = false; +# 404 +static constexpr inline bool is_integer = true; +# 405 +static constexpr inline bool is_exact = true; +# 406 +static constexpr inline int radix = 2; +# 409 +static constexpr bool epsilon() noexcept { return false; } +# 412 +static constexpr bool round_error() noexcept { return false; } +# 414 +static constexpr inline int min_exponent = 0; +# 415 +static constexpr inline int min_exponent10 = 0; +# 416 +static constexpr inline int max_exponent = 0; +# 417 +static constexpr inline int max_exponent10 = 0; +# 419 +static constexpr inline bool has_infinity = false; +# 420 +static constexpr inline bool has_quiet_NaN = false; +# 421 +static constexpr inline bool has_signaling_NaN = false; +# 422 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 424 +static constexpr inline bool has_denorm_loss = false; +# 427 +static constexpr bool infinity() noexcept { return false; } +# 430 +static constexpr bool quiet_NaN() noexcept { return false; } +# 433 +static constexpr bool signaling_NaN() noexcept { return false; } +# 436 +static constexpr bool denorm_min() noexcept { return false; } +# 438 +static constexpr inline bool is_iec559 = false; +# 439 +static constexpr inline bool is_bounded = true; +# 440 +static constexpr inline bool is_modulo = false; +# 445 +static constexpr inline bool traps = true; +# 446 +static constexpr inline bool tinyness_before = false; +# 447 +static constexpr inline float_round_style round_style = round_toward_zero; +# 449 +}; +# 453 +template<> struct numeric_limits< char> { +# 455 +static constexpr inline bool is_specialized = true; +# 458 +static constexpr char min() noexcept { return ((((char)(-1)) < 0) ? (-((((char)(-1)) < 0) ? (((((char)1) << (((sizeof(char) * (8)) - (((char)(-1)) < 0)) - (1))) - 1) << 1) + 1 : (~((char)0)))) - 1 : ((char)0)); } +# 461 +static constexpr char max() noexcept { return ((((char)(-1)) < 0) ? (((((char)1) << (((sizeof(char) * (8)) - (((char)(-1)) < 0)) - (1))) - 1) << 1) + 1 : (~((char)0))); } +# 465 +static constexpr char lowest() noexcept { return min(); } +# 468 +static constexpr inline int digits = ((sizeof(char) * (8)) - (((char)(-1)) < 0)); +# 469 +static constexpr inline int digits10 = ((((sizeof(char) * (8)) - (((char)(-1)) < 0)) * (643L)) / (2136)); +# 471 +static constexpr inline int max_digits10 = 0; +# 473 +static constexpr inline bool is_signed = (((char)(-1)) < 0); +# 474 +static constexpr inline bool is_integer = true; +# 475 +static constexpr inline bool is_exact = true; +# 476 +static constexpr inline int radix = 2; +# 479 +static constexpr char epsilon() noexcept { return 0; } +# 482 +static constexpr char round_error() noexcept { return 0; } +# 484 +static constexpr inline int min_exponent = 0; +# 485 +static constexpr inline int min_exponent10 = 0; +# 486 +static constexpr inline int max_exponent = 0; +# 487 +static constexpr inline int max_exponent10 = 0; +# 489 +static constexpr inline bool has_infinity = false; +# 490 +static constexpr inline bool has_quiet_NaN = false; +# 491 +static constexpr inline bool has_signaling_NaN = false; +# 492 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 494 +static constexpr inline bool has_denorm_loss = false; +# 497 +static constexpr char infinity() noexcept { return ((char)0); } +# 500 +static constexpr char quiet_NaN() noexcept { return ((char)0); } +# 503 +static constexpr char signaling_NaN() noexcept { return ((char)0); } +# 506 +static constexpr char denorm_min() noexcept { return static_cast< char>(0); } +# 508 +static constexpr inline bool is_iec559 = false; +# 509 +static constexpr inline bool is_bounded = true; +# 510 +static constexpr inline bool is_modulo = (!is_signed); +# 512 +static constexpr inline bool traps = true; +# 513 +static constexpr inline bool tinyness_before = false; +# 514 +static constexpr inline float_round_style round_style = round_toward_zero; +# 516 +}; +# 520 +template<> struct numeric_limits< signed char> { +# 522 +static constexpr inline bool is_specialized = true; +# 525 +static constexpr signed char min() noexcept { return (-127) - 1; } +# 528 +static constexpr signed char max() noexcept { return 127; } +# 532 +static constexpr signed char lowest() noexcept { return min(); } +# 535 +static constexpr inline int digits = ((sizeof(signed char) * (8)) - (((signed char)(-1)) < 0)); +# 536 +static constexpr inline int digits10 = ((((sizeof(signed char) * (8)) - (((signed char)(-1)) < 0)) * (643L)) / (2136)); +# 539 +static constexpr inline int max_digits10 = 0; +# 541 +static constexpr inline bool is_signed = true; +# 542 +static constexpr inline bool is_integer = true; +# 543 +static constexpr inline bool is_exact = true; +# 544 +static constexpr inline int radix = 2; +# 547 +static constexpr signed char epsilon() noexcept { return 0; } +# 550 +static constexpr signed char round_error() noexcept { return 0; } +# 552 +static constexpr inline int min_exponent = 0; +# 553 +static constexpr inline int min_exponent10 = 0; +# 554 +static constexpr inline int max_exponent = 0; +# 555 +static constexpr inline int max_exponent10 = 0; +# 557 +static constexpr inline bool has_infinity = false; +# 558 +static constexpr inline bool has_quiet_NaN = false; +# 559 +static constexpr inline bool has_signaling_NaN = false; +# 560 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 562 +static constexpr inline bool has_denorm_loss = false; +# 565 +static constexpr signed char infinity() noexcept { return static_cast< signed char>(0); } +# 568 +static constexpr signed char quiet_NaN() noexcept { return static_cast< signed char>(0); } +# 571 +static constexpr signed char signaling_NaN() noexcept +# 572 +{ return static_cast< signed char>(0); } +# 575 +static constexpr signed char denorm_min() noexcept +# 576 +{ return static_cast< signed char>(0); } +# 578 +static constexpr inline bool is_iec559 = false; +# 579 +static constexpr inline bool is_bounded = true; +# 580 +static constexpr inline bool is_modulo = false; +# 582 +static constexpr inline bool traps = true; +# 583 +static constexpr inline bool tinyness_before = false; +# 584 +static constexpr inline float_round_style round_style = round_toward_zero; +# 586 +}; +# 590 +template<> struct numeric_limits< unsigned char> { +# 592 +static constexpr inline bool is_specialized = true; +# 595 +static constexpr unsigned char min() noexcept { return 0; } +# 598 +static constexpr unsigned char max() noexcept { return ((127) * 2U) + (1); } +# 602 +static constexpr unsigned char lowest() noexcept { return min(); } +# 605 +static constexpr inline int digits = ((sizeof(unsigned char) * (8)) - (((unsigned char)(-1)) < 0)); +# 607 +static constexpr inline int digits10 = ((((sizeof(unsigned char) * (8)) - (((unsigned char)(-1)) < 0)) * (643L)) / (2136)); +# 610 +static constexpr inline int max_digits10 = 0; +# 612 +static constexpr inline bool is_signed = false; +# 613 +static constexpr inline bool is_integer = true; +# 614 +static constexpr inline bool is_exact = true; +# 615 +static constexpr inline int radix = 2; +# 618 +static constexpr unsigned char epsilon() noexcept { return 0; } +# 621 +static constexpr unsigned char round_error() noexcept { return 0; } +# 623 +static constexpr inline int min_exponent = 0; +# 624 +static constexpr inline int min_exponent10 = 0; +# 625 +static constexpr inline int max_exponent = 0; +# 626 +static constexpr inline int max_exponent10 = 0; +# 628 +static constexpr inline bool has_infinity = false; +# 629 +static constexpr inline bool has_quiet_NaN = false; +# 630 +static constexpr inline bool has_signaling_NaN = false; +# 631 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 633 +static constexpr inline bool has_denorm_loss = false; +# 636 +static constexpr unsigned char infinity() noexcept +# 637 +{ return static_cast< unsigned char>(0); } +# 640 +static constexpr unsigned char quiet_NaN() noexcept +# 641 +{ return static_cast< unsigned char>(0); } +# 644 +static constexpr unsigned char signaling_NaN() noexcept +# 645 +{ return static_cast< unsigned char>(0); } +# 648 +static constexpr unsigned char denorm_min() noexcept +# 649 +{ return static_cast< unsigned char>(0); } +# 651 +static constexpr inline bool is_iec559 = false; +# 652 +static constexpr inline bool is_bounded = true; +# 653 +static constexpr inline bool is_modulo = true; +# 655 +static constexpr inline bool traps = true; +# 656 +static constexpr inline bool tinyness_before = false; +# 657 +static constexpr inline float_round_style round_style = round_toward_zero; +# 659 +}; +# 663 +template<> struct numeric_limits< wchar_t> { +# 665 +static constexpr inline bool is_specialized = true; +# 668 +static constexpr wchar_t min() noexcept { return ((((wchar_t)(-1)) < 0) ? (-((((wchar_t)(-1)) < 0) ? (((((wchar_t)1) << (((sizeof(wchar_t) * (8)) - (((wchar_t)(-1)) < 0)) - (1))) - 1) << 1) + 1 : (~((wchar_t)0)))) - 1 : ((wchar_t)0)); } +# 671 +static constexpr wchar_t max() noexcept { return ((((wchar_t)(-1)) < 0) ? (((((wchar_t)1) << (((sizeof(wchar_t) * (8)) - (((wchar_t)(-1)) < 0)) - (1))) - 1) << 1) + 1 : (~((wchar_t)0))); } +# 675 +static constexpr wchar_t lowest() noexcept { return min(); } +# 678 +static constexpr inline int digits = ((sizeof(wchar_t) * (8)) - (((wchar_t)(-1)) < 0)); +# 679 +static constexpr inline int digits10 = ((((sizeof(wchar_t) * (8)) - (((wchar_t)(-1)) < 0)) * (643L)) / (2136)); +# 682 +static constexpr inline int max_digits10 = 0; +# 684 +static constexpr inline bool is_signed = (((wchar_t)(-1)) < 0); +# 685 +static constexpr inline bool is_integer = true; +# 686 +static constexpr inline bool is_exact = true; +# 687 +static constexpr inline int radix = 2; +# 690 +static constexpr wchar_t epsilon() noexcept { return 0; } +# 693 +static constexpr wchar_t round_error() noexcept { return 0; } +# 695 +static constexpr inline int min_exponent = 0; +# 696 +static constexpr inline int min_exponent10 = 0; +# 697 +static constexpr inline int max_exponent = 0; +# 698 +static constexpr inline int max_exponent10 = 0; +# 700 +static constexpr inline bool has_infinity = false; +# 701 +static constexpr inline bool has_quiet_NaN = false; +# 702 +static constexpr inline bool has_signaling_NaN = false; +# 703 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 705 +static constexpr inline bool has_denorm_loss = false; +# 708 +static constexpr wchar_t infinity() noexcept { return ((wchar_t)0); } +# 711 +static constexpr wchar_t quiet_NaN() noexcept { return ((wchar_t)0); } +# 714 +static constexpr wchar_t signaling_NaN() noexcept { return ((wchar_t)0); } +# 717 +static constexpr wchar_t denorm_min() noexcept { return ((wchar_t)0); } +# 719 +static constexpr inline bool is_iec559 = false; +# 720 +static constexpr inline bool is_bounded = true; +# 721 +static constexpr inline bool is_modulo = (!is_signed); +# 723 +static constexpr inline bool traps = true; +# 724 +static constexpr inline bool tinyness_before = false; +# 725 +static constexpr inline float_round_style round_style = round_toward_zero; +# 727 +}; +# 797 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +template<> struct numeric_limits< char16_t> { +# 799 +static constexpr inline bool is_specialized = true; +# 802 +static constexpr char16_t min() noexcept { return ((((char16_t)(-1)) < 0) ? (-((((char16_t)(-1)) < 0) ? (((((char16_t)1) << (((sizeof(char16_t) * (8)) - (((char16_t)(-1)) < 0)) - (1))) - 1) << 1) + 1 : (~((char16_t)0)))) - 1 : ((char16_t)0)); } +# 805 +static constexpr char16_t max() noexcept { return ((((char16_t)(-1)) < 0) ? (((((char16_t)1) << (((sizeof(char16_t) * (8)) - (((char16_t)(-1)) < 0)) - (1))) - 1) << 1) + 1 : (~((char16_t)0))); } +# 808 +static constexpr char16_t lowest() noexcept { return min(); } +# 810 +static constexpr inline int digits = ((sizeof(char16_t) * (8)) - (((char16_t)(-1)) < 0)); +# 811 +static constexpr inline int digits10 = ((((sizeof(char16_t) * (8)) - (((char16_t)(-1)) < 0)) * (643L)) / (2136)); +# 812 +static constexpr inline int max_digits10 = 0; +# 813 +static constexpr inline bool is_signed = (((char16_t)(-1)) < 0); +# 814 +static constexpr inline bool is_integer = true; +# 815 +static constexpr inline bool is_exact = true; +# 816 +static constexpr inline int radix = 2; +# 819 +static constexpr char16_t epsilon() noexcept { return 0; } +# 822 +static constexpr char16_t round_error() noexcept { return 0; } +# 824 +static constexpr inline int min_exponent = 0; +# 825 +static constexpr inline int min_exponent10 = 0; +# 826 +static constexpr inline int max_exponent = 0; +# 827 +static constexpr inline int max_exponent10 = 0; +# 829 +static constexpr inline bool has_infinity = false; +# 830 +static constexpr inline bool has_quiet_NaN = false; +# 831 +static constexpr inline bool has_signaling_NaN = false; +# 832 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 833 +static constexpr inline bool has_denorm_loss = false; +# 836 +static constexpr char16_t infinity() noexcept { return ((char16_t)0); } +# 839 +static constexpr char16_t quiet_NaN() noexcept { return ((char16_t)0); } +# 842 +static constexpr char16_t signaling_NaN() noexcept { return ((char16_t)0); } +# 845 +static constexpr char16_t denorm_min() noexcept { return ((char16_t)0); } +# 847 +static constexpr inline bool is_iec559 = false; +# 848 +static constexpr inline bool is_bounded = true; +# 849 +static constexpr inline bool is_modulo = (!is_signed); +# 851 +static constexpr inline bool traps = true; +# 852 +static constexpr inline bool tinyness_before = false; +# 853 +static constexpr inline float_round_style round_style = round_toward_zero; +# 854 +}; +# 858 +template<> struct numeric_limits< char32_t> { +# 860 +static constexpr inline bool is_specialized = true; +# 863 +static constexpr char32_t min() noexcept { return ((((char32_t)(-1)) < (0)) ? (-((((char32_t)(-1)) < (0)) ? (((((char32_t)1) << (((sizeof(char32_t) * (8)) - (((char32_t)(-1)) < (0))) - (1))) - (1)) << 1) + (1) : (~((char32_t)0)))) - (1) : ((char32_t)0)); } +# 866 +static constexpr char32_t max() noexcept { return ((((char32_t)(-1)) < (0)) ? (((((char32_t)1) << (((sizeof(char32_t) * (8)) - (((char32_t)(-1)) < (0))) - (1))) - (1)) << 1) + (1) : (~((char32_t)0))); } +# 869 +static constexpr char32_t lowest() noexcept { return min(); } +# 871 +static constexpr inline int digits = ((sizeof(char32_t) * (8)) - (((char32_t)(-1)) < (0))); +# 872 +static constexpr inline int digits10 = ((((sizeof(char32_t) * (8)) - (((char32_t)(-1)) < (0))) * (643L)) / (2136)); +# 873 +static constexpr inline int max_digits10 = 0; +# 874 +static constexpr inline bool is_signed = (((char32_t)(-1)) < (0)); +# 875 +static constexpr inline bool is_integer = true; +# 876 +static constexpr inline bool is_exact = true; +# 877 +static constexpr inline int radix = 2; +# 880 +static constexpr char32_t epsilon() noexcept { return 0; } +# 883 +static constexpr char32_t round_error() noexcept { return 0; } +# 885 +static constexpr inline int min_exponent = 0; +# 886 +static constexpr inline int min_exponent10 = 0; +# 887 +static constexpr inline int max_exponent = 0; +# 888 +static constexpr inline int max_exponent10 = 0; +# 890 +static constexpr inline bool has_infinity = false; +# 891 +static constexpr inline bool has_quiet_NaN = false; +# 892 +static constexpr inline bool has_signaling_NaN = false; +# 893 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 894 +static constexpr inline bool has_denorm_loss = false; +# 897 +static constexpr char32_t infinity() noexcept { return ((char32_t)0); } +# 900 +static constexpr char32_t quiet_NaN() noexcept { return ((char32_t)0); } +# 903 +static constexpr char32_t signaling_NaN() noexcept { return ((char32_t)0); } +# 906 +static constexpr char32_t denorm_min() noexcept { return ((char32_t)0); } +# 908 +static constexpr inline bool is_iec559 = false; +# 909 +static constexpr inline bool is_bounded = true; +# 910 +static constexpr inline bool is_modulo = (!is_signed); +# 912 +static constexpr inline bool traps = true; +# 913 +static constexpr inline bool tinyness_before = false; +# 914 +static constexpr inline float_round_style round_style = round_toward_zero; +# 915 +}; +# 920 +template<> struct numeric_limits< short> { +# 922 +static constexpr inline bool is_specialized = true; +# 925 +static constexpr short min() noexcept { return (-32767) - 1; } +# 928 +static constexpr short max() noexcept { return 32767; } +# 932 +static constexpr short lowest() noexcept { return min(); } +# 935 +static constexpr inline int digits = ((sizeof(short) * (8)) - (((short)(-1)) < 0)); +# 936 +static constexpr inline int digits10 = ((((sizeof(short) * (8)) - (((short)(-1)) < 0)) * (643L)) / (2136)); +# 938 +static constexpr inline int max_digits10 = 0; +# 940 +static constexpr inline bool is_signed = true; +# 941 +static constexpr inline bool is_integer = true; +# 942 +static constexpr inline bool is_exact = true; +# 943 +static constexpr inline int radix = 2; +# 946 +static constexpr short epsilon() noexcept { return 0; } +# 949 +static constexpr short round_error() noexcept { return 0; } +# 951 +static constexpr inline int min_exponent = 0; +# 952 +static constexpr inline int min_exponent10 = 0; +# 953 +static constexpr inline int max_exponent = 0; +# 954 +static constexpr inline int max_exponent10 = 0; +# 956 +static constexpr inline bool has_infinity = false; +# 957 +static constexpr inline bool has_quiet_NaN = false; +# 958 +static constexpr inline bool has_signaling_NaN = false; +# 959 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 961 +static constexpr inline bool has_denorm_loss = false; +# 964 +static constexpr short infinity() noexcept { return ((short)0); } +# 967 +static constexpr short quiet_NaN() noexcept { return ((short)0); } +# 970 +static constexpr short signaling_NaN() noexcept { return ((short)0); } +# 973 +static constexpr short denorm_min() noexcept { return ((short)0); } +# 975 +static constexpr inline bool is_iec559 = false; +# 976 +static constexpr inline bool is_bounded = true; +# 977 +static constexpr inline bool is_modulo = false; +# 979 +static constexpr inline bool traps = true; +# 980 +static constexpr inline bool tinyness_before = false; +# 981 +static constexpr inline float_round_style round_style = round_toward_zero; +# 983 +}; +# 987 +template<> struct numeric_limits< unsigned short> { +# 989 +static constexpr inline bool is_specialized = true; +# 992 +static constexpr unsigned short min() noexcept { return 0; } +# 995 +static constexpr unsigned short max() noexcept { return ((32767) * 2U) + (1); } +# 999 +static constexpr unsigned short lowest() noexcept { return min(); } +# 1002 +static constexpr inline int digits = ((sizeof(unsigned short) * (8)) - (((unsigned short)(-1)) < 0)); +# 1004 +static constexpr inline int digits10 = ((((sizeof(unsigned short) * (8)) - (((unsigned short)(-1)) < 0)) * (643L)) / (2136)); +# 1007 +static constexpr inline int max_digits10 = 0; +# 1009 +static constexpr inline bool is_signed = false; +# 1010 +static constexpr inline bool is_integer = true; +# 1011 +static constexpr inline bool is_exact = true; +# 1012 +static constexpr inline int radix = 2; +# 1015 +static constexpr unsigned short epsilon() noexcept { return 0; } +# 1018 +static constexpr unsigned short round_error() noexcept { return 0; } +# 1020 +static constexpr inline int min_exponent = 0; +# 1021 +static constexpr inline int min_exponent10 = 0; +# 1022 +static constexpr inline int max_exponent = 0; +# 1023 +static constexpr inline int max_exponent10 = 0; +# 1025 +static constexpr inline bool has_infinity = false; +# 1026 +static constexpr inline bool has_quiet_NaN = false; +# 1027 +static constexpr inline bool has_signaling_NaN = false; +# 1028 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 1030 +static constexpr inline bool has_denorm_loss = false; +# 1033 +static constexpr unsigned short infinity() noexcept +# 1034 +{ return static_cast< unsigned short>(0); } +# 1037 +static constexpr unsigned short quiet_NaN() noexcept +# 1038 +{ return static_cast< unsigned short>(0); } +# 1041 +static constexpr unsigned short signaling_NaN() noexcept +# 1042 +{ return static_cast< unsigned short>(0); } +# 1045 +static constexpr unsigned short denorm_min() noexcept +# 1046 +{ return static_cast< unsigned short>(0); } +# 1048 +static constexpr inline bool is_iec559 = false; +# 1049 +static constexpr inline bool is_bounded = true; +# 1050 +static constexpr inline bool is_modulo = true; +# 1052 +static constexpr inline bool traps = true; +# 1053 +static constexpr inline bool tinyness_before = false; +# 1054 +static constexpr inline float_round_style round_style = round_toward_zero; +# 1056 +}; +# 1060 +template<> struct numeric_limits< int> { +# 1062 +static constexpr inline bool is_specialized = true; +# 1065 +static constexpr int min() noexcept { return (-2147483647) - 1; } +# 1068 +static constexpr int max() noexcept { return 2147483647; } +# 1072 +static constexpr int lowest() noexcept { return min(); } +# 1075 +static constexpr inline int digits = ((sizeof(int) * (8)) - (((int)(-1)) < 0)); +# 1076 +static constexpr inline int digits10 = ((((sizeof(int) * (8)) - (((int)(-1)) < 0)) * (643L)) / (2136)); +# 1078 +static constexpr inline int max_digits10 = 0; +# 1080 +static constexpr inline bool is_signed = true; +# 1081 +static constexpr inline bool is_integer = true; +# 1082 +static constexpr inline bool is_exact = true; +# 1083 +static constexpr inline int radix = 2; +# 1086 +static constexpr int epsilon() noexcept { return 0; } +# 1089 +static constexpr int round_error() noexcept { return 0; } +# 1091 +static constexpr inline int min_exponent = 0; +# 1092 +static constexpr inline int min_exponent10 = 0; +# 1093 +static constexpr inline int max_exponent = 0; +# 1094 +static constexpr inline int max_exponent10 = 0; +# 1096 +static constexpr inline bool has_infinity = false; +# 1097 +static constexpr inline bool has_quiet_NaN = false; +# 1098 +static constexpr inline bool has_signaling_NaN = false; +# 1099 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 1101 +static constexpr inline bool has_denorm_loss = false; +# 1104 +static constexpr int infinity() noexcept { return static_cast< int>(0); } +# 1107 +static constexpr int quiet_NaN() noexcept { return static_cast< int>(0); } +# 1110 +static constexpr int signaling_NaN() noexcept { return static_cast< int>(0); } +# 1113 +static constexpr int denorm_min() noexcept { return static_cast< int>(0); } +# 1115 +static constexpr inline bool is_iec559 = false; +# 1116 +static constexpr inline bool is_bounded = true; +# 1117 +static constexpr inline bool is_modulo = false; +# 1119 +static constexpr inline bool traps = true; +# 1120 +static constexpr inline bool tinyness_before = false; +# 1121 +static constexpr inline float_round_style round_style = round_toward_zero; +# 1123 +}; +# 1127 +template<> struct numeric_limits< unsigned> { +# 1129 +static constexpr inline bool is_specialized = true; +# 1132 +static constexpr unsigned min() noexcept { return 0; } +# 1135 +static constexpr unsigned max() noexcept { return ((2147483647) * 2U) + (1); } +# 1139 +static constexpr unsigned lowest() noexcept { return min(); } +# 1142 +static constexpr inline int digits = ((sizeof(unsigned) * (8)) - (((unsigned)(-1)) < (0))); +# 1144 +static constexpr inline int digits10 = ((((sizeof(unsigned) * (8)) - (((unsigned)(-1)) < (0))) * (643L)) / (2136)); +# 1147 +static constexpr inline int max_digits10 = 0; +# 1149 +static constexpr inline bool is_signed = false; +# 1150 +static constexpr inline bool is_integer = true; +# 1151 +static constexpr inline bool is_exact = true; +# 1152 +static constexpr inline int radix = 2; +# 1155 +static constexpr unsigned epsilon() noexcept { return 0; } +# 1158 +static constexpr unsigned round_error() noexcept { return 0; } +# 1160 +static constexpr inline int min_exponent = 0; +# 1161 +static constexpr inline int min_exponent10 = 0; +# 1162 +static constexpr inline int max_exponent = 0; +# 1163 +static constexpr inline int max_exponent10 = 0; +# 1165 +static constexpr inline bool has_infinity = false; +# 1166 +static constexpr inline bool has_quiet_NaN = false; +# 1167 +static constexpr inline bool has_signaling_NaN = false; +# 1168 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 1170 +static constexpr inline bool has_denorm_loss = false; +# 1173 +static constexpr unsigned infinity() noexcept { return static_cast< unsigned>(0); } +# 1176 +static constexpr unsigned quiet_NaN() noexcept +# 1177 +{ return static_cast< unsigned>(0); } +# 1180 +static constexpr unsigned signaling_NaN() noexcept +# 1181 +{ return static_cast< unsigned>(0); } +# 1184 +static constexpr unsigned denorm_min() noexcept +# 1185 +{ return static_cast< unsigned>(0); } +# 1187 +static constexpr inline bool is_iec559 = false; +# 1188 +static constexpr inline bool is_bounded = true; +# 1189 +static constexpr inline bool is_modulo = true; +# 1191 +static constexpr inline bool traps = true; +# 1192 +static constexpr inline bool tinyness_before = false; +# 1193 +static constexpr inline float_round_style round_style = round_toward_zero; +# 1195 +}; +# 1199 +template<> struct numeric_limits< long> { +# 1201 +static constexpr inline bool is_specialized = true; +# 1204 +static constexpr long min() noexcept { return (-9223372036854775807L) - (1); } +# 1207 +static constexpr long max() noexcept { return 9223372036854775807L; } +# 1211 +static constexpr long lowest() noexcept { return min(); } +# 1214 +static constexpr inline int digits = ((sizeof(long) * (8)) - (((long)(-1)) < (0))); +# 1215 +static constexpr inline int digits10 = ((((sizeof(long) * (8)) - (((long)(-1)) < (0))) * (643L)) / (2136)); +# 1217 +static constexpr inline int max_digits10 = 0; +# 1219 +static constexpr inline bool is_signed = true; +# 1220 +static constexpr inline bool is_integer = true; +# 1221 +static constexpr inline bool is_exact = true; +# 1222 +static constexpr inline int radix = 2; +# 1225 +static constexpr long epsilon() noexcept { return 0; } +# 1228 +static constexpr long round_error() noexcept { return 0; } +# 1230 +static constexpr inline int min_exponent = 0; +# 1231 +static constexpr inline int min_exponent10 = 0; +# 1232 +static constexpr inline int max_exponent = 0; +# 1233 +static constexpr inline int max_exponent10 = 0; +# 1235 +static constexpr inline bool has_infinity = false; +# 1236 +static constexpr inline bool has_quiet_NaN = false; +# 1237 +static constexpr inline bool has_signaling_NaN = false; +# 1238 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 1240 +static constexpr inline bool has_denorm_loss = false; +# 1243 +static constexpr long infinity() noexcept { return static_cast< long>(0); } +# 1246 +static constexpr long quiet_NaN() noexcept { return static_cast< long>(0); } +# 1249 +static constexpr long signaling_NaN() noexcept { return static_cast< long>(0); } +# 1252 +static constexpr long denorm_min() noexcept { return static_cast< long>(0); } +# 1254 +static constexpr inline bool is_iec559 = false; +# 1255 +static constexpr inline bool is_bounded = true; +# 1256 +static constexpr inline bool is_modulo = false; +# 1258 +static constexpr inline bool traps = true; +# 1259 +static constexpr inline bool tinyness_before = false; +# 1260 +static constexpr inline float_round_style round_style = round_toward_zero; +# 1262 +}; +# 1266 +template<> struct numeric_limits< unsigned long> { +# 1268 +static constexpr inline bool is_specialized = true; +# 1271 +static constexpr unsigned long min() noexcept { return 0; } +# 1274 +static constexpr unsigned long max() noexcept { return ((9223372036854775807L) * 2UL) + (1); } +# 1278 +static constexpr unsigned long lowest() noexcept { return min(); } +# 1281 +static constexpr inline int digits = ((sizeof(unsigned long) * (8)) - (((unsigned long)(-1)) < (0))); +# 1283 +static constexpr inline int digits10 = ((((sizeof(unsigned long) * (8)) - (((unsigned long)(-1)) < (0))) * (643L)) / (2136)); +# 1286 +static constexpr inline int max_digits10 = 0; +# 1288 +static constexpr inline bool is_signed = false; +# 1289 +static constexpr inline bool is_integer = true; +# 1290 +static constexpr inline bool is_exact = true; +# 1291 +static constexpr inline int radix = 2; +# 1294 +static constexpr unsigned long epsilon() noexcept { return 0; } +# 1297 +static constexpr unsigned long round_error() noexcept { return 0; } +# 1299 +static constexpr inline int min_exponent = 0; +# 1300 +static constexpr inline int min_exponent10 = 0; +# 1301 +static constexpr inline int max_exponent = 0; +# 1302 +static constexpr inline int max_exponent10 = 0; +# 1304 +static constexpr inline bool has_infinity = false; +# 1305 +static constexpr inline bool has_quiet_NaN = false; +# 1306 +static constexpr inline bool has_signaling_NaN = false; +# 1307 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 1309 +static constexpr inline bool has_denorm_loss = false; +# 1312 +static constexpr unsigned long infinity() noexcept +# 1313 +{ return static_cast< unsigned long>(0); } +# 1316 +static constexpr unsigned long quiet_NaN() noexcept +# 1317 +{ return static_cast< unsigned long>(0); } +# 1320 +static constexpr unsigned long signaling_NaN() noexcept +# 1321 +{ return static_cast< unsigned long>(0); } +# 1324 +static constexpr unsigned long denorm_min() noexcept +# 1325 +{ return static_cast< unsigned long>(0); } +# 1327 +static constexpr inline bool is_iec559 = false; +# 1328 +static constexpr inline bool is_bounded = true; +# 1329 +static constexpr inline bool is_modulo = true; +# 1331 +static constexpr inline bool traps = true; +# 1332 +static constexpr inline bool tinyness_before = false; +# 1333 +static constexpr inline float_round_style round_style = round_toward_zero; +# 1335 +}; +# 1339 +template<> struct numeric_limits< long long> { +# 1341 +static constexpr inline bool is_specialized = true; +# 1344 +static constexpr long long min() noexcept { return (-9223372036854775807LL) - (1); } +# 1347 +static constexpr long long max() noexcept { return 9223372036854775807LL; } +# 1351 +static constexpr long long lowest() noexcept { return min(); } +# 1354 +static constexpr inline int digits = ((sizeof(long long) * (8)) - (((long long)(-1)) < (0))); +# 1356 +static constexpr inline int digits10 = ((((sizeof(long long) * (8)) - (((long long)(-1)) < (0))) * (643L)) / (2136)); +# 1359 +static constexpr inline int max_digits10 = 0; +# 1361 +static constexpr inline bool is_signed = true; +# 1362 +static constexpr inline bool is_integer = true; +# 1363 +static constexpr inline bool is_exact = true; +# 1364 +static constexpr inline int radix = 2; +# 1367 +static constexpr long long epsilon() noexcept { return 0; } +# 1370 +static constexpr long long round_error() noexcept { return 0; } +# 1372 +static constexpr inline int min_exponent = 0; +# 1373 +static constexpr inline int min_exponent10 = 0; +# 1374 +static constexpr inline int max_exponent = 0; +# 1375 +static constexpr inline int max_exponent10 = 0; +# 1377 +static constexpr inline bool has_infinity = false; +# 1378 +static constexpr inline bool has_quiet_NaN = false; +# 1379 +static constexpr inline bool has_signaling_NaN = false; +# 1380 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 1382 +static constexpr inline bool has_denorm_loss = false; +# 1385 +static constexpr long long infinity() noexcept { return static_cast< long long>(0); } +# 1388 +static constexpr long long quiet_NaN() noexcept { return static_cast< long long>(0); } +# 1391 +static constexpr long long signaling_NaN() noexcept +# 1392 +{ return static_cast< long long>(0); } +# 1395 +static constexpr long long denorm_min() noexcept { return static_cast< long long>(0); } +# 1397 +static constexpr inline bool is_iec559 = false; +# 1398 +static constexpr inline bool is_bounded = true; +# 1399 +static constexpr inline bool is_modulo = false; +# 1401 +static constexpr inline bool traps = true; +# 1402 +static constexpr inline bool tinyness_before = false; +# 1403 +static constexpr inline float_round_style round_style = round_toward_zero; +# 1405 +}; +# 1409 +template<> struct numeric_limits< unsigned long long> { +# 1411 +static constexpr inline bool is_specialized = true; +# 1414 +static constexpr unsigned long long min() noexcept { return 0; } +# 1417 +static constexpr unsigned long long max() noexcept { return ((9223372036854775807LL) * 2ULL) + (1); } +# 1421 +static constexpr unsigned long long lowest() noexcept { return min(); } +# 1424 +static constexpr inline int digits = ((sizeof(unsigned long long) * (8)) - (((unsigned long long)(-1)) < (0))); +# 1426 +static constexpr inline int digits10 = ((((sizeof(unsigned long long) * (8)) - (((unsigned long long)(-1)) < (0))) * (643L)) / (2136)); +# 1429 +static constexpr inline int max_digits10 = 0; +# 1431 +static constexpr inline bool is_signed = false; +# 1432 +static constexpr inline bool is_integer = true; +# 1433 +static constexpr inline bool is_exact = true; +# 1434 +static constexpr inline int radix = 2; +# 1437 +static constexpr unsigned long long epsilon() noexcept { return 0; } +# 1440 +static constexpr unsigned long long round_error() noexcept { return 0; } +# 1442 +static constexpr inline int min_exponent = 0; +# 1443 +static constexpr inline int min_exponent10 = 0; +# 1444 +static constexpr inline int max_exponent = 0; +# 1445 +static constexpr inline int max_exponent10 = 0; +# 1447 +static constexpr inline bool has_infinity = false; +# 1448 +static constexpr inline bool has_quiet_NaN = false; +# 1449 +static constexpr inline bool has_signaling_NaN = false; +# 1450 +static constexpr inline float_denorm_style has_denorm = denorm_absent; +# 1452 +static constexpr inline bool has_denorm_loss = false; +# 1455 +static constexpr unsigned long long infinity() noexcept +# 1456 +{ return static_cast< unsigned long long>(0); } +# 1459 +static constexpr unsigned long long quiet_NaN() noexcept +# 1460 +{ return static_cast< unsigned long long>(0); } +# 1463 +static constexpr unsigned long long signaling_NaN() noexcept +# 1464 +{ return static_cast< unsigned long long>(0); } +# 1467 +static constexpr unsigned long long denorm_min() noexcept +# 1468 +{ return static_cast< unsigned long long>(0); } +# 1470 +static constexpr inline bool is_iec559 = false; +# 1471 +static constexpr inline bool is_bounded = true; +# 1472 +static constexpr inline bool is_modulo = true; +# 1474 +static constexpr inline bool traps = true; +# 1475 +static constexpr inline bool tinyness_before = false; +# 1476 +static constexpr inline float_round_style round_style = round_toward_zero; +# 1478 +}; +# 1637 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +template<> struct numeric_limits< __int128> { static constexpr inline bool is_specialized = true; static constexpr __int128 min() noexcept { return ((((__int128)(-1)) < (0)) ? (-((((__int128)(-1)) < (0)) ? (((((__int128)1) << ((128 - (((__int128)(-1)) < (0))) - 1)) - (1)) << 1) + (1) : (~((__int128)0)))) - (1) : ((__int128)0)); } static constexpr __int128 max() noexcept { return ((((__int128)(-1)) < (0)) ? (((((__int128)1) << ((128 - (((__int128)(-1)) < (0))) - 1)) - (1)) << 1) + (1) : (~((__int128)0))); } static constexpr inline int digits = (128 - 1); static constexpr inline int digits10 = (((128 - 1) * 643L) / (2136)); static constexpr inline bool is_signed = true; static constexpr inline bool is_integer = true; static constexpr inline bool is_exact = true; static constexpr inline int radix = 2; static constexpr __int128 epsilon() noexcept { return 0; } static constexpr __int128 round_error() noexcept { return 0; } static constexpr __int128 lowest() noexcept { return min(); } static constexpr inline int max_digits10 = 0; static constexpr inline int min_exponent = 0; static constexpr inline int min_exponent10 = 0; static constexpr inline int max_exponent = 0; static constexpr inline int max_exponent10 = 0; static constexpr inline bool has_infinity = false; static constexpr inline bool has_quiet_NaN = false; static constexpr inline bool has_signaling_NaN = false; static constexpr inline float_denorm_style has_denorm = denorm_absent; static constexpr inline bool has_denorm_loss = false; static constexpr __int128 infinity() noexcept { return static_cast< __int128>(0); } static constexpr __int128 quiet_NaN() noexcept { return static_cast< __int128>(0); } static constexpr __int128 signaling_NaN() noexcept { return static_cast< __int128>(0); } static constexpr __int128 denorm_min() noexcept { return static_cast< __int128>(0); } static constexpr inline bool is_iec559 = false; static constexpr inline bool is_bounded = true; static constexpr inline bool is_modulo = false; static constexpr inline bool traps = true; static constexpr inline bool tinyness_before = false; static constexpr inline float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits< unsigned __int128> { static constexpr inline bool is_specialized = true; static constexpr unsigned __int128 min() noexcept { return 0; } static constexpr unsigned __int128 max() noexcept { return ((((unsigned __int128)(-1)) < (0)) ? (((((unsigned __int128)1) << ((128 - (((unsigned __int128)(-1)) < (0))) - 1)) - (1)) << 1) + (1) : (~((unsigned __int128)0))); } static constexpr unsigned __int128 lowest() noexcept { return min(); } static constexpr inline int max_digits10 = 0; static constexpr inline int digits = 128; static constexpr inline int digits10 = (((128) * 643L) / (2136)); static constexpr inline bool is_signed = false; static constexpr inline bool is_integer = true; static constexpr inline bool is_exact = true; static constexpr inline int radix = 2; static constexpr unsigned __int128 epsilon() noexcept { return 0; } static constexpr unsigned __int128 round_error() noexcept { return 0; } static constexpr inline int min_exponent = 0; static constexpr inline int min_exponent10 = 0; static constexpr inline int max_exponent = 0; static constexpr inline int max_exponent10 = 0; static constexpr inline bool has_infinity = false; static constexpr inline bool has_quiet_NaN = false; static constexpr inline bool has_signaling_NaN = false; static constexpr inline float_denorm_style has_denorm = denorm_absent; static constexpr inline bool has_denorm_loss = false; static constexpr unsigned __int128 infinity() noexcept { return static_cast< unsigned __int128>(0); } static constexpr unsigned __int128 quiet_NaN() noexcept { return static_cast< unsigned __int128>(0); } static constexpr unsigned __int128 signaling_NaN() noexcept { return static_cast< unsigned __int128>(0); } static constexpr unsigned __int128 denorm_min() noexcept { return static_cast< unsigned __int128>(0); } static constexpr inline bool is_iec559 = false; static constexpr inline bool is_bounded = true; static constexpr inline bool is_modulo = true; static constexpr inline bool traps = true; static constexpr inline bool tinyness_before = false; static constexpr inline float_round_style round_style = round_toward_zero; }; +# 1670 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +template<> struct numeric_limits< float> { +# 1672 +static constexpr inline bool is_specialized = true; +# 1675 +static constexpr float min() noexcept { return (1.1754944E-38F); } +# 1678 +static constexpr float max() noexcept { return (3.4028235E38F); } +# 1682 +static constexpr float lowest() noexcept { return -(3.4028235E38F); } +# 1685 +static constexpr inline int digits = 24; +# 1686 +static constexpr inline int digits10 = 6; +# 1688 +static constexpr inline int max_digits10 = ((2) + (((24) * 643L) / (2136))); +# 1691 +static constexpr inline bool is_signed = true; +# 1692 +static constexpr inline bool is_integer = false; +# 1693 +static constexpr inline bool is_exact = false; +# 1694 +static constexpr inline int radix = 2; +# 1697 +static constexpr float epsilon() noexcept { return (1.1920929E-7F); } +# 1700 +static constexpr float round_error() noexcept { return (0.5F); } +# 1702 +static constexpr inline int min_exponent = (-125); +# 1703 +static constexpr inline int min_exponent10 = (-37); +# 1704 +static constexpr inline int max_exponent = 128; +# 1705 +static constexpr inline int max_exponent10 = 38; +# 1707 +static constexpr inline bool has_infinity = (1); +# 1708 +static constexpr inline bool has_quiet_NaN = (1); +# 1709 +static constexpr inline bool has_signaling_NaN = has_quiet_NaN; +# 1710 +static constexpr inline float_denorm_style has_denorm = (((bool)1) ? denorm_present : denorm_absent); +# 1712 +static constexpr inline bool has_denorm_loss = false; +# 1716 +static constexpr float infinity() noexcept { return __builtin_huge_valf(); } +# 1719 +static constexpr float quiet_NaN() noexcept { return __builtin_nanf(""); } +# 1722 +static constexpr float signaling_NaN() noexcept { return __builtin_nansf(""); } +# 1725 +static constexpr float denorm_min() noexcept { return (1.4E-45F); } +# 1727 +static constexpr inline bool is_iec559 = (has_infinity && has_quiet_NaN && (has_denorm == (denorm_present))); +# 1729 +static constexpr inline bool is_bounded = true; +# 1730 +static constexpr inline bool is_modulo = false; +# 1732 +static constexpr inline bool traps = false; +# 1733 +static constexpr inline bool tinyness_before = false; +# 1735 +static constexpr inline float_round_style round_style = round_to_nearest; +# 1737 +}; +# 1745 +template<> struct numeric_limits< double> { +# 1747 +static constexpr inline bool is_specialized = true; +# 1750 +static constexpr double min() noexcept { return (double)(2.2250738585072013831E-308L); } +# 1753 +static constexpr double max() noexcept { return (double)(1.7976931348623157081E308L); } +# 1757 +static constexpr double lowest() noexcept { return -((double)(1.7976931348623157081E308L)); } +# 1760 +static constexpr inline int digits = 53; +# 1761 +static constexpr inline int digits10 = 15; +# 1763 +static constexpr inline int max_digits10 = ((2) + (((53) * 643L) / (2136))); +# 1766 +static constexpr inline bool is_signed = true; +# 1767 +static constexpr inline bool is_integer = false; +# 1768 +static constexpr inline bool is_exact = false; +# 1769 +static constexpr inline int radix = 2; +# 1772 +static constexpr double epsilon() noexcept { return (double)(2.2204460492503130808E-16L); } +# 1775 +static constexpr double round_error() noexcept { return (0.5); } +# 1777 +static constexpr inline int min_exponent = (-1021); +# 1778 +static constexpr inline int min_exponent10 = (-307); +# 1779 +static constexpr inline int max_exponent = 1024; +# 1780 +static constexpr inline int max_exponent10 = 308; +# 1782 +static constexpr inline bool has_infinity = (1); +# 1783 +static constexpr inline bool has_quiet_NaN = (1); +# 1784 +static constexpr inline bool has_signaling_NaN = has_quiet_NaN; +# 1785 +static constexpr inline float_denorm_style has_denorm = (((bool)1) ? denorm_present : denorm_absent); +# 1787 +static constexpr inline bool has_denorm_loss = false; +# 1791 +static constexpr double infinity() noexcept { return __builtin_huge_val(); } +# 1794 +static constexpr double quiet_NaN() noexcept { return __builtin_nan(""); } +# 1797 +static constexpr double signaling_NaN() noexcept { return __builtin_nans(""); } +# 1800 +static constexpr double denorm_min() noexcept { return (double)(4.940656458412465442E-324L); } +# 1802 +static constexpr inline bool is_iec559 = (has_infinity && has_quiet_NaN && (has_denorm == (denorm_present))); +# 1804 +static constexpr inline bool is_bounded = true; +# 1805 +static constexpr inline bool is_modulo = false; +# 1807 +static constexpr inline bool traps = false; +# 1808 +static constexpr inline bool tinyness_before = false; +# 1810 +static constexpr inline float_round_style round_style = round_to_nearest; +# 1812 +}; +# 1820 +template<> struct numeric_limits< long double> { +# 1822 +static constexpr inline bool is_specialized = true; +# 1825 +static constexpr long double min() noexcept { return (3.3621031431120935063E-4932L); } +# 1828 +static constexpr long double max() noexcept { return (1.189731495357231765E4932L); } +# 1832 +static constexpr long double lowest() noexcept { return -(1.189731495357231765E4932L); } +# 1835 +static constexpr inline int digits = 64; +# 1836 +static constexpr inline int digits10 = 18; +# 1838 +static constexpr inline int max_digits10 = ((2) + (((64) * 643L) / (2136))); +# 1841 +static constexpr inline bool is_signed = true; +# 1842 +static constexpr inline bool is_integer = false; +# 1843 +static constexpr inline bool is_exact = false; +# 1844 +static constexpr inline int radix = 2; +# 1847 +static constexpr long double epsilon() noexcept { return (1.084202172485504434E-19L); } +# 1850 +static constexpr long double round_error() noexcept { return (0.5L); } +# 1852 +static constexpr inline int min_exponent = (-16381); +# 1853 +static constexpr inline int min_exponent10 = (-4931); +# 1854 +static constexpr inline int max_exponent = 16384; +# 1855 +static constexpr inline int max_exponent10 = 4932; +# 1857 +static constexpr inline bool has_infinity = (1); +# 1858 +static constexpr inline bool has_quiet_NaN = (1); +# 1859 +static constexpr inline bool has_signaling_NaN = has_quiet_NaN; +# 1860 +static constexpr inline float_denorm_style has_denorm = (((bool)1) ? denorm_present : denorm_absent); +# 1862 +static constexpr inline bool has_denorm_loss = false; +# 1866 +static constexpr long double infinity() noexcept { return __builtin_huge_vall(); } +# 1869 +static constexpr long double quiet_NaN() noexcept { return __builtin_nanl(""); } +# 1872 +static constexpr long double signaling_NaN() noexcept { return __builtin_nansl(""); } +# 1875 +static constexpr long double denorm_min() noexcept { return (3.6E-4951L); } +# 1877 +static constexpr inline bool is_iec559 = (has_infinity && has_quiet_NaN && (has_denorm == (denorm_present))); +# 1879 +static constexpr inline bool is_bounded = true; +# 1880 +static constexpr inline bool is_modulo = false; +# 1882 +static constexpr inline bool traps = false; +# 1883 +static constexpr inline bool tinyness_before = false; +# 1885 +static constexpr inline float_round_style round_style = round_to_nearest; +# 1887 +}; +# 1989 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +template<> struct numeric_limits< _Float32> { static constexpr inline bool is_specialized = true; static constexpr _Float32 min() noexcept { return (1.1754944E-38f32); } static constexpr _Float32 max() noexcept { return (3.4028235E38f32); } static constexpr _Float32 lowest() noexcept { return -(3.4028235E38f32); } static constexpr inline int digits = 24; static constexpr inline int digits10 = 6; static constexpr inline int max_digits10 = ((2) + (((24) * 643L) / (2136))); static constexpr inline bool is_signed = true; static constexpr inline bool is_integer = false; static constexpr inline bool is_exact = false; static constexpr inline int radix = 2; static constexpr _Float32 epsilon() noexcept { return (1.1920929E-7f32); } static constexpr _Float32 round_error() noexcept { return (0.5f32); } static constexpr inline int min_exponent = (-125); static constexpr inline int min_exponent10 = (-37); static constexpr inline int max_exponent = 128; static constexpr inline int max_exponent10 = 38; static constexpr inline bool has_infinity = (1); static constexpr inline bool has_quiet_NaN = (1); static constexpr inline bool has_signaling_NaN = has_quiet_NaN; static constexpr inline float_denorm_style has_denorm = (((bool)1) ? denorm_present : denorm_absent); static constexpr inline bool has_denorm_loss = false; static constexpr _Float32 infinity() noexcept { return __builtin_huge_valf32(); } static constexpr _Float32 quiet_NaN() noexcept { return __builtin_nanf32(""); } static constexpr _Float32 signaling_NaN() noexcept { return __builtin_nansf32(""); } static constexpr _Float32 denorm_min() noexcept { return (1.4E-45f32); } static constexpr inline bool is_iec559 = (has_infinity && has_quiet_NaN && (has_denorm == (denorm_present))); static constexpr inline bool is_bounded = true; static constexpr inline bool is_modulo = false; static constexpr inline bool traps = false; static constexpr inline bool tinyness_before = false; static constexpr inline float_round_style round_style = round_to_nearest; }; +# 1992 +template<> struct numeric_limits< _Float64> { static constexpr inline bool is_specialized = true; static constexpr _Float64 min() noexcept { return (2.2250738585072014E-308f64); } static constexpr _Float64 max() noexcept { return (1.7976931348623157E308f64); } static constexpr _Float64 lowest() noexcept { return -(1.7976931348623157E308f64); } static constexpr inline int digits = 53; static constexpr inline int digits10 = 15; static constexpr inline int max_digits10 = ((2) + (((53) * 643L) / (2136))); static constexpr inline bool is_signed = true; static constexpr inline bool is_integer = false; static constexpr inline bool is_exact = false; static constexpr inline int radix = 2; static constexpr _Float64 epsilon() noexcept { return (2.220446049250313E-16f64); } static constexpr _Float64 round_error() noexcept { return (0.5f64); } static constexpr inline int min_exponent = (-1021); static constexpr inline int min_exponent10 = (-307); static constexpr inline int max_exponent = 1024; static constexpr inline int max_exponent10 = 308; static constexpr inline bool has_infinity = (1); static constexpr inline bool has_quiet_NaN = (1); static constexpr inline bool has_signaling_NaN = has_quiet_NaN; static constexpr inline float_denorm_style has_denorm = (((bool)1) ? denorm_present : denorm_absent); static constexpr inline bool has_denorm_loss = false; static constexpr _Float64 infinity() noexcept { return __builtin_huge_valf64(); } static constexpr _Float64 quiet_NaN() noexcept { return __builtin_nanf64(""); } static constexpr _Float64 signaling_NaN() noexcept { return __builtin_nansf64(""); } static constexpr _Float64 denorm_min() noexcept { return (4.9E-324f64); } static constexpr inline bool is_iec559 = (has_infinity && has_quiet_NaN && (has_denorm == (denorm_present))); static constexpr inline bool is_bounded = true; static constexpr inline bool is_modulo = false; static constexpr inline bool traps = false; static constexpr inline bool tinyness_before = false; static constexpr inline float_round_style round_style = round_to_nearest; }; +# 1995 +template<> struct numeric_limits< _Float128> { static constexpr inline bool is_specialized = true; static constexpr _Float128 min() noexcept { return (3.3621031431120935062626778173217526E-4932f128); } static constexpr _Float128 max() noexcept { return (1.189731495357231765085759326628007E4932f128); } static constexpr _Float128 lowest() noexcept { return -(1.189731495357231765085759326628007E4932f128); } static constexpr inline int digits = 113; static constexpr inline int digits10 = 33; static constexpr inline int max_digits10 = ((2) + (((113) * 643L) / (2136))); static constexpr inline bool is_signed = true; static constexpr inline bool is_integer = false; static constexpr inline bool is_exact = false; static constexpr inline int radix = 2; static constexpr _Float128 epsilon() noexcept { return (1.9259299443872358530559779425849273E-34f128); } static constexpr _Float128 round_error() noexcept { return (0.5f128); } static constexpr inline int min_exponent = (-16381); static constexpr inline int min_exponent10 = (-4931); static constexpr inline int max_exponent = 16384; static constexpr inline int max_exponent10 = 4932; static constexpr inline bool has_infinity = (1); static constexpr inline bool has_quiet_NaN = (1); static constexpr inline bool has_signaling_NaN = has_quiet_NaN; static constexpr inline float_denorm_style has_denorm = (((bool)1) ? denorm_present : denorm_absent); static constexpr inline bool has_denorm_loss = false; static constexpr _Float128 infinity() noexcept { return __builtin_huge_valf128(); } static constexpr _Float128 quiet_NaN() noexcept { return __builtin_nanf128(""); } static constexpr _Float128 signaling_NaN() noexcept { return __builtin_nansf128(""); } static constexpr _Float128 denorm_min() noexcept { return (6.5E-4966f128); } static constexpr inline bool is_iec559 = (has_infinity && has_quiet_NaN && (has_denorm == (denorm_present))); static constexpr inline bool is_bounded = true; static constexpr inline bool is_modulo = false; static constexpr inline bool traps = false; static constexpr inline bool tinyness_before = false; static constexpr inline float_round_style round_style = round_to_nearest; }; +# 2089 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +template<> struct numeric_limits< __float128> { +# 2091 +static constexpr inline bool is_specialized = true; +# 2094 +static constexpr __float128 min() noexcept +# 2095 +{ +# 2100 +return __extension__ (3.3621031431120935062626778173217526E-4932Q); +# 2102 +} +# 2105 +static constexpr __float128 max() noexcept +# 2106 +{ +# 2114 +return __extension__ (1.189731495357231765085759326628007E4932Q); +# 2116 +} +# 2119 +static constexpr __float128 lowest() noexcept +# 2120 +{ return -max(); } +# 2122 +static constexpr inline int digits = 113; +# 2123 +static constexpr inline int digits10 = 33; +# 2125 +static constexpr inline int max_digits10 = 35; +# 2127 +static constexpr inline bool is_signed = true; +# 2128 +static constexpr inline bool is_integer = false; +# 2129 +static constexpr inline bool is_exact = false; +# 2130 +static constexpr inline int radix = 2; +# 2133 +static constexpr __float128 epsilon() noexcept +# 2134 +{ return (double)(1.925929944387236E-34); } +# 2137 +static constexpr __float128 round_error() noexcept { return (0.5); } +# 2139 +static constexpr inline int min_exponent = (-16381); +# 2140 +static constexpr inline int min_exponent10 = (-4931); +# 2141 +static constexpr inline int max_exponent = 16384; +# 2142 +static constexpr inline int max_exponent10 = 4932; +# 2144 +static constexpr inline bool has_infinity = (1); +# 2145 +static constexpr inline bool has_quiet_NaN = (1); +# 2148 +static constexpr inline bool has_signaling_NaN = true; +# 2152 +static constexpr inline float_denorm_style has_denorm = denorm_present; +# 2154 +static constexpr inline bool has_denorm_loss = false; +# 2157 +static constexpr __float128 infinity() noexcept +# 2158 +{ return __builtin_huge_val(); } +# 2161 +static constexpr __float128 quiet_NaN() noexcept +# 2162 +{ return __builtin_nan(""); } +# 2165 +static constexpr __float128 signaling_NaN() noexcept +# 2166 +{ +# 2168 +return __builtin_nansq(""); +# 2174 +} +# 2177 +static constexpr __float128 denorm_min() noexcept +# 2178 +{ +# 2183 +return __extension__ (6.5E-4966Q); +# 2185 +} +# 2187 +static constexpr inline bool is_iec559 = has_signaling_NaN; +# 2188 +static constexpr inline bool is_bounded = true; +# 2189 +static constexpr inline bool is_modulo = false; +# 2191 +static constexpr inline bool traps = false; +# 2192 +static constexpr inline bool tinyness_before = false; +# 2193 +static constexpr inline float_round_style round_style = round_to_nearest; +# 2218 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/limits" 3 +}; +# 2223 +} +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 +namespace __detail { +# 55 +template< class _Tp> +# 56 +struct __floating_point_constant { +# 58 +static const _Tp __value; +# 59 +}; +# 63 +template< class _Tp> +# 64 +struct __numeric_constants { +# 67 +static _Tp __pi() throw() +# 68 +{ return static_cast< _Tp>((3.1415926535897932385L)); } +# 70 +static _Tp __pi_2() throw() +# 71 +{ return static_cast< _Tp>((1.5707963267948966193L)); } +# 73 +static _Tp __pi_3() throw() +# 74 +{ return static_cast< _Tp>((1.0471975511965977461L)); } +# 76 +static _Tp __pi_4() throw() +# 77 +{ return static_cast< _Tp>((0.78539816339744830963L)); } +# 79 +static _Tp __1_pi() throw() +# 80 +{ return static_cast< _Tp>((0.31830988618379067154L)); } +# 82 +static _Tp __2_sqrtpi() throw() +# 83 +{ return static_cast< _Tp>((1.1283791670955125738L)); } +# 85 +static _Tp __sqrt2() throw() +# 86 +{ return static_cast< _Tp>((1.4142135623730950488L)); } +# 88 +static _Tp __sqrt3() throw() +# 89 +{ return static_cast< _Tp>((1.7320508075688772936L)); } +# 91 +static _Tp __sqrtpio2() throw() +# 92 +{ return static_cast< _Tp>((1.2533141373155002512L)); } +# 94 +static _Tp __sqrt1_2() throw() +# 95 +{ return static_cast< _Tp>((0.7071067811865475244L)); } +# 97 +static _Tp __lnpi() throw() +# 98 +{ return static_cast< _Tp>((1.1447298858494001742L)); } +# 100 +static _Tp __gamma_e() throw() +# 101 +{ return static_cast< _Tp>((0.5772156649015328606L)); } +# 103 +static _Tp __euler() throw() +# 104 +{ return static_cast< _Tp>((2.7182818284590452354L)); } +# 105 +}; +# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 +template< class _Tp> inline bool +# 115 +__isnan(_Tp __x) +# 116 +{ return std::isnan(__x); } +# 133 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/special_function_util.h" 3 +} +# 139 +} +# 51 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +namespace __detail { +# 76 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 78 +__bernoulli_series(unsigned __n) +# 79 +{ +# 81 +static const _Tp __num[28] = {((_Tp)1UL), ((-((_Tp)1UL)) / ((_Tp)2UL)), (((_Tp)1UL) / ((_Tp)6UL)), ((_Tp)0UL), ((-((_Tp)1UL)) / ((_Tp)30UL)), ((_Tp)0UL), (((_Tp)1UL) / ((_Tp)42UL)), ((_Tp)0UL), ((-((_Tp)1UL)) / ((_Tp)30UL)), ((_Tp)0UL), (((_Tp)5UL) / ((_Tp)66UL)), ((_Tp)0UL), ((-((_Tp)691UL)) / ((_Tp)2730UL)), ((_Tp)0UL), (((_Tp)7UL) / ((_Tp)6UL)), ((_Tp)0UL), ((-((_Tp)3617UL)) / ((_Tp)510UL)), ((_Tp)0UL), (((_Tp)43867UL) / ((_Tp)798UL)), ((_Tp)0UL), ((-((_Tp)174611)) / ((_Tp)330UL)), ((_Tp)0UL), (((_Tp)854513UL) / ((_Tp)138UL)), ((_Tp)0UL), ((-((_Tp)236364091UL)) / ((_Tp)2730UL)), ((_Tp)0UL), (((_Tp)8553103UL) / ((_Tp)6UL)), ((_Tp)0UL)}; +# 98 +if (__n == (0)) { +# 99 +return (_Tp)1; } +# 101 +if (__n == (1)) { +# 102 +return (-((_Tp)1)) / ((_Tp)2); } +# 105 +if ((__n % (2)) == (1)) { +# 106 +return (_Tp)0; } +# 109 +if (__n < (28)) { +# 110 +return __num[__n]; } +# 113 +_Tp __fact = ((_Tp)1); +# 114 +if (((__n / (2)) % (2)) == (0)) { +# 115 +__fact *= ((_Tp)(-1)); } +# 116 +for (unsigned __k = (1); __k <= __n; ++__k) { +# 117 +__fact *= (__k / (((_Tp)2) * __numeric_constants< _Tp> ::__pi())); } +# 118 +__fact *= ((_Tp)2); +# 120 +_Tp __sum = ((_Tp)0); +# 121 +for (unsigned __i = (1); __i < (1000); ++__i) +# 122 +{ +# 123 +_Tp __term = std::pow((_Tp)__i, -((_Tp)__n)); +# 124 +if (__term < std::template numeric_limits< _Tp> ::epsilon()) { +# 125 +break; } +# 126 +__sum += __term; +# 127 +} +# 129 +return __fact * __sum; +# 130 +} +# 139 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> inline _Tp +# 141 +__bernoulli(int __n) +# 142 +{ return __bernoulli_series< _Tp> (__n); } +# 153 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 155 +__log_gamma_bernoulli(_Tp __x) +# 156 +{ +# 157 +_Tp __lg = (((__x - ((_Tp)(0.5L))) * std::log(__x)) - __x) + (((_Tp)(0.5L)) * std::log(((_Tp)2) * __numeric_constants< _Tp> ::__pi())); +# 161 +const _Tp __xx = __x * __x; +# 162 +_Tp __help = ((_Tp)1) / __x; +# 163 +for (unsigned __i = (1); __i < (20); ++__i) +# 164 +{ +# 165 +const _Tp __2i = (_Tp)((2) * __i); +# 166 +__help /= ((__2i * (__2i - ((_Tp)1))) * __xx); +# 167 +__lg += (__bernoulli< _Tp> ((2) * __i) * __help); +# 168 +} +# 170 +return __lg; +# 171 +} +# 181 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 183 +__log_gamma_lanczos(_Tp __x) +# 184 +{ +# 185 +const _Tp __xm1 = __x - ((_Tp)1); +# 187 +static const _Tp __lanczos_cheb_7[9] = {((_Tp)(0.99999999999980993226L)), ((_Tp)(676.52036812188509857L)), ((_Tp)(-(1259.1392167224028704L))), ((_Tp)(771.32342877765307887L)), ((_Tp)(-(176.61502916214059906L))), ((_Tp)(12.507343278686904814L)), ((_Tp)(-(0.1385710952657201169L))), ((_Tp)(9.9843695780195708595E-6L)), ((_Tp)(1.5056327351493115584E-7L))}; +# 199 +static const _Tp __LOGROOT2PI = ((_Tp)(0.9189385332046727418L)); +# 202 +_Tp __sum = (__lanczos_cheb_7[0]); +# 203 +for (unsigned __k = (1); __k < (9); ++__k) { +# 204 +__sum += ((__lanczos_cheb_7[__k]) / (__xm1 + __k)); } +# 206 +const _Tp __term1 = (__xm1 + ((_Tp)(0.5L))) * std::log((__xm1 + ((_Tp)(7.5L))) / __numeric_constants< _Tp> ::__euler()); +# 209 +const _Tp __term2 = __LOGROOT2PI + std::log(__sum); +# 210 +const _Tp __result = __term1 + (__term2 - ((_Tp)7)); +# 212 +return __result; +# 213 +} +# 225 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 227 +__log_gamma(_Tp __x) +# 228 +{ +# 229 +if (__x > ((_Tp)(0.5L))) { +# 230 +return __log_gamma_lanczos(__x); } else +# 232 +{ +# 233 +const _Tp __sin_fact = std::abs(std::sin(__numeric_constants< _Tp> ::__pi() * __x)); +# 235 +if (__sin_fact == ((_Tp)0)) { +# 236 +std::__throw_domain_error("Argument is nonpositive integer in __log_gamma"); } +# 238 +return (__numeric_constants< _Tp> ::__lnpi() - std::log(__sin_fact)) - __log_gamma_lanczos(((_Tp)1) - __x); +# 241 +} +# 242 +} +# 252 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 254 +__log_gamma_sign(_Tp __x) +# 255 +{ +# 256 +if (__x > ((_Tp)0)) { +# 257 +return (_Tp)1; } else +# 259 +{ +# 260 +const _Tp __sin_fact = std::sin(__numeric_constants< _Tp> ::__pi() * __x); +# 262 +if (__sin_fact > ((_Tp)0)) { +# 263 +return 1; } else { +# 264 +if (__sin_fact < ((_Tp)0)) { +# 265 +return -((_Tp)1); } else { +# 267 +return (_Tp)0; } } +# 268 +} +# 269 +} +# 283 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 285 +__log_bincoef(unsigned __n, unsigned __k) +# 286 +{ +# 288 +static const _Tp __max_bincoeff = (std::template numeric_limits< _Tp> ::max_exponent10 * std::log((_Tp)10)) - ((_Tp)1); +# 292 +_Tp __coeff = (std::lgamma((_Tp)((1) + __n)) - std::lgamma((_Tp)((1) + __k))) - std::lgamma((_Tp)(((1) + __n) - __k)); +# 300 +} +# 314 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 316 +__bincoef(unsigned __n, unsigned __k) +# 317 +{ +# 319 +static const _Tp __max_bincoeff = (std::template numeric_limits< _Tp> ::max_exponent10 * std::log((_Tp)10)) - ((_Tp)1); +# 323 +const _Tp __log_coeff = __log_bincoef< _Tp> (__n, __k); +# 324 +if (__log_coeff > __max_bincoeff) { +# 325 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 327 +return std::exp(__log_coeff); } +# 328 +} +# 337 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> inline _Tp +# 339 +__gamma(_Tp __x) +# 340 +{ return std::exp(__log_gamma(__x)); } +# 356 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 358 +__psi_series(_Tp __x) +# 359 +{ +# 360 +_Tp __sum = (-__numeric_constants< _Tp> ::__gamma_e()) - (((_Tp)1) / __x); +# 361 +const unsigned __max_iter = (100000); +# 362 +for (unsigned __k = (1); __k < __max_iter; ++__k) +# 363 +{ +# 364 +const _Tp __term = __x / (__k * (__k + __x)); +# 365 +__sum += __term; +# 366 +if (std::abs(__term / __sum) < std::template numeric_limits< _Tp> ::epsilon()) { +# 367 +break; } +# 368 +} +# 369 +return __sum; +# 370 +} +# 386 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 388 +__psi_asymp(_Tp __x) +# 389 +{ +# 390 +_Tp __sum = std::log(__x) - (((_Tp)(0.5L)) / __x); +# 391 +const _Tp __xx = __x * __x; +# 392 +_Tp __xp = __xx; +# 393 +const unsigned __max_iter = (100); +# 394 +for (unsigned __k = (1); __k < __max_iter; ++__k) +# 395 +{ +# 396 +const _Tp __term = __bernoulli< _Tp> ((2) * __k) / (((2) * __k) * __xp); +# 397 +__sum -= __term; +# 398 +if (std::abs(__term / __sum) < std::template numeric_limits< _Tp> ::epsilon()) { +# 399 +break; } +# 400 +__xp *= __xx; +# 401 +} +# 402 +return __sum; +# 403 +} +# 417 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 419 +__psi(_Tp __x) +# 420 +{ +# 421 +const int __n = static_cast< int>(__x + (0.5L)); +# 422 +const _Tp __eps = ((_Tp)4) * std::template numeric_limits< _Tp> ::epsilon(); +# 423 +if ((__n <= 0) && (std::abs(__x - ((_Tp)__n)) < __eps)) { +# 424 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 425 +if (__x < ((_Tp)0)) +# 426 +{ +# 427 +const _Tp __pi = __numeric_constants< _Tp> ::__pi(); +# 428 +return __psi(((_Tp)1) - __x) - ((__pi * std::cos(__pi * __x)) / std::sin(__pi * __x)); +# 430 +} else { +# 431 +if (__x > ((_Tp)100)) { +# 432 +return __psi_asymp(__x); } else { +# 434 +return __psi_series(__x); } } } +# 435 +} +# 446 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/gamma.tcc" 3 +template< class _Tp> _Tp +# 448 +__psi(unsigned __n, _Tp __x) +# 449 +{ +# 450 +if (__x <= ((_Tp)0)) { +# 451 +std::__throw_domain_error("Argument out of range in __psi"); } else { +# 453 +if (__n == (0)) { +# 454 +return __psi(__x); } else +# 456 +{ +# 457 +const _Tp __hzeta = __hurwitz_zeta((_Tp)(__n + (1)), __x); +# 459 +const _Tp __ln_nfact = std::lgamma((_Tp)(__n + (1))); +# 463 +_Tp __result = std::exp(__ln_nfact) * __hzeta; +# 464 +if ((__n % (2)) == (1)) { +# 465 +__result = (-__result); } +# 466 +return __result; +# 467 +} } +# 468 +} +# 469 +} +# 476 +} +# 55 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 71 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +namespace __detail { +# 98 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +template< class _Tp> void +# 100 +__gamma_temme(_Tp __mu, _Tp & +# 101 +__gam1, _Tp &__gam2, _Tp &__gampl, _Tp &__gammi) +# 102 +{ +# 104 +__gampl = (((_Tp)1) / std::tgamma(((_Tp)1) + __mu)); +# 105 +__gammi = (((_Tp)1) / std::tgamma(((_Tp)1) - __mu)); +# 111 +if (std::abs(__mu) < std::template numeric_limits< _Tp> ::epsilon()) { +# 112 +__gam1 = (-((_Tp)__numeric_constants< _Tp> ::__gamma_e())); } else { +# 114 +__gam1 = ((__gammi - __gampl) / (((_Tp)2) * __mu)); } +# 116 +__gam2 = ((__gammi + __gampl) / ((_Tp)2)); +# 119 +} +# 136 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +template< class _Tp> void +# 138 +__bessel_jn(_Tp __nu, _Tp __x, _Tp & +# 139 +__Jnu, _Tp &__Nnu, _Tp &__Jpnu, _Tp &__Npnu) +# 140 +{ +# 141 +if (__x == ((_Tp)0)) +# 142 +{ +# 143 +if (__nu == ((_Tp)0)) +# 144 +{ +# 145 +__Jnu = ((_Tp)1); +# 146 +__Jpnu = ((_Tp)0); +# 147 +} else { +# 148 +if (__nu == ((_Tp)1)) +# 149 +{ +# 150 +__Jnu = ((_Tp)0); +# 151 +__Jpnu = ((_Tp)(0.5L)); +# 152 +} else +# 154 +{ +# 155 +__Jnu = ((_Tp)0); +# 156 +__Jpnu = ((_Tp)0); +# 157 +} } +# 158 +__Nnu = (-std::template numeric_limits< _Tp> ::infinity()); +# 159 +__Npnu = std::template numeric_limits< _Tp> ::infinity(); +# 160 +return; +# 161 +} +# 163 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 168 +const _Tp __fp_min = std::sqrt(std::template numeric_limits< _Tp> ::min()); +# 169 +const int __max_iter = 15000; +# 170 +const _Tp __x_min = ((_Tp)2); +# 172 +const int __nl = (__x < __x_min) ? static_cast< int>(__nu + ((_Tp)(0.5L))) : std::max(0, static_cast< int>((__nu - __x) + ((_Tp)(1.5L)))); +# 176 +const _Tp __mu = __nu - __nl; +# 177 +const _Tp __mu2 = __mu * __mu; +# 178 +const _Tp __xi = ((_Tp)1) / __x; +# 179 +const _Tp __xi2 = ((_Tp)2) * __xi; +# 180 +_Tp __w = __xi2 / __numeric_constants< _Tp> ::__pi(); +# 181 +int __isign = 1; +# 182 +_Tp __h = __nu * __xi; +# 183 +if (__h < __fp_min) { +# 184 +__h = __fp_min; } +# 185 +_Tp __b = __xi2 * __nu; +# 186 +_Tp __d = ((_Tp)0); +# 187 +_Tp __c = __h; +# 188 +int __i; +# 189 +for (__i = 1; __i <= __max_iter; ++__i) +# 190 +{ +# 191 +__b += __xi2; +# 192 +__d = (__b - __d); +# 193 +if (std::abs(__d) < __fp_min) { +# 194 +__d = __fp_min; } +# 195 +__c = (__b - (((_Tp)1) / __c)); +# 196 +if (std::abs(__c) < __fp_min) { +# 197 +__c = __fp_min; } +# 198 +__d = (((_Tp)1) / __d); +# 199 +const _Tp __del = __c * __d; +# 200 +__h *= __del; +# 201 +if (__d < ((_Tp)0)) { +# 202 +__isign = (-__isign); } +# 203 +if (std::abs(__del - ((_Tp)1)) < __eps) { +# 204 +break; } +# 205 +} +# 206 +if (__i > __max_iter) { +# 207 +std::__throw_runtime_error("Argument x too large in __bessel_jn; try asymptotic expansion."); } +# 209 +_Tp __Jnul = __isign * __fp_min; +# 210 +_Tp __Jpnul = __h * __Jnul; +# 211 +_Tp __Jnul1 = __Jnul; +# 212 +_Tp __Jpnu1 = __Jpnul; +# 213 +_Tp __fact = __nu * __xi; +# 214 +for (int __l = __nl; __l >= 1; --__l) +# 215 +{ +# 216 +const _Tp __Jnutemp = (__fact * __Jnul) + __Jpnul; +# 217 +__fact -= __xi; +# 218 +__Jpnul = ((__fact * __Jnutemp) - __Jnul); +# 219 +__Jnul = __Jnutemp; +# 220 +} +# 221 +if (__Jnul == ((_Tp)0)) { +# 222 +__Jnul = __eps; } +# 223 +_Tp __f = __Jpnul / __Jnul; +# 224 +_Tp __Nmu, __Nnu1, __Npmu, __Jmu; +# 225 +if (__x < __x_min) +# 226 +{ +# 227 +const _Tp __x2 = __x / ((_Tp)2); +# 228 +const _Tp __pimu = __numeric_constants< _Tp> ::__pi() * __mu; +# 229 +_Tp __fact = (std::abs(__pimu) < __eps) ? (_Tp)1 : (__pimu / std::sin(__pimu)); +# 231 +_Tp __d = (-std::log(__x2)); +# 232 +_Tp __e = __mu * __d; +# 233 +_Tp __fact2 = (std::abs(__e) < __eps) ? (_Tp)1 : (std::sinh(__e) / __e); +# 235 +_Tp __gam1, __gam2, __gampl, __gammi; +# 236 +__gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi); +# 237 +_Tp __ff = ((((_Tp)2) / __numeric_constants< _Tp> ::__pi()) * __fact) * ((__gam1 * std::cosh(__e)) + ((__gam2 * __fact2) * __d)); +# 239 +__e = std::exp(__e); +# 240 +_Tp __p = __e / (__numeric_constants< _Tp> ::__pi() * __gampl); +# 241 +_Tp __q = ((_Tp)1) / ((__e * __numeric_constants< _Tp> ::__pi()) * __gammi); +# 242 +const _Tp __pimu2 = __pimu / ((_Tp)2); +# 243 +_Tp __fact3 = (std::abs(__pimu2) < __eps) ? (_Tp)1 : (std::sin(__pimu2) / __pimu2); +# 245 +_Tp __r = ((__numeric_constants< _Tp> ::__pi() * __pimu2) * __fact3) * __fact3; +# 246 +_Tp __c = ((_Tp)1); +# 247 +__d = ((-__x2) * __x2); +# 248 +_Tp __sum = __ff + (__r * __q); +# 249 +_Tp __sum1 = __p; +# 250 +for (__i = 1; __i <= __max_iter; ++__i) +# 251 +{ +# 252 +__ff = ((((__i * __ff) + __p) + __q) / ((__i * __i) - __mu2)); +# 253 +__c *= (__d / ((_Tp)__i)); +# 254 +__p /= (((_Tp)__i) - __mu); +# 255 +__q /= (((_Tp)__i) + __mu); +# 256 +const _Tp __del = __c * (__ff + (__r * __q)); +# 257 +__sum += __del; +# 258 +const _Tp __del1 = (__c * __p) - (__i * __del); +# 259 +__sum1 += __del1; +# 260 +if (std::abs(__del) < (__eps * (((_Tp)1) + std::abs(__sum)))) { +# 261 +break; } +# 262 +} +# 263 +if (__i > __max_iter) { +# 264 +std::__throw_runtime_error("Bessel y series failed to converge in __bessel_jn."); } +# 266 +__Nmu = (-__sum); +# 267 +__Nnu1 = ((-__sum1) * __xi2); +# 268 +__Npmu = (((__mu * __xi) * __Nmu) - __Nnu1); +# 269 +__Jmu = (__w / (__Npmu - (__f * __Nmu))); +# 270 +} else +# 272 +{ +# 273 +_Tp __a = ((_Tp)(0.25L)) - __mu2; +# 274 +_Tp __q = ((_Tp)1); +# 275 +_Tp __p = ((-__xi) / ((_Tp)2)); +# 276 +_Tp __br = ((_Tp)2) * __x; +# 277 +_Tp __bi = ((_Tp)2); +# 278 +_Tp __fact = (__a * __xi) / ((__p * __p) + (__q * __q)); +# 279 +_Tp __cr = __br + (__q * __fact); +# 280 +_Tp __ci = __bi + (__p * __fact); +# 281 +_Tp __den = (__br * __br) + (__bi * __bi); +# 282 +_Tp __dr = __br / __den; +# 283 +_Tp __di = (-__bi) / __den; +# 284 +_Tp __dlr = (__cr * __dr) - (__ci * __di); +# 285 +_Tp __dli = (__cr * __di) + (__ci * __dr); +# 286 +_Tp __temp = (__p * __dlr) - (__q * __dli); +# 287 +__q = ((__p * __dli) + (__q * __dlr)); +# 288 +__p = __temp; +# 289 +int __i; +# 290 +for (__i = 2; __i <= __max_iter; ++__i) +# 291 +{ +# 292 +__a += ((_Tp)(2 * (__i - 1))); +# 293 +__bi += ((_Tp)2); +# 294 +__dr = ((__a * __dr) + __br); +# 295 +__di = ((__a * __di) + __bi); +# 296 +if ((std::abs(__dr) + std::abs(__di)) < __fp_min) { +# 297 +__dr = __fp_min; } +# 298 +__fact = (__a / ((__cr * __cr) + (__ci * __ci))); +# 299 +__cr = (__br + (__cr * __fact)); +# 300 +__ci = (__bi - (__ci * __fact)); +# 301 +if ((std::abs(__cr) + std::abs(__ci)) < __fp_min) { +# 302 +__cr = __fp_min; } +# 303 +__den = ((__dr * __dr) + (__di * __di)); +# 304 +__dr /= __den; +# 305 +__di /= (-__den); +# 306 +__dlr = ((__cr * __dr) - (__ci * __di)); +# 307 +__dli = ((__cr * __di) + (__ci * __dr)); +# 308 +__temp = ((__p * __dlr) - (__q * __dli)); +# 309 +__q = ((__p * __dli) + (__q * __dlr)); +# 310 +__p = __temp; +# 311 +if ((std::abs(__dlr - ((_Tp)1)) + std::abs(__dli)) < __eps) { +# 312 +break; } +# 313 +} +# 314 +if (__i > __max_iter) { +# 315 +std::__throw_runtime_error("Lentz\'s method failed in __bessel_jn."); } +# 317 +const _Tp __gam = (__p - __f) / __q; +# 318 +__Jmu = std::sqrt(__w / (((__p - __f) * __gam) + __q)); +# 320 +__Jmu = std::copysign(__Jmu, __Jnul); +# 325 +__Nmu = (__gam * __Jmu); +# 326 +__Npmu = ((__p + (__q / __gam)) * __Nmu); +# 327 +__Nnu1 = (((__mu * __xi) * __Nmu) - __Npmu); +# 328 +} +# 329 +__fact = (__Jmu / __Jnul); +# 330 +__Jnu = (__fact * __Jnul1); +# 331 +__Jpnu = (__fact * __Jpnu1); +# 332 +for (__i = 1; __i <= __nl; ++__i) +# 333 +{ +# 334 +const _Tp __Nnutemp = (((__mu + __i) * __xi2) * __Nnu1) - __Nmu; +# 335 +__Nmu = __Nnu1; +# 336 +__Nnu1 = __Nnutemp; +# 337 +} +# 338 +__Nnu = __Nmu; +# 339 +__Npnu = (((__nu * __xi) * __Nmu) - __Nnu1); +# 342 +} +# 361 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +template< class _Tp> void +# 363 +__cyl_bessel_jn_asymp(_Tp __nu, _Tp __x, _Tp &__Jnu, _Tp &__Nnu) +# 364 +{ +# 365 +const _Tp __mu = (((_Tp)4) * __nu) * __nu; +# 366 +const _Tp __8x = ((_Tp)8) * __x; +# 368 +_Tp __P = ((_Tp)0); +# 369 +_Tp __Q = ((_Tp)0); +# 371 +_Tp __k = ((_Tp)0); +# 372 +_Tp __term = ((_Tp)1); +# 374 +int __epsP = 0; +# 375 +int __epsQ = 0; +# 377 +_Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 379 +do +# 380 +{ +# 381 +__term *= ((__k == 0) ? (_Tp)1 : ((-(__mu - (((2 * __k) - 1) * ((2 * __k) - 1)))) / (__k * __8x))); +# 385 +__epsP = (std::abs(__term) < (__eps * std::abs(__P))); +# 386 +__P += __term; +# 388 +__k++; +# 390 +__term *= ((__mu - (((2 * __k) - 1) * ((2 * __k) - 1))) / (__k * __8x)); +# 391 +__epsQ = (std::abs(__term) < (__eps * std::abs(__Q))); +# 392 +__Q += __term; +# 394 +if (__epsP && __epsQ && (__k > (__nu / (2.0)))) { +# 395 +break; } +# 397 +__k++; +# 398 +} +# 399 +while (__k < 1000); +# 401 +const _Tp __chi = __x - ((__nu + ((_Tp)(0.5L))) * __numeric_constants< _Tp> ::__pi_2()); +# 404 +const _Tp __c = std::cos(__chi); +# 405 +const _Tp __s = std::sin(__chi); +# 407 +const _Tp __coef = std::sqrt(((_Tp)2) / (__numeric_constants< _Tp> ::__pi() * __x)); +# 410 +__Jnu = (__coef * ((__c * __P) - (__s * __Q))); +# 411 +__Nnu = (__coef * ((__s * __P) + (__c * __Q))); +# 414 +} +# 444 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +template< class _Tp> _Tp +# 446 +__cyl_bessel_ij_series(_Tp __nu, _Tp __x, _Tp __sgn, unsigned +# 447 +__max_iter) +# 448 +{ +# 449 +if (__x == ((_Tp)0)) { +# 450 +return (__nu == ((_Tp)0)) ? (_Tp)1 : ((_Tp)0); } +# 452 +const _Tp __x2 = __x / ((_Tp)2); +# 453 +_Tp __fact = __nu * std::log(__x2); +# 455 +__fact -= std::lgamma(__nu + ((_Tp)1)); +# 459 +__fact = std::exp(__fact); +# 460 +const _Tp __xx4 = (__sgn * __x2) * __x2; +# 461 +_Tp __Jn = ((_Tp)1); +# 462 +_Tp __term = ((_Tp)1); +# 464 +for (unsigned __i = (1); __i < __max_iter; ++__i) +# 465 +{ +# 466 +__term *= (__xx4 / (((_Tp)__i) * (__nu + ((_Tp)__i)))); +# 467 +__Jn += __term; +# 468 +if (std::abs(__term / __Jn) < std::template numeric_limits< _Tp> ::epsilon()) { +# 469 +break; } +# 470 +} +# 472 +return __fact * __Jn; +# 473 +} +# 490 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +template< class _Tp> _Tp +# 492 +__cyl_bessel_j(_Tp __nu, _Tp __x) +# 493 +{ +# 494 +if ((__nu < ((_Tp)0)) || (__x < ((_Tp)0))) { +# 495 +std::__throw_domain_error("Bad argument in __cyl_bessel_j."); } else { +# 497 +if (__isnan(__nu) || __isnan(__x)) { +# 498 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 499 +if ((__x * __x) < (((_Tp)10) * (__nu + ((_Tp)1)))) { +# 500 +return __cyl_bessel_ij_series(__nu, __x, -((_Tp)1), 200); } else { +# 501 +if (__x > ((_Tp)1000)) +# 502 +{ +# 503 +_Tp __J_nu, __N_nu; +# 504 +__cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); +# 505 +return __J_nu; +# 506 +} else +# 508 +{ +# 509 +_Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; +# 510 +__bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); +# 511 +return __J_nu; +# 512 +} } } } +# 513 +} +# 532 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +template< class _Tp> _Tp +# 534 +__cyl_neumann_n(_Tp __nu, _Tp __x) +# 535 +{ +# 536 +if ((__nu < ((_Tp)0)) || (__x < ((_Tp)0))) { +# 537 +std::__throw_domain_error("Bad argument in __cyl_neumann_n."); } else { +# 539 +if (__isnan(__nu) || __isnan(__x)) { +# 540 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 541 +if (__x > ((_Tp)1000)) +# 542 +{ +# 543 +_Tp __J_nu, __N_nu; +# 544 +__cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); +# 545 +return __N_nu; +# 546 +} else +# 548 +{ +# 549 +_Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; +# 550 +__bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); +# 551 +return __N_nu; +# 552 +} } } +# 553 +} +# 569 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +template< class _Tp> void +# 571 +__sph_bessel_jn(unsigned __n, _Tp __x, _Tp & +# 572 +__j_n, _Tp &__n_n, _Tp &__jp_n, _Tp &__np_n) +# 573 +{ +# 574 +const _Tp __nu = ((_Tp)__n) + ((_Tp)(0.5L)); +# 576 +_Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; +# 577 +__bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); +# 579 +const _Tp __factor = __numeric_constants< _Tp> ::__sqrtpio2() / std::sqrt(__x); +# 582 +__j_n = (__factor * __J_nu); +# 583 +__n_n = (__factor * __N_nu); +# 584 +__jp_n = ((__factor * __Jp_nu) - (__j_n / (((_Tp)2) * __x))); +# 585 +__np_n = ((__factor * __Np_nu) - (__n_n / (((_Tp)2) * __x))); +# 588 +} +# 604 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +template< class _Tp> _Tp +# 606 +__sph_bessel(unsigned __n, _Tp __x) +# 607 +{ +# 608 +if (__x < ((_Tp)0)) { +# 609 +std::__throw_domain_error("Bad argument in __sph_bessel."); } else { +# 611 +if (__isnan(__x)) { +# 612 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 613 +if (__x == ((_Tp)0)) +# 614 +{ +# 615 +if (__n == (0)) { +# 616 +return (_Tp)1; } else { +# 618 +return (_Tp)0; } +# 619 +} else +# 621 +{ +# 622 +_Tp __j_n, __n_n, __jp_n, __np_n; +# 623 +__sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n); +# 624 +return __j_n; +# 625 +} } } +# 626 +} +# 642 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/bessel_function.tcc" 3 +template< class _Tp> _Tp +# 644 +__sph_neumann(unsigned __n, _Tp __x) +# 645 +{ +# 646 +if (__x < ((_Tp)0)) { +# 647 +std::__throw_domain_error("Bad argument in __sph_neumann."); } else { +# 649 +if (__isnan(__x)) { +# 650 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 651 +if (__x == ((_Tp)0)) { +# 652 +return -std::template numeric_limits< _Tp> ::infinity(); } else +# 654 +{ +# 655 +_Tp __j_n, __n_n, __jp_n, __np_n; +# 656 +__sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n); +# 657 +return __n_n; +# 658 +} } } +# 659 +} +# 660 +} +# 667 +} +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 +namespace __detail { +# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 +template< class _Tp> _Tp +# 81 +__beta_gamma(_Tp __x, _Tp __y) +# 82 +{ +# 84 +_Tp __bet; +# 86 +if (__x > __y) +# 87 +{ +# 88 +__bet = (std::tgamma(__x) / std::tgamma(__x + __y)); +# 90 +__bet *= std::tgamma(__y); +# 91 +} else +# 93 +{ +# 94 +__bet = (std::tgamma(__y) / std::tgamma(__x + __y)); +# 96 +__bet *= std::tgamma(__x); +# 97 +} +# 111 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 +return __bet; +# 112 +} +# 127 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 +template< class _Tp> _Tp +# 129 +__beta_lgamma(_Tp __x, _Tp __y) +# 130 +{ +# 132 +_Tp __bet = (std::lgamma(__x) + std::lgamma(__y)) - std::lgamma(__x + __y); +# 140 +__bet = std::exp(__bet); +# 141 +return __bet; +# 142 +} +# 158 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 +template< class _Tp> _Tp +# 160 +__beta_product(_Tp __x, _Tp __y) +# 161 +{ +# 163 +_Tp __bet = (__x + __y) / (__x * __y); +# 165 +unsigned __max_iter = (1000000); +# 166 +for (unsigned __k = (1); __k < __max_iter; ++__k) +# 167 +{ +# 168 +_Tp __term = (((_Tp)1) + ((__x + __y) / __k)) / ((((_Tp)1) + (__x / __k)) * (((_Tp)1) + (__y / __k))); +# 170 +__bet *= __term; +# 171 +} +# 173 +return __bet; +# 174 +} +# 189 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/beta_function.tcc" 3 +template< class _Tp> inline _Tp +# 191 +__beta(_Tp __x, _Tp __y) +# 192 +{ +# 193 +if (__isnan(__x) || __isnan(__y)) { +# 194 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 196 +return __beta_lgamma(__x, __y); } +# 197 +} +# 198 +} +# 205 +} +# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +namespace __detail { +# 76 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 78 +__ellint_rf(_Tp __x, _Tp __y, _Tp __z) +# 79 +{ +# 80 +const _Tp __min = std::template numeric_limits< _Tp> ::min(); +# 81 +const _Tp __lolim = ((_Tp)5) * __min; +# 83 +if (((__x < ((_Tp)0)) || (__y < ((_Tp)0))) || (__z < ((_Tp)0))) { +# 84 +std::__throw_domain_error("Argument less than zero in __ellint_rf."); } else { +# 86 +if ((((__x + __y) < __lolim) || ((__x + __z) < __lolim)) || ((__y + __z) < __lolim)) { +# 88 +std::__throw_domain_error("Argument too small in __ellint_rf"); } else +# 90 +{ +# 91 +const _Tp __c0 = (((_Tp)1) / ((_Tp)4)); +# 92 +const _Tp __c1 = (((_Tp)1) / ((_Tp)24)); +# 93 +const _Tp __c2 = (((_Tp)1) / ((_Tp)10)); +# 94 +const _Tp __c3 = (((_Tp)3) / ((_Tp)44)); +# 95 +const _Tp __c4 = (((_Tp)1) / ((_Tp)14)); +# 97 +_Tp __xn = __x; +# 98 +_Tp __yn = __y; +# 99 +_Tp __zn = __z; +# 101 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 102 +const _Tp __errtol = std::pow(__eps, ((_Tp)1) / ((_Tp)6)); +# 103 +_Tp __mu; +# 104 +_Tp __xndev, __yndev, __zndev; +# 106 +const unsigned __max_iter = (100); +# 107 +for (unsigned __iter = (0); __iter < __max_iter; ++__iter) +# 108 +{ +# 109 +__mu = (((__xn + __yn) + __zn) / ((_Tp)3)); +# 110 +__xndev = (2 - ((__mu + __xn) / __mu)); +# 111 +__yndev = (2 - ((__mu + __yn) / __mu)); +# 112 +__zndev = (2 - ((__mu + __zn) / __mu)); +# 113 +_Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); +# 114 +__epsilon = std::max(__epsilon, std::abs(__zndev)); +# 115 +if (__epsilon < __errtol) { +# 116 +break; } +# 117 +const _Tp __xnroot = std::sqrt(__xn); +# 118 +const _Tp __ynroot = std::sqrt(__yn); +# 119 +const _Tp __znroot = std::sqrt(__zn); +# 120 +const _Tp __lambda = (__xnroot * (__ynroot + __znroot)) + (__ynroot * __znroot); +# 122 +__xn = (__c0 * (__xn + __lambda)); +# 123 +__yn = (__c0 * (__yn + __lambda)); +# 124 +__zn = (__c0 * (__zn + __lambda)); +# 125 +} +# 127 +const _Tp __e2 = (__xndev * __yndev) - (__zndev * __zndev); +# 128 +const _Tp __e3 = (__xndev * __yndev) * __zndev; +# 129 +const _Tp __s = (((_Tp)1) + ((((__c1 * __e2) - __c2) - (__c3 * __e3)) * __e2)) + (__c4 * __e3); +# 132 +return __s / std::sqrt(__mu); +# 133 +} } +# 134 +} +# 153 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 155 +__comp_ellint_1_series(_Tp __k) +# 156 +{ +# 158 +const _Tp __kk = __k * __k; +# 160 +_Tp __term = __kk / ((_Tp)4); +# 161 +_Tp __sum = ((_Tp)1) + __term; +# 163 +const unsigned __max_iter = (1000); +# 164 +for (unsigned __i = (2); __i < __max_iter; ++__i) +# 165 +{ +# 166 +__term *= (((((2) * __i) - (1)) * __kk) / ((2) * __i)); +# 167 +if (__term < std::template numeric_limits< _Tp> ::epsilon()) { +# 168 +break; } +# 169 +__sum += __term; +# 170 +} +# 172 +return __numeric_constants< _Tp> ::__pi_2() * __sum; +# 173 +} +# 191 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 193 +__comp_ellint_1(_Tp __k) +# 194 +{ +# 196 +if (__isnan(__k)) { +# 197 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 198 +if (std::abs(__k) >= ((_Tp)1)) { +# 199 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 201 +return __ellint_rf((_Tp)0, ((_Tp)1) - (__k * __k), (_Tp)1); } } +# 202 +} +# 219 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 221 +__ellint_1(_Tp __k, _Tp __phi) +# 222 +{ +# 224 +if (__isnan(__k) || __isnan(__phi)) { +# 225 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 226 +if (std::abs(__k) > ((_Tp)1)) { +# 227 +std::__throw_domain_error("Bad argument in __ellint_1."); } else +# 229 +{ +# 231 +const int __n = std::floor((__phi / __numeric_constants< _Tp> ::__pi()) + ((_Tp)(0.5L))); +# 233 +const _Tp __phi_red = __phi - (__n * __numeric_constants< _Tp> ::__pi()); +# 236 +const _Tp __s = std::sin(__phi_red); +# 237 +const _Tp __c = std::cos(__phi_red); +# 239 +const _Tp __F = __s * __ellint_rf(__c * __c, ((_Tp)1) - (((__k * __k) * __s) * __s), (_Tp)1); +# 243 +if (__n == 0) { +# 244 +return __F; } else { +# 246 +return __F + ((((_Tp)2) * __n) * __comp_ellint_1(__k)); } +# 247 +} } +# 248 +} +# 266 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 268 +__comp_ellint_2_series(_Tp __k) +# 269 +{ +# 271 +const _Tp __kk = __k * __k; +# 273 +_Tp __term = __kk; +# 274 +_Tp __sum = __term; +# 276 +const unsigned __max_iter = (1000); +# 277 +for (unsigned __i = (2); __i < __max_iter; ++__i) +# 278 +{ +# 279 +const _Tp __i2m = ((2) * __i) - (1); +# 280 +const _Tp __i2 = (2) * __i; +# 281 +__term *= (((__i2m * __i2m) * __kk) / (__i2 * __i2)); +# 282 +if (__term < std::template numeric_limits< _Tp> ::epsilon()) { +# 283 +break; } +# 284 +__sum += (__term / __i2m); +# 285 +} +# 287 +return __numeric_constants< _Tp> ::__pi_2() * (((_Tp)1) - __sum); +# 288 +} +# 314 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 316 +__ellint_rd(_Tp __x, _Tp __y, _Tp __z) +# 317 +{ +# 318 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 319 +const _Tp __errtol = std::pow(__eps / ((_Tp)8), ((_Tp)1) / ((_Tp)6)); +# 320 +const _Tp __max = std::template numeric_limits< _Tp> ::max(); +# 321 +const _Tp __lolim = ((_Tp)2) / std::pow(__max, ((_Tp)2) / ((_Tp)3)); +# 323 +if ((__x < ((_Tp)0)) || (__y < ((_Tp)0))) { +# 324 +std::__throw_domain_error("Argument less than zero in __ellint_rd."); } else { +# 326 +if (((__x + __y) < __lolim) || (__z < __lolim)) { +# 327 +std::__throw_domain_error("Argument too small in __ellint_rd."); } else +# 330 +{ +# 331 +const _Tp __c0 = (((_Tp)1) / ((_Tp)4)); +# 332 +const _Tp __c1 = (((_Tp)3) / ((_Tp)14)); +# 333 +const _Tp __c2 = (((_Tp)1) / ((_Tp)6)); +# 334 +const _Tp __c3 = (((_Tp)9) / ((_Tp)22)); +# 335 +const _Tp __c4 = (((_Tp)3) / ((_Tp)26)); +# 337 +_Tp __xn = __x; +# 338 +_Tp __yn = __y; +# 339 +_Tp __zn = __z; +# 340 +_Tp __sigma = ((_Tp)0); +# 341 +_Tp __power4 = ((_Tp)1); +# 343 +_Tp __mu; +# 344 +_Tp __xndev, __yndev, __zndev; +# 346 +const unsigned __max_iter = (100); +# 347 +for (unsigned __iter = (0); __iter < __max_iter; ++__iter) +# 348 +{ +# 349 +__mu = (((__xn + __yn) + (((_Tp)3) * __zn)) / ((_Tp)5)); +# 350 +__xndev = ((__mu - __xn) / __mu); +# 351 +__yndev = ((__mu - __yn) / __mu); +# 352 +__zndev = ((__mu - __zn) / __mu); +# 353 +_Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); +# 354 +__epsilon = std::max(__epsilon, std::abs(__zndev)); +# 355 +if (__epsilon < __errtol) { +# 356 +break; } +# 357 +_Tp __xnroot = std::sqrt(__xn); +# 358 +_Tp __ynroot = std::sqrt(__yn); +# 359 +_Tp __znroot = std::sqrt(__zn); +# 360 +_Tp __lambda = (__xnroot * (__ynroot + __znroot)) + (__ynroot * __znroot); +# 362 +__sigma += (__power4 / (__znroot * (__zn + __lambda))); +# 363 +__power4 *= __c0; +# 364 +__xn = (__c0 * (__xn + __lambda)); +# 365 +__yn = (__c0 * (__yn + __lambda)); +# 366 +__zn = (__c0 * (__zn + __lambda)); +# 367 +} +# 369 +_Tp __ea = __xndev * __yndev; +# 370 +_Tp __eb = __zndev * __zndev; +# 371 +_Tp __ec = __ea - __eb; +# 372 +_Tp __ed = __ea - (((_Tp)6) * __eb); +# 373 +_Tp __ef = (__ed + __ec) + __ec; +# 374 +_Tp __s1 = __ed * (((-__c1) + ((__c3 * __ed) / ((_Tp)3))) - ((((((_Tp)3) * __c4) * __zndev) * __ef) / ((_Tp)2))); +# 377 +_Tp __s2 = __zndev * ((__c2 * __ef) + (__zndev * ((((-__c3) * __ec) - (__zndev * __c4)) - __ea))); +# 381 +return (((_Tp)3) * __sigma) + ((__power4 * ((((_Tp)1) + __s1) + __s2)) / (__mu * std::sqrt(__mu))); +# 383 +} } +# 384 +} +# 399 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 401 +__comp_ellint_2(_Tp __k) +# 402 +{ +# 404 +if (__isnan(__k)) { +# 405 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 406 +if (std::abs(__k) == 1) { +# 407 +return (_Tp)1; } else { +# 408 +if (std::abs(__k) > ((_Tp)1)) { +# 409 +std::__throw_domain_error("Bad argument in __comp_ellint_2."); } else +# 411 +{ +# 412 +const _Tp __kk = __k * __k; +# 414 +return __ellint_rf((_Tp)0, ((_Tp)1) - __kk, (_Tp)1) - ((__kk * __ellint_rd((_Tp)0, ((_Tp)1) - __kk, (_Tp)1)) / ((_Tp)3)); +# 416 +} } } +# 417 +} +# 433 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 435 +__ellint_2(_Tp __k, _Tp __phi) +# 436 +{ +# 438 +if (__isnan(__k) || __isnan(__phi)) { +# 439 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 440 +if (std::abs(__k) > ((_Tp)1)) { +# 441 +std::__throw_domain_error("Bad argument in __ellint_2."); } else +# 443 +{ +# 445 +const int __n = std::floor((__phi / __numeric_constants< _Tp> ::__pi()) + ((_Tp)(0.5L))); +# 447 +const _Tp __phi_red = __phi - (__n * __numeric_constants< _Tp> ::__pi()); +# 450 +const _Tp __kk = __k * __k; +# 451 +const _Tp __s = std::sin(__phi_red); +# 452 +const _Tp __ss = __s * __s; +# 453 +const _Tp __sss = __ss * __s; +# 454 +const _Tp __c = std::cos(__phi_red); +# 455 +const _Tp __cc = __c * __c; +# 457 +const _Tp __E = (__s * __ellint_rf(__cc, ((_Tp)1) - (__kk * __ss), (_Tp)1)) - (((__kk * __sss) * __ellint_rd(__cc, ((_Tp)1) - (__kk * __ss), (_Tp)1)) / ((_Tp)3)); +# 463 +if (__n == 0) { +# 464 +return __E; } else { +# 466 +return __E + ((((_Tp)2) * __n) * __comp_ellint_2(__k)); } +# 467 +} } +# 468 +} +# 492 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 494 +__ellint_rc(_Tp __x, _Tp __y) +# 495 +{ +# 496 +const _Tp __min = std::template numeric_limits< _Tp> ::min(); +# 497 +const _Tp __lolim = ((_Tp)5) * __min; +# 499 +if (((__x < ((_Tp)0)) || (__y < ((_Tp)0))) || ((__x + __y) < __lolim)) { +# 500 +std::__throw_domain_error("Argument less than zero in __ellint_rc."); } else +# 503 +{ +# 504 +const _Tp __c0 = (((_Tp)1) / ((_Tp)4)); +# 505 +const _Tp __c1 = (((_Tp)1) / ((_Tp)7)); +# 506 +const _Tp __c2 = (((_Tp)9) / ((_Tp)22)); +# 507 +const _Tp __c3 = (((_Tp)3) / ((_Tp)10)); +# 508 +const _Tp __c4 = (((_Tp)3) / ((_Tp)8)); +# 510 +_Tp __xn = __x; +# 511 +_Tp __yn = __y; +# 513 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 514 +const _Tp __errtol = std::pow(__eps / ((_Tp)30), ((_Tp)1) / ((_Tp)6)); +# 515 +_Tp __mu; +# 516 +_Tp __sn; +# 518 +const unsigned __max_iter = (100); +# 519 +for (unsigned __iter = (0); __iter < __max_iter; ++__iter) +# 520 +{ +# 521 +__mu = ((__xn + (((_Tp)2) * __yn)) / ((_Tp)3)); +# 522 +__sn = (((__yn + __mu) / __mu) - ((_Tp)2)); +# 523 +if (std::abs(__sn) < __errtol) { +# 524 +break; } +# 525 +const _Tp __lambda = ((((_Tp)2) * std::sqrt(__xn)) * std::sqrt(__yn)) + __yn; +# 527 +__xn = (__c0 * (__xn + __lambda)); +# 528 +__yn = (__c0 * (__yn + __lambda)); +# 529 +} +# 531 +_Tp __s = (__sn * __sn) * (__c3 + (__sn * (__c1 + (__sn * (__c4 + (__sn * __c2)))))); +# 534 +return (((_Tp)1) + __s) / std::sqrt(__mu); +# 535 +} +# 536 +} +# 561 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 563 +__ellint_rj(_Tp __x, _Tp __y, _Tp __z, _Tp __p) +# 564 +{ +# 565 +const _Tp __min = std::template numeric_limits< _Tp> ::min(); +# 566 +const _Tp __lolim = std::pow(((_Tp)5) * __min, ((_Tp)1) / ((_Tp)3)); +# 568 +if (((__x < ((_Tp)0)) || (__y < ((_Tp)0))) || (__z < ((_Tp)0))) { +# 569 +std::__throw_domain_error("Argument less than zero in __ellint_rj."); } else { +# 571 +if (((((__x + __y) < __lolim) || ((__x + __z) < __lolim)) || ((__y + __z) < __lolim)) || (__p < __lolim)) { +# 573 +std::__throw_domain_error("Argument too small in __ellint_rj"); } else +# 576 +{ +# 577 +const _Tp __c0 = (((_Tp)1) / ((_Tp)4)); +# 578 +const _Tp __c1 = (((_Tp)3) / ((_Tp)14)); +# 579 +const _Tp __c2 = (((_Tp)1) / ((_Tp)3)); +# 580 +const _Tp __c3 = (((_Tp)3) / ((_Tp)22)); +# 581 +const _Tp __c4 = (((_Tp)3) / ((_Tp)26)); +# 583 +_Tp __xn = __x; +# 584 +_Tp __yn = __y; +# 585 +_Tp __zn = __z; +# 586 +_Tp __pn = __p; +# 587 +_Tp __sigma = ((_Tp)0); +# 588 +_Tp __power4 = ((_Tp)1); +# 590 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 591 +const _Tp __errtol = std::pow(__eps / ((_Tp)8), ((_Tp)1) / ((_Tp)6)); +# 593 +_Tp __mu; +# 594 +_Tp __xndev, __yndev, __zndev, __pndev; +# 596 +const unsigned __max_iter = (100); +# 597 +for (unsigned __iter = (0); __iter < __max_iter; ++__iter) +# 598 +{ +# 599 +__mu = ((((__xn + __yn) + __zn) + (((_Tp)2) * __pn)) / ((_Tp)5)); +# 600 +__xndev = ((__mu - __xn) / __mu); +# 601 +__yndev = ((__mu - __yn) / __mu); +# 602 +__zndev = ((__mu - __zn) / __mu); +# 603 +__pndev = ((__mu - __pn) / __mu); +# 604 +_Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); +# 605 +__epsilon = std::max(__epsilon, std::abs(__zndev)); +# 606 +__epsilon = std::max(__epsilon, std::abs(__pndev)); +# 607 +if (__epsilon < __errtol) { +# 608 +break; } +# 609 +const _Tp __xnroot = std::sqrt(__xn); +# 610 +const _Tp __ynroot = std::sqrt(__yn); +# 611 +const _Tp __znroot = std::sqrt(__zn); +# 612 +const _Tp __lambda = (__xnroot * (__ynroot + __znroot)) + (__ynroot * __znroot); +# 614 +const _Tp __alpha1 = (__pn * ((__xnroot + __ynroot) + __znroot)) + ((__xnroot * __ynroot) * __znroot); +# 616 +const _Tp __alpha2 = __alpha1 * __alpha1; +# 617 +const _Tp __beta = (__pn * (__pn + __lambda)) * (__pn + __lambda); +# 619 +__sigma += (__power4 * __ellint_rc(__alpha2, __beta)); +# 620 +__power4 *= __c0; +# 621 +__xn = (__c0 * (__xn + __lambda)); +# 622 +__yn = (__c0 * (__yn + __lambda)); +# 623 +__zn = (__c0 * (__zn + __lambda)); +# 624 +__pn = (__c0 * (__pn + __lambda)); +# 625 +} +# 627 +_Tp __ea = (__xndev * (__yndev + __zndev)) + (__yndev * __zndev); +# 628 +_Tp __eb = (__xndev * __yndev) * __zndev; +# 629 +_Tp __ec = __pndev * __pndev; +# 630 +_Tp __e2 = __ea - (((_Tp)3) * __ec); +# 631 +_Tp __e3 = __eb + ((((_Tp)2) * __pndev) * (__ea - __ec)); +# 632 +_Tp __s1 = ((_Tp)1) + (__e2 * (((-__c1) + (((((_Tp)3) * __c3) * __e2) / ((_Tp)4))) - (((((_Tp)3) * __c4) * __e3) / ((_Tp)2)))); +# 634 +_Tp __s2 = __eb * ((__c2 / ((_Tp)2)) + (__pndev * (((-__c3) - __c3) + (__pndev * __c4)))); +# 636 +_Tp __s3 = ((__pndev * __ea) * (__c2 - (__pndev * __c3))) - ((__c2 * __pndev) * __ec); +# 639 +return (((_Tp)3) * __sigma) + ((__power4 * ((__s1 + __s2) + __s3)) / (__mu * std::sqrt(__mu))); +# 641 +} } +# 642 +} +# 661 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 663 +__comp_ellint_3(_Tp __k, _Tp __nu) +# 664 +{ +# 666 +if (__isnan(__k) || __isnan(__nu)) { +# 667 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 668 +if (__nu == ((_Tp)1)) { +# 669 +return std::template numeric_limits< _Tp> ::infinity(); } else { +# 670 +if (std::abs(__k) > ((_Tp)1)) { +# 671 +std::__throw_domain_error("Bad argument in __comp_ellint_3."); } else +# 673 +{ +# 674 +const _Tp __kk = __k * __k; +# 676 +return __ellint_rf((_Tp)0, ((_Tp)1) - __kk, (_Tp)1) + ((__nu * __ellint_rj((_Tp)0, ((_Tp)1) - __kk, (_Tp)1, ((_Tp)1) - __nu)) / ((_Tp)3)); +# 680 +} } } +# 681 +} +# 701 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/ell_integral.tcc" 3 +template< class _Tp> _Tp +# 703 +__ellint_3(_Tp __k, _Tp __nu, _Tp __phi) +# 704 +{ +# 706 +if ((__isnan(__k) || __isnan(__nu)) || __isnan(__phi)) { +# 707 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 708 +if (std::abs(__k) > ((_Tp)1)) { +# 709 +std::__throw_domain_error("Bad argument in __ellint_3."); } else +# 711 +{ +# 713 +const int __n = std::floor((__phi / __numeric_constants< _Tp> ::__pi()) + ((_Tp)(0.5L))); +# 715 +const _Tp __phi_red = __phi - (__n * __numeric_constants< _Tp> ::__pi()); +# 718 +const _Tp __kk = __k * __k; +# 719 +const _Tp __s = std::sin(__phi_red); +# 720 +const _Tp __ss = __s * __s; +# 721 +const _Tp __sss = __ss * __s; +# 722 +const _Tp __c = std::cos(__phi_red); +# 723 +const _Tp __cc = __c * __c; +# 725 +const _Tp __Pi = (__s * __ellint_rf(__cc, ((_Tp)1) - (__kk * __ss), (_Tp)1)) + (((__nu * __sss) * __ellint_rj(__cc, ((_Tp)1) - (__kk * __ss), (_Tp)1, ((_Tp)1) - (__nu * __ss))) / ((_Tp)3)); +# 731 +if (__n == 0) { +# 732 +return __Pi; } else { +# 734 +return __Pi + ((((_Tp)2) * __n) * __comp_ellint_3(__k, __nu)); } +# 735 +} } +# 736 +} +# 737 +} +# 743 +} +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +namespace __detail { +# 66 +template< class _Tp> _Tp __expint_E1(_Tp); +# 81 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 83 +__expint_E1_series(_Tp __x) +# 84 +{ +# 85 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 86 +_Tp __term = ((_Tp)1); +# 87 +_Tp __esum = ((_Tp)0); +# 88 +_Tp __osum = ((_Tp)0); +# 89 +const unsigned __max_iter = (1000); +# 90 +for (unsigned __i = (1); __i < __max_iter; ++__i) +# 91 +{ +# 92 +__term *= ((-__x) / __i); +# 93 +if (std::abs(__term) < __eps) { +# 94 +break; } +# 95 +if (__term >= ((_Tp)0)) { +# 96 +__esum += (__term / __i); } else { +# 98 +__osum += (__term / __i); } +# 99 +} +# 101 +return (((-__esum) - __osum) - __numeric_constants< _Tp> ::__gamma_e()) - std::log(__x); +# 103 +} +# 118 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 120 +__expint_E1_asymp(_Tp __x) +# 121 +{ +# 122 +_Tp __term = ((_Tp)1); +# 123 +_Tp __esum = ((_Tp)1); +# 124 +_Tp __osum = ((_Tp)0); +# 125 +const unsigned __max_iter = (1000); +# 126 +for (unsigned __i = (1); __i < __max_iter; ++__i) +# 127 +{ +# 128 +_Tp __prev = __term; +# 129 +__term *= ((-__i) / __x); +# 130 +if (std::abs(__term) > std::abs(__prev)) { +# 131 +break; } +# 132 +if (__term >= ((_Tp)0)) { +# 133 +__esum += __term; } else { +# 135 +__osum += __term; } +# 136 +} +# 138 +return (std::exp(-__x) * (__esum + __osum)) / __x; +# 139 +} +# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 157 +__expint_En_series(unsigned __n, _Tp __x) +# 158 +{ +# 159 +const unsigned __max_iter = (1000); +# 160 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 161 +const int __nm1 = __n - (1); +# 162 +_Tp __ans = (__nm1 != 0) ? ((_Tp)1) / __nm1 : ((-std::log(__x)) - __numeric_constants< _Tp> ::__gamma_e()); +# 165 +_Tp __fact = ((_Tp)1); +# 166 +for (int __i = 1; __i <= __max_iter; ++__i) +# 167 +{ +# 168 +__fact *= ((-__x) / ((_Tp)__i)); +# 169 +_Tp __del; +# 170 +if (__i != __nm1) { +# 171 +__del = ((-__fact) / ((_Tp)(__i - __nm1))); } else +# 173 +{ +# 174 +_Tp __psi = (-__numeric_constants< _Tp> ::gamma_e()); +# 175 +for (int __ii = 1; __ii <= __nm1; ++__ii) { +# 176 +__psi += (((_Tp)1) / ((_Tp)__ii)); } +# 177 +__del = (__fact * (__psi - std::log(__x))); +# 178 +} +# 179 +__ans += __del; +# 180 +if (std::abs(__del) < (__eps * std::abs(__ans))) { +# 181 +return __ans; } +# 182 +} +# 183 +std::__throw_runtime_error("Series summation failed in __expint_En_series."); +# 185 +} +# 201 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 203 +__expint_En_cont_frac(unsigned __n, _Tp __x) +# 204 +{ +# 205 +const unsigned __max_iter = (1000); +# 206 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 207 +const _Tp __fp_min = std::template numeric_limits< _Tp> ::min(); +# 208 +const int __nm1 = __n - (1); +# 209 +_Tp __b = __x + ((_Tp)__n); +# 210 +_Tp __c = ((_Tp)1) / __fp_min; +# 211 +_Tp __d = ((_Tp)1) / __b; +# 212 +_Tp __h = __d; +# 213 +for (unsigned __i = (1); __i <= __max_iter; ++__i) +# 214 +{ +# 215 +_Tp __a = (-((_Tp)(__i * (__nm1 + __i)))); +# 216 +__b += ((_Tp)2); +# 217 +__d = (((_Tp)1) / ((__a * __d) + __b)); +# 218 +__c = (__b + (__a / __c)); +# 219 +const _Tp __del = __c * __d; +# 220 +__h *= __del; +# 221 +if (std::abs(__del - ((_Tp)1)) < __eps) +# 222 +{ +# 223 +const _Tp __ans = __h * std::exp(-__x); +# 224 +return __ans; +# 225 +} +# 226 +} +# 227 +std::__throw_runtime_error("Continued fraction failed in __expint_En_cont_frac."); +# 229 +} +# 246 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 248 +__expint_En_recursion(unsigned __n, _Tp __x) +# 249 +{ +# 250 +_Tp __En; +# 251 +_Tp __E1 = __expint_E1(__x); +# 252 +if (__x < ((_Tp)__n)) +# 253 +{ +# 255 +__En = __E1; +# 256 +for (unsigned __j = (2); __j < __n; ++__j) { +# 257 +__En = ((std::exp(-__x) - (__x * __En)) / ((_Tp)(__j - (1)))); } +# 258 +} else +# 260 +{ +# 262 +__En = ((_Tp)1); +# 263 +const int __N = __n + (20); +# 264 +_Tp __save = ((_Tp)0); +# 265 +for (int __j = __N; __j > 0; --__j) +# 266 +{ +# 267 +__En = ((std::exp(-__x) - (__j * __En)) / __x); +# 268 +if (__j == __n) { +# 269 +__save = __En; } +# 270 +} +# 271 +_Tp __norm = __En / __E1; +# 272 +__En /= __norm; +# 273 +} +# 275 +return __En; +# 276 +} +# 290 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 292 +__expint_Ei_series(_Tp __x) +# 293 +{ +# 294 +_Tp __term = ((_Tp)1); +# 295 +_Tp __sum = ((_Tp)0); +# 296 +const unsigned __max_iter = (1000); +# 297 +for (unsigned __i = (1); __i < __max_iter; ++__i) +# 298 +{ +# 299 +__term *= (__x / __i); +# 300 +__sum += (__term / __i); +# 301 +if (__term < (std::template numeric_limits< _Tp> ::epsilon() * __sum)) { +# 302 +break; } +# 303 +} +# 305 +return (__numeric_constants< _Tp> ::__gamma_e() + __sum) + std::log(__x); +# 306 +} +# 321 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 323 +__expint_Ei_asymp(_Tp __x) +# 324 +{ +# 325 +_Tp __term = ((_Tp)1); +# 326 +_Tp __sum = ((_Tp)1); +# 327 +const unsigned __max_iter = (1000); +# 328 +for (unsigned __i = (1); __i < __max_iter; ++__i) +# 329 +{ +# 330 +_Tp __prev = __term; +# 331 +__term *= (__i / __x); +# 332 +if (__term < std::template numeric_limits< _Tp> ::epsilon()) { +# 333 +break; } +# 334 +if (__term >= __prev) { +# 335 +break; } +# 336 +__sum += __term; +# 337 +} +# 339 +return (std::exp(__x) * __sum) / __x; +# 340 +} +# 354 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 356 +__expint_Ei(_Tp __x) +# 357 +{ +# 358 +if (__x < ((_Tp)0)) { +# 359 +return -__expint_E1(-__x); } else { +# 360 +if (__x < (-std::log(std::template numeric_limits< _Tp> ::epsilon()))) { +# 361 +return __expint_Ei_series(__x); } else { +# 363 +return __expint_Ei_asymp(__x); } } +# 364 +} +# 378 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 380 +__expint_E1(_Tp __x) +# 381 +{ +# 382 +if (__x < ((_Tp)0)) { +# 383 +return -__expint_Ei(-__x); } else { +# 384 +if (__x < ((_Tp)1)) { +# 385 +return __expint_E1_series(__x); } else { +# 386 +if (__x < ((_Tp)100)) { +# 387 +return __expint_En_cont_frac(1, __x); } else { +# 389 +return __expint_E1_asymp(__x); } } } +# 390 +} +# 408 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 410 +__expint_asymp(unsigned __n, _Tp __x) +# 411 +{ +# 412 +_Tp __term = ((_Tp)1); +# 413 +_Tp __sum = ((_Tp)1); +# 414 +for (unsigned __i = (1); __i <= __n; ++__i) +# 415 +{ +# 416 +_Tp __prev = __term; +# 417 +__term *= ((-((__n - __i) + (1))) / __x); +# 418 +if (std::abs(__term) > std::abs(__prev)) { +# 419 +break; } +# 420 +__sum += __term; +# 421 +} +# 423 +return (std::exp(-__x) * __sum) / __x; +# 424 +} +# 442 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 444 +__expint_large_n(unsigned __n, _Tp __x) +# 445 +{ +# 446 +const _Tp __xpn = __x + __n; +# 447 +const _Tp __xpn2 = __xpn * __xpn; +# 448 +_Tp __term = ((_Tp)1); +# 449 +_Tp __sum = ((_Tp)1); +# 450 +for (unsigned __i = (1); __i <= __n; ++__i) +# 451 +{ +# 452 +_Tp __prev = __term; +# 453 +__term *= ((__n - (((2) * (__i - (1))) * __x)) / __xpn2); +# 454 +if (std::abs(__term) < std::template numeric_limits< _Tp> ::epsilon()) { +# 455 +break; } +# 456 +__sum += __term; +# 457 +} +# 459 +return (std::exp(-__x) * __sum) / __xpn; +# 460 +} +# 476 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> _Tp +# 478 +__expint(unsigned __n, _Tp __x) +# 479 +{ +# 481 +if (__isnan(__x)) { +# 482 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 483 +if ((__n <= (1)) && (__x == ((_Tp)0))) { +# 484 +return std::template numeric_limits< _Tp> ::infinity(); } else +# 486 +{ +# 487 +_Tp __E0 = std::exp(__x) / __x; +# 488 +if (__n == (0)) { +# 489 +return __E0; } +# 491 +_Tp __E1 = __expint_E1(__x); +# 492 +if (__n == (1)) { +# 493 +return __E1; } +# 495 +if (__x == ((_Tp)0)) { +# 496 +return ((_Tp)1) / (static_cast< _Tp>(__n - (1))); } +# 498 +_Tp __En = __expint_En_recursion(__n, __x); +# 500 +return __En; +# 501 +} } +# 502 +} +# 516 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/exp_integral.tcc" 3 +template< class _Tp> inline _Tp +# 518 +__expint(_Tp __x) +# 519 +{ +# 520 +if (__isnan(__x)) { +# 521 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 523 +return __expint_Ei(__x); } +# 524 +} +# 525 +} +# 531 +} +# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 +namespace __detail { +# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 +template< class _Tp> _Tp +# 85 +__conf_hyperg_series(_Tp __a, _Tp __c, _Tp __x) +# 86 +{ +# 87 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 89 +_Tp __term = ((_Tp)1); +# 90 +_Tp __Fac = ((_Tp)1); +# 91 +const unsigned __max_iter = (100000); +# 92 +unsigned __i; +# 93 +for (__i = (0); __i < __max_iter; ++__i) +# 94 +{ +# 95 +__term *= (((__a + ((_Tp)__i)) * __x) / ((__c + ((_Tp)__i)) * ((_Tp)((1) + __i)))); +# 97 +if (std::abs(__term) < __eps) +# 98 +{ +# 99 +break; +# 100 +} +# 101 +__Fac += __term; +# 102 +} +# 103 +if (__i == __max_iter) { +# 104 +std::__throw_runtime_error("Series failed to converge in __conf_hyperg_series."); } +# 107 +return __Fac; +# 108 +} +# 120 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 +template< class _Tp> _Tp +# 122 +__conf_hyperg_luke(_Tp __a, _Tp __c, _Tp __xin) +# 123 +{ +# 124 +const _Tp __big = std::pow(std::template numeric_limits< _Tp> ::max(), (_Tp)(0.16L)); +# 125 +const int __nmax = 20000; +# 126 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 127 +const _Tp __x = (-__xin); +# 128 +const _Tp __x3 = (__x * __x) * __x; +# 129 +const _Tp __t0 = __a / __c; +# 130 +const _Tp __t1 = (__a + ((_Tp)1)) / (((_Tp)2) * __c); +# 131 +const _Tp __t2 = (__a + ((_Tp)2)) / (((_Tp)2) * (__c + ((_Tp)1))); +# 132 +_Tp __F = ((_Tp)1); +# 133 +_Tp __prec; +# 135 +_Tp __Bnm3 = ((_Tp)1); +# 136 +_Tp __Bnm2 = ((_Tp)1) + (__t1 * __x); +# 137 +_Tp __Bnm1 = ((_Tp)1) + ((__t2 * __x) * (((_Tp)1) + ((__t1 / ((_Tp)3)) * __x))); +# 139 +_Tp __Anm3 = ((_Tp)1); +# 140 +_Tp __Anm2 = __Bnm2 - (__t0 * __x); +# 141 +_Tp __Anm1 = (__Bnm1 - ((__t0 * (((_Tp)1) + (__t2 * __x))) * __x)) + ((((__t0 * __t1) * (__c / (__c + ((_Tp)1)))) * __x) * __x); +# 144 +int __n = 3; +# 145 +while (1) +# 146 +{ +# 147 +_Tp __npam1 = ((_Tp)(__n - 1)) + __a; +# 148 +_Tp __npcm1 = ((_Tp)(__n - 1)) + __c; +# 149 +_Tp __npam2 = ((_Tp)(__n - 2)) + __a; +# 150 +_Tp __npcm2 = ((_Tp)(__n - 2)) + __c; +# 151 +_Tp __tnm1 = (_Tp)((2 * __n) - 1); +# 152 +_Tp __tnm3 = (_Tp)((2 * __n) - 3); +# 153 +_Tp __tnm5 = (_Tp)((2 * __n) - 5); +# 154 +_Tp __F1 = (((_Tp)(__n - 2)) - __a) / ((((_Tp)2) * __tnm3) * __npcm1); +# 155 +_Tp __F2 = ((((_Tp)__n) + __a) * __npam1) / ((((((_Tp)4) * __tnm1) * __tnm3) * __npcm2) * __npcm1); +# 157 +_Tp __F3 = (((-__npam2) * __npam1) * (((_Tp)(__n - 2)) - __a)) / ((((((((_Tp)8) * __tnm3) * __tnm3) * __tnm5) * (((_Tp)(__n - 3)) + __c)) * __npcm2) * __npcm1); +# 160 +_Tp __E = ((-__npam1) * (((_Tp)(__n - 1)) - __c)) / (((((_Tp)2) * __tnm3) * __npcm2) * __npcm1); +# 163 +_Tp __An = (((((_Tp)1) + (__F1 * __x)) * __Anm1) + (((__E + (__F2 * __x)) * __x) * __Anm2)) + ((__F3 * __x3) * __Anm3); +# 165 +_Tp __Bn = (((((_Tp)1) + (__F1 * __x)) * __Bnm1) + (((__E + (__F2 * __x)) * __x) * __Bnm2)) + ((__F3 * __x3) * __Bnm3); +# 167 +_Tp __r = __An / __Bn; +# 169 +__prec = std::abs((__F - __r) / __F); +# 170 +__F = __r; +# 172 +if ((__prec < __eps) || (__n > __nmax)) { +# 173 +break; } +# 175 +if ((std::abs(__An) > __big) || (std::abs(__Bn) > __big)) +# 176 +{ +# 177 +__An /= __big; +# 178 +__Bn /= __big; +# 179 +__Anm1 /= __big; +# 180 +__Bnm1 /= __big; +# 181 +__Anm2 /= __big; +# 182 +__Bnm2 /= __big; +# 183 +__Anm3 /= __big; +# 184 +__Bnm3 /= __big; +# 185 +} else { +# 186 +if ((std::abs(__An) < (((_Tp)1) / __big)) || (std::abs(__Bn) < (((_Tp)1) / __big))) +# 188 +{ +# 189 +__An *= __big; +# 190 +__Bn *= __big; +# 191 +__Anm1 *= __big; +# 192 +__Bnm1 *= __big; +# 193 +__Anm2 *= __big; +# 194 +__Bnm2 *= __big; +# 195 +__Anm3 *= __big; +# 196 +__Bnm3 *= __big; +# 197 +} } +# 199 +++__n; +# 200 +__Bnm3 = __Bnm2; +# 201 +__Bnm2 = __Bnm1; +# 202 +__Bnm1 = __Bn; +# 203 +__Anm3 = __Anm2; +# 204 +__Anm2 = __Anm1; +# 205 +__Anm1 = __An; +# 206 +} +# 208 +if (__n >= __nmax) { +# 209 +std::__throw_runtime_error("Iteration failed to converge in __conf_hyperg_luke."); } +# 212 +return __F; +# 213 +} +# 227 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 +template< class _Tp> _Tp +# 229 +__conf_hyperg(_Tp __a, _Tp __c, _Tp __x) +# 230 +{ +# 232 +const _Tp __c_nint = std::nearbyint(__c); +# 236 +if ((__isnan(__a) || __isnan(__c)) || __isnan(__x)) { +# 237 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 238 +if ((__c_nint == __c) && (__c_nint <= 0)) { +# 239 +return std::template numeric_limits< _Tp> ::infinity(); } else { +# 240 +if (__a == ((_Tp)0)) { +# 241 +return (_Tp)1; } else { +# 242 +if (__c == __a) { +# 243 +return std::exp(__x); } else { +# 244 +if (__x < ((_Tp)0)) { +# 245 +return __conf_hyperg_luke(__a, __c, __x); } else { +# 247 +return __conf_hyperg_series(__a, __c, __x); } } } } } +# 248 +} +# 271 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 +template< class _Tp> _Tp +# 273 +__hyperg_series(_Tp __a, _Tp __b, _Tp __c, _Tp __x) +# 274 +{ +# 275 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 277 +_Tp __term = ((_Tp)1); +# 278 +_Tp __Fabc = ((_Tp)1); +# 279 +const unsigned __max_iter = (100000); +# 280 +unsigned __i; +# 281 +for (__i = (0); __i < __max_iter; ++__i) +# 282 +{ +# 283 +__term *= ((((__a + ((_Tp)__i)) * (__b + ((_Tp)__i))) * __x) / ((__c + ((_Tp)__i)) * ((_Tp)((1) + __i)))); +# 285 +if (std::abs(__term) < __eps) +# 286 +{ +# 287 +break; +# 288 +} +# 289 +__Fabc += __term; +# 290 +} +# 291 +if (__i == __max_iter) { +# 292 +std::__throw_runtime_error("Series failed to converge in __hyperg_series."); } +# 295 +return __Fabc; +# 296 +} +# 304 +template< class _Tp> _Tp +# 306 +__hyperg_luke(_Tp __a, _Tp __b, _Tp __c, _Tp __xin) +# 307 +{ +# 308 +const _Tp __big = std::pow(std::template numeric_limits< _Tp> ::max(), (_Tp)(0.16L)); +# 309 +const int __nmax = 20000; +# 310 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 311 +const _Tp __x = (-__xin); +# 312 +const _Tp __x3 = (__x * __x) * __x; +# 313 +const _Tp __t0 = (__a * __b) / __c; +# 314 +const _Tp __t1 = ((__a + ((_Tp)1)) * (__b + ((_Tp)1))) / (((_Tp)2) * __c); +# 315 +const _Tp __t2 = ((__a + ((_Tp)2)) * (__b + ((_Tp)2))) / (((_Tp)2) * (__c + ((_Tp)1))); +# 318 +_Tp __F = ((_Tp)1); +# 320 +_Tp __Bnm3 = ((_Tp)1); +# 321 +_Tp __Bnm2 = ((_Tp)1) + (__t1 * __x); +# 322 +_Tp __Bnm1 = ((_Tp)1) + ((__t2 * __x) * (((_Tp)1) + ((__t1 / ((_Tp)3)) * __x))); +# 324 +_Tp __Anm3 = ((_Tp)1); +# 325 +_Tp __Anm2 = __Bnm2 - (__t0 * __x); +# 326 +_Tp __Anm1 = (__Bnm1 - ((__t0 * (((_Tp)1) + (__t2 * __x))) * __x)) + ((((__t0 * __t1) * (__c / (__c + ((_Tp)1)))) * __x) * __x); +# 329 +int __n = 3; +# 330 +while (1) +# 331 +{ +# 332 +const _Tp __npam1 = ((_Tp)(__n - 1)) + __a; +# 333 +const _Tp __npbm1 = ((_Tp)(__n - 1)) + __b; +# 334 +const _Tp __npcm1 = ((_Tp)(__n - 1)) + __c; +# 335 +const _Tp __npam2 = ((_Tp)(__n - 2)) + __a; +# 336 +const _Tp __npbm2 = ((_Tp)(__n - 2)) + __b; +# 337 +const _Tp __npcm2 = ((_Tp)(__n - 2)) + __c; +# 338 +const _Tp __tnm1 = (_Tp)((2 * __n) - 1); +# 339 +const _Tp __tnm3 = (_Tp)((2 * __n) - 3); +# 340 +const _Tp __tnm5 = (_Tp)((2 * __n) - 5); +# 341 +const _Tp __n2 = __n * __n; +# 342 +const _Tp __F1 = (((((((_Tp)3) * __n2) + (((__a + __b) - ((_Tp)6)) * __n)) + ((_Tp)2)) - (__a * __b)) - (((_Tp)2) * (__a + __b))) / ((((_Tp)2) * __tnm3) * __npcm1); +# 345 +const _Tp __F2 = (((-((((((_Tp)3) * __n2) - (((__a + __b) + ((_Tp)6)) * __n)) + ((_Tp)2)) - (__a * __b))) * __npam1) * __npbm1) / ((((((_Tp)4) * __tnm1) * __tnm3) * __npcm2) * __npcm1); +# 348 +const _Tp __F3 = (((((__npam2 * __npam1) * __npbm2) * __npbm1) * (((_Tp)(__n - 2)) - __a)) * (((_Tp)(__n - 2)) - __b)) / ((((((((_Tp)8) * __tnm3) * __tnm3) * __tnm5) * (((_Tp)(__n - 3)) + __c)) * __npcm2) * __npcm1); +# 352 +const _Tp __E = (((-__npam1) * __npbm1) * (((_Tp)(__n - 1)) - __c)) / (((((_Tp)2) * __tnm3) * __npcm2) * __npcm1); +# 355 +_Tp __An = (((((_Tp)1) + (__F1 * __x)) * __Anm1) + (((__E + (__F2 * __x)) * __x) * __Anm2)) + ((__F3 * __x3) * __Anm3); +# 357 +_Tp __Bn = (((((_Tp)1) + (__F1 * __x)) * __Bnm1) + (((__E + (__F2 * __x)) * __x) * __Bnm2)) + ((__F3 * __x3) * __Bnm3); +# 359 +const _Tp __r = __An / __Bn; +# 361 +const _Tp __prec = std::abs((__F - __r) / __F); +# 362 +__F = __r; +# 364 +if ((__prec < __eps) || (__n > __nmax)) { +# 365 +break; } +# 367 +if ((std::abs(__An) > __big) || (std::abs(__Bn) > __big)) +# 368 +{ +# 369 +__An /= __big; +# 370 +__Bn /= __big; +# 371 +__Anm1 /= __big; +# 372 +__Bnm1 /= __big; +# 373 +__Anm2 /= __big; +# 374 +__Bnm2 /= __big; +# 375 +__Anm3 /= __big; +# 376 +__Bnm3 /= __big; +# 377 +} else { +# 378 +if ((std::abs(__An) < (((_Tp)1) / __big)) || (std::abs(__Bn) < (((_Tp)1) / __big))) +# 380 +{ +# 381 +__An *= __big; +# 382 +__Bn *= __big; +# 383 +__Anm1 *= __big; +# 384 +__Bnm1 *= __big; +# 385 +__Anm2 *= __big; +# 386 +__Bnm2 *= __big; +# 387 +__Anm3 *= __big; +# 388 +__Bnm3 *= __big; +# 389 +} } +# 391 +++__n; +# 392 +__Bnm3 = __Bnm2; +# 393 +__Bnm2 = __Bnm1; +# 394 +__Bnm1 = __Bn; +# 395 +__Anm3 = __Anm2; +# 396 +__Anm2 = __Anm1; +# 397 +__Anm1 = __An; +# 398 +} +# 400 +if (__n >= __nmax) { +# 401 +std::__throw_runtime_error("Iteration failed to converge in __hyperg_luke."); } +# 404 +return __F; +# 405 +} +# 438 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 +template< class _Tp> _Tp +# 440 +__hyperg_reflect(_Tp __a, _Tp __b, _Tp __c, _Tp __x) +# 441 +{ +# 442 +const _Tp __d = (__c - __a) - __b; +# 443 +const int __intd = std::floor(__d + ((_Tp)(0.5L))); +# 444 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 445 +const _Tp __toler = ((_Tp)1000) * __eps; +# 446 +const _Tp __log_max = std::log(std::template numeric_limits< _Tp> ::max()); +# 447 +const bool __d_integer = std::abs(__d - __intd) < __toler; +# 449 +if (__d_integer) +# 450 +{ +# 451 +const _Tp __ln_omx = std::log(((_Tp)1) - __x); +# 452 +const _Tp __ad = std::abs(__d); +# 453 +_Tp __F1, __F2; +# 455 +_Tp __d1, __d2; +# 456 +if (__d >= ((_Tp)0)) +# 457 +{ +# 458 +__d1 = __d; +# 459 +__d2 = ((_Tp)0); +# 460 +} else +# 462 +{ +# 463 +__d1 = ((_Tp)0); +# 464 +__d2 = __d; +# 465 +} +# 467 +const _Tp __lng_c = __log_gamma(__c); +# 470 +if (__ad < __eps) +# 471 +{ +# 473 +__F1 = ((_Tp)0); +# 474 +} else +# 476 +{ +# 478 +bool __ok_d1 = true; +# 479 +_Tp __lng_ad, __lng_ad1, __lng_bd1; +# 480 +try +# 481 +{ +# 482 +__lng_ad = __log_gamma(__ad); +# 483 +__lng_ad1 = __log_gamma(__a + __d1); +# 484 +__lng_bd1 = __log_gamma(__b + __d1); +# 485 +} +# 486 +catch (...) +# 487 +{ +# 488 +__ok_d1 = false; +# 489 +} +# 491 +if (__ok_d1) +# 492 +{ +# 496 +_Tp __sum1 = ((_Tp)1); +# 497 +_Tp __term = ((_Tp)1); +# 498 +_Tp __ln_pre1 = (((__lng_ad + __lng_c) + (__d2 * __ln_omx)) - __lng_ad1) - __lng_bd1; +# 503 +for (int __i = 1; __i < __ad; ++__i) +# 504 +{ +# 505 +const int __j = __i - 1; +# 506 +__term *= ((((((__a + __d2) + __j) * ((__b + __d2) + __j)) / ((((_Tp)1) + __d2) + __j)) / __i) * (((_Tp)1) - __x)); +# 508 +__sum1 += __term; +# 509 +} +# 511 +if (__ln_pre1 > __log_max) { +# 512 +std::__throw_runtime_error("Overflow of gamma functions in __hyperg_luke."); } else { +# 515 +__F1 = (std::exp(__ln_pre1) * __sum1); } +# 516 +} else +# 518 +{ +# 521 +__F1 = ((_Tp)0); +# 522 +} +# 523 +} +# 526 +bool __ok_d2 = true; +# 527 +_Tp __lng_ad2, __lng_bd2; +# 528 +try +# 529 +{ +# 530 +__lng_ad2 = __log_gamma(__a + __d2); +# 531 +__lng_bd2 = __log_gamma(__b + __d2); +# 532 +} +# 533 +catch (...) +# 534 +{ +# 535 +__ok_d2 = false; +# 536 +} +# 538 +if (__ok_d2) +# 539 +{ +# 542 +const int __maxiter = 2000; +# 543 +const _Tp __psi_1 = (-__numeric_constants< _Tp> ::__gamma_e()); +# 544 +const _Tp __psi_1pd = __psi(((_Tp)1) + __ad); +# 545 +const _Tp __psi_apd1 = __psi(__a + __d1); +# 546 +const _Tp __psi_bpd1 = __psi(__b + __d1); +# 548 +_Tp __psi_term = (((__psi_1 + __psi_1pd) - __psi_apd1) - __psi_bpd1) - __ln_omx; +# 550 +_Tp __fact = ((_Tp)1); +# 551 +_Tp __sum2 = __psi_term; +# 552 +_Tp __ln_pre2 = ((__lng_c + (__d1 * __ln_omx)) - __lng_ad2) - __lng_bd2; +# 556 +int __j; +# 557 +for (__j = 1; __j < __maxiter; ++__j) +# 558 +{ +# 561 +const _Tp __term1 = (((_Tp)1) / ((_Tp)__j)) + (((_Tp)1) / (__ad + __j)); +# 563 +const _Tp __term2 = (((_Tp)1) / ((__a + __d1) + ((_Tp)(__j - 1)))) + (((_Tp)1) / ((__b + __d1) + ((_Tp)(__j - 1)))); +# 565 +__psi_term += (__term1 - __term2); +# 566 +__fact *= (((((__a + __d1) + ((_Tp)(__j - 1))) * ((__b + __d1) + ((_Tp)(__j - 1)))) / ((__ad + __j) * __j)) * (((_Tp)1) - __x)); +# 569 +const _Tp __delta = __fact * __psi_term; +# 570 +__sum2 += __delta; +# 571 +if (std::abs(__delta) < (__eps * std::abs(__sum2))) { +# 572 +break; } +# 573 +} +# 574 +if (__j == __maxiter) { +# 575 +std::__throw_runtime_error("Sum F2 failed to converge in __hyperg_reflect"); } +# 578 +if (__sum2 == ((_Tp)0)) { +# 579 +__F2 = ((_Tp)0); } else { +# 581 +__F2 = (std::exp(__ln_pre2) * __sum2); } +# 582 +} else +# 584 +{ +# 587 +__F2 = ((_Tp)0); +# 588 +} +# 590 +const _Tp __sgn_2 = (((__intd % 2) == 1) ? -((_Tp)1) : ((_Tp)1)); +# 591 +const _Tp __F = __F1 + (__sgn_2 * __F2); +# 593 +return __F; +# 594 +} else +# 596 +{ +# 601 +bool __ok1 = true; +# 602 +_Tp __sgn_g1ca = ((_Tp)0), __ln_g1ca = ((_Tp)0); +# 603 +_Tp __sgn_g1cb = ((_Tp)0), __ln_g1cb = ((_Tp)0); +# 604 +try +# 605 +{ +# 606 +__sgn_g1ca = __log_gamma_sign(__c - __a); +# 607 +__ln_g1ca = __log_gamma(__c - __a); +# 608 +__sgn_g1cb = __log_gamma_sign(__c - __b); +# 609 +__ln_g1cb = __log_gamma(__c - __b); +# 610 +} +# 611 +catch (...) +# 612 +{ +# 613 +__ok1 = false; +# 614 +} +# 616 +bool __ok2 = true; +# 617 +_Tp __sgn_g2a = ((_Tp)0), __ln_g2a = ((_Tp)0); +# 618 +_Tp __sgn_g2b = ((_Tp)0), __ln_g2b = ((_Tp)0); +# 619 +try +# 620 +{ +# 621 +__sgn_g2a = __log_gamma_sign(__a); +# 622 +__ln_g2a = __log_gamma(__a); +# 623 +__sgn_g2b = __log_gamma_sign(__b); +# 624 +__ln_g2b = __log_gamma(__b); +# 625 +} +# 626 +catch (...) +# 627 +{ +# 628 +__ok2 = false; +# 629 +} +# 631 +const _Tp __sgn_gc = __log_gamma_sign(__c); +# 632 +const _Tp __ln_gc = __log_gamma(__c); +# 633 +const _Tp __sgn_gd = __log_gamma_sign(__d); +# 634 +const _Tp __ln_gd = __log_gamma(__d); +# 635 +const _Tp __sgn_gmd = __log_gamma_sign(-__d); +# 636 +const _Tp __ln_gmd = __log_gamma(-__d); +# 638 +const _Tp __sgn1 = ((__sgn_gc * __sgn_gd) * __sgn_g1ca) * __sgn_g1cb; +# 639 +const _Tp __sgn2 = ((__sgn_gc * __sgn_gmd) * __sgn_g2a) * __sgn_g2b; +# 641 +_Tp __pre1, __pre2; +# 642 +if (__ok1 && __ok2) +# 643 +{ +# 644 +_Tp __ln_pre1 = ((__ln_gc + __ln_gd) - __ln_g1ca) - __ln_g1cb; +# 645 +_Tp __ln_pre2 = (((__ln_gc + __ln_gmd) - __ln_g2a) - __ln_g2b) + (__d * std::log(((_Tp)1) - __x)); +# 647 +if ((__ln_pre1 < __log_max) && (__ln_pre2 < __log_max)) +# 648 +{ +# 649 +__pre1 = std::exp(__ln_pre1); +# 650 +__pre2 = std::exp(__ln_pre2); +# 651 +__pre1 *= __sgn1; +# 652 +__pre2 *= __sgn2; +# 653 +} else +# 655 +{ +# 656 +std::__throw_runtime_error("Overflow of gamma functions in __hyperg_reflect"); +# 658 +} +# 659 +} else { +# 660 +if (__ok1 && (!__ok2)) +# 661 +{ +# 662 +_Tp __ln_pre1 = ((__ln_gc + __ln_gd) - __ln_g1ca) - __ln_g1cb; +# 663 +if (__ln_pre1 < __log_max) +# 664 +{ +# 665 +__pre1 = std::exp(__ln_pre1); +# 666 +__pre1 *= __sgn1; +# 667 +__pre2 = ((_Tp)0); +# 668 +} else +# 670 +{ +# 671 +std::__throw_runtime_error("Overflow of gamma functions in __hyperg_reflect"); +# 673 +} +# 674 +} else { +# 675 +if ((!__ok1) && __ok2) +# 676 +{ +# 677 +_Tp __ln_pre2 = (((__ln_gc + __ln_gmd) - __ln_g2a) - __ln_g2b) + (__d * std::log(((_Tp)1) - __x)); +# 679 +if (__ln_pre2 < __log_max) +# 680 +{ +# 681 +__pre1 = ((_Tp)0); +# 682 +__pre2 = std::exp(__ln_pre2); +# 683 +__pre2 *= __sgn2; +# 684 +} else +# 686 +{ +# 687 +std::__throw_runtime_error("Overflow of gamma functions in __hyperg_reflect"); +# 689 +} +# 690 +} else +# 692 +{ +# 693 +__pre1 = ((_Tp)0); +# 694 +__pre2 = ((_Tp)0); +# 695 +std::__throw_runtime_error("Underflow of gamma functions in __hyperg_reflect"); +# 697 +} } } +# 699 +const _Tp __F1 = __hyperg_series(__a, __b, ((_Tp)1) - __d, ((_Tp)1) - __x); +# 701 +const _Tp __F2 = __hyperg_series(__c - __a, __c - __b, ((_Tp)1) + __d, ((_Tp)1) - __x); +# 704 +const _Tp __F = (__pre1 * __F1) + (__pre2 * __F2); +# 706 +return __F; +# 707 +} +# 708 +} +# 728 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/hypergeometric.tcc" 3 +template< class _Tp> _Tp +# 730 +__hyperg(_Tp __a, _Tp __b, _Tp __c, _Tp __x) +# 731 +{ +# 733 +const _Tp __a_nint = std::nearbyint(__a); +# 734 +const _Tp __b_nint = std::nearbyint(__b); +# 735 +const _Tp __c_nint = std::nearbyint(__c); +# 741 +const _Tp __toler = ((_Tp)1000) * std::template numeric_limits< _Tp> ::epsilon(); +# 742 +if (std::abs(__x) >= ((_Tp)1)) { +# 743 +std::__throw_domain_error("Argument outside unit circle in __hyperg."); } else { +# 745 +if (((__isnan(__a) || __isnan(__b)) || __isnan(__c)) || __isnan(__x)) { +# 747 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 748 +if ((__c_nint == __c) && (__c_nint <= ((_Tp)0))) { +# 749 +return std::template numeric_limits< _Tp> ::infinity(); } else { +# 750 +if ((std::abs(__c - __b) < __toler) || (std::abs(__c - __a) < __toler)) { +# 751 +return std::pow(((_Tp)1) - __x, (__c - __a) - __b); } else { +# 752 +if ((__a >= ((_Tp)0)) && (__b >= ((_Tp)0)) && (__c >= ((_Tp)0)) && (__x >= ((_Tp)0)) && (__x < ((_Tp)(0.995L)))) { +# 754 +return __hyperg_series(__a, __b, __c, __x); } else { +# 755 +if ((std::abs(__a) < ((_Tp)10)) && (std::abs(__b) < ((_Tp)10))) +# 756 +{ +# 759 +if ((__a < ((_Tp)0)) && (std::abs(__a - __a_nint) < __toler)) { +# 760 +return __hyperg_series(__a_nint, __b, __c, __x); } else { +# 761 +if ((__b < ((_Tp)0)) && (std::abs(__b - __b_nint) < __toler)) { +# 762 +return __hyperg_series(__a, __b_nint, __c, __x); } else { +# 763 +if (__x < (-((_Tp)(0.25L)))) { +# 764 +return __hyperg_luke(__a, __b, __c, __x); } else { +# 765 +if (__x < ((_Tp)(0.5L))) { +# 766 +return __hyperg_series(__a, __b, __c, __x); } else { +# 768 +if (std::abs(__c) > ((_Tp)10)) { +# 769 +return __hyperg_series(__a, __b, __c, __x); } else { +# 771 +return __hyperg_reflect(__a, __b, __c, __x); } } } } } +# 772 +} else { +# 774 +return __hyperg_luke(__a, __b, __c, __x); } } } } } } +# 775 +} +# 776 +} +# 783 +} +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 +namespace __detail { +# 80 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 +template< class _Tp> _Tp +# 82 +__poly_legendre_p(unsigned __l, _Tp __x) +# 83 +{ +# 85 +if (__isnan(__x)) { +# 86 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 87 +if (__x == (+((_Tp)1))) { +# 88 +return +((_Tp)1); } else { +# 89 +if (__x == (-((_Tp)1))) { +# 90 +return (((__l % (2)) == (1)) ? -((_Tp)1) : (+((_Tp)1))); } else +# 92 +{ +# 93 +_Tp __p_lm2 = ((_Tp)1); +# 94 +if (__l == (0)) { +# 95 +return __p_lm2; } +# 97 +_Tp __p_lm1 = __x; +# 98 +if (__l == (1)) { +# 99 +return __p_lm1; } +# 101 +_Tp __p_l = (0); +# 102 +for (unsigned __ll = (2); __ll <= __l; ++__ll) +# 103 +{ +# 106 +__p_l = ((((((_Tp)2) * __x) * __p_lm1) - __p_lm2) - (((__x * __p_lm1) - __p_lm2) / ((_Tp)__ll))); +# 108 +__p_lm2 = __p_lm1; +# 109 +__p_lm1 = __p_l; +# 110 +} +# 112 +return __p_l; +# 113 +} } } +# 114 +} +# 136 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 +template< class _Tp> _Tp +# 138 +__assoc_legendre_p(unsigned __l, unsigned __m, _Tp __x, _Tp +# 139 +__phase = (_Tp)(+1)) +# 140 +{ +# 142 +if (__m > __l) { +# 143 +return (_Tp)0; } else { +# 144 +if (__isnan(__x)) { +# 145 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 146 +if (__m == (0)) { +# 147 +return __poly_legendre_p(__l, __x); } else +# 149 +{ +# 150 +_Tp __p_mm = ((_Tp)1); +# 151 +if (__m > (0)) +# 152 +{ +# 155 +_Tp __root = std::sqrt(((_Tp)1) - __x) * std::sqrt(((_Tp)1) + __x); +# 156 +_Tp __fact = ((_Tp)1); +# 157 +for (unsigned __i = (1); __i <= __m; ++__i) +# 158 +{ +# 159 +__p_mm *= ((__phase * __fact) * __root); +# 160 +__fact += ((_Tp)2); +# 161 +} +# 162 +} +# 163 +if (__l == __m) { +# 164 +return __p_mm; } +# 166 +_Tp __p_mp1m = (((_Tp)(((2) * __m) + (1))) * __x) * __p_mm; +# 167 +if (__l == (__m + (1))) { +# 168 +return __p_mp1m; } +# 170 +_Tp __p_lm2m = __p_mm; +# 171 +_Tp __P_lm1m = __p_mp1m; +# 172 +_Tp __p_lm = ((_Tp)0); +# 173 +for (unsigned __j = __m + (2); __j <= __l; ++__j) +# 174 +{ +# 175 +__p_lm = ((((((_Tp)(((2) * __j) - (1))) * __x) * __P_lm1m) - (((_Tp)((__j + __m) - (1))) * __p_lm2m)) / ((_Tp)(__j - __m))); +# 177 +__p_lm2m = __P_lm1m; +# 178 +__P_lm1m = __p_lm; +# 179 +} +# 181 +return __p_lm; +# 182 +} } } +# 183 +} +# 214 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/legendre_function.tcc" 3 +template< class _Tp> _Tp +# 216 +__sph_legendre(unsigned __l, unsigned __m, _Tp __theta) +# 217 +{ +# 218 +if (__isnan(__theta)) { +# 219 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } +# 221 +const _Tp __x = std::cos(__theta); +# 223 +if (__m > __l) { +# 224 +return (_Tp)0; } else { +# 225 +if (__m == (0)) +# 226 +{ +# 227 +_Tp __P = __poly_legendre_p(__l, __x); +# 228 +_Tp __fact = std::sqrt(((_Tp)(((2) * __l) + (1))) / (((_Tp)4) * __numeric_constants< _Tp> ::__pi())); +# 230 +__P *= __fact; +# 231 +return __P; +# 232 +} else { +# 233 +if ((__x == ((_Tp)1)) || (__x == (-((_Tp)1)))) +# 234 +{ +# 236 +return (_Tp)0; +# 237 +} else +# 239 +{ +# 245 +const _Tp __sgn = ((__m % (2)) == (1)) ? -((_Tp)1) : ((_Tp)1); +# 246 +const _Tp __y_mp1m_factor = __x * std::sqrt((_Tp)(((2) * __m) + (3))); +# 248 +const _Tp __lncirc = std::log1p((-__x) * __x); +# 254 +const _Tp __lnpoch = std::lgamma((_Tp)(__m + ((_Tp)(0.5L)))) - std::lgamma((_Tp)__m); +# 260 +const _Tp __lnpre_val = ((-((_Tp)(0.25L))) * __numeric_constants< _Tp> ::__lnpi()) + (((_Tp)(0.5L)) * (__lnpoch + (__m * __lncirc))); +# 263 +const _Tp __sr = std::sqrt((((_Tp)2) + (((_Tp)1) / __m)) / (((_Tp)4) * __numeric_constants< _Tp> ::__pi())); +# 265 +_Tp __y_mm = (__sgn * __sr) * std::exp(__lnpre_val); +# 266 +_Tp __y_mp1m = __y_mp1m_factor * __y_mm; +# 268 +if (__l == __m) { +# 269 +return __y_mm; } else { +# 270 +if (__l == (__m + (1))) { +# 271 +return __y_mp1m; } else +# 273 +{ +# 274 +_Tp __y_lm = ((_Tp)0); +# 277 +for (unsigned __ll = __m + (2); __ll <= __l; ++__ll) +# 278 +{ +# 279 +const _Tp __rat1 = ((_Tp)(__ll - __m)) / ((_Tp)(__ll + __m)); +# 280 +const _Tp __rat2 = ((_Tp)((__ll - __m) - (1))) / ((_Tp)((__ll + __m) - (1))); +# 281 +const _Tp __fact1 = std::sqrt((__rat1 * ((_Tp)(((2) * __ll) + (1)))) * ((_Tp)(((2) * __ll) - (1)))); +# 283 +const _Tp __fact2 = std::sqrt(((__rat1 * __rat2) * ((_Tp)(((2) * __ll) + (1)))) / ((_Tp)(((2) * __ll) - (3)))); +# 285 +__y_lm = ((((__x * __y_mp1m) * __fact1) - ((((__ll + __m) - (1)) * __y_mm) * __fact2)) / ((_Tp)(__ll - __m))); +# 287 +__y_mm = __y_mp1m; +# 288 +__y_mp1m = __y_lm; +# 289 +} +# 291 +return __y_lm; +# 292 +} } +# 293 +} } } +# 294 +} +# 295 +} +# 302 +} +# 51 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 +namespace __detail { +# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 +template< class _Tp> void +# 85 +__bessel_ik(_Tp __nu, _Tp __x, _Tp & +# 86 +__Inu, _Tp &__Knu, _Tp &__Ipnu, _Tp &__Kpnu) +# 87 +{ +# 88 +if (__x == ((_Tp)0)) +# 89 +{ +# 90 +if (__nu == ((_Tp)0)) +# 91 +{ +# 92 +__Inu = ((_Tp)1); +# 93 +__Ipnu = ((_Tp)0); +# 94 +} else { +# 95 +if (__nu == ((_Tp)1)) +# 96 +{ +# 97 +__Inu = ((_Tp)0); +# 98 +__Ipnu = ((_Tp)(0.5L)); +# 99 +} else +# 101 +{ +# 102 +__Inu = ((_Tp)0); +# 103 +__Ipnu = ((_Tp)0); +# 104 +} } +# 105 +__Knu = std::template numeric_limits< _Tp> ::infinity(); +# 106 +__Kpnu = (-std::template numeric_limits< _Tp> ::infinity()); +# 107 +return; +# 108 +} +# 110 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 111 +const _Tp __fp_min = ((_Tp)10) * std::template numeric_limits< _Tp> ::epsilon(); +# 112 +const int __max_iter = 15000; +# 113 +const _Tp __x_min = ((_Tp)2); +# 115 +const int __nl = static_cast< int>(__nu + ((_Tp)(0.5L))); +# 117 +const _Tp __mu = __nu - __nl; +# 118 +const _Tp __mu2 = __mu * __mu; +# 119 +const _Tp __xi = ((_Tp)1) / __x; +# 120 +const _Tp __xi2 = ((_Tp)2) * __xi; +# 121 +_Tp __h = __nu * __xi; +# 122 +if (__h < __fp_min) { +# 123 +__h = __fp_min; } +# 124 +_Tp __b = __xi2 * __nu; +# 125 +_Tp __d = ((_Tp)0); +# 126 +_Tp __c = __h; +# 127 +int __i; +# 128 +for (__i = 1; __i <= __max_iter; ++__i) +# 129 +{ +# 130 +__b += __xi2; +# 131 +__d = (((_Tp)1) / (__b + __d)); +# 132 +__c = (__b + (((_Tp)1) / __c)); +# 133 +const _Tp __del = __c * __d; +# 134 +__h *= __del; +# 135 +if (std::abs(__del - ((_Tp)1)) < __eps) { +# 136 +break; } +# 137 +} +# 138 +if (__i > __max_iter) { +# 139 +std::__throw_runtime_error("Argument x too large in __bessel_ik; try asymptotic expansion."); } +# 142 +_Tp __Inul = __fp_min; +# 143 +_Tp __Ipnul = __h * __Inul; +# 144 +_Tp __Inul1 = __Inul; +# 145 +_Tp __Ipnu1 = __Ipnul; +# 146 +_Tp __fact = __nu * __xi; +# 147 +for (int __l = __nl; __l >= 1; --__l) +# 148 +{ +# 149 +const _Tp __Inutemp = (__fact * __Inul) + __Ipnul; +# 150 +__fact -= __xi; +# 151 +__Ipnul = ((__fact * __Inutemp) + __Inul); +# 152 +__Inul = __Inutemp; +# 153 +} +# 154 +_Tp __f = __Ipnul / __Inul; +# 155 +_Tp __Kmu, __Knu1; +# 156 +if (__x < __x_min) +# 157 +{ +# 158 +const _Tp __x2 = __x / ((_Tp)2); +# 159 +const _Tp __pimu = __numeric_constants< _Tp> ::__pi() * __mu; +# 160 +const _Tp __fact = (std::abs(__pimu) < __eps) ? (_Tp)1 : (__pimu / std::sin(__pimu)); +# 162 +_Tp __d = (-std::log(__x2)); +# 163 +_Tp __e = __mu * __d; +# 164 +const _Tp __fact2 = (std::abs(__e) < __eps) ? (_Tp)1 : (std::sinh(__e) / __e); +# 166 +_Tp __gam1, __gam2, __gampl, __gammi; +# 167 +__gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi); +# 168 +_Tp __ff = __fact * ((__gam1 * std::cosh(__e)) + ((__gam2 * __fact2) * __d)); +# 170 +_Tp __sum = __ff; +# 171 +__e = std::exp(__e); +# 172 +_Tp __p = __e / (((_Tp)2) * __gampl); +# 173 +_Tp __q = ((_Tp)1) / ((((_Tp)2) * __e) * __gammi); +# 174 +_Tp __c = ((_Tp)1); +# 175 +__d = (__x2 * __x2); +# 176 +_Tp __sum1 = __p; +# 177 +int __i; +# 178 +for (__i = 1; __i <= __max_iter; ++__i) +# 179 +{ +# 180 +__ff = ((((__i * __ff) + __p) + __q) / ((__i * __i) - __mu2)); +# 181 +__c *= (__d / __i); +# 182 +__p /= (__i - __mu); +# 183 +__q /= (__i + __mu); +# 184 +const _Tp __del = __c * __ff; +# 185 +__sum += __del; +# 186 +const _Tp __del1 = __c * (__p - (__i * __ff)); +# 187 +__sum1 += __del1; +# 188 +if (std::abs(__del) < (__eps * std::abs(__sum))) { +# 189 +break; } +# 190 +} +# 191 +if (__i > __max_iter) { +# 192 +std::__throw_runtime_error("Bessel k series failed to converge in __bessel_ik."); } +# 194 +__Kmu = __sum; +# 195 +__Knu1 = (__sum1 * __xi2); +# 196 +} else +# 198 +{ +# 199 +_Tp __b = ((_Tp)2) * (((_Tp)1) + __x); +# 200 +_Tp __d = ((_Tp)1) / __b; +# 201 +_Tp __delh = __d; +# 202 +_Tp __h = __delh; +# 203 +_Tp __q1 = ((_Tp)0); +# 204 +_Tp __q2 = ((_Tp)1); +# 205 +_Tp __a1 = ((_Tp)(0.25L)) - __mu2; +# 206 +_Tp __q = __c = __a1; +# 207 +_Tp __a = (-__a1); +# 208 +_Tp __s = ((_Tp)1) + (__q * __delh); +# 209 +int __i; +# 210 +for (__i = 2; __i <= __max_iter; ++__i) +# 211 +{ +# 212 +__a -= (2 * (__i - 1)); +# 213 +__c = (((-__a) * __c) / __i); +# 214 +const _Tp __qnew = (__q1 - (__b * __q2)) / __a; +# 215 +__q1 = __q2; +# 216 +__q2 = __qnew; +# 217 +__q += (__c * __qnew); +# 218 +__b += ((_Tp)2); +# 219 +__d = (((_Tp)1) / (__b + (__a * __d))); +# 220 +__delh = (((__b * __d) - ((_Tp)1)) * __delh); +# 221 +__h += __delh; +# 222 +const _Tp __dels = __q * __delh; +# 223 +__s += __dels; +# 224 +if (std::abs(__dels / __s) < __eps) { +# 225 +break; } +# 226 +} +# 227 +if (__i > __max_iter) { +# 228 +std::__throw_runtime_error("Steed\'s method failed in __bessel_ik."); } +# 230 +__h = (__a1 * __h); +# 231 +__Kmu = ((std::sqrt(__numeric_constants< _Tp> ::__pi() / (((_Tp)2) * __x)) * std::exp(-__x)) / __s); +# 233 +__Knu1 = ((__Kmu * (((__mu + __x) + ((_Tp)(0.5L))) - __h)) * __xi); +# 234 +} +# 236 +_Tp __Kpmu = ((__mu * __xi) * __Kmu) - __Knu1; +# 237 +_Tp __Inumu = __xi / ((__f * __Kmu) - __Kpmu); +# 238 +__Inu = ((__Inumu * __Inul1) / __Inul); +# 239 +__Ipnu = ((__Inumu * __Ipnu1) / __Inul); +# 240 +for (__i = 1; __i <= __nl; ++__i) +# 241 +{ +# 242 +const _Tp __Knutemp = (((__mu + __i) * __xi2) * __Knu1) + __Kmu; +# 243 +__Kmu = __Knu1; +# 244 +__Knu1 = __Knutemp; +# 245 +} +# 246 +__Knu = __Kmu; +# 247 +__Kpnu = (((__nu * __xi) * __Kmu) - __Knu1); +# 250 +} +# 267 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 +template< class _Tp> _Tp +# 269 +__cyl_bessel_i(_Tp __nu, _Tp __x) +# 270 +{ +# 271 +if ((__nu < ((_Tp)0)) || (__x < ((_Tp)0))) { +# 272 +std::__throw_domain_error("Bad argument in __cyl_bessel_i."); } else { +# 274 +if (__isnan(__nu) || __isnan(__x)) { +# 275 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 276 +if ((__x * __x) < (((_Tp)10) * (__nu + ((_Tp)1)))) { +# 277 +return __cyl_bessel_ij_series(__nu, __x, +((_Tp)1), 200); } else +# 279 +{ +# 280 +_Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; +# 281 +__bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); +# 282 +return __I_nu; +# 283 +} } } +# 284 +} +# 303 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 +template< class _Tp> _Tp +# 305 +__cyl_bessel_k(_Tp __nu, _Tp __x) +# 306 +{ +# 307 +if ((__nu < ((_Tp)0)) || (__x < ((_Tp)0))) { +# 308 +std::__throw_domain_error("Bad argument in __cyl_bessel_k."); } else { +# 310 +if (__isnan(__nu) || __isnan(__x)) { +# 311 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else +# 313 +{ +# 314 +_Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; +# 315 +__bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); +# 316 +return __K_nu; +# 317 +} } +# 318 +} +# 337 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 +template< class _Tp> void +# 339 +__sph_bessel_ik(unsigned __n, _Tp __x, _Tp & +# 340 +__i_n, _Tp &__k_n, _Tp &__ip_n, _Tp &__kp_n) +# 341 +{ +# 342 +const _Tp __nu = ((_Tp)__n) + ((_Tp)(0.5L)); +# 344 +_Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu; +# 345 +__bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); +# 347 +const _Tp __factor = __numeric_constants< _Tp> ::__sqrtpio2() / std::sqrt(__x); +# 350 +__i_n = (__factor * __I_nu); +# 351 +__k_n = (__factor * __K_nu); +# 352 +__ip_n = ((__factor * __Ip_nu) - (__i_n / (((_Tp)2) * __x))); +# 353 +__kp_n = ((__factor * __Kp_nu) - (__k_n / (((_Tp)2) * __x))); +# 356 +} +# 373 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/modified_bessel_func.tcc" 3 +template< class _Tp> void +# 375 +__airy(_Tp __x, _Tp &__Ai, _Tp &__Bi, _Tp &__Aip, _Tp &__Bip) +# 376 +{ +# 377 +const _Tp __absx = std::abs(__x); +# 378 +const _Tp __rootx = std::sqrt(__absx); +# 379 +const _Tp __z = ((((_Tp)2) * __absx) * __rootx) / ((_Tp)3); +# 380 +const _Tp _S_inf = std::template numeric_limits< _Tp> ::infinity(); +# 382 +if (__isnan(__x)) { +# 383 +__Bip = (__Aip = (__Bi = (__Ai = std::template numeric_limits< _Tp> ::quiet_NaN()))); } else { +# 384 +if (__z == _S_inf) +# 385 +{ +# 386 +__Aip = (__Ai = ((_Tp)0)); +# 387 +__Bip = (__Bi = _S_inf); +# 388 +} else { +# 389 +if (__z == (-_S_inf)) { +# 390 +__Bip = (__Aip = (__Bi = (__Ai = ((_Tp)0)))); } else { +# 391 +if (__x > ((_Tp)0)) +# 392 +{ +# 393 +_Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu; +# 395 +__bessel_ik(((_Tp)1) / ((_Tp)3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu); +# 396 +__Ai = ((__rootx * __K_nu) / (__numeric_constants< _Tp> ::__sqrt3() * __numeric_constants< _Tp> ::__pi())); +# 399 +__Bi = (__rootx * ((__K_nu / __numeric_constants< _Tp> ::__pi()) + ((((_Tp)2) * __I_nu) / __numeric_constants< _Tp> ::__sqrt3()))); +# 402 +__bessel_ik(((_Tp)2) / ((_Tp)3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu); +# 403 +__Aip = (((-__x) * __K_nu) / (__numeric_constants< _Tp> ::__sqrt3() * __numeric_constants< _Tp> ::__pi())); +# 406 +__Bip = (__x * ((__K_nu / __numeric_constants< _Tp> ::__pi()) + ((((_Tp)2) * __I_nu) / __numeric_constants< _Tp> ::__sqrt3()))); +# 409 +} else { +# 410 +if (__x < ((_Tp)0)) +# 411 +{ +# 412 +_Tp __J_nu, __Jp_nu, __N_nu, __Np_nu; +# 414 +__bessel_jn(((_Tp)1) / ((_Tp)3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu); +# 415 +__Ai = ((__rootx * (__J_nu - (__N_nu / __numeric_constants< _Tp> ::__sqrt3()))) / ((_Tp)2)); +# 417 +__Bi = (((-__rootx) * (__N_nu + (__J_nu / __numeric_constants< _Tp> ::__sqrt3()))) / ((_Tp)2)); +# 420 +__bessel_jn(((_Tp)2) / ((_Tp)3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu); +# 421 +__Aip = ((__absx * ((__N_nu / __numeric_constants< _Tp> ::__sqrt3()) + __J_nu)) / ((_Tp)2)); +# 423 +__Bip = ((__absx * ((__J_nu / __numeric_constants< _Tp> ::__sqrt3()) - __N_nu)) / ((_Tp)2)); +# 425 +} else +# 427 +{ +# 431 +__Ai = ((_Tp)(0.35502805388781723926L)); +# 432 +__Bi = (__Ai * __numeric_constants< _Tp> ::__sqrt3()); +# 437 +__Aip = (-((_Tp)(0.2588194037928067984L))); +# 438 +__Bip = ((-__Aip) * __numeric_constants< _Tp> ::__sqrt3()); +# 439 +} } } } } +# 442 +} +# 443 +} +# 449 +} +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 56 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 +namespace __detail { +# 72 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 +template< class _Tp> _Tp +# 74 +__poly_hermite_recursion(unsigned __n, _Tp __x) +# 75 +{ +# 77 +_Tp __H_0 = (1); +# 78 +if (__n == (0)) { +# 79 +return __H_0; } +# 82 +_Tp __H_1 = 2 * __x; +# 83 +if (__n == (1)) { +# 84 +return __H_1; } +# 87 +_Tp __H_n, __H_nm1, __H_nm2; +# 88 +unsigned __i; +# 89 +for (((__H_nm2 = __H_0), (__H_nm1 = __H_1)), (__i = (2)); __i <= __n; ++__i) +# 90 +{ +# 91 +__H_n = (2 * ((__x * __H_nm1) - ((__i - (1)) * __H_nm2))); +# 92 +__H_nm2 = __H_nm1; +# 93 +__H_nm1 = __H_n; +# 94 +} +# 96 +return __H_n; +# 97 +} +# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_hermite.tcc" 3 +template< class _Tp> inline _Tp +# 116 +__poly_hermite(unsigned __n, _Tp __x) +# 117 +{ +# 118 +if (__isnan(__x)) { +# 119 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 121 +return __poly_hermite_recursion(__n, __x); } +# 122 +} +# 123 +} +# 129 +} +# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 +namespace __detail { +# 75 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 +template< class _Tpa, class _Tp> _Tp +# 77 +__poly_laguerre_large_n(unsigned __n, _Tpa __alpha1, _Tp __x) +# 78 +{ +# 79 +const _Tp __a = (-((_Tp)__n)); +# 80 +const _Tp __b = ((_Tp)__alpha1) + ((_Tp)1); +# 81 +const _Tp __eta = (((_Tp)2) * __b) - (((_Tp)4) * __a); +# 82 +const _Tp __cos2th = __x / __eta; +# 83 +const _Tp __sin2th = ((_Tp)1) - __cos2th; +# 84 +const _Tp __th = std::acos(std::sqrt(__cos2th)); +# 85 +const _Tp __pre_h = ((((__numeric_constants< _Tp> ::__pi_2() * __numeric_constants< _Tp> ::__pi_2()) * __eta) * __eta) * __cos2th) * __sin2th; +# 90 +const _Tp __lg_b = std::lgamma(((_Tp)__n) + __b); +# 91 +const _Tp __lnfact = std::lgamma((_Tp)(__n + (1))); +# 97 +_Tp __pre_term1 = (((_Tp)(0.5L)) * (((_Tp)1) - __b)) * std::log((((_Tp)(0.25L)) * __x) * __eta); +# 99 +_Tp __pre_term2 = ((_Tp)(0.25L)) * std::log(__pre_h); +# 100 +_Tp __lnpre = (((__lg_b - __lnfact) + (((_Tp)(0.5L)) * __x)) + __pre_term1) - __pre_term2; +# 102 +_Tp __ser_term1 = std::sin(__a * __numeric_constants< _Tp> ::__pi()); +# 103 +_Tp __ser_term2 = std::sin(((((_Tp)(0.25L)) * __eta) * ((((_Tp)2) * __th) - std::sin(((_Tp)2) * __th))) + __numeric_constants< _Tp> ::__pi_4()); +# 107 +_Tp __ser = __ser_term1 + __ser_term2; +# 109 +return std::exp(__lnpre) * __ser; +# 110 +} +# 129 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 +template< class _Tpa, class _Tp> _Tp +# 131 +__poly_laguerre_hyperg(unsigned __n, _Tpa __alpha1, _Tp __x) +# 132 +{ +# 133 +const _Tp __b = ((_Tp)__alpha1) + ((_Tp)1); +# 134 +const _Tp __mx = (-__x); +# 135 +const _Tp __tc_sgn = (__x < ((_Tp)0)) ? (_Tp)1 : (((__n % (2)) == (1)) ? -((_Tp)1) : ((_Tp)1)); +# 138 +_Tp __tc = ((_Tp)1); +# 139 +const _Tp __ax = std::abs(__x); +# 140 +for (unsigned __k = (1); __k <= __n; ++__k) { +# 141 +__tc *= (__ax / __k); } +# 143 +_Tp __term = __tc * __tc_sgn; +# 144 +_Tp __sum = __term; +# 145 +for (int __k = ((int)__n) - 1; __k >= 0; --__k) +# 146 +{ +# 147 +__term *= ((((__b + ((_Tp)__k)) / ((_Tp)(((int)__n) - __k))) * ((_Tp)(__k + 1))) / __mx); +# 149 +__sum += __term; +# 150 +} +# 152 +return __sum; +# 153 +} +# 185 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 +template< class _Tpa, class _Tp> _Tp +# 187 +__poly_laguerre_recursion(unsigned __n, _Tpa __alpha1, _Tp __x) +# 188 +{ +# 190 +_Tp __l_0 = ((_Tp)1); +# 191 +if (__n == (0)) { +# 192 +return __l_0; } +# 195 +_Tp __l_1 = ((-__x) + ((_Tp)1)) + ((_Tp)__alpha1); +# 196 +if (__n == (1)) { +# 197 +return __l_1; } +# 200 +_Tp __l_n2 = __l_0; +# 201 +_Tp __l_n1 = __l_1; +# 202 +_Tp __l_n = ((_Tp)0); +# 203 +for (unsigned __nn = (2); __nn <= __n; ++__nn) +# 204 +{ +# 205 +__l_n = (((((((_Tp)(((2) * __nn) - (1))) + ((_Tp)__alpha1)) - __x) * __l_n1) / ((_Tp)__nn)) - (((((_Tp)(__nn - (1))) + ((_Tp)__alpha1)) * __l_n2) / ((_Tp)__nn))); +# 208 +__l_n2 = __l_n1; +# 209 +__l_n1 = __l_n; +# 210 +} +# 212 +return __l_n; +# 213 +} +# 244 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 +template< class _Tpa, class _Tp> _Tp +# 246 +__poly_laguerre(unsigned __n, _Tpa __alpha1, _Tp __x) +# 247 +{ +# 248 +if (__x < ((_Tp)0)) { +# 249 +std::__throw_domain_error("Negative argument in __poly_laguerre."); } else { +# 252 +if (__isnan(__x)) { +# 253 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 254 +if (__n == (0)) { +# 255 +return (_Tp)1; } else { +# 256 +if (__n == (1)) { +# 257 +return (((_Tp)1) + ((_Tp)__alpha1)) - __x; } else { +# 258 +if (__x == ((_Tp)0)) +# 259 +{ +# 260 +_Tp __prod = ((_Tp)__alpha1) + ((_Tp)1); +# 261 +for (unsigned __k = (2); __k <= __n; ++__k) { +# 262 +__prod *= ((((_Tp)__alpha1) + ((_Tp)__k)) / ((_Tp)__k)); } +# 263 +return __prod; +# 264 +} else { +# 265 +if ((__n > (10000000)) && (((_Tp)__alpha1) > (-((_Tp)1))) && (__x < ((((_Tp)2) * (((_Tp)__alpha1) + ((_Tp)1))) + ((_Tp)((4) * __n))))) { +# 267 +return __poly_laguerre_large_n(__n, __alpha1, __x); } else { +# 268 +if ((((_Tp)__alpha1) >= ((_Tp)0)) || ((__x > ((_Tp)0)) && (((_Tp)__alpha1) < (-((_Tp)(__n + (1))))))) { +# 270 +return __poly_laguerre_recursion(__n, __alpha1, __x); } else { +# 272 +return __poly_laguerre_hyperg(__n, __alpha1, __x); } } } } } } } +# 273 +} +# 296 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 +template< class _Tp> inline _Tp +# 298 +__assoc_laguerre(unsigned __n, unsigned __m, _Tp __x) +# 299 +{ return __poly_laguerre< unsigned, _Tp> (__n, __m, __x); } +# 316 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/poly_laguerre.tcc" 3 +template< class _Tp> inline _Tp +# 318 +__laguerre(unsigned __n, _Tp __x) +# 319 +{ return __poly_laguerre< unsigned, _Tp> (__n, 0, __x); } +# 320 +} +# 327 +} +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +namespace __detail { +# 78 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +template< class _Tp> _Tp +# 80 +__riemann_zeta_sum(_Tp __s) +# 81 +{ +# 83 +if (__s < ((_Tp)1)) { +# 84 +std::__throw_domain_error("Bad argument in zeta sum."); } +# 86 +const unsigned max_iter = (10000); +# 87 +_Tp __zeta = ((_Tp)0); +# 88 +for (unsigned __k = (1); __k < max_iter; ++__k) +# 89 +{ +# 90 +_Tp __term = std::pow(static_cast< _Tp>(__k), -__s); +# 91 +if (__term < std::template numeric_limits< _Tp> ::epsilon()) +# 92 +{ +# 93 +break; +# 94 +} +# 95 +__zeta += __term; +# 96 +} +# 98 +return __zeta; +# 99 +} +# 115 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +template< class _Tp> _Tp +# 117 +__riemann_zeta_alt(_Tp __s) +# 118 +{ +# 119 +_Tp __sgn = ((_Tp)1); +# 120 +_Tp __zeta = ((_Tp)0); +# 121 +for (unsigned __i = (1); __i < (10000000); ++__i) +# 122 +{ +# 123 +_Tp __term = __sgn / std::pow(__i, __s); +# 124 +if (std::abs(__term) < std::template numeric_limits< _Tp> ::epsilon()) { +# 125 +break; } +# 126 +__zeta += __term; +# 127 +__sgn *= ((_Tp)(-1)); +# 128 +} +# 129 +__zeta /= (((_Tp)1) - std::pow((_Tp)2, ((_Tp)1) - __s)); +# 131 +return __zeta; +# 132 +} +# 157 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +template< class _Tp> _Tp +# 159 +__riemann_zeta_glob(_Tp __s) +# 160 +{ +# 161 +_Tp __zeta = ((_Tp)0); +# 163 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 165 +const _Tp __max_bincoeff = (std::template numeric_limits< _Tp> ::max_exponent10 * std::log((_Tp)10)) - ((_Tp)1); +# 170 +if (__s < ((_Tp)0)) +# 171 +{ +# 173 +if (std::fmod(__s, (_Tp)2) == ((_Tp)0)) { +# 174 +return (_Tp)0; } else +# 177 +{ +# 178 +_Tp __zeta = __riemann_zeta_glob(((_Tp)1) - __s); +# 179 +__zeta *= (((std::pow(((_Tp)2) * __numeric_constants< _Tp> ::__pi(), __s) * std::sin(__numeric_constants< _Tp> ::__pi_2() * __s)) * std::exp(std::lgamma(((_Tp)1) - __s))) / __numeric_constants< _Tp> ::__pi()); +# 188 +return __zeta; +# 189 +} +# 190 +} +# 192 +_Tp __num = ((_Tp)(0.5L)); +# 193 +const unsigned __maxit = (10000); +# 194 +for (unsigned __i = (0); __i < __maxit; ++__i) +# 195 +{ +# 196 +bool __punt = false; +# 197 +_Tp __sgn = ((_Tp)1); +# 198 +_Tp __term = ((_Tp)0); +# 199 +for (unsigned __j = (0); __j <= __i; ++__j) +# 200 +{ +# 202 +_Tp __bincoeff = (std::lgamma((_Tp)((1) + __i)) - std::lgamma((_Tp)((1) + __j))) - std::lgamma((_Tp)(((1) + __i) - __j)); +# 210 +if (__bincoeff > __max_bincoeff) +# 211 +{ +# 213 +__punt = true; +# 214 +break; +# 215 +} +# 216 +__bincoeff = std::exp(__bincoeff); +# 217 +__term += ((__sgn * __bincoeff) * std::pow((_Tp)((1) + __j), -__s)); +# 218 +__sgn *= ((_Tp)(-1)); +# 219 +} +# 220 +if (__punt) { +# 221 +break; } +# 222 +__term *= __num; +# 223 +__zeta += __term; +# 224 +if (std::abs(__term / __zeta) < __eps) { +# 225 +break; } +# 226 +__num *= ((_Tp)(0.5L)); +# 227 +} +# 229 +__zeta /= (((_Tp)1) - std::pow((_Tp)2, ((_Tp)1) - __s)); +# 231 +return __zeta; +# 232 +} +# 252 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +template< class _Tp> _Tp +# 254 +__riemann_zeta_product(_Tp __s) +# 255 +{ +# 256 +static const _Tp __prime[] = {((_Tp)2), ((_Tp)3), ((_Tp)5), ((_Tp)7), ((_Tp)11), ((_Tp)13), ((_Tp)17), ((_Tp)19), ((_Tp)23), ((_Tp)29), ((_Tp)31), ((_Tp)37), ((_Tp)41), ((_Tp)43), ((_Tp)47), ((_Tp)53), ((_Tp)59), ((_Tp)61), ((_Tp)67), ((_Tp)71), ((_Tp)73), ((_Tp)79), ((_Tp)83), ((_Tp)89), ((_Tp)97), ((_Tp)101), ((_Tp)103), ((_Tp)107), ((_Tp)109)}; +# 262 +static const unsigned __num_primes = (sizeof(__prime) / sizeof(_Tp)); +# 264 +_Tp __zeta = ((_Tp)1); +# 265 +for (unsigned __i = (0); __i < __num_primes; ++__i) +# 266 +{ +# 267 +const _Tp __fact = ((_Tp)1) - std::pow(__prime[__i], -__s); +# 268 +__zeta *= __fact; +# 269 +if ((((_Tp)1) - __fact) < std::template numeric_limits< _Tp> ::epsilon()) { +# 270 +break; } +# 271 +} +# 273 +__zeta = (((_Tp)1) / __zeta); +# 275 +return __zeta; +# 276 +} +# 293 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +template< class _Tp> _Tp +# 295 +__riemann_zeta(_Tp __s) +# 296 +{ +# 297 +if (__isnan(__s)) { +# 298 +return std::template numeric_limits< _Tp> ::quiet_NaN(); } else { +# 299 +if (__s == ((_Tp)1)) { +# 300 +return std::template numeric_limits< _Tp> ::infinity(); } else { +# 301 +if (__s < (-((_Tp)19))) +# 302 +{ +# 303 +_Tp __zeta = __riemann_zeta_product(((_Tp)1) - __s); +# 304 +__zeta *= (((std::pow(((_Tp)2) * __numeric_constants< _Tp> ::__pi(), __s) * std::sin(__numeric_constants< _Tp> ::__pi_2() * __s)) * std::exp(std::lgamma(((_Tp)1) - __s))) / __numeric_constants< _Tp> ::__pi()); +# 312 +return __zeta; +# 313 +} else { +# 314 +if (__s < ((_Tp)20)) +# 315 +{ +# 317 +bool __glob = true; +# 318 +if (__glob) { +# 319 +return __riemann_zeta_glob(__s); } else +# 321 +{ +# 322 +if (__s > ((_Tp)1)) { +# 323 +return __riemann_zeta_sum(__s); } else +# 325 +{ +# 326 +_Tp __zeta = ((std::pow(((_Tp)2) * __numeric_constants< _Tp> ::__pi(), __s) * std::sin(__numeric_constants< _Tp> ::__pi_2() * __s)) * std::tgamma(((_Tp)1) - __s)) * __riemann_zeta_sum(((_Tp)1) - __s); +# 335 +return __zeta; +# 336 +} +# 337 +} +# 338 +} else { +# 340 +return __riemann_zeta_product(__s); } } } } +# 341 +} +# 365 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +template< class _Tp> _Tp +# 367 +__hurwitz_zeta_glob(_Tp __a, _Tp __s) +# 368 +{ +# 369 +_Tp __zeta = ((_Tp)0); +# 371 +const _Tp __eps = std::template numeric_limits< _Tp> ::epsilon(); +# 373 +const _Tp __max_bincoeff = (std::template numeric_limits< _Tp> ::max_exponent10 * std::log((_Tp)10)) - ((_Tp)1); +# 376 +const unsigned __maxit = (10000); +# 377 +for (unsigned __i = (0); __i < __maxit; ++__i) +# 378 +{ +# 379 +bool __punt = false; +# 380 +_Tp __sgn = ((_Tp)1); +# 381 +_Tp __term = ((_Tp)0); +# 382 +for (unsigned __j = (0); __j <= __i; ++__j) +# 383 +{ +# 385 +_Tp __bincoeff = (std::lgamma((_Tp)((1) + __i)) - std::lgamma((_Tp)((1) + __j))) - std::lgamma((_Tp)(((1) + __i) - __j)); +# 393 +if (__bincoeff > __max_bincoeff) +# 394 +{ +# 396 +__punt = true; +# 397 +break; +# 398 +} +# 399 +__bincoeff = std::exp(__bincoeff); +# 400 +__term += ((__sgn * __bincoeff) * std::pow((_Tp)(__a + __j), -__s)); +# 401 +__sgn *= ((_Tp)(-1)); +# 402 +} +# 403 +if (__punt) { +# 404 +break; } +# 405 +__term /= ((_Tp)(__i + (1))); +# 406 +if (std::abs(__term / __zeta) < __eps) { +# 407 +break; } +# 408 +__zeta += __term; +# 409 +} +# 411 +__zeta /= (__s - ((_Tp)1)); +# 413 +return __zeta; +# 414 +} +# 430 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/tr1/riemann_zeta.tcc" 3 +template< class _Tp> inline _Tp +# 432 +__hurwitz_zeta(_Tp __a, _Tp __s) +# 433 +{ return __hurwitz_zeta_glob(__a, __s); } +# 434 +} +# 441 +} +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 204 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float assoc_laguerref(unsigned __n, unsigned __m, float __x) +# 205 +{ return __detail::__assoc_laguerre< float> (__n, __m, __x); } +# 214 +inline long double assoc_laguerrel(unsigned __n, unsigned __m, long double __x) +# 215 +{ return __detail::__assoc_laguerre< long double> (__n, __m, __x); } +# 248 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 250 +assoc_laguerre(unsigned __n, unsigned __m, _Tp __x) +# 251 +{ +# 252 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 253 +return __detail::__assoc_laguerre< typename __gnu_cxx::__promote< _Tp> ::__type> (__n, __m, __x); +# 254 +} +# 265 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float assoc_legendref(unsigned __l, unsigned __m, float __x) +# 266 +{ return __detail::__assoc_legendre_p< float> (__l, __m, __x); } +# 274 +inline long double assoc_legendrel(unsigned __l, unsigned __m, long double __x) +# 275 +{ return __detail::__assoc_legendre_p< long double> (__l, __m, __x); } +# 294 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 296 +assoc_legendre(unsigned __l, unsigned __m, _Tp __x) +# 297 +{ +# 298 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 299 +return __detail::__assoc_legendre_p< typename __gnu_cxx::__promote< _Tp> ::__type> (__l, __m, __x); +# 300 +} +# 310 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float betaf(float __a, float __b) +# 311 +{ return __detail::__beta< float> (__a, __b); } +# 320 +inline long double betal(long double __a, long double __b) +# 321 +{ return __detail::__beta< long double> (__a, __b); } +# 339 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tpa, class _Tpb> inline typename __gnu_cxx::__promote_2< _Tpa, _Tpb> ::__type +# 341 +beta(_Tpa __a, _Tpb __b) +# 342 +{ +# 343 +typedef typename __gnu_cxx::__promote_2< _Tpa, _Tpb> ::__type __type; +# 344 +return __detail::__beta< typename __gnu_cxx::__promote_2< _Tpa, _Tpb> ::__type> (__a, __b); +# 345 +} +# 356 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float comp_ellint_1f(float __k) +# 357 +{ return __detail::__comp_ellint_1< float> (__k); } +# 366 +inline long double comp_ellint_1l(long double __k) +# 367 +{ return __detail::__comp_ellint_1< long double> (__k); } +# 387 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 389 +comp_ellint_1(_Tp __k) +# 390 +{ +# 391 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 392 +return __detail::__comp_ellint_1< typename __gnu_cxx::__promote< _Tp> ::__type> (__k); +# 393 +} +# 404 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float comp_ellint_2f(float __k) +# 405 +{ return __detail::__comp_ellint_2< float> (__k); } +# 414 +inline long double comp_ellint_2l(long double __k) +# 415 +{ return __detail::__comp_ellint_2< long double> (__k); } +# 434 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 436 +comp_ellint_2(_Tp __k) +# 437 +{ +# 438 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 439 +return __detail::__comp_ellint_2< typename __gnu_cxx::__promote< _Tp> ::__type> (__k); +# 440 +} +# 451 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float comp_ellint_3f(float __k, float __nu) +# 452 +{ return __detail::__comp_ellint_3< float> (__k, __nu); } +# 461 +inline long double comp_ellint_3l(long double __k, long double __nu) +# 462 +{ return __detail::__comp_ellint_3< long double> (__k, __nu); } +# 485 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp, class _Tpn> inline typename __gnu_cxx::__promote_2< _Tp, _Tpn> ::__type +# 487 +comp_ellint_3(_Tp __k, _Tpn __nu) +# 488 +{ +# 489 +typedef typename __gnu_cxx::__promote_2< _Tp, _Tpn> ::__type __type; +# 490 +return __detail::__comp_ellint_3< typename __gnu_cxx::__promote_2< _Tp, _Tpn> ::__type> (__k, __nu); +# 491 +} +# 502 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float cyl_bessel_if(float __nu, float __x) +# 503 +{ return __detail::__cyl_bessel_i< float> (__nu, __x); } +# 512 +inline long double cyl_bessel_il(long double __nu, long double __x) +# 513 +{ return __detail::__cyl_bessel_i< long double> (__nu, __x); } +# 531 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tpnu, class _Tp> inline typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type +# 533 +cyl_bessel_i(_Tpnu __nu, _Tp __x) +# 534 +{ +# 535 +typedef typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type __type; +# 536 +return __detail::__cyl_bessel_i< typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type> (__nu, __x); +# 537 +} +# 548 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float cyl_bessel_jf(float __nu, float __x) +# 549 +{ return __detail::__cyl_bessel_j< float> (__nu, __x); } +# 558 +inline long double cyl_bessel_jl(long double __nu, long double __x) +# 559 +{ return __detail::__cyl_bessel_j< long double> (__nu, __x); } +# 577 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tpnu, class _Tp> inline typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type +# 579 +cyl_bessel_j(_Tpnu __nu, _Tp __x) +# 580 +{ +# 581 +typedef typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type __type; +# 582 +return __detail::__cyl_bessel_j< typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type> (__nu, __x); +# 583 +} +# 594 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float cyl_bessel_kf(float __nu, float __x) +# 595 +{ return __detail::__cyl_bessel_k< float> (__nu, __x); } +# 604 +inline long double cyl_bessel_kl(long double __nu, long double __x) +# 605 +{ return __detail::__cyl_bessel_k< long double> (__nu, __x); } +# 629 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tpnu, class _Tp> inline typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type +# 631 +cyl_bessel_k(_Tpnu __nu, _Tp __x) +# 632 +{ +# 633 +typedef typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type __type; +# 634 +return __detail::__cyl_bessel_k< typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type> (__nu, __x); +# 635 +} +# 646 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float cyl_neumannf(float __nu, float __x) +# 647 +{ return __detail::__cyl_neumann_n< float> (__nu, __x); } +# 656 +inline long double cyl_neumannl(long double __nu, long double __x) +# 657 +{ return __detail::__cyl_neumann_n< long double> (__nu, __x); } +# 677 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tpnu, class _Tp> inline typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type +# 679 +cyl_neumann(_Tpnu __nu, _Tp __x) +# 680 +{ +# 681 +typedef typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type __type; +# 682 +return __detail::__cyl_neumann_n< typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type> (__nu, __x); +# 683 +} +# 694 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float ellint_1f(float __k, float __phi) +# 695 +{ return __detail::__ellint_1< float> (__k, __phi); } +# 704 +inline long double ellint_1l(long double __k, long double __phi) +# 705 +{ return __detail::__ellint_1< long double> (__k, __phi); } +# 725 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp, class _Tpp> inline typename __gnu_cxx::__promote_2< _Tp, _Tpp> ::__type +# 727 +ellint_1(_Tp __k, _Tpp __phi) +# 728 +{ +# 729 +typedef typename __gnu_cxx::__promote_2< _Tp, _Tpp> ::__type __type; +# 730 +return __detail::__ellint_1< typename __gnu_cxx::__promote_2< _Tp, _Tpp> ::__type> (__k, __phi); +# 731 +} +# 742 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float ellint_2f(float __k, float __phi) +# 743 +{ return __detail::__ellint_2< float> (__k, __phi); } +# 752 +inline long double ellint_2l(long double __k, long double __phi) +# 753 +{ return __detail::__ellint_2< long double> (__k, __phi); } +# 773 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp, class _Tpp> inline typename __gnu_cxx::__promote_2< _Tp, _Tpp> ::__type +# 775 +ellint_2(_Tp __k, _Tpp __phi) +# 776 +{ +# 777 +typedef typename __gnu_cxx::__promote_2< _Tp, _Tpp> ::__type __type; +# 778 +return __detail::__ellint_2< typename __gnu_cxx::__promote_2< _Tp, _Tpp> ::__type> (__k, __phi); +# 779 +} +# 790 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float ellint_3f(float __k, float __nu, float __phi) +# 791 +{ return __detail::__ellint_3< float> (__k, __nu, __phi); } +# 800 +inline long double ellint_3l(long double __k, long double __nu, long double __phi) +# 801 +{ return __detail::__ellint_3< long double> (__k, __nu, __phi); } +# 826 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp, class _Tpn, class _Tpp> inline typename __gnu_cxx::__promote_3< _Tp, _Tpn, _Tpp> ::__type +# 828 +ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi) +# 829 +{ +# 830 +typedef typename __gnu_cxx::__promote_3< _Tp, _Tpn, _Tpp> ::__type __type; +# 831 +return __detail::__ellint_3< typename __gnu_cxx::__promote_3< _Tp, _Tpn, _Tpp> ::__type> (__k, __nu, __phi); +# 832 +} +# 842 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float expintf(float __x) +# 843 +{ return __detail::__expint< float> (__x); } +# 852 +inline long double expintl(long double __x) +# 853 +{ return __detail::__expint< long double> (__x); } +# 866 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 868 +expint(_Tp __x) +# 869 +{ +# 870 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 871 +return __detail::__expint< typename __gnu_cxx::__promote< _Tp> ::__type> (__x); +# 872 +} +# 883 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float hermitef(unsigned __n, float __x) +# 884 +{ return __detail::__poly_hermite< float> (__n, __x); } +# 893 +inline long double hermitel(unsigned __n, long double __x) +# 894 +{ return __detail::__poly_hermite< long double> (__n, __x); } +# 914 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 916 +hermite(unsigned __n, _Tp __x) +# 917 +{ +# 918 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 919 +return __detail::__poly_hermite< typename __gnu_cxx::__promote< _Tp> ::__type> (__n, __x); +# 920 +} +# 931 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float laguerref(unsigned __n, float __x) +# 932 +{ return __detail::__laguerre< float> (__n, __x); } +# 941 +inline long double laguerrel(unsigned __n, long double __x) +# 942 +{ return __detail::__laguerre< long double> (__n, __x); } +# 958 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 960 +laguerre(unsigned __n, _Tp __x) +# 961 +{ +# 962 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 963 +return __detail::__laguerre< typename __gnu_cxx::__promote< _Tp> ::__type> (__n, __x); +# 964 +} +# 975 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float legendref(unsigned __l, float __x) +# 976 +{ return __detail::__poly_legendre_p< float> (__l, __x); } +# 985 +inline long double legendrel(unsigned __l, long double __x) +# 986 +{ return __detail::__poly_legendre_p< long double> (__l, __x); } +# 1003 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 1005 +legendre(unsigned __l, _Tp __x) +# 1006 +{ +# 1007 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 1008 +return __detail::__poly_legendre_p< typename __gnu_cxx::__promote< _Tp> ::__type> (__l, __x); +# 1009 +} +# 1020 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float riemann_zetaf(float __s) +# 1021 +{ return __detail::__riemann_zeta< float> (__s); } +# 1030 +inline long double riemann_zetal(long double __s) +# 1031 +{ return __detail::__riemann_zeta< long double> (__s); } +# 1054 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 1056 +riemann_zeta(_Tp __s) +# 1057 +{ +# 1058 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 1059 +return __detail::__riemann_zeta< typename __gnu_cxx::__promote< _Tp> ::__type> (__s); +# 1060 +} +# 1071 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float sph_besself(unsigned __n, float __x) +# 1072 +{ return __detail::__sph_bessel< float> (__n, __x); } +# 1081 +inline long double sph_bessell(unsigned __n, long double __x) +# 1082 +{ return __detail::__sph_bessel< long double> (__n, __x); } +# 1098 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 1100 +sph_bessel(unsigned __n, _Tp __x) +# 1101 +{ +# 1102 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 1103 +return __detail::__sph_bessel< typename __gnu_cxx::__promote< _Tp> ::__type> (__n, __x); +# 1104 +} +# 1115 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float sph_legendref(unsigned __l, unsigned __m, float __theta) +# 1116 +{ return __detail::__sph_legendre< float> (__l, __m, __theta); } +# 1126 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline long double sph_legendrel(unsigned __l, unsigned __m, long double __theta) +# 1127 +{ return __detail::__sph_legendre< long double> (__l, __m, __theta); } +# 1145 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 1147 +sph_legendre(unsigned __l, unsigned __m, _Tp __theta) +# 1148 +{ +# 1149 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 1150 +return __detail::__sph_legendre< typename __gnu_cxx::__promote< _Tp> ::__type> (__l, __m, __theta); +# 1151 +} +# 1162 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float sph_neumannf(unsigned __n, float __x) +# 1163 +{ return __detail::__sph_neumann< float> (__n, __x); } +# 1172 +inline long double sph_neumannl(unsigned __n, long double __x) +# 1173 +{ return __detail::__sph_neumann< long double> (__n, __x); } +# 1189 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 1191 +sph_neumann(unsigned __n, _Tp __x) +# 1192 +{ +# 1193 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 1194 +return __detail::__sph_neumann< typename __gnu_cxx::__promote< _Tp> ::__type> (__n, __x); +# 1195 +} +# 1200 +} +# 1203 +namespace __gnu_cxx __attribute((__visibility__("default"))) { +# 1217 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float airy_aif(float __x) +# 1218 +{ +# 1219 +float __Ai, __Bi, __Aip, __Bip; +# 1220 +std::__detail::__airy< float> (__x, __Ai, __Bi, __Aip, __Bip); +# 1221 +return __Ai; +# 1222 +} +# 1228 +inline long double airy_ail(long double __x) +# 1229 +{ +# 1230 +long double __Ai, __Bi, __Aip, __Bip; +# 1231 +std::__detail::__airy< long double> (__x, __Ai, __Bi, __Aip, __Bip); +# 1232 +return __Ai; +# 1233 +} +# 1238 +template< class _Tp> inline typename __promote< _Tp> ::__type +# 1240 +airy_ai(_Tp __x) +# 1241 +{ +# 1242 +typedef typename __promote< _Tp> ::__type __type; +# 1243 +__type __Ai, __Bi, __Aip, __Bip; +# 1244 +std::__detail::__airy< typename __promote< _Tp> ::__type> (__x, __Ai, __Bi, __Aip, __Bip); +# 1245 +return __Ai; +# 1246 +} +# 1252 +inline float airy_bif(float __x) +# 1253 +{ +# 1254 +float __Ai, __Bi, __Aip, __Bip; +# 1255 +std::__detail::__airy< float> (__x, __Ai, __Bi, __Aip, __Bip); +# 1256 +return __Bi; +# 1257 +} +# 1263 +inline long double airy_bil(long double __x) +# 1264 +{ +# 1265 +long double __Ai, __Bi, __Aip, __Bip; +# 1266 +std::__detail::__airy< long double> (__x, __Ai, __Bi, __Aip, __Bip); +# 1267 +return __Bi; +# 1268 +} +# 1273 +template< class _Tp> inline typename __promote< _Tp> ::__type +# 1275 +airy_bi(_Tp __x) +# 1276 +{ +# 1277 +typedef typename __promote< _Tp> ::__type __type; +# 1278 +__type __Ai, __Bi, __Aip, __Bip; +# 1279 +std::__detail::__airy< typename __promote< _Tp> ::__type> (__x, __Ai, __Bi, __Aip, __Bip); +# 1280 +return __Bi; +# 1281 +} +# 1293 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float conf_hypergf(float __a, float __c, float __x) +# 1294 +{ return std::__detail::__conf_hyperg< float> (__a, __c, __x); } +# 1304 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline long double conf_hypergl(long double __a, long double __c, long double __x) +# 1305 +{ return std::__detail::__conf_hyperg< long double> (__a, __c, __x); } +# 1323 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tpa, class _Tpc, class _Tp> inline typename __promote_3< _Tpa, _Tpc, _Tp> ::__type +# 1325 +conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x) +# 1326 +{ +# 1327 +typedef typename __promote_3< _Tpa, _Tpc, _Tp> ::__type __type; +# 1328 +return std::__detail::__conf_hyperg< typename __promote_3< _Tpa, _Tpc, _Tp> ::__type> (__a, __c, __x); +# 1329 +} +# 1341 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline float hypergf(float __a, float __b, float __c, float __x) +# 1342 +{ return std::__detail::__hyperg< float> (__a, __b, __c, __x); } +# 1352 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +inline long double hypergl(long double __a, long double __b, long double __c, long double __x) +# 1353 +{ return std::__detail::__hyperg< long double> (__a, __b, __c, __x); } +# 1372 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/specfun.h" 3 +template< class _Tpa, class _Tpb, class _Tpc, class _Tp> inline typename __promote_4< _Tpa, _Tpb, _Tpc, _Tp> ::__type +# 1374 +hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x) +# 1375 +{ +# 1377 +typedef typename __promote_4< _Tpa, _Tpb, _Tpc, _Tp> ::__type __type; +# 1378 +return std::__detail::__hyperg< typename __promote_4< _Tpa, _Tpb, _Tpc, _Tp> ::__type> (__a, __b, __c, __x); +# 1379 +} +# 1383 +} +# 3909 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/cmath" 3 +} +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/math.h" 3 +using std::abs; +# 39 +using std::acos; +# 40 +using std::asin; +# 41 +using std::atan; +# 42 +using std::atan2; +# 43 +using std::cos; +# 44 +using std::sin; +# 45 +using std::tan; +# 46 +using std::cosh; +# 47 +using std::sinh; +# 48 +using std::tanh; +# 49 +using std::exp; +# 50 +using std::frexp; +# 51 +using std::ldexp; +# 52 +using std::log; +# 53 +using std::log10; +# 54 +using std::modf; +# 55 +using std::pow; +# 56 +using std::sqrt; +# 57 +using std::ceil; +# 58 +using std::fabs; +# 59 +using std::floor; +# 60 +using std::fmod; +# 63 +using std::fpclassify; +# 64 +using std::isfinite; +# 65 +using std::isinf; +# 66 +using std::isnan; +# 67 +using std::isnormal; +# 68 +using std::signbit; +# 69 +using std::isgreater; +# 70 +using std::isgreaterequal; +# 71 +using std::isless; +# 72 +using std::islessequal; +# 73 +using std::islessgreater; +# 74 +using std::isunordered; +# 78 +using std::acosh; +# 79 +using std::asinh; +# 80 +using std::atanh; +# 81 +using std::cbrt; +# 82 +using std::copysign; +# 83 +using std::erf; +# 84 +using std::erfc; +# 85 +using std::exp2; +# 86 +using std::expm1; +# 87 +using std::fdim; +# 88 +using std::fma; +# 89 +using std::fmax; +# 90 +using std::fmin; +# 91 +using std::hypot; +# 92 +using std::ilogb; +# 93 +using std::lgamma; +# 94 +using std::llrint; +# 95 +using std::llround; +# 96 +using std::log1p; +# 97 +using std::log2; +# 98 +using std::logb; +# 99 +using std::lrint; +# 100 +using std::lround; +# 101 +using std::nearbyint; +# 102 +using std::nextafter; +# 103 +using std::nexttoward; +# 104 +using std::remainder; +# 105 +using std::remquo; +# 106 +using std::rint; +# 107 +using std::round; +# 108 +using std::scalbln; +# 109 +using std::scalbn; +# 110 +using std::tgamma; +# 111 +using std::trunc; +# 4653 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +# 4654 +constexpr bool signbit(float x); +# 4655 +constexpr bool signbit(double x); +# 4656 +constexpr bool signbit(long double x); +# 4657 +constexpr bool isfinite(float x); +# 4658 +constexpr bool isfinite(double x); +# 4659 +constexpr bool isfinite(long double x); +# 4660 +constexpr bool isnan(float x); +# 4665 +constexpr bool isnan(double x); +# 4667 +constexpr bool isnan(long double x); +# 4668 +constexpr bool isinf(float x); +# 4673 +constexpr bool isinf(double x); +# 4675 +constexpr bool isinf(long double x); +# 4676 +} +# 4832 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +# 4834 +template< class T> extern T __pow_helper(T, int); +# 4835 +template< class T> extern T __cmath_power(T, unsigned); +# 4836 +} +# 4838 +using std::abs; +# 4839 +using std::fabs; +# 4840 +using std::ceil; +# 4841 +using std::floor; +# 4842 +using std::sqrt; +# 4844 +using std::pow; +# 4846 +using std::log; +# 4847 +using std::log10; +# 4848 +using std::fmod; +# 4849 +using std::modf; +# 4850 +using std::exp; +# 4851 +using std::frexp; +# 4852 +using std::ldexp; +# 4853 +using std::asin; +# 4854 +using std::sin; +# 4855 +using std::sinh; +# 4856 +using std::acos; +# 4857 +using std::cos; +# 4858 +using std::cosh; +# 4859 +using std::atan; +# 4860 +using std::atan2; +# 4861 +using std::tan; +# 4862 +using std::tanh; +# 5243 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +# 5252 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern inline long long abs(long long); +# 5272 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern inline long abs(long a); +# 5273 +extern constexpr float abs(float); +# 5274 +extern constexpr double abs(double); +# 5275 +extern constexpr float fabs(float); +# 5276 +extern constexpr float ceil(float); +# 5277 +extern constexpr float floor(float); +# 5278 +extern constexpr float sqrt(float); +# 5279 +extern constexpr float pow(float, float); +# 5284 +template< class _Tp, class _Up> extern constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type pow(_Tp, _Up); +# 5294 +extern constexpr float log(float); +# 5295 +extern constexpr float log10(float); +# 5296 +extern constexpr float fmod(float, float); +# 5297 +extern inline float modf(float, float *); +# 5298 +extern constexpr float exp(float); +# 5299 +extern inline float frexp(float, int *); +# 5300 +extern constexpr float ldexp(float, int); +# 5301 +extern constexpr float asin(float); +# 5302 +extern constexpr float sin(float); +# 5303 +extern constexpr float sinh(float); +# 5304 +extern constexpr float acos(float); +# 5305 +extern constexpr float cos(float); +# 5306 +extern constexpr float cosh(float); +# 5307 +extern constexpr float atan(float); +# 5308 +extern constexpr float atan2(float, float); +# 5309 +extern constexpr float tan(float); +# 5310 +extern constexpr float tanh(float); +# 5399 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +} +# 5505 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +# 5506 +constexpr float logb(float a); +# 5507 +constexpr int ilogb(float a); +# 5508 +constexpr float scalbn(float a, int b); +# 5509 +constexpr float scalbln(float a, long b); +# 5510 +constexpr float exp2(float a); +# 5511 +constexpr float expm1(float a); +# 5512 +constexpr float log2(float a); +# 5513 +constexpr float log1p(float a); +# 5514 +constexpr float acosh(float a); +# 5515 +constexpr float asinh(float a); +# 5516 +constexpr float atanh(float a); +# 5517 +constexpr float hypot(float a, float b); +# 5518 +constexpr float cbrt(float a); +# 5519 +constexpr float erf(float a); +# 5520 +constexpr float erfc(float a); +# 5521 +constexpr float lgamma(float a); +# 5522 +constexpr float tgamma(float a); +# 5523 +constexpr float copysign(float a, float b); +# 5524 +constexpr float nextafter(float a, float b); +# 5525 +constexpr float remainder(float a, float b); +# 5526 +inline float remquo(float a, float b, int * quo); +# 5527 +constexpr float round(float a); +# 5528 +constexpr long lround(float a); +# 5529 +constexpr long long llround(float a); +# 5530 +constexpr float trunc(float a); +# 5531 +constexpr float rint(float a); +# 5532 +constexpr long lrint(float a); +# 5533 +constexpr long long llrint(float a); +# 5534 +constexpr float nearbyint(float a); +# 5535 +constexpr float fdim(float a, float b); +# 5536 +constexpr float fma(float a, float b, float c); +# 5537 +constexpr float fmax(float a, float b); +# 5538 +constexpr float fmin(float a, float b); +# 5539 +} +# 5644 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline float exp10(const float a); +# 5646 +static inline float rsqrt(const float a); +# 5648 +static inline float rcbrt(const float a); +# 5650 +static inline float sinpi(const float a); +# 5652 +static inline float cospi(const float a); +# 5654 +static inline void sincospi(const float a, float *const sptr, float *const cptr); +# 5656 +static inline void sincos(const float a, float *const sptr, float *const cptr); +# 5658 +static inline float j0(const float a); +# 5660 +static inline float j1(const float a); +# 5662 +static inline float jn(const int n, const float a); +# 5664 +static inline float y0(const float a); +# 5666 +static inline float y1(const float a); +# 5668 +static inline float yn(const int n, const float a); +# 5670 +__attribute__((unused)) static inline float cyl_bessel_i0(const float a); +# 5672 +__attribute__((unused)) static inline float cyl_bessel_i1(const float a); +# 5674 +static inline float erfinv(const float a); +# 5676 +static inline float erfcinv(const float a); +# 5678 +static inline float normcdfinv(const float a); +# 5680 +static inline float normcdf(const float a); +# 5682 +static inline float erfcx(const float a); +# 5684 +static inline double copysign(const double a, const float b); +# 5686 +static inline double copysign(const float a, const double b); +# 5694 +static inline unsigned min(const unsigned a, const unsigned b); +# 5702 +static inline unsigned min(const int a, const unsigned b); +# 5710 +static inline unsigned min(const unsigned a, const int b); +# 5718 +static inline long min(const long a, const long b); +# 5726 +static inline unsigned long min(const unsigned long a, const unsigned long b); +# 5734 +static inline unsigned long min(const long a, const unsigned long b); +# 5742 +static inline unsigned long min(const unsigned long a, const long b); +# 5750 +static inline long long min(const long long a, const long long b); +# 5758 +static inline unsigned long long min(const unsigned long long a, const unsigned long long b); +# 5766 +static inline unsigned long long min(const long long a, const unsigned long long b); +# 5774 +static inline unsigned long long min(const unsigned long long a, const long long b); +# 5785 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline float min(const float a, const float b); +# 5796 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline double min(const double a, const double b); +# 5806 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline double min(const float a, const double b); +# 5816 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline double min(const double a, const float b); +# 5824 +static inline unsigned max(const unsigned a, const unsigned b); +# 5832 +static inline unsigned max(const int a, const unsigned b); +# 5840 +static inline unsigned max(const unsigned a, const int b); +# 5848 +static inline long max(const long a, const long b); +# 5856 +static inline unsigned long max(const unsigned long a, const unsigned long b); +# 5864 +static inline unsigned long max(const long a, const unsigned long b); +# 5872 +static inline unsigned long max(const unsigned long a, const long b); +# 5880 +static inline long long max(const long long a, const long long b); +# 5888 +static inline unsigned long long max(const unsigned long long a, const unsigned long long b); +# 5896 +static inline unsigned long long max(const long long a, const unsigned long long b); +# 5904 +static inline unsigned long long max(const unsigned long long a, const long long b); +# 5915 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline float max(const float a, const float b); +# 5926 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline double max(const double a, const double b); +# 5936 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline double max(const float a, const double b); +# 5946 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline double max(const double a, const float b); +# 5958 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern "C" { +# 5959 +__attribute__((unused)) inline void *__nv_aligned_device_malloc(size_t size, size_t align) +# 5960 +{int volatile ___ = 1;(void)size;(void)align; +# 5963 +::exit(___);} +#if 0 +# 5960 +{ +# 5961 +__attribute__((unused)) void *__nv_aligned_device_malloc_impl(size_t, size_t); +# 5962 +return __nv_aligned_device_malloc_impl(size, align); +# 5963 +} +#endif +# 5964 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +} +# 758 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +static inline float exp10(const float a) +# 759 +{ +# 760 +return exp10f(a); +# 761 +} +# 763 +static inline float rsqrt(const float a) +# 764 +{ +# 765 +return rsqrtf(a); +# 766 +} +# 768 +static inline float rcbrt(const float a) +# 769 +{ +# 770 +return rcbrtf(a); +# 771 +} +# 773 +static inline float sinpi(const float a) +# 774 +{ +# 775 +return sinpif(a); +# 776 +} +# 778 +static inline float cospi(const float a) +# 779 +{ +# 780 +return cospif(a); +# 781 +} +# 783 +static inline void sincospi(const float a, float *const sptr, float *const cptr) +# 784 +{ +# 785 +sincospif(a, sptr, cptr); +# 786 +} +# 788 +static inline void sincos(const float a, float *const sptr, float *const cptr) +# 789 +{ +# 790 +sincosf(a, sptr, cptr); +# 791 +} +# 793 +static inline float j0(const float a) +# 794 +{ +# 795 +return j0f(a); +# 796 +} +# 798 +static inline float j1(const float a) +# 799 +{ +# 800 +return j1f(a); +# 801 +} +# 803 +static inline float jn(const int n, const float a) +# 804 +{ +# 805 +return jnf(n, a); +# 806 +} +# 808 +static inline float y0(const float a) +# 809 +{ +# 810 +return y0f(a); +# 811 +} +# 813 +static inline float y1(const float a) +# 814 +{ +# 815 +return y1f(a); +# 816 +} +# 818 +static inline float yn(const int n, const float a) +# 819 +{ +# 820 +return ynf(n, a); +# 821 +} +# 823 +__attribute__((unused)) static inline float cyl_bessel_i0(const float a) +# 824 +{int volatile ___ = 1;(void)a; +# 826 +::exit(___);} +#if 0 +# 824 +{ +# 825 +return cyl_bessel_i0f(a); +# 826 +} +#endif +# 828 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +__attribute__((unused)) static inline float cyl_bessel_i1(const float a) +# 829 +{int volatile ___ = 1;(void)a; +# 831 +::exit(___);} +#if 0 +# 829 +{ +# 830 +return cyl_bessel_i1f(a); +# 831 +} +#endif +# 833 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +static inline float erfinv(const float a) +# 834 +{ +# 835 +return erfinvf(a); +# 836 +} +# 838 +static inline float erfcinv(const float a) +# 839 +{ +# 840 +return erfcinvf(a); +# 841 +} +# 843 +static inline float normcdfinv(const float a) +# 844 +{ +# 845 +return normcdfinvf(a); +# 846 +} +# 848 +static inline float normcdf(const float a) +# 849 +{ +# 850 +return normcdff(a); +# 851 +} +# 853 +static inline float erfcx(const float a) +# 854 +{ +# 855 +return erfcxf(a); +# 856 +} +# 858 +static inline double copysign(const double a, const float b) +# 859 +{ +# 860 +return copysign(a, static_cast< double>(b)); +# 861 +} +# 863 +static inline double copysign(const float a, const double b) +# 864 +{ +# 865 +return copysign(static_cast< double>(a), b); +# 866 +} +# 868 +static inline unsigned min(const unsigned a, const unsigned b) +# 869 +{ +# 870 +return umin(a, b); +# 871 +} +# 873 +static inline unsigned min(const int a, const unsigned b) +# 874 +{ +# 875 +return umin(static_cast< unsigned>(a), b); +# 876 +} +# 878 +static inline unsigned min(const unsigned a, const int b) +# 879 +{ +# 880 +return umin(a, static_cast< unsigned>(b)); +# 881 +} +# 883 +static inline long min(const long a, const long b) +# 884 +{ +# 885 +long retval; +# 892 +if (sizeof(long) == sizeof(int)) { +# 896 +retval = (static_cast< long>(min(static_cast< int>(a), static_cast< int>(b)))); +# 897 +} else { +# 898 +retval = (static_cast< long>(llmin(static_cast< long long>(a), static_cast< long long>(b)))); +# 899 +} +# 900 +return retval; +# 901 +} +# 903 +static inline unsigned long min(const unsigned long a, const unsigned long b) +# 904 +{ +# 905 +unsigned long retval; +# 910 +if (sizeof(unsigned long) == sizeof(unsigned)) { +# 914 +retval = (static_cast< unsigned long>(umin(static_cast< unsigned>(a), static_cast< unsigned>(b)))); +# 915 +} else { +# 916 +retval = (static_cast< unsigned long>(ullmin(static_cast< unsigned long long>(a), static_cast< unsigned long long>(b)))); +# 917 +} +# 918 +return retval; +# 919 +} +# 921 +static inline unsigned long min(const long a, const unsigned long b) +# 922 +{ +# 923 +unsigned long retval; +# 928 +if (sizeof(unsigned long) == sizeof(unsigned)) { +# 932 +retval = (static_cast< unsigned long>(umin(static_cast< unsigned>(a), static_cast< unsigned>(b)))); +# 933 +} else { +# 934 +retval = (static_cast< unsigned long>(ullmin(static_cast< unsigned long long>(a), static_cast< unsigned long long>(b)))); +# 935 +} +# 936 +return retval; +# 937 +} +# 939 +static inline unsigned long min(const unsigned long a, const long b) +# 940 +{ +# 941 +unsigned long retval; +# 946 +if (sizeof(unsigned long) == sizeof(unsigned)) { +# 950 +retval = (static_cast< unsigned long>(umin(static_cast< unsigned>(a), static_cast< unsigned>(b)))); +# 951 +} else { +# 952 +retval = (static_cast< unsigned long>(ullmin(static_cast< unsigned long long>(a), static_cast< unsigned long long>(b)))); +# 953 +} +# 954 +return retval; +# 955 +} +# 957 +static inline long long min(const long long a, const long long b) +# 958 +{ +# 959 +return llmin(a, b); +# 960 +} +# 962 +static inline unsigned long long min(const unsigned long long a, const unsigned long long b) +# 963 +{ +# 964 +return ullmin(a, b); +# 965 +} +# 967 +static inline unsigned long long min(const long long a, const unsigned long long b) +# 968 +{ +# 969 +return ullmin(static_cast< unsigned long long>(a), b); +# 970 +} +# 972 +static inline unsigned long long min(const unsigned long long a, const long long b) +# 973 +{ +# 974 +return ullmin(a, static_cast< unsigned long long>(b)); +# 975 +} +# 977 +static inline float min(const float a, const float b) +# 978 +{ +# 979 +return fminf(a, b); +# 980 +} +# 982 +static inline double min(const double a, const double b) +# 983 +{ +# 984 +return fmin(a, b); +# 985 +} +# 987 +static inline double min(const float a, const double b) +# 988 +{ +# 989 +return fmin(static_cast< double>(a), b); +# 990 +} +# 992 +static inline double min(const double a, const float b) +# 993 +{ +# 994 +return fmin(a, static_cast< double>(b)); +# 995 +} +# 997 +static inline unsigned max(const unsigned a, const unsigned b) +# 998 +{ +# 999 +return umax(a, b); +# 1000 +} +# 1002 +static inline unsigned max(const int a, const unsigned b) +# 1003 +{ +# 1004 +return umax(static_cast< unsigned>(a), b); +# 1005 +} +# 1007 +static inline unsigned max(const unsigned a, const int b) +# 1008 +{ +# 1009 +return umax(a, static_cast< unsigned>(b)); +# 1010 +} +# 1012 +static inline long max(const long a, const long b) +# 1013 +{ +# 1014 +long retval; +# 1020 +if (sizeof(long) == sizeof(int)) { +# 1024 +retval = (static_cast< long>(max(static_cast< int>(a), static_cast< int>(b)))); +# 1025 +} else { +# 1026 +retval = (static_cast< long>(llmax(static_cast< long long>(a), static_cast< long long>(b)))); +# 1027 +} +# 1028 +return retval; +# 1029 +} +# 1031 +static inline unsigned long max(const unsigned long a, const unsigned long b) +# 1032 +{ +# 1033 +unsigned long retval; +# 1038 +if (sizeof(unsigned long) == sizeof(unsigned)) { +# 1042 +retval = (static_cast< unsigned long>(umax(static_cast< unsigned>(a), static_cast< unsigned>(b)))); +# 1043 +} else { +# 1044 +retval = (static_cast< unsigned long>(ullmax(static_cast< unsigned long long>(a), static_cast< unsigned long long>(b)))); +# 1045 +} +# 1046 +return retval; +# 1047 +} +# 1049 +static inline unsigned long max(const long a, const unsigned long b) +# 1050 +{ +# 1051 +unsigned long retval; +# 1056 +if (sizeof(unsigned long) == sizeof(unsigned)) { +# 1060 +retval = (static_cast< unsigned long>(umax(static_cast< unsigned>(a), static_cast< unsigned>(b)))); +# 1061 +} else { +# 1062 +retval = (static_cast< unsigned long>(ullmax(static_cast< unsigned long long>(a), static_cast< unsigned long long>(b)))); +# 1063 +} +# 1064 +return retval; +# 1065 +} +# 1067 +static inline unsigned long max(const unsigned long a, const long b) +# 1068 +{ +# 1069 +unsigned long retval; +# 1074 +if (sizeof(unsigned long) == sizeof(unsigned)) { +# 1078 +retval = (static_cast< unsigned long>(umax(static_cast< unsigned>(a), static_cast< unsigned>(b)))); +# 1079 +} else { +# 1080 +retval = (static_cast< unsigned long>(ullmax(static_cast< unsigned long long>(a), static_cast< unsigned long long>(b)))); +# 1081 +} +# 1082 +return retval; +# 1083 +} +# 1085 +static inline long long max(const long long a, const long long b) +# 1086 +{ +# 1087 +return llmax(a, b); +# 1088 +} +# 1090 +static inline unsigned long long max(const unsigned long long a, const unsigned long long b) +# 1091 +{ +# 1092 +return ullmax(a, b); +# 1093 +} +# 1095 +static inline unsigned long long max(const long long a, const unsigned long long b) +# 1096 +{ +# 1097 +return ullmax(static_cast< unsigned long long>(a), b); +# 1098 +} +# 1100 +static inline unsigned long long max(const unsigned long long a, const long long b) +# 1101 +{ +# 1102 +return ullmax(a, static_cast< unsigned long long>(b)); +# 1103 +} +# 1105 +static inline float max(const float a, const float b) +# 1106 +{ +# 1107 +return fmaxf(a, b); +# 1108 +} +# 1110 +static inline double max(const double a, const double b) +# 1111 +{ +# 1112 +return fmax(a, b); +# 1113 +} +# 1115 +static inline double max(const float a, const double b) +# 1116 +{ +# 1117 +return fmax(static_cast< double>(a), b); +# 1118 +} +# 1120 +static inline double max(const double a, const float b) +# 1121 +{ +# 1122 +return fmax(a, static_cast< double>(b)); +# 1123 +} +# 1135 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +inline int min(const int a, const int b) +# 1136 +{ +# 1137 +return (a < b) ? a : b; +# 1138 +} +# 1140 +inline unsigned umin(const unsigned a, const unsigned b) +# 1141 +{ +# 1142 +return (a < b) ? a : b; +# 1143 +} +# 1145 +inline long long llmin(const long long a, const long long b) +# 1146 +{ +# 1147 +return (a < b) ? a : b; +# 1148 +} +# 1150 +inline unsigned long long ullmin(const unsigned long long a, const unsigned long long +# 1151 +b) +# 1152 +{ +# 1153 +return (a < b) ? a : b; +# 1154 +} +# 1156 +inline int max(const int a, const int b) +# 1157 +{ +# 1158 +return (a > b) ? a : b; +# 1159 +} +# 1161 +inline unsigned umax(const unsigned a, const unsigned b) +# 1162 +{ +# 1163 +return (a > b) ? a : b; +# 1164 +} +# 1166 +inline long long llmax(const long long a, const long long b) +# 1167 +{ +# 1168 +return (a > b) ? a : b; +# 1169 +} +# 1171 +inline unsigned long long ullmax(const unsigned long long a, const unsigned long long +# 1172 +b) +# 1173 +{ +# 1174 +return (a > b) ? a : b; +# 1175 +} +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +extern "C" { +# 2497 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __vimax_s32_relu(const int a, const int b); +# 2509 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vimax_s16x2_relu(const unsigned a, const unsigned b); +# 2518 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __vimin_s32_relu(const int a, const int b); +# 2530 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vimin_s16x2_relu(const unsigned a, const unsigned b); +# 2539 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __vimax3_s32(const int a, const int b, const int c); +# 2551 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vimax3_s16x2(const unsigned a, const unsigned b, const unsigned c); +# 2560 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vimax3_u32(const unsigned a, const unsigned b, const unsigned c); +# 2572 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vimax3_u16x2(const unsigned a, const unsigned b, const unsigned c); +# 2581 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __vimin3_s32(const int a, const int b, const int c); +# 2593 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vimin3_s16x2(const unsigned a, const unsigned b, const unsigned c); +# 2602 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vimin3_u32(const unsigned a, const unsigned b, const unsigned c); +# 2614 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vimin3_u16x2(const unsigned a, const unsigned b, const unsigned c); +# 2623 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __vimax3_s32_relu(const int a, const int b, const int c); +# 2635 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vimax3_s16x2_relu(const unsigned a, const unsigned b, const unsigned c); +# 2644 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __vimin3_s32_relu(const int a, const int b, const int c); +# 2656 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vimin3_s16x2_relu(const unsigned a, const unsigned b, const unsigned c); +# 2665 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __viaddmax_s32(const int a, const int b, const int c); +# 2677 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __viaddmax_s16x2(const unsigned a, const unsigned b, const unsigned c); +# 2686 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __viaddmax_u32(const unsigned a, const unsigned b, const unsigned c); +# 2698 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __viaddmax_u16x2(const unsigned a, const unsigned b, const unsigned c); +# 2707 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __viaddmin_s32(const int a, const int b, const int c); +# 2719 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __viaddmin_s16x2(const unsigned a, const unsigned b, const unsigned c); +# 2728 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __viaddmin_u32(const unsigned a, const unsigned b, const unsigned c); +# 2740 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __viaddmin_u16x2(const unsigned a, const unsigned b, const unsigned c); +# 2750 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __viaddmax_s32_relu(const int a, const int b, const int c); +# 2762 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __viaddmax_s16x2_relu(const unsigned a, const unsigned b, const unsigned c); +# 2772 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __viaddmin_s32_relu(const int a, const int b, const int c); +# 2784 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __viaddmin_s16x2_relu(const unsigned a, const unsigned b, const unsigned c); +# 2793 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __vibmax_s32(const int a, const int b, bool *const pred); +# 2802 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vibmax_u32(const unsigned a, const unsigned b, bool *const pred); +# 2811 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline int __vibmin_s32(const int a, const int b, bool *const pred); +# 2820 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vibmin_u32(const unsigned a, const unsigned b, bool *const pred); +# 2834 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vibmax_s16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo); +# 2848 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vibmax_u16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo); +# 2862 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vibmin_s16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo); +# 2876 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static inline unsigned __vibmin_u16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo); +# 2883 +} +# 116 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +static short __internal_cast_u2s(unsigned short x) +# 117 +{ +# 118 +short res; +# 120 +(void)memcpy(&res, &x, sizeof x); +# 124 +return res; +# 125 +} +# 127 +static inline int __vimax_s32_relu(const int a, const int b) { +# 134 +int ans = max(a, b); +# 136 +return (ans > 0) ? ans : 0; +# 138 +} +# 140 +static inline unsigned __vimax_s16x2_relu(const unsigned a, const unsigned b) { +# 141 +unsigned res; +# 149 +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 150 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 152 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 153 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 156 +short aS_lo = __internal_cast_u2s(aU_lo); +# 157 +short aS_hi = __internal_cast_u2s(aU_hi); +# 159 +short bS_lo = __internal_cast_u2s(bU_lo); +# 160 +short bS_hi = __internal_cast_u2s(bU_hi); +# 163 +int ansI_lo = max(aS_lo, bS_lo); +# 164 +int ansI_hi = max(aS_hi, bS_hi); +# 167 +if (ansI_lo < 0) { ansI_lo = 0; } +# 168 +if (ansI_hi < 0) { ansI_hi = 0; } +# 171 +unsigned ansU_lo = (unsigned)ansI_lo; +# 172 +unsigned ansU_hi = (unsigned)ansI_hi; +# 175 +res = (ansU_lo | (ansU_hi << 16)); +# 178 +return res; +# 179 +} +# 181 +static inline int __vimin_s32_relu(const int a, const int b) { +# 188 +int ans = min(a, b); +# 190 +return (ans > 0) ? ans : 0; +# 192 +} +# 194 +static inline unsigned __vimin_s16x2_relu(const unsigned a, const unsigned b) { +# 195 +unsigned res; +# 203 +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 204 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 206 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 207 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 210 +short aS_lo = __internal_cast_u2s(aU_lo); +# 211 +short aS_hi = __internal_cast_u2s(aU_hi); +# 213 +short bS_lo = __internal_cast_u2s(bU_lo); +# 214 +short bS_hi = __internal_cast_u2s(bU_hi); +# 217 +int ansI_lo = min(aS_lo, bS_lo); +# 218 +int ansI_hi = min(aS_hi, bS_hi); +# 221 +if (ansI_lo < 0) { ansI_lo = 0; } +# 222 +if (ansI_hi < 0) { ansI_hi = 0; } +# 225 +unsigned ansU_lo = (unsigned)ansI_lo; +# 226 +unsigned ansU_hi = (unsigned)ansI_hi; +# 229 +res = (ansU_lo | (ansU_hi << 16)); +# 232 +return res; +# 233 +} +# 235 +static inline int __vimax3_s32(const int a, const int b, const int c) { +# 245 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +return max(max(a, b), c); +# 247 +} +# 249 +static inline unsigned __vimax3_s16x2(const unsigned a, const unsigned b, const unsigned c) { +# 250 +unsigned res; +# 262 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 263 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 265 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 266 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 268 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 269 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 272 +short aS_lo = __internal_cast_u2s(aU_lo); +# 273 +short aS_hi = __internal_cast_u2s(aU_hi); +# 275 +short bS_lo = __internal_cast_u2s(bU_lo); +# 276 +short bS_hi = __internal_cast_u2s(bU_hi); +# 278 +short cS_lo = __internal_cast_u2s(cU_lo); +# 279 +short cS_hi = __internal_cast_u2s(cU_hi); +# 282 +unsigned ansU_lo = (unsigned)max(max(aS_lo, bS_lo), cS_lo); +# 283 +unsigned ansU_hi = (unsigned)max(max(aS_hi, bS_hi), cS_hi); +# 286 +res = ((ansU_lo & 65535U) | (ansU_hi << 16)); +# 288 +return res; +# 289 +} +# 291 +static inline unsigned __vimax3_u32(const unsigned a, const unsigned b, const unsigned c) { +# 301 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +return max(max(a, b), c); +# 303 +} +# 305 +static inline unsigned __vimax3_u16x2(const unsigned a, const unsigned b, const unsigned c) { +# 306 +unsigned res; +# 317 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 318 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 320 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 321 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 323 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 324 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 327 +unsigned short ansU_lo = (unsigned short)max(max(aU_lo, bU_lo), cU_lo); +# 328 +unsigned short ansU_hi = (unsigned short)max(max(aU_hi, bU_hi), cU_hi); +# 331 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 334 +return res; +# 335 +} +# 337 +static inline int __vimin3_s32(const int a, const int b, const int c) { +# 347 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +return min(min(a, b), c); +# 349 +} +# 351 +static inline unsigned __vimin3_s16x2(const unsigned a, const unsigned b, const unsigned c) { +# 352 +unsigned res; +# 363 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 364 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 366 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 367 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 369 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 370 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 373 +short aS_lo = __internal_cast_u2s(aU_lo); +# 374 +short aS_hi = __internal_cast_u2s(aU_hi); +# 376 +short bS_lo = __internal_cast_u2s(bU_lo); +# 377 +short bS_hi = __internal_cast_u2s(bU_hi); +# 379 +short cS_lo = __internal_cast_u2s(cU_lo); +# 380 +short cS_hi = __internal_cast_u2s(cU_hi); +# 383 +unsigned ansU_lo = (unsigned)min(min(aS_lo, bS_lo), cS_lo); +# 384 +unsigned ansU_hi = (unsigned)min(min(aS_hi, bS_hi), cS_hi); +# 387 +res = ((ansU_lo & 65535U) | (ansU_hi << 16)); +# 390 +return res; +# 391 +} +# 393 +static inline unsigned __vimin3_u32(const unsigned a, const unsigned b, const unsigned c) { +# 403 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +return min(min(a, b), c); +# 405 +} +# 407 +static inline unsigned __vimin3_u16x2(const unsigned a, const unsigned b, const unsigned c) { +# 408 +unsigned res; +# 419 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 420 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 422 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 423 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 425 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 426 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 429 +unsigned short ansU_lo = (unsigned short)min(min(aU_lo, bU_lo), cU_lo); +# 430 +unsigned short ansU_hi = (unsigned short)min(min(aU_hi, bU_hi), cU_hi); +# 433 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 436 +return res; +# 437 +} +# 439 +static inline int __vimax3_s32_relu(const int a, const int b, const int c) { +# 449 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +int ans = max(max(a, b), c); +# 451 +return (ans > 0) ? ans : 0; +# 453 +} +# 455 +static inline unsigned __vimax3_s16x2_relu(const unsigned a, const unsigned b, const unsigned c) { +# 456 +unsigned res; +# 467 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 468 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 470 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 471 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 473 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 474 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 477 +short aS_lo = __internal_cast_u2s(aU_lo); +# 478 +short aS_hi = __internal_cast_u2s(aU_hi); +# 480 +short bS_lo = __internal_cast_u2s(bU_lo); +# 481 +short bS_hi = __internal_cast_u2s(bU_hi); +# 483 +short cS_lo = __internal_cast_u2s(cU_lo); +# 484 +short cS_hi = __internal_cast_u2s(cU_hi); +# 487 +unsigned ansU_lo = (unsigned)max(0, max(max(aS_lo, bS_lo), cS_lo)); +# 488 +unsigned ansU_hi = (unsigned)max(0, max(max(aS_hi, bS_hi), cS_hi)); +# 491 +res = (ansU_lo | (ansU_hi << 16)); +# 494 +return res; +# 495 +} +# 497 +static inline int __vimin3_s32_relu(const int a, const int b, const int c) { +# 507 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +int ans = min(min(a, b), c); +# 509 +return (ans > 0) ? ans : 0; +# 511 +} +# 513 +static inline unsigned __vimin3_s16x2_relu(const unsigned a, const unsigned b, const unsigned c) { +# 514 +unsigned res; +# 525 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 526 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 528 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 529 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 531 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 532 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 535 +short aS_lo = __internal_cast_u2s(aU_lo); +# 536 +short aS_hi = __internal_cast_u2s(aU_hi); +# 538 +short bS_lo = __internal_cast_u2s(bU_lo); +# 539 +short bS_hi = __internal_cast_u2s(bU_hi); +# 541 +short cS_lo = __internal_cast_u2s(cU_lo); +# 542 +short cS_hi = __internal_cast_u2s(cU_hi); +# 545 +unsigned ansU_lo = (unsigned)max(0, min(min(aS_lo, bS_lo), cS_lo)); +# 546 +unsigned ansU_hi = (unsigned)max(0, min(min(aS_hi, bS_hi), cS_hi)); +# 549 +res = (ansU_lo | (ansU_hi << 16)); +# 553 +return res; +# 554 +} +# 556 +static inline int __viaddmax_s32(const int a, const int b, const int c) { +# 566 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +return max(a + b, c); +# 568 +} +# 570 +static inline unsigned __viaddmax_s16x2(const unsigned a, const unsigned b, const unsigned c) { +# 571 +unsigned res; +# 582 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 583 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 585 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 586 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 588 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 589 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 591 +aU_lo += bU_lo; +# 592 +aU_hi += bU_hi; +# 595 +short sS_lo = __internal_cast_u2s(aU_lo); +# 596 +short sS_hi = __internal_cast_u2s(aU_hi); +# 598 +short cS_lo = __internal_cast_u2s(cU_lo); +# 599 +short cS_hi = __internal_cast_u2s(cU_hi); +# 602 +unsigned ansU_lo = (unsigned)max(sS_lo, cS_lo); +# 603 +unsigned ansU_hi = (unsigned)max(sS_hi, cS_hi); +# 606 +res = ((ansU_lo & 65535U) | (ansU_hi << 16)); +# 609 +return res; +# 610 +} +# 612 +static inline unsigned __viaddmax_u32(const unsigned a, const unsigned b, const unsigned c) { +# 622 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +return max(a + b, c); +# 624 +} +# 626 +static inline unsigned __viaddmax_u16x2(const unsigned a, const unsigned b, const unsigned c) { +# 627 +unsigned res; +# 638 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 639 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 641 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 642 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 644 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 645 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 648 +unsigned short ansU_lo = (unsigned short)max((unsigned short)(aU_lo + bU_lo), cU_lo); +# 649 +unsigned short ansU_hi = (unsigned short)max((unsigned short)(aU_hi + bU_hi), cU_hi); +# 652 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 655 +return res; +# 656 +} +# 658 +static inline int __viaddmin_s32(const int a, const int b, const int c) { +# 668 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +return min(a + b, c); +# 670 +} +# 672 +static inline unsigned __viaddmin_s16x2(const unsigned a, const unsigned b, const unsigned c) { +# 673 +unsigned res; +# 684 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 685 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 687 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 688 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 690 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 691 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 693 +aU_lo += bU_lo; +# 694 +aU_hi += bU_hi; +# 697 +short sS_lo = __internal_cast_u2s(aU_lo); +# 698 +short sS_hi = __internal_cast_u2s(aU_hi); +# 700 +short cS_lo = __internal_cast_u2s(cU_lo); +# 701 +short cS_hi = __internal_cast_u2s(cU_hi); +# 704 +unsigned ansU_lo = (unsigned)min(sS_lo, cS_lo); +# 705 +unsigned ansU_hi = (unsigned)min(sS_hi, cS_hi); +# 708 +res = ((ansU_lo & 65535U) | (ansU_hi << 16)); +# 711 +return res; +# 712 +} +# 714 +static inline unsigned __viaddmin_u32(const unsigned a, const unsigned b, const unsigned c) { +# 724 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +return min(a + b, c); +# 726 +} +# 728 +static inline unsigned __viaddmin_u16x2(const unsigned a, const unsigned b, const unsigned c) { +# 729 +unsigned res; +# 740 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 741 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 743 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 744 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 746 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 747 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 750 +unsigned short ansU_lo = (unsigned short)min((unsigned short)(aU_lo + bU_lo), cU_lo); +# 751 +unsigned short ansU_hi = (unsigned short)min((unsigned short)(aU_hi + bU_hi), cU_hi); +# 754 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 757 +return res; +# 758 +} +# 760 +static inline int __viaddmax_s32_relu(const int a, const int b, const int c) { +# 770 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +int ans = max(a + b, c); +# 772 +return (ans > 0) ? ans : 0; +# 774 +} +# 776 +static inline unsigned __viaddmax_s16x2_relu(const unsigned a, const unsigned b, const unsigned c) { +# 777 +unsigned res; +# 788 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 789 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 791 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 792 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 794 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 795 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 797 +aU_lo += bU_lo; +# 798 +aU_hi += bU_hi; +# 801 +short sS_lo = __internal_cast_u2s(aU_lo); +# 802 +short sS_hi = __internal_cast_u2s(aU_hi); +# 804 +short cS_lo = __internal_cast_u2s(cU_lo); +# 805 +short cS_hi = __internal_cast_u2s(cU_hi); +# 808 +unsigned ansU_lo = (unsigned)max(0, max(sS_lo, cS_lo)); +# 809 +unsigned ansU_hi = (unsigned)max(0, max(sS_hi, cS_hi)); +# 812 +res = (ansU_lo | (ansU_hi << 16)); +# 815 +return res; +# 816 +} +# 818 +static inline int __viaddmin_s32_relu(const int a, const int b, const int c) { +# 828 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +int ans = min(a + b, c); +# 830 +return (ans > 0) ? ans : 0; +# 832 +} +# 834 +static inline unsigned __viaddmin_s16x2_relu(const unsigned a, const unsigned b, const unsigned c) { +# 835 +unsigned res; +# 846 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 847 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 849 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 850 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 852 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 853 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 855 +aU_lo += bU_lo; +# 856 +aU_hi += bU_hi; +# 859 +short sS_lo = __internal_cast_u2s(aU_lo); +# 860 +short sS_hi = __internal_cast_u2s(aU_hi); +# 862 +short cS_lo = __internal_cast_u2s(cU_lo); +# 863 +short cS_hi = __internal_cast_u2s(cU_hi); +# 866 +unsigned ansU_lo = (unsigned)max(0, min(sS_lo, cS_lo)); +# 867 +unsigned ansU_hi = (unsigned)max(0, min(sS_hi, cS_hi)); +# 870 +res = (ansU_lo | (ansU_hi << 16)); +# 873 +return res; +# 874 +} +# 878 +static inline int __vibmax_s32(const int a, const int b, bool *const pred) { +# 892 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +int ans = max(a, b); +# 894 +(*pred) = (a >= b); +# 895 +return ans; +# 897 +} +# 899 +static inline unsigned __vibmax_u32(const unsigned a, const unsigned b, bool *const pred) { +# 913 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned ans = max(a, b); +# 915 +(*pred) = (a >= b); +# 916 +return ans; +# 918 +} +# 921 +static inline int __vibmin_s32(const int a, const int b, bool *const pred) { +# 935 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +int ans = min(a, b); +# 937 +(*pred) = (a <= b); +# 938 +return ans; +# 940 +} +# 943 +static inline unsigned __vibmin_u32(const unsigned a, const unsigned b, bool *const pred) { +# 957 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned ans = min(a, b); +# 959 +(*pred) = (a <= b); +# 960 +return ans; +# 962 +} +# 964 +static inline unsigned __vibmax_s16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo) { +# 986 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 987 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 989 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 990 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 993 +short aS_lo = __internal_cast_u2s(aU_lo); +# 994 +short aS_hi = __internal_cast_u2s(aU_hi); +# 996 +short bS_lo = __internal_cast_u2s(bU_lo); +# 997 +short bS_hi = __internal_cast_u2s(bU_hi); +# 1000 +unsigned ansU_lo = (unsigned)max(aS_lo, bS_lo); +# 1001 +unsigned ansU_hi = (unsigned)max(aS_hi, bS_hi); +# 1003 +(*pred_hi) = (aS_hi >= bS_hi); +# 1004 +(*pred_lo) = (aS_lo >= bS_lo); +# 1007 +unsigned ans = (ansU_lo & 65535U) | (ansU_hi << 16); +# 1009 +return ans; +# 1011 +} +# 1013 +static inline unsigned __vibmax_u16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo) { +# 1035 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 1036 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 1038 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 1039 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 1042 +unsigned short ansU_lo = (unsigned short)max(aU_lo, bU_lo); +# 1043 +unsigned short ansU_hi = (unsigned short)max(aU_hi, bU_hi); +# 1045 +(*pred_hi) = (aU_hi >= bU_hi); +# 1046 +(*pred_lo) = (aU_lo >= bU_lo); +# 1049 +unsigned ans = ((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16); +# 1051 +return ans; +# 1053 +} +# 1055 +static inline unsigned __vibmin_s16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo) { +# 1077 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 1078 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 1080 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 1081 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 1084 +short aS_lo = __internal_cast_u2s(aU_lo); +# 1085 +short aS_hi = __internal_cast_u2s(aU_hi); +# 1087 +short bS_lo = __internal_cast_u2s(bU_lo); +# 1088 +short bS_hi = __internal_cast_u2s(bU_hi); +# 1091 +unsigned ansU_lo = (unsigned)min(aS_lo, bS_lo); +# 1092 +unsigned ansU_hi = (unsigned)min(aS_hi, bS_hi); +# 1094 +(*pred_hi) = (aS_hi <= bS_hi); +# 1095 +(*pred_lo) = (aS_lo <= bS_lo); +# 1098 +unsigned ans = (ansU_lo & 65535U) | (ansU_hi << 16); +# 1100 +return ans; +# 1102 +} +# 1104 +static inline unsigned __vibmin_u16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo) { +# 1126 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 1127 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 1129 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 1130 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 1133 +unsigned short ansU_lo = (unsigned short)min(aU_lo, bU_lo); +# 1134 +unsigned short ansU_hi = (unsigned short)min(aU_hi, bU_hi); +# 1136 +(*pred_hi) = (aU_hi <= bU_hi); +# 1137 +(*pred_lo) = (aU_lo <= bU_lo); +# 1140 +unsigned ans = ((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16); +# 1142 +return ans; +# 1144 +} +# 89 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline int atomicAdd(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 89 +{ } +#endif +# 91 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicAdd(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 91 +{ } +#endif +# 93 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline int atomicSub(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 93 +{ } +#endif +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicSub(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 95 +{ } +#endif +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline int atomicExch(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 97 +{ } +#endif +# 99 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicExch(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 99 +{ } +#endif +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline float atomicExch(float *address, float val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 101 +{ } +#endif +# 103 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline int atomicMin(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 103 +{ } +#endif +# 105 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicMin(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 105 +{ } +#endif +# 107 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline int atomicMax(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 107 +{ } +#endif +# 109 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicMax(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 109 +{ } +#endif +# 111 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicInc(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 111 +{ } +#endif +# 113 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicDec(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 113 +{ } +#endif +# 115 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline int atomicAnd(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 115 +{ } +#endif +# 117 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicAnd(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 117 +{ } +#endif +# 119 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline int atomicOr(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 119 +{ } +#endif +# 121 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicOr(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 121 +{ } +#endif +# 123 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline int atomicXor(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 123 +{ } +#endif +# 125 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicXor(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 125 +{ } +#endif +# 127 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline int atomicCAS(int *address, int compare, int val) {int volatile ___ = 1;(void)address;(void)compare;(void)val;::exit(___);} +#if 0 +# 127 +{ } +#endif +# 129 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicCAS(unsigned *address, unsigned compare, unsigned val) {int volatile ___ = 1;(void)address;(void)compare;(void)val;::exit(___);} +#if 0 +# 129 +{ } +#endif +# 156 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +extern "C" { +# 160 +} +# 169 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicAdd(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 169 +{ } +#endif +# 171 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicExch(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 171 +{ } +#endif +# 173 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicCAS(unsigned long long *address, unsigned long long compare, unsigned long long val) {int volatile ___ = 1;(void)address;(void)compare;(void)val;::exit(___);} +#if 0 +# 173 +{ } +#endif +# 175 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute((deprecated("__any() is deprecated in favor of __any_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppr" "ess this warning)."))) __attribute__((unused)) static inline bool any(bool cond) {int volatile ___ = 1;(void)cond;::exit(___);} +#if 0 +# 175 +{ } +#endif +# 177 "/opt/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +__attribute((deprecated("__all() is deprecated in favor of __all_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppr" "ess this warning)."))) __attribute__((unused)) static inline bool all(bool cond) {int volatile ___ = 1;(void)cond;::exit(___);} +#if 0 +# 177 +{ } +#endif +# 90 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern "C" { +# 1142 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +} +# 1150 +__attribute__((unused)) static inline double fma(double a, double b, double c, cudaRoundMode mode); +# 1154 +__attribute__((unused)) static inline double dmul(double a, double b, cudaRoundMode mode = cudaRoundNearest); +# 1156 +__attribute__((unused)) static inline double dadd(double a, double b, cudaRoundMode mode = cudaRoundNearest); +# 1158 +__attribute__((unused)) static inline double dsub(double a, double b, cudaRoundMode mode = cudaRoundNearest); +# 1160 +__attribute__((unused)) static inline int double2int(double a, cudaRoundMode mode = cudaRoundZero); +# 1162 +__attribute__((unused)) static inline unsigned double2uint(double a, cudaRoundMode mode = cudaRoundZero); +# 1164 +__attribute__((unused)) static inline long long double2ll(double a, cudaRoundMode mode = cudaRoundZero); +# 1166 +__attribute__((unused)) static inline unsigned long long double2ull(double a, cudaRoundMode mode = cudaRoundZero); +# 1168 +__attribute__((unused)) static inline double ll2double(long long a, cudaRoundMode mode = cudaRoundNearest); +# 1170 +__attribute__((unused)) static inline double ull2double(unsigned long long a, cudaRoundMode mode = cudaRoundNearest); +# 1172 +__attribute__((unused)) static inline double int2double(int a, cudaRoundMode mode = cudaRoundNearest); +# 1174 +__attribute__((unused)) static inline double uint2double(unsigned a, cudaRoundMode mode = cudaRoundNearest); +# 1176 +__attribute__((unused)) static inline double float2double(float a, cudaRoundMode mode = cudaRoundNearest); +# 93 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline double fma(double a, double b, double c, cudaRoundMode mode) +# 94 +{int volatile ___ = 1;(void)a;(void)b;(void)c;(void)mode; +# 99 +::exit(___);} +#if 0 +# 94 +{ +# 95 +return (mode == (cudaRoundZero)) ? __fma_rz(a, b, c) : ((mode == (cudaRoundPosInf)) ? __fma_ru(a, b, c) : ((mode == (cudaRoundMinInf)) ? __fma_rd(a, b, c) : __fma_rn(a, b, c))); +# 99 +} +#endif +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline double dmul(double a, double b, cudaRoundMode mode) +# 102 +{int volatile ___ = 1;(void)a;(void)b;(void)mode; +# 107 +::exit(___);} +#if 0 +# 102 +{ +# 103 +return (mode == (cudaRoundZero)) ? __dmul_rz(a, b) : ((mode == (cudaRoundPosInf)) ? __dmul_ru(a, b) : ((mode == (cudaRoundMinInf)) ? __dmul_rd(a, b) : __dmul_rn(a, b))); +# 107 +} +#endif +# 109 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline double dadd(double a, double b, cudaRoundMode mode) +# 110 +{int volatile ___ = 1;(void)a;(void)b;(void)mode; +# 115 +::exit(___);} +#if 0 +# 110 +{ +# 111 +return (mode == (cudaRoundZero)) ? __dadd_rz(a, b) : ((mode == (cudaRoundPosInf)) ? __dadd_ru(a, b) : ((mode == (cudaRoundMinInf)) ? __dadd_rd(a, b) : __dadd_rn(a, b))); +# 115 +} +#endif +# 117 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline double dsub(double a, double b, cudaRoundMode mode) +# 118 +{int volatile ___ = 1;(void)a;(void)b;(void)mode; +# 123 +::exit(___);} +#if 0 +# 118 +{ +# 119 +return (mode == (cudaRoundZero)) ? __dsub_rz(a, b) : ((mode == (cudaRoundPosInf)) ? __dsub_ru(a, b) : ((mode == (cudaRoundMinInf)) ? __dsub_rd(a, b) : __dsub_rn(a, b))); +# 123 +} +#endif +# 125 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline int double2int(double a, cudaRoundMode mode) +# 126 +{int volatile ___ = 1;(void)a;(void)mode; +# 131 +::exit(___);} +#if 0 +# 126 +{ +# 127 +return (mode == (cudaRoundNearest)) ? __double2int_rn(a) : ((mode == (cudaRoundPosInf)) ? __double2int_ru(a) : ((mode == (cudaRoundMinInf)) ? __double2int_rd(a) : __double2int_rz(a))); +# 131 +} +#endif +# 133 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline unsigned double2uint(double a, cudaRoundMode mode) +# 134 +{int volatile ___ = 1;(void)a;(void)mode; +# 139 +::exit(___);} +#if 0 +# 134 +{ +# 135 +return (mode == (cudaRoundNearest)) ? __double2uint_rn(a) : ((mode == (cudaRoundPosInf)) ? __double2uint_ru(a) : ((mode == (cudaRoundMinInf)) ? __double2uint_rd(a) : __double2uint_rz(a))); +# 139 +} +#endif +# 141 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline long long double2ll(double a, cudaRoundMode mode) +# 142 +{int volatile ___ = 1;(void)a;(void)mode; +# 147 +::exit(___);} +#if 0 +# 142 +{ +# 143 +return (mode == (cudaRoundNearest)) ? __double2ll_rn(a) : ((mode == (cudaRoundPosInf)) ? __double2ll_ru(a) : ((mode == (cudaRoundMinInf)) ? __double2ll_rd(a) : __double2ll_rz(a))); +# 147 +} +#endif +# 149 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline unsigned long long double2ull(double a, cudaRoundMode mode) +# 150 +{int volatile ___ = 1;(void)a;(void)mode; +# 155 +::exit(___);} +#if 0 +# 150 +{ +# 151 +return (mode == (cudaRoundNearest)) ? __double2ull_rn(a) : ((mode == (cudaRoundPosInf)) ? __double2ull_ru(a) : ((mode == (cudaRoundMinInf)) ? __double2ull_rd(a) : __double2ull_rz(a))); +# 155 +} +#endif +# 157 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline double ll2double(long long a, cudaRoundMode mode) +# 158 +{int volatile ___ = 1;(void)a;(void)mode; +# 163 +::exit(___);} +#if 0 +# 158 +{ +# 159 +return (mode == (cudaRoundZero)) ? __ll2double_rz(a) : ((mode == (cudaRoundPosInf)) ? __ll2double_ru(a) : ((mode == (cudaRoundMinInf)) ? __ll2double_rd(a) : __ll2double_rn(a))); +# 163 +} +#endif +# 165 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline double ull2double(unsigned long long a, cudaRoundMode mode) +# 166 +{int volatile ___ = 1;(void)a;(void)mode; +# 171 +::exit(___);} +#if 0 +# 166 +{ +# 167 +return (mode == (cudaRoundZero)) ? __ull2double_rz(a) : ((mode == (cudaRoundPosInf)) ? __ull2double_ru(a) : ((mode == (cudaRoundMinInf)) ? __ull2double_rd(a) : __ull2double_rn(a))); +# 171 +} +#endif +# 173 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline double int2double(int a, cudaRoundMode mode) +# 174 +{int volatile ___ = 1;(void)a;(void)mode; +# 176 +::exit(___);} +#if 0 +# 174 +{ +# 175 +return (double)a; +# 176 +} +#endif +# 178 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline double uint2double(unsigned a, cudaRoundMode mode) +# 179 +{int volatile ___ = 1;(void)a;(void)mode; +# 181 +::exit(___);} +#if 0 +# 179 +{ +# 180 +return (double)a; +# 181 +} +#endif +# 183 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +__attribute__((unused)) static inline double float2double(float a, cudaRoundMode mode) +# 184 +{int volatile ___ = 1;(void)a;(void)mode; +# 186 +::exit(___);} +#if 0 +# 184 +{ +# 185 +return (double)a; +# 186 +} +#endif +# 88 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_atomic_functions.h" +__attribute__((unused)) static inline float atomicAdd(float *address, float val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 88 +{ } +#endif +# 89 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +__attribute__((unused)) static inline long long atomicMin(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 89 +{ } +#endif +# 91 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +__attribute__((unused)) static inline long long atomicMax(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 91 +{ } +#endif +# 93 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +__attribute__((unused)) static inline long long atomicAnd(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 93 +{ } +#endif +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +__attribute__((unused)) static inline long long atomicOr(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 95 +{ } +#endif +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +__attribute__((unused)) static inline long long atomicXor(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 97 +{ } +#endif +# 99 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicMin(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 99 +{ } +#endif +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicMax(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 101 +{ } +#endif +# 103 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicAnd(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 103 +{ } +#endif +# 105 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicOr(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 105 +{ } +#endif +# 107 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicXor(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 107 +{ } +#endif +# 93 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline double atomicAdd(double *address, double val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 93 +{ } +#endif +# 96 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicAdd_block(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 96 +{ } +#endif +# 99 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicAdd_system(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 99 +{ } +#endif +# 102 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicAdd_block(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 102 +{ } +#endif +# 105 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicAdd_system(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 105 +{ } +#endif +# 108 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicAdd_block(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 108 +{ } +#endif +# 111 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicAdd_system(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 111 +{ } +#endif +# 114 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline float atomicAdd_block(float *address, float val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 114 +{ } +#endif +# 117 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline float atomicAdd_system(float *address, float val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 117 +{ } +#endif +# 120 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline double atomicAdd_block(double *address, double val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 120 +{ } +#endif +# 123 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline double atomicAdd_system(double *address, double val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 123 +{ } +#endif +# 126 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicSub_block(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 126 +{ } +#endif +# 129 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicSub_system(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 129 +{ } +#endif +# 132 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicSub_block(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 132 +{ } +#endif +# 135 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicSub_system(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 135 +{ } +#endif +# 138 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicExch_block(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 138 +{ } +#endif +# 141 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicExch_system(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 141 +{ } +#endif +# 144 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicExch_block(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 144 +{ } +#endif +# 147 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicExch_system(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 147 +{ } +#endif +# 150 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicExch_block(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 150 +{ } +#endif +# 153 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicExch_system(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 153 +{ } +#endif +# 156 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline float atomicExch_block(float *address, float val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 156 +{ } +#endif +# 159 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline float atomicExch_system(float *address, float val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 159 +{ } +#endif +# 162 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicMin_block(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 162 +{ } +#endif +# 165 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicMin_system(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 165 +{ } +#endif +# 168 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline long long atomicMin_block(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 168 +{ } +#endif +# 171 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline long long atomicMin_system(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 171 +{ } +#endif +# 174 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicMin_block(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 174 +{ } +#endif +# 177 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicMin_system(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 177 +{ } +#endif +# 180 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicMin_block(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 180 +{ } +#endif +# 183 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicMin_system(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 183 +{ } +#endif +# 186 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicMax_block(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 186 +{ } +#endif +# 189 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicMax_system(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 189 +{ } +#endif +# 192 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline long long atomicMax_block(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 192 +{ } +#endif +# 195 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline long long atomicMax_system(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 195 +{ } +#endif +# 198 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicMax_block(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 198 +{ } +#endif +# 201 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicMax_system(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 201 +{ } +#endif +# 204 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicMax_block(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 204 +{ } +#endif +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicMax_system(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 207 +{ } +#endif +# 210 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicInc_block(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 210 +{ } +#endif +# 213 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicInc_system(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 213 +{ } +#endif +# 216 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicDec_block(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 216 +{ } +#endif +# 219 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicDec_system(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 219 +{ } +#endif +# 222 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicCAS_block(int *address, int compare, int val) {int volatile ___ = 1;(void)address;(void)compare;(void)val;::exit(___);} +#if 0 +# 222 +{ } +#endif +# 225 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicCAS_system(int *address, int compare, int val) {int volatile ___ = 1;(void)address;(void)compare;(void)val;::exit(___);} +#if 0 +# 225 +{ } +#endif +# 228 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicCAS_block(unsigned *address, unsigned compare, unsigned +# 229 +val) {int volatile ___ = 1;(void)address;(void)compare;(void)val;::exit(___);} +#if 0 +# 229 +{ } +#endif +# 232 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicCAS_system(unsigned *address, unsigned compare, unsigned +# 233 +val) {int volatile ___ = 1;(void)address;(void)compare;(void)val;::exit(___);} +#if 0 +# 233 +{ } +#endif +# 236 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicCAS_block(unsigned long long *address, unsigned long long +# 237 +compare, unsigned long long +# 238 +val) {int volatile ___ = 1;(void)address;(void)compare;(void)val;::exit(___);} +#if 0 +# 238 +{ } +#endif +# 241 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicCAS_system(unsigned long long *address, unsigned long long +# 242 +compare, unsigned long long +# 243 +val) {int volatile ___ = 1;(void)address;(void)compare;(void)val;::exit(___);} +#if 0 +# 243 +{ } +#endif +# 246 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicAnd_block(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 246 +{ } +#endif +# 249 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicAnd_system(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 249 +{ } +#endif +# 252 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline long long atomicAnd_block(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 252 +{ } +#endif +# 255 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline long long atomicAnd_system(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 255 +{ } +#endif +# 258 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicAnd_block(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 258 +{ } +#endif +# 261 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicAnd_system(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 261 +{ } +#endif +# 264 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicAnd_block(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 264 +{ } +#endif +# 267 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicAnd_system(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 267 +{ } +#endif +# 270 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicOr_block(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 270 +{ } +#endif +# 273 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicOr_system(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 273 +{ } +#endif +# 276 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline long long atomicOr_block(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 276 +{ } +#endif +# 279 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline long long atomicOr_system(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 279 +{ } +#endif +# 282 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicOr_block(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 282 +{ } +#endif +# 285 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicOr_system(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 285 +{ } +#endif +# 288 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicOr_block(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 288 +{ } +#endif +# 291 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicOr_system(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 291 +{ } +#endif +# 294 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicXor_block(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 294 +{ } +#endif +# 297 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline int atomicXor_system(int *address, int val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 297 +{ } +#endif +# 300 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline long long atomicXor_block(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 300 +{ } +#endif +# 303 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline long long atomicXor_system(long long *address, long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 303 +{ } +#endif +# 306 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicXor_block(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 306 +{ } +#endif +# 309 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned atomicXor_system(unsigned *address, unsigned val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 309 +{ } +#endif +# 312 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicXor_block(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 312 +{ } +#endif +# 315 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +__attribute__((unused)) static inline unsigned long long atomicXor_system(unsigned long long *address, unsigned long long val) {int volatile ___ = 1;(void)address;(void)val;::exit(___);} +#if 0 +# 315 +{ } +#endif +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern "C" { +# 1038 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +} +# 1045 +__attribute((deprecated("__ballot() is deprecated in favor of __ballot_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to" " suppress this warning)."))) __attribute__((unused)) static inline unsigned ballot(bool pred) {int volatile ___ = 1;(void)pred;::exit(___);} +#if 0 +# 1045 +{ } +#endif +# 1047 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline int syncthreads_count(bool pred) {int volatile ___ = 1;(void)pred;::exit(___);} +#if 0 +# 1047 +{ } +#endif +# 1049 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline bool syncthreads_and(bool pred) {int volatile ___ = 1;(void)pred;::exit(___);} +#if 0 +# 1049 +{ } +#endif +# 1051 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline bool syncthreads_or(bool pred) {int volatile ___ = 1;(void)pred;::exit(___);} +#if 0 +# 1051 +{ } +#endif +# 1056 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline unsigned __isGlobal(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1056 +{ } +#endif +# 1057 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline unsigned __isShared(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1057 +{ } +#endif +# 1058 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline unsigned __isConstant(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1058 +{ } +#endif +# 1059 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline unsigned __isLocal(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1059 +{ } +#endif +# 1061 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline unsigned __isGridConstant(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1061 +{ } +#endif +# 1063 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline size_t __cvta_generic_to_global(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1063 +{ } +#endif +# 1064 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline size_t __cvta_generic_to_shared(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1064 +{ } +#endif +# 1065 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline size_t __cvta_generic_to_constant(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1065 +{ } +#endif +# 1066 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline size_t __cvta_generic_to_local(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1066 +{ } +#endif +# 1068 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline size_t __cvta_generic_to_grid_constant(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1068 +{ } +#endif +# 1071 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline void *__cvta_global_to_generic(size_t rawbits) {int volatile ___ = 1;(void)rawbits;::exit(___);} +#if 0 +# 1071 +{ } +#endif +# 1072 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline void *__cvta_shared_to_generic(size_t rawbits) {int volatile ___ = 1;(void)rawbits;::exit(___);} +#if 0 +# 1072 +{ } +#endif +# 1073 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline void *__cvta_constant_to_generic(size_t rawbits) {int volatile ___ = 1;(void)rawbits;::exit(___);} +#if 0 +# 1073 +{ } +#endif +# 1074 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline void *__cvta_local_to_generic(size_t rawbits) {int volatile ___ = 1;(void)rawbits;::exit(___);} +#if 0 +# 1074 +{ } +#endif +# 1076 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +__attribute__((unused)) static inline void *__cvta_grid_constant_to_generic(size_t rawbits) {int volatile ___ = 1;(void)rawbits;::exit(___);} +#if 0 +# 1076 +{ } +#endif +# 1090 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +static inline unsigned short __nv_bswap16(unsigned short x) { +# 1092 +return __builtin_bswap16(x); +# 1098 +} +# 1109 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +static inline unsigned __nv_bswap32(unsigned x) { +# 1111 +return __builtin_bswap32(x); +# 1118 +} +# 1129 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +static inline unsigned long long __nv_bswap64(unsigned long long x) { +# 1131 +return __builtin_bswap64(x); +# 1138 +} +# 123 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned __fns(unsigned mask, unsigned base, int offset) {int volatile ___ = 1;(void)mask;(void)base;(void)offset;::exit(___);} +#if 0 +# 123 +{ } +#endif +# 124 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline void __barrier_sync(unsigned id) {int volatile ___ = 1;(void)id;::exit(___);} +#if 0 +# 124 +{ } +#endif +# 125 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline void __barrier_sync_count(unsigned id, unsigned cnt) {int volatile ___ = 1;(void)id;(void)cnt;::exit(___);} +#if 0 +# 125 +{ } +#endif +# 126 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline void __syncwarp(unsigned mask = 4294967295U) {int volatile ___ = 1;(void)mask;::exit(___);} +#if 0 +# 126 +{ } +#endif +# 127 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline int __all_sync(unsigned mask, int pred) {int volatile ___ = 1;(void)mask;(void)pred;::exit(___);} +#if 0 +# 127 +{ } +#endif +# 128 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline int __any_sync(unsigned mask, int pred) {int volatile ___ = 1;(void)mask;(void)pred;::exit(___);} +#if 0 +# 128 +{ } +#endif +# 129 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline int __uni_sync(unsigned mask, int pred) {int volatile ___ = 1;(void)mask;(void)pred;::exit(___);} +#if 0 +# 129 +{ } +#endif +# 130 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned __ballot_sync(unsigned mask, int pred) {int volatile ___ = 1;(void)mask;(void)pred;::exit(___);} +#if 0 +# 130 +{ } +#endif +# 131 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned __activemask() {int volatile ___ = 1;::exit(___);} +#if 0 +# 131 +{ } +#endif +# 140 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl() is deprecated in favor of __shfl_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to sup" "press this warning)."))) __attribute__((unused)) static inline int __shfl(int var, int srcLane, int width = 32) {int volatile ___ = 1;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 140 +{ } +#endif +# 141 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl() is deprecated in favor of __shfl_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to sup" "press this warning)."))) __attribute__((unused)) static inline unsigned __shfl(unsigned var, int srcLane, int width = 32) {int volatile ___ = 1;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 141 +{ } +#endif +# 142 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_up() is deprecated in favor of __shfl_up_sync() and may be removed in a future release (Use -Wno-deprecated-declarations " "to suppress this warning)."))) __attribute__((unused)) static inline int __shfl_up(int var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 142 +{ } +#endif +# 143 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_up() is deprecated in favor of __shfl_up_sync() and may be removed in a future release (Use -Wno-deprecated-declarations " "to suppress this warning)."))) __attribute__((unused)) static inline unsigned __shfl_up(unsigned var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 143 +{ } +#endif +# 144 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_down() is deprecated in favor of __shfl_down_sync() and may be removed in a future release (Use -Wno-deprecated-declarati" "ons to suppress this warning)."))) __attribute__((unused)) static inline int __shfl_down(int var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 144 +{ } +#endif +# 145 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_down() is deprecated in favor of __shfl_down_sync() and may be removed in a future release (Use -Wno-deprecated-declarati" "ons to suppress this warning)."))) __attribute__((unused)) static inline unsigned __shfl_down(unsigned var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 145 +{ } +#endif +# 146 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_xor() is deprecated in favor of __shfl_xor_sync() and may be removed in a future release (Use -Wno-deprecated-declaration" "s to suppress this warning)."))) __attribute__((unused)) static inline int __shfl_xor(int var, int laneMask, int width = 32) {int volatile ___ = 1;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 146 +{ } +#endif +# 147 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_xor() is deprecated in favor of __shfl_xor_sync() and may be removed in a future release (Use -Wno-deprecated-declaration" "s to suppress this warning)."))) __attribute__((unused)) static inline unsigned __shfl_xor(unsigned var, int laneMask, int width = 32) {int volatile ___ = 1;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 147 +{ } +#endif +# 148 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl() is deprecated in favor of __shfl_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to sup" "press this warning)."))) __attribute__((unused)) static inline float __shfl(float var, int srcLane, int width = 32) {int volatile ___ = 1;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 148 +{ } +#endif +# 149 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_up() is deprecated in favor of __shfl_up_sync() and may be removed in a future release (Use -Wno-deprecated-declarations " "to suppress this warning)."))) __attribute__((unused)) static inline float __shfl_up(float var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 149 +{ } +#endif +# 150 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_down() is deprecated in favor of __shfl_down_sync() and may be removed in a future release (Use -Wno-deprecated-declarati" "ons to suppress this warning)."))) __attribute__((unused)) static inline float __shfl_down(float var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 150 +{ } +#endif +# 151 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_xor() is deprecated in favor of __shfl_xor_sync() and may be removed in a future release (Use -Wno-deprecated-declaration" "s to suppress this warning)."))) __attribute__((unused)) static inline float __shfl_xor(float var, int laneMask, int width = 32) {int volatile ___ = 1;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 151 +{ } +#endif +# 154 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline int __shfl_sync(unsigned mask, int var, int srcLane, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 154 +{ } +#endif +# 155 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned __shfl_sync(unsigned mask, unsigned var, int srcLane, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 155 +{ } +#endif +# 156 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline int __shfl_up_sync(unsigned mask, int var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 156 +{ } +#endif +# 157 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned __shfl_up_sync(unsigned mask, unsigned var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 157 +{ } +#endif +# 158 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline int __shfl_down_sync(unsigned mask, int var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 158 +{ } +#endif +# 159 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned __shfl_down_sync(unsigned mask, unsigned var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 159 +{ } +#endif +# 160 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline int __shfl_xor_sync(unsigned mask, int var, int laneMask, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 160 +{ } +#endif +# 161 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned __shfl_xor_sync(unsigned mask, unsigned var, int laneMask, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 161 +{ } +#endif +# 162 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline float __shfl_sync(unsigned mask, float var, int srcLane, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 162 +{ } +#endif +# 163 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline float __shfl_up_sync(unsigned mask, float var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 163 +{ } +#endif +# 164 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline float __shfl_down_sync(unsigned mask, float var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 164 +{ } +#endif +# 165 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline float __shfl_xor_sync(unsigned mask, float var, int laneMask, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 165 +{ } +#endif +# 169 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl() is deprecated in favor of __shfl_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to sup" "press this warning)."))) __attribute__((unused)) static inline unsigned long long __shfl(unsigned long long var, int srcLane, int width = 32) {int volatile ___ = 1;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 169 +{ } +#endif +# 170 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl() is deprecated in favor of __shfl_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to sup" "press this warning)."))) __attribute__((unused)) static inline long long __shfl(long long var, int srcLane, int width = 32) {int volatile ___ = 1;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 170 +{ } +#endif +# 171 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_up() is deprecated in favor of __shfl_up_sync() and may be removed in a future release (Use -Wno-deprecated-declarations " "to suppress this warning)."))) __attribute__((unused)) static inline long long __shfl_up(long long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 171 +{ } +#endif +# 172 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_up() is deprecated in favor of __shfl_up_sync() and may be removed in a future release (Use -Wno-deprecated-declarations " "to suppress this warning)."))) __attribute__((unused)) static inline unsigned long long __shfl_up(unsigned long long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 172 +{ } +#endif +# 173 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_down() is deprecated in favor of __shfl_down_sync() and may be removed in a future release (Use -Wno-deprecated-declarati" "ons to suppress this warning)."))) __attribute__((unused)) static inline long long __shfl_down(long long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 173 +{ } +#endif +# 174 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_down() is deprecated in favor of __shfl_down_sync() and may be removed in a future release (Use -Wno-deprecated-declarati" "ons to suppress this warning)."))) __attribute__((unused)) static inline unsigned long long __shfl_down(unsigned long long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 174 +{ } +#endif +# 175 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_xor() is deprecated in favor of __shfl_xor_sync() and may be removed in a future release (Use -Wno-deprecated-declaration" "s to suppress this warning)."))) __attribute__((unused)) static inline long long __shfl_xor(long long var, int laneMask, int width = 32) {int volatile ___ = 1;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 175 +{ } +#endif +# 176 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_xor() is deprecated in favor of __shfl_xor_sync() and may be removed in a future release (Use -Wno-deprecated-declaration" "s to suppress this warning)."))) __attribute__((unused)) static inline unsigned long long __shfl_xor(unsigned long long var, int laneMask, int width = 32) {int volatile ___ = 1;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 176 +{ } +#endif +# 177 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl() is deprecated in favor of __shfl_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to sup" "press this warning)."))) __attribute__((unused)) static inline double __shfl(double var, int srcLane, int width = 32) {int volatile ___ = 1;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 177 +{ } +#endif +# 178 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_up() is deprecated in favor of __shfl_up_sync() and may be removed in a future release (Use -Wno-deprecated-declarations " "to suppress this warning)."))) __attribute__((unused)) static inline double __shfl_up(double var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 178 +{ } +#endif +# 179 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_down() is deprecated in favor of __shfl_down_sync() and may be removed in a future release (Use -Wno-deprecated-declarati" "ons to suppress this warning)."))) __attribute__((unused)) static inline double __shfl_down(double var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 179 +{ } +#endif +# 180 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_xor() is deprecated in favor of __shfl_xor_sync() and may be removed in a future release (Use -Wno-deprecated-declaration" "s to suppress this warning)."))) __attribute__((unused)) static inline double __shfl_xor(double var, int laneMask, int width = 32) {int volatile ___ = 1;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 180 +{ } +#endif +# 183 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline long long __shfl_sync(unsigned mask, long long var, int srcLane, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 183 +{ } +#endif +# 184 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned long long __shfl_sync(unsigned mask, unsigned long long var, int srcLane, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 184 +{ } +#endif +# 185 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline long long __shfl_up_sync(unsigned mask, long long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 185 +{ } +#endif +# 186 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned long long __shfl_up_sync(unsigned mask, unsigned long long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 186 +{ } +#endif +# 187 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline long long __shfl_down_sync(unsigned mask, long long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 187 +{ } +#endif +# 188 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned long long __shfl_down_sync(unsigned mask, unsigned long long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 188 +{ } +#endif +# 189 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline long long __shfl_xor_sync(unsigned mask, long long var, int laneMask, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 189 +{ } +#endif +# 190 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned long long __shfl_xor_sync(unsigned mask, unsigned long long var, int laneMask, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 190 +{ } +#endif +# 191 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline double __shfl_sync(unsigned mask, double var, int srcLane, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 191 +{ } +#endif +# 192 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline double __shfl_up_sync(unsigned mask, double var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 192 +{ } +#endif +# 193 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline double __shfl_down_sync(unsigned mask, double var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 193 +{ } +#endif +# 194 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline double __shfl_xor_sync(unsigned mask, double var, int laneMask, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 194 +{ } +#endif +# 198 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl() is deprecated in favor of __shfl_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to sup" "press this warning)."))) __attribute__((unused)) static inline long __shfl(long var, int srcLane, int width = 32) {int volatile ___ = 1;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 198 +{ } +#endif +# 199 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl() is deprecated in favor of __shfl_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to sup" "press this warning)."))) __attribute__((unused)) static inline unsigned long __shfl(unsigned long var, int srcLane, int width = 32) {int volatile ___ = 1;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 199 +{ } +#endif +# 200 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_up() is deprecated in favor of __shfl_up_sync() and may be removed in a future release (Use -Wno-deprecated-declarations " "to suppress this warning)."))) __attribute__((unused)) static inline long __shfl_up(long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 200 +{ } +#endif +# 201 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_up() is deprecated in favor of __shfl_up_sync() and may be removed in a future release (Use -Wno-deprecated-declarations " "to suppress this warning)."))) __attribute__((unused)) static inline unsigned long __shfl_up(unsigned long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 201 +{ } +#endif +# 202 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_down() is deprecated in favor of __shfl_down_sync() and may be removed in a future release (Use -Wno-deprecated-declarati" "ons to suppress this warning)."))) __attribute__((unused)) static inline long __shfl_down(long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 202 +{ } +#endif +# 203 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_down() is deprecated in favor of __shfl_down_sync() and may be removed in a future release (Use -Wno-deprecated-declarati" "ons to suppress this warning)."))) __attribute__((unused)) static inline unsigned long __shfl_down(unsigned long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 203 +{ } +#endif +# 204 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_xor() is deprecated in favor of __shfl_xor_sync() and may be removed in a future release (Use -Wno-deprecated-declaration" "s to suppress this warning)."))) __attribute__((unused)) static inline long __shfl_xor(long var, int laneMask, int width = 32) {int volatile ___ = 1;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 204 +{ } +#endif +# 205 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute((deprecated("__shfl_xor() is deprecated in favor of __shfl_xor_sync() and may be removed in a future release (Use -Wno-deprecated-declaration" "s to suppress this warning)."))) __attribute__((unused)) static inline unsigned long __shfl_xor(unsigned long var, int laneMask, int width = 32) {int volatile ___ = 1;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 205 +{ } +#endif +# 208 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline long __shfl_sync(unsigned mask, long var, int srcLane, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 208 +{ } +#endif +# 209 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned long __shfl_sync(unsigned mask, unsigned long var, int srcLane, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)srcLane;(void)width;::exit(___);} +#if 0 +# 209 +{ } +#endif +# 210 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline long __shfl_up_sync(unsigned mask, long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 210 +{ } +#endif +# 211 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned long __shfl_up_sync(unsigned mask, unsigned long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 211 +{ } +#endif +# 212 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline long __shfl_down_sync(unsigned mask, long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 212 +{ } +#endif +# 213 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned long __shfl_down_sync(unsigned mask, unsigned long var, unsigned delta, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)delta;(void)width;::exit(___);} +#if 0 +# 213 +{ } +#endif +# 214 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline long __shfl_xor_sync(unsigned mask, long var, int laneMask, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 214 +{ } +#endif +# 215 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned long __shfl_xor_sync(unsigned mask, unsigned long var, int laneMask, int width = 32) {int volatile ___ = 1;(void)mask;(void)var;(void)laneMask;(void)width;::exit(___);} +#if 0 +# 215 +{ } +#endif +# 91 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long __ldg(const long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 91 +{ } +#endif +# 92 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long __ldg(const unsigned long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 92 +{ } +#endif +# 94 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char __ldg(const char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 94 +{ } +#endif +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline signed char __ldg(const signed char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 95 +{ } +#endif +# 96 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short __ldg(const short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 96 +{ } +#endif +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int __ldg(const int *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 97 +{ } +#endif +# 98 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long long __ldg(const long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 98 +{ } +#endif +# 99 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char2 __ldg(const char2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 99 +{ } +#endif +# 100 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char4 __ldg(const char4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 100 +{ } +#endif +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short2 __ldg(const short2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 101 +{ } +#endif +# 102 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short4 __ldg(const short4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 102 +{ } +#endif +# 103 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int2 __ldg(const int2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 103 +{ } +#endif +# 104 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int4 __ldg(const int4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 104 +{ } +#endif +# 105 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline longlong2 __ldg(const longlong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 105 +{ } +#endif +# 107 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned char __ldg(const unsigned char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 107 +{ } +#endif +# 108 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned short __ldg(const unsigned short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 108 +{ } +#endif +# 109 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned __ldg(const unsigned *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 109 +{ } +#endif +# 110 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long long __ldg(const unsigned long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 110 +{ } +#endif +# 111 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar2 __ldg(const uchar2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 111 +{ } +#endif +# 112 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar4 __ldg(const uchar4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 112 +{ } +#endif +# 113 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort2 __ldg(const ushort2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 113 +{ } +#endif +# 114 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort4 __ldg(const ushort4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 114 +{ } +#endif +# 115 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint2 __ldg(const uint2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 115 +{ } +#endif +# 116 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint4 __ldg(const uint4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 116 +{ } +#endif +# 117 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ulonglong2 __ldg(const ulonglong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 117 +{ } +#endif +# 119 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float __ldg(const float *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 119 +{ } +#endif +# 120 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double __ldg(const double *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 120 +{ } +#endif +# 121 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float2 __ldg(const float2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 121 +{ } +#endif +# 122 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float4 __ldg(const float4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 122 +{ } +#endif +# 123 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double2 __ldg(const double2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 123 +{ } +#endif +# 128 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long __ldcg(const long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 128 +{ } +#endif +# 129 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long __ldcg(const unsigned long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 129 +{ } +#endif +# 131 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char __ldcg(const char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 131 +{ } +#endif +# 132 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline signed char __ldcg(const signed char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 132 +{ } +#endif +# 133 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short __ldcg(const short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 133 +{ } +#endif +# 134 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int __ldcg(const int *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 134 +{ } +#endif +# 135 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long long __ldcg(const long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 135 +{ } +#endif +# 136 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char2 __ldcg(const char2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 136 +{ } +#endif +# 137 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char4 __ldcg(const char4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 137 +{ } +#endif +# 138 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short2 __ldcg(const short2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 138 +{ } +#endif +# 139 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short4 __ldcg(const short4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 139 +{ } +#endif +# 140 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int2 __ldcg(const int2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 140 +{ } +#endif +# 141 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int4 __ldcg(const int4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 141 +{ } +#endif +# 142 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline longlong2 __ldcg(const longlong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 142 +{ } +#endif +# 144 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned char __ldcg(const unsigned char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 144 +{ } +#endif +# 145 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned short __ldcg(const unsigned short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 145 +{ } +#endif +# 146 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned __ldcg(const unsigned *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 146 +{ } +#endif +# 147 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long long __ldcg(const unsigned long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 147 +{ } +#endif +# 148 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar2 __ldcg(const uchar2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 148 +{ } +#endif +# 149 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar4 __ldcg(const uchar4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 149 +{ } +#endif +# 150 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort2 __ldcg(const ushort2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 150 +{ } +#endif +# 151 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort4 __ldcg(const ushort4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 151 +{ } +#endif +# 152 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint2 __ldcg(const uint2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 152 +{ } +#endif +# 153 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint4 __ldcg(const uint4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 153 +{ } +#endif +# 154 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ulonglong2 __ldcg(const ulonglong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 154 +{ } +#endif +# 156 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float __ldcg(const float *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 156 +{ } +#endif +# 157 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double __ldcg(const double *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 157 +{ } +#endif +# 158 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float2 __ldcg(const float2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 158 +{ } +#endif +# 159 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float4 __ldcg(const float4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 159 +{ } +#endif +# 160 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double2 __ldcg(const double2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 160 +{ } +#endif +# 164 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long __ldca(const long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 164 +{ } +#endif +# 165 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long __ldca(const unsigned long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 165 +{ } +#endif +# 167 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char __ldca(const char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 167 +{ } +#endif +# 168 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline signed char __ldca(const signed char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 168 +{ } +#endif +# 169 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short __ldca(const short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 169 +{ } +#endif +# 170 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int __ldca(const int *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 170 +{ } +#endif +# 171 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long long __ldca(const long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 171 +{ } +#endif +# 172 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char2 __ldca(const char2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 172 +{ } +#endif +# 173 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char4 __ldca(const char4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 173 +{ } +#endif +# 174 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short2 __ldca(const short2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 174 +{ } +#endif +# 175 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short4 __ldca(const short4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 175 +{ } +#endif +# 176 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int2 __ldca(const int2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 176 +{ } +#endif +# 177 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int4 __ldca(const int4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 177 +{ } +#endif +# 178 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline longlong2 __ldca(const longlong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 178 +{ } +#endif +# 180 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned char __ldca(const unsigned char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 180 +{ } +#endif +# 181 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned short __ldca(const unsigned short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 181 +{ } +#endif +# 182 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned __ldca(const unsigned *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 182 +{ } +#endif +# 183 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long long __ldca(const unsigned long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 183 +{ } +#endif +# 184 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar2 __ldca(const uchar2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 184 +{ } +#endif +# 185 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar4 __ldca(const uchar4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 185 +{ } +#endif +# 186 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort2 __ldca(const ushort2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 186 +{ } +#endif +# 187 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort4 __ldca(const ushort4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 187 +{ } +#endif +# 188 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint2 __ldca(const uint2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 188 +{ } +#endif +# 189 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint4 __ldca(const uint4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 189 +{ } +#endif +# 190 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ulonglong2 __ldca(const ulonglong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 190 +{ } +#endif +# 192 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float __ldca(const float *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 192 +{ } +#endif +# 193 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double __ldca(const double *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 193 +{ } +#endif +# 194 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float2 __ldca(const float2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 194 +{ } +#endif +# 195 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float4 __ldca(const float4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 195 +{ } +#endif +# 196 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double2 __ldca(const double2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 196 +{ } +#endif +# 200 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long __ldcs(const long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 200 +{ } +#endif +# 201 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long __ldcs(const unsigned long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 201 +{ } +#endif +# 203 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char __ldcs(const char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 203 +{ } +#endif +# 204 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline signed char __ldcs(const signed char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 204 +{ } +#endif +# 205 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short __ldcs(const short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 205 +{ } +#endif +# 206 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int __ldcs(const int *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 206 +{ } +#endif +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long long __ldcs(const long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 207 +{ } +#endif +# 208 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char2 __ldcs(const char2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 208 +{ } +#endif +# 209 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char4 __ldcs(const char4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 209 +{ } +#endif +# 210 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short2 __ldcs(const short2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 210 +{ } +#endif +# 211 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short4 __ldcs(const short4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 211 +{ } +#endif +# 212 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int2 __ldcs(const int2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 212 +{ } +#endif +# 213 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int4 __ldcs(const int4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 213 +{ } +#endif +# 214 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline longlong2 __ldcs(const longlong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 214 +{ } +#endif +# 216 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned char __ldcs(const unsigned char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 216 +{ } +#endif +# 217 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned short __ldcs(const unsigned short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 217 +{ } +#endif +# 218 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned __ldcs(const unsigned *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 218 +{ } +#endif +# 219 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long long __ldcs(const unsigned long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 219 +{ } +#endif +# 220 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar2 __ldcs(const uchar2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 220 +{ } +#endif +# 221 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar4 __ldcs(const uchar4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 221 +{ } +#endif +# 222 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort2 __ldcs(const ushort2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 222 +{ } +#endif +# 223 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort4 __ldcs(const ushort4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 223 +{ } +#endif +# 224 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint2 __ldcs(const uint2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 224 +{ } +#endif +# 225 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint4 __ldcs(const uint4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 225 +{ } +#endif +# 226 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ulonglong2 __ldcs(const ulonglong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 226 +{ } +#endif +# 228 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float __ldcs(const float *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 228 +{ } +#endif +# 229 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double __ldcs(const double *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 229 +{ } +#endif +# 230 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float2 __ldcs(const float2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 230 +{ } +#endif +# 231 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float4 __ldcs(const float4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 231 +{ } +#endif +# 232 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double2 __ldcs(const double2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 232 +{ } +#endif +# 236 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long __ldlu(const long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 236 +{ } +#endif +# 237 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long __ldlu(const unsigned long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 237 +{ } +#endif +# 239 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char __ldlu(const char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 239 +{ } +#endif +# 240 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline signed char __ldlu(const signed char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 240 +{ } +#endif +# 241 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short __ldlu(const short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 241 +{ } +#endif +# 242 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int __ldlu(const int *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 242 +{ } +#endif +# 243 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long long __ldlu(const long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 243 +{ } +#endif +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char2 __ldlu(const char2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 244 +{ } +#endif +# 245 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char4 __ldlu(const char4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 245 +{ } +#endif +# 246 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short2 __ldlu(const short2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 246 +{ } +#endif +# 247 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short4 __ldlu(const short4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 247 +{ } +#endif +# 248 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int2 __ldlu(const int2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 248 +{ } +#endif +# 249 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int4 __ldlu(const int4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 249 +{ } +#endif +# 250 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline longlong2 __ldlu(const longlong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 250 +{ } +#endif +# 252 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned char __ldlu(const unsigned char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 252 +{ } +#endif +# 253 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned short __ldlu(const unsigned short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 253 +{ } +#endif +# 254 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned __ldlu(const unsigned *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 254 +{ } +#endif +# 255 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long long __ldlu(const unsigned long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 255 +{ } +#endif +# 256 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar2 __ldlu(const uchar2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 256 +{ } +#endif +# 257 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar4 __ldlu(const uchar4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 257 +{ } +#endif +# 258 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort2 __ldlu(const ushort2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 258 +{ } +#endif +# 259 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort4 __ldlu(const ushort4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 259 +{ } +#endif +# 260 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint2 __ldlu(const uint2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 260 +{ } +#endif +# 261 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint4 __ldlu(const uint4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 261 +{ } +#endif +# 262 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ulonglong2 __ldlu(const ulonglong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 262 +{ } +#endif +# 264 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float __ldlu(const float *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 264 +{ } +#endif +# 265 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double __ldlu(const double *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 265 +{ } +#endif +# 266 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float2 __ldlu(const float2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 266 +{ } +#endif +# 267 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float4 __ldlu(const float4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 267 +{ } +#endif +# 268 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double2 __ldlu(const double2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 268 +{ } +#endif +# 272 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long __ldcv(const long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 272 +{ } +#endif +# 273 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long __ldcv(const unsigned long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 273 +{ } +#endif +# 275 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char __ldcv(const char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 275 +{ } +#endif +# 276 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline signed char __ldcv(const signed char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 276 +{ } +#endif +# 277 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short __ldcv(const short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 277 +{ } +#endif +# 278 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int __ldcv(const int *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 278 +{ } +#endif +# 279 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline long long __ldcv(const long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 279 +{ } +#endif +# 280 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char2 __ldcv(const char2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 280 +{ } +#endif +# 281 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline char4 __ldcv(const char4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 281 +{ } +#endif +# 282 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short2 __ldcv(const short2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 282 +{ } +#endif +# 283 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline short4 __ldcv(const short4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 283 +{ } +#endif +# 284 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int2 __ldcv(const int2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 284 +{ } +#endif +# 285 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline int4 __ldcv(const int4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 285 +{ } +#endif +# 286 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline longlong2 __ldcv(const longlong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 286 +{ } +#endif +# 288 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned char __ldcv(const unsigned char *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 288 +{ } +#endif +# 289 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned short __ldcv(const unsigned short *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 289 +{ } +#endif +# 290 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned __ldcv(const unsigned *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 290 +{ } +#endif +# 291 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned long long __ldcv(const unsigned long long *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 291 +{ } +#endif +# 292 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar2 __ldcv(const uchar2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 292 +{ } +#endif +# 293 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uchar4 __ldcv(const uchar4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 293 +{ } +#endif +# 294 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort2 __ldcv(const ushort2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 294 +{ } +#endif +# 295 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ushort4 __ldcv(const ushort4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 295 +{ } +#endif +# 296 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint2 __ldcv(const uint2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 296 +{ } +#endif +# 297 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline uint4 __ldcv(const uint4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 297 +{ } +#endif +# 298 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline ulonglong2 __ldcv(const ulonglong2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 298 +{ } +#endif +# 300 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float __ldcv(const float *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 300 +{ } +#endif +# 301 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double __ldcv(const double *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 301 +{ } +#endif +# 302 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float2 __ldcv(const float2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 302 +{ } +#endif +# 303 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline float4 __ldcv(const float4 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 303 +{ } +#endif +# 304 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline double2 __ldcv(const double2 *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 304 +{ } +#endif +# 308 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(long *ptr, long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 308 +{ } +#endif +# 309 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(unsigned long *ptr, unsigned long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 309 +{ } +#endif +# 311 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(char *ptr, char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 311 +{ } +#endif +# 312 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(signed char *ptr, signed char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 312 +{ } +#endif +# 313 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(short *ptr, short value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 313 +{ } +#endif +# 314 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(int *ptr, int value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 314 +{ } +#endif +# 315 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(long long *ptr, long long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 315 +{ } +#endif +# 316 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(char2 *ptr, char2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 316 +{ } +#endif +# 317 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(char4 *ptr, char4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 317 +{ } +#endif +# 318 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(short2 *ptr, short2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 318 +{ } +#endif +# 319 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(short4 *ptr, short4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 319 +{ } +#endif +# 320 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(int2 *ptr, int2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 320 +{ } +#endif +# 321 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(int4 *ptr, int4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 321 +{ } +#endif +# 322 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(longlong2 *ptr, longlong2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 322 +{ } +#endif +# 324 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(unsigned char *ptr, unsigned char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 324 +{ } +#endif +# 325 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(unsigned short *ptr, unsigned short value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 325 +{ } +#endif +# 326 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(unsigned *ptr, unsigned value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 326 +{ } +#endif +# 327 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(unsigned long long *ptr, unsigned long long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 327 +{ } +#endif +# 328 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(uchar2 *ptr, uchar2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 328 +{ } +#endif +# 329 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(uchar4 *ptr, uchar4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 329 +{ } +#endif +# 330 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(ushort2 *ptr, ushort2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 330 +{ } +#endif +# 331 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(ushort4 *ptr, ushort4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 331 +{ } +#endif +# 332 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(uint2 *ptr, uint2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 332 +{ } +#endif +# 333 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(uint4 *ptr, uint4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 333 +{ } +#endif +# 334 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(ulonglong2 *ptr, ulonglong2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 334 +{ } +#endif +# 336 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(float *ptr, float value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 336 +{ } +#endif +# 337 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(double *ptr, double value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 337 +{ } +#endif +# 338 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(float2 *ptr, float2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 338 +{ } +#endif +# 339 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(float4 *ptr, float4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 339 +{ } +#endif +# 340 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwb(double2 *ptr, double2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 340 +{ } +#endif +# 344 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(long *ptr, long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 344 +{ } +#endif +# 345 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(unsigned long *ptr, unsigned long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 345 +{ } +#endif +# 347 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(char *ptr, char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 347 +{ } +#endif +# 348 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(signed char *ptr, signed char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 348 +{ } +#endif +# 349 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(short *ptr, short value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 349 +{ } +#endif +# 350 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(int *ptr, int value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 350 +{ } +#endif +# 351 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(long long *ptr, long long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 351 +{ } +#endif +# 352 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(char2 *ptr, char2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 352 +{ } +#endif +# 353 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(char4 *ptr, char4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 353 +{ } +#endif +# 354 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(short2 *ptr, short2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 354 +{ } +#endif +# 355 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(short4 *ptr, short4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 355 +{ } +#endif +# 356 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(int2 *ptr, int2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 356 +{ } +#endif +# 357 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(int4 *ptr, int4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 357 +{ } +#endif +# 358 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(longlong2 *ptr, longlong2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 358 +{ } +#endif +# 360 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(unsigned char *ptr, unsigned char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 360 +{ } +#endif +# 361 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(unsigned short *ptr, unsigned short value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 361 +{ } +#endif +# 362 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(unsigned *ptr, unsigned value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 362 +{ } +#endif +# 363 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(unsigned long long *ptr, unsigned long long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 363 +{ } +#endif +# 364 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(uchar2 *ptr, uchar2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 364 +{ } +#endif +# 365 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(uchar4 *ptr, uchar4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 365 +{ } +#endif +# 366 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(ushort2 *ptr, ushort2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 366 +{ } +#endif +# 367 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(ushort4 *ptr, ushort4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 367 +{ } +#endif +# 368 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(uint2 *ptr, uint2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 368 +{ } +#endif +# 369 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(uint4 *ptr, uint4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 369 +{ } +#endif +# 370 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(ulonglong2 *ptr, ulonglong2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 370 +{ } +#endif +# 372 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(float *ptr, float value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 372 +{ } +#endif +# 373 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(double *ptr, double value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 373 +{ } +#endif +# 374 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(float2 *ptr, float2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 374 +{ } +#endif +# 375 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(float4 *ptr, float4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 375 +{ } +#endif +# 376 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcg(double2 *ptr, double2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 376 +{ } +#endif +# 380 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(long *ptr, long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 380 +{ } +#endif +# 381 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(unsigned long *ptr, unsigned long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 381 +{ } +#endif +# 383 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(char *ptr, char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 383 +{ } +#endif +# 384 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(signed char *ptr, signed char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 384 +{ } +#endif +# 385 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(short *ptr, short value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 385 +{ } +#endif +# 386 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(int *ptr, int value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 386 +{ } +#endif +# 387 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(long long *ptr, long long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 387 +{ } +#endif +# 388 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(char2 *ptr, char2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 388 +{ } +#endif +# 389 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(char4 *ptr, char4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 389 +{ } +#endif +# 390 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(short2 *ptr, short2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 390 +{ } +#endif +# 391 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(short4 *ptr, short4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 391 +{ } +#endif +# 392 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(int2 *ptr, int2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 392 +{ } +#endif +# 393 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(int4 *ptr, int4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 393 +{ } +#endif +# 394 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(longlong2 *ptr, longlong2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 394 +{ } +#endif +# 396 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(unsigned char *ptr, unsigned char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 396 +{ } +#endif +# 397 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(unsigned short *ptr, unsigned short value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 397 +{ } +#endif +# 398 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(unsigned *ptr, unsigned value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 398 +{ } +#endif +# 399 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(unsigned long long *ptr, unsigned long long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 399 +{ } +#endif +# 400 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(uchar2 *ptr, uchar2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 400 +{ } +#endif +# 401 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(uchar4 *ptr, uchar4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 401 +{ } +#endif +# 402 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(ushort2 *ptr, ushort2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 402 +{ } +#endif +# 403 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(ushort4 *ptr, ushort4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 403 +{ } +#endif +# 404 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(uint2 *ptr, uint2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 404 +{ } +#endif +# 405 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(uint4 *ptr, uint4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 405 +{ } +#endif +# 406 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(ulonglong2 *ptr, ulonglong2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 406 +{ } +#endif +# 408 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(float *ptr, float value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 408 +{ } +#endif +# 409 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(double *ptr, double value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 409 +{ } +#endif +# 410 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(float2 *ptr, float2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 410 +{ } +#endif +# 411 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(float4 *ptr, float4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 411 +{ } +#endif +# 412 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stcs(double2 *ptr, double2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 412 +{ } +#endif +# 416 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(long *ptr, long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 416 +{ } +#endif +# 417 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(unsigned long *ptr, unsigned long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 417 +{ } +#endif +# 419 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(char *ptr, char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 419 +{ } +#endif +# 420 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(signed char *ptr, signed char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 420 +{ } +#endif +# 421 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(short *ptr, short value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 421 +{ } +#endif +# 422 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(int *ptr, int value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 422 +{ } +#endif +# 423 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(long long *ptr, long long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 423 +{ } +#endif +# 424 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(char2 *ptr, char2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 424 +{ } +#endif +# 425 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(char4 *ptr, char4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 425 +{ } +#endif +# 426 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(short2 *ptr, short2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 426 +{ } +#endif +# 427 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(short4 *ptr, short4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 427 +{ } +#endif +# 428 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(int2 *ptr, int2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 428 +{ } +#endif +# 429 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(int4 *ptr, int4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 429 +{ } +#endif +# 430 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(longlong2 *ptr, longlong2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 430 +{ } +#endif +# 432 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(unsigned char *ptr, unsigned char value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 432 +{ } +#endif +# 433 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(unsigned short *ptr, unsigned short value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 433 +{ } +#endif +# 434 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(unsigned *ptr, unsigned value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 434 +{ } +#endif +# 435 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(unsigned long long *ptr, unsigned long long value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 435 +{ } +#endif +# 436 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(uchar2 *ptr, uchar2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 436 +{ } +#endif +# 437 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(uchar4 *ptr, uchar4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 437 +{ } +#endif +# 438 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(ushort2 *ptr, ushort2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 438 +{ } +#endif +# 439 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(ushort4 *ptr, ushort4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 439 +{ } +#endif +# 440 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(uint2 *ptr, uint2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 440 +{ } +#endif +# 441 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(uint4 *ptr, uint4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 441 +{ } +#endif +# 442 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(ulonglong2 *ptr, ulonglong2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 442 +{ } +#endif +# 444 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(float *ptr, float value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 444 +{ } +#endif +# 445 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(double *ptr, double value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 445 +{ } +#endif +# 446 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(float2 *ptr, float2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 446 +{ } +#endif +# 447 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(float4 *ptr, float4 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 447 +{ } +#endif +# 448 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline void __stwt(double2 *ptr, double2 value) {int volatile ___ = 1;(void)ptr;(void)value;::exit(___);} +#if 0 +# 448 +{ } +#endif +# 465 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned __funnelshift_l(unsigned lo, unsigned hi, unsigned shift) {int volatile ___ = 1;(void)lo;(void)hi;(void)shift;::exit(___);} +#if 0 +# 465 +{ } +#endif +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned __funnelshift_lc(unsigned lo, unsigned hi, unsigned shift) {int volatile ___ = 1;(void)lo;(void)hi;(void)shift;::exit(___);} +#if 0 +# 477 +{ } +#endif +# 490 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned __funnelshift_r(unsigned lo, unsigned hi, unsigned shift) {int volatile ___ = 1;(void)lo;(void)hi;(void)shift;::exit(___);} +#if 0 +# 490 +{ } +#endif +# 502 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +__attribute__((unused)) static inline unsigned __funnelshift_rc(unsigned lo, unsigned hi, unsigned shift) {int volatile ___ = 1;(void)lo;(void)hi;(void)shift;::exit(___);} +#if 0 +# 502 +{ } +#endif +# 102 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline int __dp2a_lo(int srcA, int srcB, int c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 102 +{ } +#endif +# 113 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline unsigned __dp2a_lo(unsigned srcA, unsigned srcB, unsigned c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 113 +{ } +#endif +# 125 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline int __dp2a_lo(short2 srcA, char4 srcB, int c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 125 +{ } +#endif +# 136 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline unsigned __dp2a_lo(ushort2 srcA, uchar4 srcB, unsigned c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 136 +{ } +#endif +# 148 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline int __dp2a_hi(int srcA, int srcB, int c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 148 +{ } +#endif +# 159 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline unsigned __dp2a_hi(unsigned srcA, unsigned srcB, unsigned c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 159 +{ } +#endif +# 171 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline int __dp2a_hi(short2 srcA, char4 srcB, int c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 171 +{ } +#endif +# 182 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline unsigned __dp2a_hi(ushort2 srcA, uchar4 srcB, unsigned c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 182 +{ } +#endif +# 197 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline int __dp4a(int srcA, int srcB, int c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 197 +{ } +#endif +# 206 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline unsigned __dp4a(unsigned srcA, unsigned srcB, unsigned c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 206 +{ } +#endif +# 216 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline int __dp4a(char4 srcA, char4 srcB, int c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 216 +{ } +#endif +# 225 "/opt/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +__attribute__((unused)) static inline unsigned __dp4a(uchar4 srcA, uchar4 srcB, unsigned c) {int volatile ___ = 1;(void)srcA;(void)srcB;(void)c;::exit(___);} +#if 0 +# 225 +{ } +#endif +# 98 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_any_sync(unsigned mask, unsigned value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 98 +{ } +#endif +# 99 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_any_sync(unsigned mask, int value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 99 +{ } +#endif +# 100 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_any_sync(unsigned mask, unsigned long value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 100 +{ } +#endif +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_any_sync(unsigned mask, long value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 101 +{ } +#endif +# 102 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_any_sync(unsigned mask, unsigned long long value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 102 +{ } +#endif +# 103 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_any_sync(unsigned mask, long long value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 103 +{ } +#endif +# 104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_any_sync(unsigned mask, float value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 104 +{ } +#endif +# 105 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_any_sync(unsigned mask, double value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 105 +{ } +#endif +# 107 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_all_sync(unsigned mask, unsigned value, int *pred) {int volatile ___ = 1;(void)mask;(void)value;(void)pred;::exit(___);} +#if 0 +# 107 +{ } +#endif +# 108 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_all_sync(unsigned mask, int value, int *pred) {int volatile ___ = 1;(void)mask;(void)value;(void)pred;::exit(___);} +#if 0 +# 108 +{ } +#endif +# 109 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_all_sync(unsigned mask, unsigned long value, int *pred) {int volatile ___ = 1;(void)mask;(void)value;(void)pred;::exit(___);} +#if 0 +# 109 +{ } +#endif +# 110 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_all_sync(unsigned mask, long value, int *pred) {int volatile ___ = 1;(void)mask;(void)value;(void)pred;::exit(___);} +#if 0 +# 110 +{ } +#endif +# 111 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_all_sync(unsigned mask, unsigned long long value, int *pred) {int volatile ___ = 1;(void)mask;(void)value;(void)pred;::exit(___);} +#if 0 +# 111 +{ } +#endif +# 112 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_all_sync(unsigned mask, long long value, int *pred) {int volatile ___ = 1;(void)mask;(void)value;(void)pred;::exit(___);} +#if 0 +# 112 +{ } +#endif +# 113 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_all_sync(unsigned mask, float value, int *pred) {int volatile ___ = 1;(void)mask;(void)value;(void)pred;::exit(___);} +#if 0 +# 113 +{ } +#endif +# 114 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned __match_all_sync(unsigned mask, double value, int *pred) {int volatile ___ = 1;(void)mask;(void)value;(void)pred;::exit(___);} +#if 0 +# 114 +{ } +#endif +# 116 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline void __nanosleep(unsigned ns) {int volatile ___ = 1;(void)ns;::exit(___);} +#if 0 +# 116 +{ } +#endif +# 118 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +__attribute__((unused)) static inline unsigned short atomicCAS(unsigned short *address, unsigned short compare, unsigned short val) {int volatile ___ = 1;(void)address;(void)compare;(void)val;::exit(___);} +#if 0 +# 118 +{ } +#endif +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) static inline unsigned __reduce_add_sync(unsigned mask, unsigned value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 97 +{ } +#endif +# 98 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) static inline unsigned __reduce_min_sync(unsigned mask, unsigned value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 98 +{ } +#endif +# 99 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) static inline unsigned __reduce_max_sync(unsigned mask, unsigned value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 99 +{ } +#endif +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) static inline int __reduce_add_sync(unsigned mask, int value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 101 +{ } +#endif +# 102 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) static inline int __reduce_min_sync(unsigned mask, int value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 102 +{ } +#endif +# 103 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) static inline int __reduce_max_sync(unsigned mask, int value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 103 +{ } +#endif +# 105 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) static inline unsigned __reduce_and_sync(unsigned mask, unsigned value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 105 +{ } +#endif +# 106 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) static inline unsigned __reduce_or_sync(unsigned mask, unsigned value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 106 +{ } +#endif +# 107 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) static inline unsigned __reduce_xor_sync(unsigned mask, unsigned value) {int volatile ___ = 1;(void)mask;(void)value;::exit(___);} +#if 0 +# 107 +{ } +#endif +# 112 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +extern "C" { +# 113 +__attribute__((unused)) inline void *__nv_associate_access_property(const void *ptr, unsigned long long +# 114 +property) {int volatile ___ = 1;(void)ptr;(void)property; +# 118 +::exit(___);} +#if 0 +# 114 +{ +# 115 +__attribute__((unused)) extern void *__nv_associate_access_property_impl(const void *, unsigned long long); +# 117 +return __nv_associate_access_property_impl(ptr, property); +# 118 +} +#endif +# 120 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) inline void __nv_memcpy_async_shared_global_4(void *dst, const void * +# 121 +src, unsigned +# 122 +src_size) {int volatile ___ = 1;(void)dst;(void)src;(void)src_size; +# 127 +::exit(___);} +#if 0 +# 122 +{ +# 123 +__attribute__((unused)) extern void __nv_memcpy_async_shared_global_4_impl(void *, const void *, unsigned); +# 126 +__nv_memcpy_async_shared_global_4_impl(dst, src, src_size); +# 127 +} +#endif +# 129 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) inline void __nv_memcpy_async_shared_global_8(void *dst, const void * +# 130 +src, unsigned +# 131 +src_size) {int volatile ___ = 1;(void)dst;(void)src;(void)src_size; +# 136 +::exit(___);} +#if 0 +# 131 +{ +# 132 +__attribute__((unused)) extern void __nv_memcpy_async_shared_global_8_impl(void *, const void *, unsigned); +# 135 +__nv_memcpy_async_shared_global_8_impl(dst, src, src_size); +# 136 +} +#endif +# 138 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +__attribute__((unused)) inline void __nv_memcpy_async_shared_global_16(void *dst, const void * +# 139 +src, unsigned +# 140 +src_size) {int volatile ___ = 1;(void)dst;(void)src;(void)src_size; +# 145 +::exit(___);} +#if 0 +# 140 +{ +# 141 +__attribute__((unused)) extern void __nv_memcpy_async_shared_global_16_impl(void *, const void *, unsigned); +# 144 +__nv_memcpy_async_shared_global_16_impl(dst, src, src_size); +# 145 +} +#endif +# 147 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +} +# 92 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline unsigned __isCtaShared(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 92 +{ } +#endif +# 93 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline unsigned __isClusterShared(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 93 +{ } +#endif +# 94 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline void *__cluster_map_shared_rank(const void *ptr, unsigned target_block_rank) {int volatile ___ = 1;(void)ptr;(void)target_block_rank;::exit(___);} +#if 0 +# 94 +{ } +#endif +# 95 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline unsigned __cluster_query_shared_rank(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 95 +{ } +#endif +# 96 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline uint2 __cluster_map_shared_multicast(const void *ptr, unsigned cluster_cta_mask) {int volatile ___ = 1;(void)ptr;(void)cluster_cta_mask;::exit(___);} +#if 0 +# 96 +{ } +#endif +# 97 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline unsigned __clusterDimIsSpecified() {int volatile ___ = 1;::exit(___);} +#if 0 +# 97 +{ } +#endif +# 98 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline dim3 __clusterDim() {int volatile ___ = 1;::exit(___);} +#if 0 +# 98 +{ } +#endif +# 99 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline dim3 __clusterRelativeBlockIdx() {int volatile ___ = 1;::exit(___);} +#if 0 +# 99 +{ } +#endif +# 100 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline dim3 __clusterGridDimInClusters() {int volatile ___ = 1;::exit(___);} +#if 0 +# 100 +{ } +#endif +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline dim3 __clusterIdx() {int volatile ___ = 1;::exit(___);} +#if 0 +# 101 +{ } +#endif +# 102 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline unsigned __clusterRelativeBlockRank() {int volatile ___ = 1;::exit(___);} +#if 0 +# 102 +{ } +#endif +# 103 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline unsigned __clusterSizeInBlocks() {int volatile ___ = 1;::exit(___);} +#if 0 +# 103 +{ } +#endif +# 104 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline void __cluster_barrier_arrive() {int volatile ___ = 1;::exit(___);} +#if 0 +# 104 +{ } +#endif +# 105 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline void __cluster_barrier_arrive_relaxed() {int volatile ___ = 1;::exit(___);} +#if 0 +# 105 +{ } +#endif +# 106 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline void __cluster_barrier_wait() {int volatile ___ = 1;::exit(___);} +#if 0 +# 106 +{ } +#endif +# 107 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline void __threadfence_cluster() {int volatile ___ = 1;::exit(___);} +#if 0 +# 107 +{ } +#endif +# 109 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline float2 atomicAdd(float2 *__address, float2 val) {int volatile ___ = 1;(void)__address;(void)val;::exit(___);} +#if 0 +# 109 +{ } +#endif +# 110 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline float2 atomicAdd_block(float2 *__address, float2 val) {int volatile ___ = 1;(void)__address;(void)val;::exit(___);} +#if 0 +# 110 +{ } +#endif +# 111 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline float2 atomicAdd_system(float2 *__address, float2 val) {int volatile ___ = 1;(void)__address;(void)val;::exit(___);} +#if 0 +# 111 +{ } +#endif +# 112 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline float4 atomicAdd(float4 *__address, float4 val) {int volatile ___ = 1;(void)__address;(void)val;::exit(___);} +#if 0 +# 112 +{ } +#endif +# 113 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline float4 atomicAdd_block(float4 *__address, float4 val) {int volatile ___ = 1;(void)__address;(void)val;::exit(___);} +#if 0 +# 113 +{ } +#endif +# 114 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +__attribute__((unused)) static inline float4 atomicAdd_system(float4 *__address, float4 val) {int volatile ___ = 1;(void)__address;(void)val;::exit(___);} +#if 0 +# 114 +{ } +#endif +# 125 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +extern "C" { +# 132 +} +# 139 +template< bool __b, class _T> +# 140 +struct __nv_atomic_enable_if { }; +# 142 +template< class _T> +# 143 +struct __nv_atomic_enable_if< true, _T> { typedef _T __type; }; +# 153 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +template< class _T> +# 154 +struct __nv_atomic_triv_cp_helper { +# 161 +static const bool __val = __is_trivially_copyable(_T); +# 166 +}; +# 201 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +template< class _T> __attribute__((unused)) static inline typename __nv_atomic_enable_if< (sizeof(_T) == (16)) && (__alignof__(_T) >= (16)) && __nv_atomic_triv_cp_helper< _T> ::__val, _T> ::__type +# 203 +atomicCAS(_T *__address, _T __compare, _T __val) {int volatile ___ = 1;(void)__address;(void)__compare;(void)__val; +# 210 +::exit(___);} +#if 0 +# 203 +{ +# 204 +union _U { _T __ret; _U() {int *volatile ___ = 0;::free(___);} +#if 0 +# 204 +{ } +#endif +# 204 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +}; _U __u; +# 205 +__u128AtomicCAS((void *)__address, (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__compare)))), (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__val)))), (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__u.__ret))))); +# 209 +return __u.__ret; +# 210 +} +#endif +# 212 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +template< class _T> __attribute__((unused)) static inline typename __nv_atomic_enable_if< (sizeof(_T) == (16)) && (__alignof__(_T) >= (16)) && __nv_atomic_triv_cp_helper< _T> ::__val, _T> ::__type +# 214 +atomicCAS_block(_T *__address, _T __compare, _T __val) {int volatile ___ = 1;(void)__address;(void)__compare;(void)__val; +# 221 +::exit(___);} +#if 0 +# 214 +{ +# 215 +union _U { _T __ret; _U() {int *volatile ___ = 0;::free(___);} +#if 0 +# 215 +{ } +#endif +# 215 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +}; _U __u; +# 216 +__u128AtomicCAS_block((void *)__address, (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__compare)))), (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__val)))), (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__u.__ret))))); +# 220 +return __u.__ret; +# 221 +} +#endif +# 223 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +template< class _T> __attribute__((unused)) static inline typename __nv_atomic_enable_if< (sizeof(_T) == (16)) && (__alignof__(_T) >= (16)) && __nv_atomic_triv_cp_helper< _T> ::__val, _T> ::__type +# 225 +atomicCAS_system(_T *__address, _T __compare, _T __val) {int volatile ___ = 1;(void)__address;(void)__compare;(void)__val; +# 232 +::exit(___);} +#if 0 +# 225 +{ +# 226 +union _U { _T __ret; _U() {int *volatile ___ = 0;::free(___);} +#if 0 +# 226 +{ } +#endif +# 226 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +}; _U __u; +# 227 +__u128AtomicCAS_system((void *)__address, (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__compare)))), (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__val)))), (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__u.__ret))))); +# 231 +return __u.__ret; +# 232 +} +#endif +# 234 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +template< class _T> __attribute__((unused)) static inline typename __nv_atomic_enable_if< (sizeof(_T) == (16)) && (__alignof__(_T) >= (16)) && __nv_atomic_triv_cp_helper< _T> ::__val, _T> ::__type +# 236 +atomicExch(_T *__address, _T __val) {int volatile ___ = 1;(void)__address;(void)__val; +# 242 +::exit(___);} +#if 0 +# 236 +{ +# 237 +union _U { _T __ret; _U() {int *volatile ___ = 0;::free(___);} +#if 0 +# 237 +{ } +#endif +# 237 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +}; _U __u; +# 238 +__u128AtomicExch((void *)__address, (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__val)))), (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__u.__ret))))); +# 241 +return __u.__ret; +# 242 +} +#endif +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +template< class _T> __attribute__((unused)) static inline typename __nv_atomic_enable_if< (sizeof(_T) == (16)) && (__alignof__(_T) >= (16)) && __nv_atomic_triv_cp_helper< _T> ::__val, _T> ::__type +# 246 +atomicExch_block(_T *__address, _T __val) {int volatile ___ = 1;(void)__address;(void)__val; +# 252 +::exit(___);} +#if 0 +# 246 +{ +# 247 +union _U { _T __ret; _U() {int *volatile ___ = 0;::free(___);} +#if 0 +# 247 +{ } +#endif +# 247 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +}; _U __u; +# 248 +__u128AtomicExch_block((void *)__address, (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__val)))), (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__u.__ret))))); +# 251 +return __u.__ret; +# 252 +} +#endif +# 254 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +template< class _T> __attribute__((unused)) static inline typename __nv_atomic_enable_if< (sizeof(_T) == (16)) && (__alignof__(_T) >= (16)) && __nv_atomic_triv_cp_helper< _T> ::__val, _T> ::__type +# 256 +atomicExch_system(_T *__address, _T __val) {int volatile ___ = 1;(void)__address;(void)__val; +# 262 +::exit(___);} +#if 0 +# 256 +{ +# 257 +union _U { _T __ret; _U() {int *volatile ___ = 0;::free(___);} +#if 0 +# 257 +{ } +#endif +# 257 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +}; _U __u; +# 258 +__u128AtomicExch_system((void *)__address, (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__val)))), (void *)(&(const_cast< char &>(reinterpret_cast< const volatile char &>(__u.__ret))))); +# 261 +return __u.__ret; +# 262 +} +#endif +# 100 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __ffma2_rn(float2 x, float2 y, float2 z) {int volatile ___ = 1;(void)x;(void)y;(void)z;::exit(___);} +#if 0 +# 100 +{ } +#endif +# 112 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __ffma2_rz(float2 x, float2 y, float2 z) {int volatile ___ = 1;(void)x;(void)y;(void)z;::exit(___);} +#if 0 +# 112 +{ } +#endif +# 124 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __ffma2_rd(float2 x, float2 y, float2 z) {int volatile ___ = 1;(void)x;(void)y;(void)z;::exit(___);} +#if 0 +# 124 +{ } +#endif +# 136 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __ffma2_ru(float2 x, float2 y, float2 z) {int volatile ___ = 1;(void)x;(void)y;(void)z;::exit(___);} +#if 0 +# 136 +{ } +#endif +# 149 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __fadd2_rn(float2 x, float2 y) {int volatile ___ = 1;(void)x;(void)y;::exit(___);} +#if 0 +# 149 +{ } +#endif +# 161 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __fadd2_rz(float2 x, float2 y) {int volatile ___ = 1;(void)x;(void)y;::exit(___);} +#if 0 +# 161 +{ } +#endif +# 173 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __fadd2_rd(float2 x, float2 y) {int volatile ___ = 1;(void)x;(void)y;::exit(___);} +#if 0 +# 173 +{ } +#endif +# 185 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __fadd2_ru(float2 x, float2 y) {int volatile ___ = 1;(void)x;(void)y;::exit(___);} +#if 0 +# 185 +{ } +#endif +# 198 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __fmul2_rn(float2 x, float2 y) {int volatile ___ = 1;(void)x;(void)y;::exit(___);} +#if 0 +# 198 +{ } +#endif +# 210 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __fmul2_rz(float2 x, float2 y) {int volatile ___ = 1;(void)x;(void)y;::exit(___);} +#if 0 +# 210 +{ } +#endif +# 222 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __fmul2_rd(float2 x, float2 y) {int volatile ___ = 1;(void)x;(void)y;::exit(___);} +#if 0 +# 222 +{ } +#endif +# 234 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/sm_100_rt.h" +__attribute__((unused)) static inline float2 __fmul2_ru(float2 x, float2 y) {int volatile ___ = 1;(void)x;(void)y;::exit(___);} +#if 0 +# 234 +{ } +#endif +# 65 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> struct __nv_itex_trait { }; +# 66 +template<> struct __nv_itex_trait< char> { typedef void type; }; +# 67 +template<> struct __nv_itex_trait< signed char> { typedef void type; }; +# 68 +template<> struct __nv_itex_trait< char1> { typedef void type; }; +# 69 +template<> struct __nv_itex_trait< char2> { typedef void type; }; +# 70 +template<> struct __nv_itex_trait< char4> { typedef void type; }; +# 71 +template<> struct __nv_itex_trait< unsigned char> { typedef void type; }; +# 72 +template<> struct __nv_itex_trait< uchar1> { typedef void type; }; +# 73 +template<> struct __nv_itex_trait< uchar2> { typedef void type; }; +# 74 +template<> struct __nv_itex_trait< uchar4> { typedef void type; }; +# 75 +template<> struct __nv_itex_trait< short> { typedef void type; }; +# 76 +template<> struct __nv_itex_trait< short1> { typedef void type; }; +# 77 +template<> struct __nv_itex_trait< short2> { typedef void type; }; +# 78 +template<> struct __nv_itex_trait< short4> { typedef void type; }; +# 79 +template<> struct __nv_itex_trait< unsigned short> { typedef void type; }; +# 80 +template<> struct __nv_itex_trait< ushort1> { typedef void type; }; +# 81 +template<> struct __nv_itex_trait< ushort2> { typedef void type; }; +# 82 +template<> struct __nv_itex_trait< ushort4> { typedef void type; }; +# 83 +template<> struct __nv_itex_trait< int> { typedef void type; }; +# 84 +template<> struct __nv_itex_trait< int1> { typedef void type; }; +# 85 +template<> struct __nv_itex_trait< int2> { typedef void type; }; +# 86 +template<> struct __nv_itex_trait< int4> { typedef void type; }; +# 87 +template<> struct __nv_itex_trait< unsigned> { typedef void type; }; +# 88 +template<> struct __nv_itex_trait< uint1> { typedef void type; }; +# 89 +template<> struct __nv_itex_trait< uint2> { typedef void type; }; +# 90 +template<> struct __nv_itex_trait< uint4> { typedef void type; }; +# 101 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template<> struct __nv_itex_trait< float> { typedef void type; }; +# 102 +template<> struct __nv_itex_trait< float1> { typedef void type; }; +# 103 +template<> struct __nv_itex_trait< float2> { typedef void type; }; +# 104 +template<> struct __nv_itex_trait< float4> { typedef void type; }; +# 108 +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 109 +tex1Dfetch(T *ptr, cudaTextureObject_t obj, int x) +# 110 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x; +# 112 +::exit(___);} +#if 0 +# 110 +{ +# 111 +__nv_tex_surf_handler("__itex1Dfetch", ptr, obj, x); +# 112 +} +#endif +# 114 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 115 +tex1Dfetch(cudaTextureObject_t texObject, int x) +# 116 +{int volatile ___ = 1;(void)texObject;(void)x; +# 120 +::exit(___);} +#if 0 +# 116 +{ +# 117 +T ret; +# 118 +tex1Dfetch(&ret, texObject, x); +# 119 +return ret; +# 120 +} +#endif +# 122 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 123 +tex1D(T *ptr, cudaTextureObject_t obj, float x) +# 124 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x; +# 126 +::exit(___);} +#if 0 +# 124 +{ +# 125 +__nv_tex_surf_handler("__itex1D", ptr, obj, x); +# 126 +} +#endif +# 129 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 130 +tex1D(cudaTextureObject_t texObject, float x) +# 131 +{int volatile ___ = 1;(void)texObject;(void)x; +# 135 +::exit(___);} +#if 0 +# 131 +{ +# 132 +T ret; +# 133 +tex1D(&ret, texObject, x); +# 134 +return ret; +# 135 +} +#endif +# 138 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 139 +tex2D(T *ptr, cudaTextureObject_t obj, float x, float y) +# 140 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y; +# 142 +::exit(___);} +#if 0 +# 140 +{ +# 141 +__nv_tex_surf_handler("__itex2D", ptr, obj, x, y); +# 142 +} +#endif +# 144 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 145 +tex2D(cudaTextureObject_t texObject, float x, float y) +# 146 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y; +# 150 +::exit(___);} +#if 0 +# 146 +{ +# 147 +T ret; +# 148 +tex2D(&ret, texObject, x, y); +# 149 +return ret; +# 150 +} +#endif +# 153 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 154 +tex2D(T *ptr, cudaTextureObject_t obj, float x, float y, bool * +# 155 +isResident) +# 156 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)isResident; +# 160 +::exit(___);} +#if 0 +# 156 +{ +# 157 +unsigned char res; +# 158 +__nv_tex_surf_handler("__itex2D_sparse", ptr, obj, x, y, &res); +# 159 +(*isResident) = (res != 0); +# 160 +} +#endif +# 162 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 163 +tex2D(cudaTextureObject_t texObject, float x, float y, bool *isResident) +# 164 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)isResident; +# 168 +::exit(___);} +#if 0 +# 164 +{ +# 165 +T ret; +# 166 +tex2D(&ret, texObject, x, y, isResident); +# 167 +return ret; +# 168 +} +#endif +# 173 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 174 +tex3D(T *ptr, cudaTextureObject_t obj, float x, float y, float z) +# 175 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z; +# 177 +::exit(___);} +#if 0 +# 175 +{ +# 176 +__nv_tex_surf_handler("__itex3D", ptr, obj, x, y, z); +# 177 +} +#endif +# 179 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 180 +tex3D(cudaTextureObject_t texObject, float x, float y, float z) +# 181 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z; +# 185 +::exit(___);} +#if 0 +# 181 +{ +# 182 +T ret; +# 183 +tex3D(&ret, texObject, x, y, z); +# 184 +return ret; +# 185 +} +#endif +# 188 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 189 +tex3D(T *ptr, cudaTextureObject_t obj, float x, float y, float z, bool * +# 190 +isResident) +# 191 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)isResident; +# 195 +::exit(___);} +#if 0 +# 191 +{ +# 192 +unsigned char res; +# 193 +__nv_tex_surf_handler("__itex3D_sparse", ptr, obj, x, y, z, &res); +# 194 +(*isResident) = (res != 0); +# 195 +} +#endif +# 197 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 198 +tex3D(cudaTextureObject_t texObject, float x, float y, float z, bool *isResident) +# 199 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z;(void)isResident; +# 203 +::exit(___);} +#if 0 +# 199 +{ +# 200 +T ret; +# 201 +tex3D(&ret, texObject, x, y, z, isResident); +# 202 +return ret; +# 203 +} +#endif +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 208 +tex1DLayered(T *ptr, cudaTextureObject_t obj, float x, int layer) +# 209 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)layer; +# 211 +::exit(___);} +#if 0 +# 209 +{ +# 210 +__nv_tex_surf_handler("__itex1DLayered", ptr, obj, x, layer); +# 211 +} +#endif +# 213 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 214 +tex1DLayered(cudaTextureObject_t texObject, float x, int layer) +# 215 +{int volatile ___ = 1;(void)texObject;(void)x;(void)layer; +# 219 +::exit(___);} +#if 0 +# 215 +{ +# 216 +T ret; +# 217 +tex1DLayered(&ret, texObject, x, layer); +# 218 +return ret; +# 219 +} +#endif +# 221 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 222 +tex2DLayered(T *ptr, cudaTextureObject_t obj, float x, float y, int layer) +# 223 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)layer; +# 225 +::exit(___);} +#if 0 +# 223 +{ +# 224 +__nv_tex_surf_handler("__itex2DLayered", ptr, obj, x, y, layer); +# 225 +} +#endif +# 227 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 228 +tex2DLayered(cudaTextureObject_t texObject, float x, float y, int layer) +# 229 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)layer; +# 233 +::exit(___);} +#if 0 +# 229 +{ +# 230 +T ret; +# 231 +tex2DLayered(&ret, texObject, x, y, layer); +# 232 +return ret; +# 233 +} +#endif +# 236 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 237 +tex2DLayered(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, bool *isResident) +# 238 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)layer;(void)isResident; +# 242 +::exit(___);} +#if 0 +# 238 +{ +# 239 +unsigned char res; +# 240 +__nv_tex_surf_handler("__itex2DLayered_sparse", ptr, obj, x, y, layer, &res); +# 241 +(*isResident) = (res != 0); +# 242 +} +#endif +# 244 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 245 +tex2DLayered(cudaTextureObject_t texObject, float x, float y, int layer, bool *isResident) +# 246 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)layer;(void)isResident; +# 250 +::exit(___);} +#if 0 +# 246 +{ +# 247 +T ret; +# 248 +tex2DLayered(&ret, texObject, x, y, layer, isResident); +# 249 +return ret; +# 250 +} +#endif +# 254 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 255 +texCubemap(T *ptr, cudaTextureObject_t obj, float x, float y, float z) +# 256 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z; +# 258 +::exit(___);} +#if 0 +# 256 +{ +# 257 +__nv_tex_surf_handler("__itexCubemap", ptr, obj, x, y, z); +# 258 +} +#endif +# 261 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 262 +texCubemap(cudaTextureObject_t texObject, float x, float y, float z) +# 263 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z; +# 267 +::exit(___);} +#if 0 +# 263 +{ +# 264 +T ret; +# 265 +texCubemap(&ret, texObject, x, y, z); +# 266 +return ret; +# 267 +} +#endif +# 270 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 271 +texCubemapLayered(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer) +# 272 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)layer; +# 274 +::exit(___);} +#if 0 +# 272 +{ +# 273 +__nv_tex_surf_handler("__itexCubemapLayered", ptr, obj, x, y, z, layer); +# 274 +} +#endif +# 276 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 277 +texCubemapLayered(cudaTextureObject_t texObject, float x, float y, float z, int layer) +# 278 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z;(void)layer; +# 282 +::exit(___);} +#if 0 +# 278 +{ +# 279 +T ret; +# 280 +texCubemapLayered(&ret, texObject, x, y, z, layer); +# 281 +return ret; +# 282 +} +#endif +# 284 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 285 +tex2Dgather(T *ptr, cudaTextureObject_t obj, float x, float y, int comp = 0) +# 286 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)comp; +# 288 +::exit(___);} +#if 0 +# 286 +{ +# 287 +__nv_tex_surf_handler("__itex2Dgather", ptr, obj, x, y, comp); +# 288 +} +#endif +# 290 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 291 +tex2Dgather(cudaTextureObject_t to, float x, float y, int comp = 0) +# 292 +{int volatile ___ = 1;(void)to;(void)x;(void)y;(void)comp; +# 296 +::exit(___);} +#if 0 +# 292 +{ +# 293 +T ret; +# 294 +tex2Dgather(&ret, to, x, y, comp); +# 295 +return ret; +# 296 +} +#endif +# 299 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 300 +tex2Dgather(T *ptr, cudaTextureObject_t obj, float x, float y, bool *isResident, int comp = 0) +# 301 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)isResident;(void)comp; +# 305 +::exit(___);} +#if 0 +# 301 +{ +# 302 +unsigned char res; +# 303 +__nv_tex_surf_handler("__itex2Dgather_sparse", ptr, obj, x, y, comp, &res); +# 304 +(*isResident) = (res != 0); +# 305 +} +#endif +# 307 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 308 +tex2Dgather(cudaTextureObject_t to, float x, float y, bool *isResident, int comp = 0) +# 309 +{int volatile ___ = 1;(void)to;(void)x;(void)y;(void)isResident;(void)comp; +# 313 +::exit(___);} +#if 0 +# 309 +{ +# 310 +T ret; +# 311 +tex2Dgather(&ret, to, x, y, isResident, comp); +# 312 +return ret; +# 313 +} +#endif +# 317 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 318 +tex1DLod(T *ptr, cudaTextureObject_t obj, float x, float level) +# 319 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)level; +# 321 +::exit(___);} +#if 0 +# 319 +{ +# 320 +__nv_tex_surf_handler("__itex1DLod", ptr, obj, x, level); +# 321 +} +#endif +# 323 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 324 +tex1DLod(cudaTextureObject_t texObject, float x, float level) +# 325 +{int volatile ___ = 1;(void)texObject;(void)x;(void)level; +# 329 +::exit(___);} +#if 0 +# 325 +{ +# 326 +T ret; +# 327 +tex1DLod(&ret, texObject, x, level); +# 328 +return ret; +# 329 +} +#endif +# 332 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 333 +tex2DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float level) +# 334 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)level; +# 336 +::exit(___);} +#if 0 +# 334 +{ +# 335 +__nv_tex_surf_handler("__itex2DLod", ptr, obj, x, y, level); +# 336 +} +#endif +# 338 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 339 +tex2DLod(cudaTextureObject_t texObject, float x, float y, float level) +# 340 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)level; +# 344 +::exit(___);} +#if 0 +# 340 +{ +# 341 +T ret; +# 342 +tex2DLod(&ret, texObject, x, y, level); +# 343 +return ret; +# 344 +} +#endif +# 348 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 349 +tex2DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float level, bool *isResident) +# 350 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)level;(void)isResident; +# 354 +::exit(___);} +#if 0 +# 350 +{ +# 351 +unsigned char res; +# 352 +__nv_tex_surf_handler("__itex2DLod_sparse", ptr, obj, x, y, level, &res); +# 353 +(*isResident) = (res != 0); +# 354 +} +#endif +# 356 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 357 +tex2DLod(cudaTextureObject_t texObject, float x, float y, float level, bool *isResident) +# 358 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)level;(void)isResident; +# 362 +::exit(___);} +#if 0 +# 358 +{ +# 359 +T ret; +# 360 +tex2DLod(&ret, texObject, x, y, level, isResident); +# 361 +return ret; +# 362 +} +#endif +# 367 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 368 +tex3DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level) +# 369 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)level; +# 371 +::exit(___);} +#if 0 +# 369 +{ +# 370 +__nv_tex_surf_handler("__itex3DLod", ptr, obj, x, y, z, level); +# 371 +} +#endif +# 373 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 374 +tex3DLod(cudaTextureObject_t texObject, float x, float y, float z, float level) +# 375 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z;(void)level; +# 379 +::exit(___);} +#if 0 +# 375 +{ +# 376 +T ret; +# 377 +tex3DLod(&ret, texObject, x, y, z, level); +# 378 +return ret; +# 379 +} +#endif +# 382 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 383 +tex3DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level, bool *isResident) +# 384 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)level;(void)isResident; +# 388 +::exit(___);} +#if 0 +# 384 +{ +# 385 +unsigned char res; +# 386 +__nv_tex_surf_handler("__itex3DLod_sparse", ptr, obj, x, y, z, level, &res); +# 387 +(*isResident) = (res != 0); +# 388 +} +#endif +# 390 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 391 +tex3DLod(cudaTextureObject_t texObject, float x, float y, float z, float level, bool *isResident) +# 392 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z;(void)level;(void)isResident; +# 396 +::exit(___);} +#if 0 +# 392 +{ +# 393 +T ret; +# 394 +tex3DLod(&ret, texObject, x, y, z, level, isResident); +# 395 +return ret; +# 396 +} +#endif +# 401 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 402 +tex1DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, int layer, float level) +# 403 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)layer;(void)level; +# 405 +::exit(___);} +#if 0 +# 403 +{ +# 404 +__nv_tex_surf_handler("__itex1DLayeredLod", ptr, obj, x, layer, level); +# 405 +} +#endif +# 407 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 408 +tex1DLayeredLod(cudaTextureObject_t texObject, float x, int layer, float level) +# 409 +{int volatile ___ = 1;(void)texObject;(void)x;(void)layer;(void)level; +# 413 +::exit(___);} +#if 0 +# 409 +{ +# 410 +T ret; +# 411 +tex1DLayeredLod(&ret, texObject, x, layer, level); +# 412 +return ret; +# 413 +} +#endif +# 416 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 417 +tex2DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, float level) +# 418 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)layer;(void)level; +# 420 +::exit(___);} +#if 0 +# 418 +{ +# 419 +__nv_tex_surf_handler("__itex2DLayeredLod", ptr, obj, x, y, layer, level); +# 420 +} +#endif +# 422 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 423 +tex2DLayeredLod(cudaTextureObject_t texObject, float x, float y, int layer, float level) +# 424 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)layer;(void)level; +# 428 +::exit(___);} +#if 0 +# 424 +{ +# 425 +T ret; +# 426 +tex2DLayeredLod(&ret, texObject, x, y, layer, level); +# 427 +return ret; +# 428 +} +#endif +# 431 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 432 +tex2DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, float level, bool *isResident) +# 433 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)layer;(void)level;(void)isResident; +# 437 +::exit(___);} +#if 0 +# 433 +{ +# 434 +unsigned char res; +# 435 +__nv_tex_surf_handler("__itex2DLayeredLod_sparse", ptr, obj, x, y, layer, level, &res); +# 436 +(*isResident) = (res != 0); +# 437 +} +#endif +# 439 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 440 +tex2DLayeredLod(cudaTextureObject_t texObject, float x, float y, int layer, float level, bool *isResident) +# 441 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)layer;(void)level;(void)isResident; +# 445 +::exit(___);} +#if 0 +# 441 +{ +# 442 +T ret; +# 443 +tex2DLayeredLod(&ret, texObject, x, y, layer, level, isResident); +# 444 +return ret; +# 445 +} +#endif +# 448 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 449 +texCubemapLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level) +# 450 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)level; +# 452 +::exit(___);} +#if 0 +# 450 +{ +# 451 +__nv_tex_surf_handler("__itexCubemapLod", ptr, obj, x, y, z, level); +# 452 +} +#endif +# 454 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 455 +texCubemapLod(cudaTextureObject_t texObject, float x, float y, float z, float level) +# 456 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z;(void)level; +# 460 +::exit(___);} +#if 0 +# 456 +{ +# 457 +T ret; +# 458 +texCubemapLod(&ret, texObject, x, y, z, level); +# 459 +return ret; +# 460 +} +#endif +# 463 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 464 +texCubemapGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy) +# 465 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)dPdx;(void)dPdy; +# 467 +::exit(___);} +#if 0 +# 465 +{ +# 466 +__nv_tex_surf_handler("__itexCubemapGrad_v2", ptr, obj, x, y, z, &dPdx, &dPdy); +# 467 +} +#endif +# 469 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 470 +texCubemapGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy) +# 471 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z;(void)dPdx;(void)dPdy; +# 475 +::exit(___);} +#if 0 +# 471 +{ +# 472 +T ret; +# 473 +texCubemapGrad(&ret, texObject, x, y, z, dPdx, dPdy); +# 474 +return ret; +# 475 +} +#endif +# 477 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 478 +texCubemapLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer, float level) +# 479 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)layer;(void)level; +# 481 +::exit(___);} +#if 0 +# 479 +{ +# 480 +__nv_tex_surf_handler("__itexCubemapLayeredLod", ptr, obj, x, y, z, layer, level); +# 481 +} +#endif +# 483 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 484 +texCubemapLayeredLod(cudaTextureObject_t texObject, float x, float y, float z, int layer, float level) +# 485 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z;(void)layer;(void)level; +# 489 +::exit(___);} +#if 0 +# 485 +{ +# 486 +T ret; +# 487 +texCubemapLayeredLod(&ret, texObject, x, y, z, layer, level); +# 488 +return ret; +# 489 +} +#endif +# 491 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 492 +tex1DGrad(T *ptr, cudaTextureObject_t obj, float x, float dPdx, float dPdy) +# 493 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)dPdx;(void)dPdy; +# 495 +::exit(___);} +#if 0 +# 493 +{ +# 494 +__nv_tex_surf_handler("__itex1DGrad", ptr, obj, x, dPdx, dPdy); +# 495 +} +#endif +# 497 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 498 +tex1DGrad(cudaTextureObject_t texObject, float x, float dPdx, float dPdy) +# 499 +{int volatile ___ = 1;(void)texObject;(void)x;(void)dPdx;(void)dPdy; +# 503 +::exit(___);} +#if 0 +# 499 +{ +# 500 +T ret; +# 501 +tex1DGrad(&ret, texObject, x, dPdx, dPdy); +# 502 +return ret; +# 503 +} +#endif +# 506 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 507 +tex2DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float2 dPdx, float2 dPdy) +# 508 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)dPdx;(void)dPdy; +# 510 +::exit(___);} +#if 0 +# 508 +{ +# 509 +__nv_tex_surf_handler("__itex2DGrad_v2", ptr, obj, x, y, &dPdx, &dPdy); +# 510 +} +#endif +# 512 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 513 +tex2DGrad(cudaTextureObject_t texObject, float x, float y, float2 dPdx, float2 dPdy) +# 514 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)dPdx;(void)dPdy; +# 518 +::exit(___);} +#if 0 +# 514 +{ +# 515 +T ret; +# 516 +tex2DGrad(&ret, texObject, x, y, dPdx, dPdy); +# 517 +return ret; +# 518 +} +#endif +# 521 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 522 +tex2DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float2 dPdx, float2 dPdy, bool *isResident) +# 523 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)dPdx;(void)dPdy;(void)isResident; +# 527 +::exit(___);} +#if 0 +# 523 +{ +# 524 +unsigned char res; +# 525 +__nv_tex_surf_handler("__itex2DGrad_sparse", ptr, obj, x, y, &dPdx, &dPdy, &res); +# 526 +(*isResident) = (res != 0); +# 527 +} +#endif +# 529 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 530 +tex2DGrad(cudaTextureObject_t texObject, float x, float y, float2 dPdx, float2 dPdy, bool *isResident) +# 531 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)dPdx;(void)dPdy;(void)isResident; +# 535 +::exit(___);} +#if 0 +# 531 +{ +# 532 +T ret; +# 533 +tex2DGrad(&ret, texObject, x, y, dPdx, dPdy, isResident); +# 534 +return ret; +# 535 +} +#endif +# 539 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 540 +tex3DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy) +# 541 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)dPdx;(void)dPdy; +# 543 +::exit(___);} +#if 0 +# 541 +{ +# 542 +__nv_tex_surf_handler("__itex3DGrad_v2", ptr, obj, x, y, z, &dPdx, &dPdy); +# 543 +} +#endif +# 545 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 546 +tex3DGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy) +# 547 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z;(void)dPdx;(void)dPdy; +# 551 +::exit(___);} +#if 0 +# 547 +{ +# 548 +T ret; +# 549 +tex3DGrad(&ret, texObject, x, y, z, dPdx, dPdy); +# 550 +return ret; +# 551 +} +#endif +# 554 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 555 +tex3DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy, bool *isResident) +# 556 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)dPdx;(void)dPdy;(void)isResident; +# 560 +::exit(___);} +#if 0 +# 556 +{ +# 557 +unsigned char res; +# 558 +__nv_tex_surf_handler("__itex3DGrad_sparse", ptr, obj, x, y, z, &dPdx, &dPdy, &res); +# 559 +(*isResident) = (res != 0); +# 560 +} +#endif +# 562 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 563 +tex3DGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy, bool *isResident) +# 564 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z;(void)dPdx;(void)dPdy;(void)isResident; +# 568 +::exit(___);} +#if 0 +# 564 +{ +# 565 +T ret; +# 566 +tex3DGrad(&ret, texObject, x, y, z, dPdx, dPdy, isResident); +# 567 +return ret; +# 568 +} +#endif +# 573 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 574 +tex1DLayeredGrad(T *ptr, cudaTextureObject_t obj, float x, int layer, float dPdx, float dPdy) +# 575 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)layer;(void)dPdx;(void)dPdy; +# 577 +::exit(___);} +#if 0 +# 575 +{ +# 576 +__nv_tex_surf_handler("__itex1DLayeredGrad", ptr, obj, x, layer, dPdx, dPdy); +# 577 +} +#endif +# 579 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 580 +tex1DLayeredGrad(cudaTextureObject_t texObject, float x, int layer, float dPdx, float dPdy) +# 581 +{int volatile ___ = 1;(void)texObject;(void)x;(void)layer;(void)dPdx;(void)dPdy; +# 585 +::exit(___);} +#if 0 +# 581 +{ +# 582 +T ret; +# 583 +tex1DLayeredGrad(&ret, texObject, x, layer, dPdx, dPdy); +# 584 +return ret; +# 585 +} +#endif +# 588 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 589 +tex2DLayeredGrad(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, float2 dPdx, float2 dPdy) +# 590 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)layer;(void)dPdx;(void)dPdy; +# 592 +::exit(___);} +#if 0 +# 590 +{ +# 591 +__nv_tex_surf_handler("__itex2DLayeredGrad_v2", ptr, obj, x, y, layer, &dPdx, &dPdy); +# 592 +} +#endif +# 594 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 595 +tex2DLayeredGrad(cudaTextureObject_t texObject, float x, float y, int layer, float2 dPdx, float2 dPdy) +# 596 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)layer;(void)dPdx;(void)dPdy; +# 600 +::exit(___);} +#if 0 +# 596 +{ +# 597 +T ret; +# 598 +tex2DLayeredGrad(&ret, texObject, x, y, layer, dPdx, dPdy); +# 599 +return ret; +# 600 +} +#endif +# 603 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 604 +tex2DLayeredGrad(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, float2 dPdx, float2 dPdy, bool *isResident) +# 605 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)layer;(void)dPdx;(void)dPdy;(void)isResident; +# 609 +::exit(___);} +#if 0 +# 605 +{ +# 606 +unsigned char res; +# 607 +__nv_tex_surf_handler("__itex2DLayeredGrad_sparse", ptr, obj, x, y, layer, &dPdx, &dPdy, &res); +# 608 +(*isResident) = (res != 0); +# 609 +} +#endif +# 611 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 612 +tex2DLayeredGrad(cudaTextureObject_t texObject, float x, float y, int layer, float2 dPdx, float2 dPdy, bool *isResident) +# 613 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)layer;(void)dPdx;(void)dPdy;(void)isResident; +# 617 +::exit(___);} +#if 0 +# 613 +{ +# 614 +T ret; +# 615 +tex2DLayeredGrad(&ret, texObject, x, y, layer, dPdx, dPdy, isResident); +# 616 +return ret; +# 617 +} +#endif +# 621 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_itex_trait< T> ::type +# 622 +texCubemapLayeredGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer, float4 dPdx, float4 dPdy) +# 623 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)layer;(void)dPdx;(void)dPdy; +# 625 +::exit(___);} +#if 0 +# 623 +{ +# 624 +__nv_tex_surf_handler("__itexCubemapLayeredGrad_v2", ptr, obj, x, y, z, layer, &dPdx, &dPdy); +# 625 +} +#endif +# 627 "/opt/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 628 +texCubemapLayeredGrad(cudaTextureObject_t texObject, float x, float y, float z, int layer, float4 dPdx, float4 dPdy) +# 629 +{int volatile ___ = 1;(void)texObject;(void)x;(void)y;(void)z;(void)layer;(void)dPdx;(void)dPdy; +# 633 +::exit(___);} +#if 0 +# 629 +{ +# 630 +T ret; +# 631 +texCubemapLayeredGrad(&ret, texObject, x, y, z, layer, dPdx, dPdy); +# 632 +return ret; +# 633 +} +#endif +# 58 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> struct __nv_isurf_trait { }; +# 59 +template<> struct __nv_isurf_trait< char> { typedef void type; }; +# 60 +template<> struct __nv_isurf_trait< signed char> { typedef void type; }; +# 61 +template<> struct __nv_isurf_trait< char1> { typedef void type; }; +# 62 +template<> struct __nv_isurf_trait< unsigned char> { typedef void type; }; +# 63 +template<> struct __nv_isurf_trait< uchar1> { typedef void type; }; +# 64 +template<> struct __nv_isurf_trait< short> { typedef void type; }; +# 65 +template<> struct __nv_isurf_trait< short1> { typedef void type; }; +# 66 +template<> struct __nv_isurf_trait< unsigned short> { typedef void type; }; +# 67 +template<> struct __nv_isurf_trait< ushort1> { typedef void type; }; +# 68 +template<> struct __nv_isurf_trait< int> { typedef void type; }; +# 69 +template<> struct __nv_isurf_trait< int1> { typedef void type; }; +# 70 +template<> struct __nv_isurf_trait< unsigned> { typedef void type; }; +# 71 +template<> struct __nv_isurf_trait< uint1> { typedef void type; }; +# 72 +template<> struct __nv_isurf_trait< long long> { typedef void type; }; +# 73 +template<> struct __nv_isurf_trait< longlong1> { typedef void type; }; +# 74 +template<> struct __nv_isurf_trait< unsigned long long> { typedef void type; }; +# 75 +template<> struct __nv_isurf_trait< ulonglong1> { typedef void type; }; +# 76 +template<> struct __nv_isurf_trait< float> { typedef void type; }; +# 77 +template<> struct __nv_isurf_trait< float1> { typedef void type; }; +# 79 +template<> struct __nv_isurf_trait< char2> { typedef void type; }; +# 80 +template<> struct __nv_isurf_trait< uchar2> { typedef void type; }; +# 81 +template<> struct __nv_isurf_trait< short2> { typedef void type; }; +# 82 +template<> struct __nv_isurf_trait< ushort2> { typedef void type; }; +# 83 +template<> struct __nv_isurf_trait< int2> { typedef void type; }; +# 84 +template<> struct __nv_isurf_trait< uint2> { typedef void type; }; +# 85 +template<> struct __nv_isurf_trait< longlong2> { typedef void type; }; +# 86 +template<> struct __nv_isurf_trait< ulonglong2> { typedef void type; }; +# 87 +template<> struct __nv_isurf_trait< float2> { typedef void type; }; +# 89 +template<> struct __nv_isurf_trait< char4> { typedef void type; }; +# 90 +template<> struct __nv_isurf_trait< uchar4> { typedef void type; }; +# 91 +template<> struct __nv_isurf_trait< short4> { typedef void type; }; +# 92 +template<> struct __nv_isurf_trait< ushort4> { typedef void type; }; +# 93 +template<> struct __nv_isurf_trait< int4> { typedef void type; }; +# 94 +template<> struct __nv_isurf_trait< uint4> { typedef void type; }; +# 95 +template<> struct __nv_isurf_trait< float4> { typedef void type; }; +# 98 +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 99 +surf1Dread(T *ptr, cudaSurfaceObject_t obj, int x, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 100 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)mode; +# 102 +::exit(___);} +#if 0 +# 100 +{ +# 101 +__nv_tex_surf_handler("__isurf1Dread", ptr, obj, x, mode); +# 102 +} +#endif +# 104 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 105 +surf1Dread(cudaSurfaceObject_t surfObject, int x, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +# 106 +{int volatile ___ = 1;(void)surfObject;(void)x;(void)boundaryMode; +# 110 +::exit(___);} +#if 0 +# 106 +{ +# 107 +T ret; +# 108 +surf1Dread(&ret, surfObject, x, boundaryMode); +# 109 +return ret; +# 110 +} +#endif +# 112 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 113 +surf2Dread(T *ptr, cudaSurfaceObject_t obj, int x, int y, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 114 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)mode; +# 116 +::exit(___);} +#if 0 +# 114 +{ +# 115 +__nv_tex_surf_handler("__isurf2Dread", ptr, obj, x, y, mode); +# 116 +} +#endif +# 118 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 119 +surf2Dread(cudaSurfaceObject_t surfObject, int x, int y, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +# 120 +{int volatile ___ = 1;(void)surfObject;(void)x;(void)y;(void)boundaryMode; +# 124 +::exit(___);} +#if 0 +# 120 +{ +# 121 +T ret; +# 122 +surf2Dread(&ret, surfObject, x, y, boundaryMode); +# 123 +return ret; +# 124 +} +#endif +# 127 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 128 +surf3Dread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int z, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 129 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)z;(void)mode; +# 131 +::exit(___);} +#if 0 +# 129 +{ +# 130 +__nv_tex_surf_handler("__isurf3Dread", ptr, obj, x, y, z, mode); +# 131 +} +#endif +# 133 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 134 +surf3Dread(cudaSurfaceObject_t surfObject, int x, int y, int z, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +# 135 +{int volatile ___ = 1;(void)surfObject;(void)x;(void)y;(void)z;(void)boundaryMode; +# 139 +::exit(___);} +#if 0 +# 135 +{ +# 136 +T ret; +# 137 +surf3Dread(&ret, surfObject, x, y, z, boundaryMode); +# 138 +return ret; +# 139 +} +#endif +# 141 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 142 +surf1DLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 143 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)layer;(void)mode; +# 145 +::exit(___);} +#if 0 +# 143 +{ +# 144 +__nv_tex_surf_handler("__isurf1DLayeredread", ptr, obj, x, layer, mode); +# 145 +} +#endif +# 147 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 148 +surf1DLayeredread(cudaSurfaceObject_t surfObject, int x, int layer, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +# 149 +{int volatile ___ = 1;(void)surfObject;(void)x;(void)layer;(void)boundaryMode; +# 153 +::exit(___);} +#if 0 +# 149 +{ +# 150 +T ret; +# 151 +surf1DLayeredread(&ret, surfObject, x, layer, boundaryMode); +# 152 +return ret; +# 153 +} +#endif +# 155 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 156 +surf2DLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 157 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)layer;(void)mode; +# 159 +::exit(___);} +#if 0 +# 157 +{ +# 158 +__nv_tex_surf_handler("__isurf2DLayeredread", ptr, obj, x, y, layer, mode); +# 159 +} +#endif +# 161 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 162 +surf2DLayeredread(cudaSurfaceObject_t surfObject, int x, int y, int layer, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +# 163 +{int volatile ___ = 1;(void)surfObject;(void)x;(void)y;(void)layer;(void)boundaryMode; +# 167 +::exit(___);} +#if 0 +# 163 +{ +# 164 +T ret; +# 165 +surf2DLayeredread(&ret, surfObject, x, y, layer, boundaryMode); +# 166 +return ret; +# 167 +} +#endif +# 169 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 170 +surfCubemapread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int face, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 171 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)face;(void)mode; +# 173 +::exit(___);} +#if 0 +# 171 +{ +# 172 +__nv_tex_surf_handler("__isurfCubemapread", ptr, obj, x, y, face, mode); +# 173 +} +#endif +# 175 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 176 +surfCubemapread(cudaSurfaceObject_t surfObject, int x, int y, int face, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +# 177 +{int volatile ___ = 1;(void)surfObject;(void)x;(void)y;(void)face;(void)boundaryMode; +# 181 +::exit(___);} +#if 0 +# 177 +{ +# 178 +T ret; +# 179 +surfCubemapread(&ret, surfObject, x, y, face, boundaryMode); +# 180 +return ret; +# 181 +} +#endif +# 183 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 184 +surfCubemapLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int layerface, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 185 +{int volatile ___ = 1;(void)ptr;(void)obj;(void)x;(void)y;(void)layerface;(void)mode; +# 187 +::exit(___);} +#if 0 +# 185 +{ +# 186 +__nv_tex_surf_handler("__isurfCubemapLayeredread", ptr, obj, x, y, layerface, mode); +# 187 +} +#endif +# 189 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static T +# 190 +surfCubemapLayeredread(cudaSurfaceObject_t surfObject, int x, int y, int layerface, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +# 191 +{int volatile ___ = 1;(void)surfObject;(void)x;(void)y;(void)layerface;(void)boundaryMode; +# 195 +::exit(___);} +#if 0 +# 191 +{ +# 192 +T ret; +# 193 +surfCubemapLayeredread(&ret, surfObject, x, y, layerface, boundaryMode); +# 194 +return ret; +# 195 +} +#endif +# 197 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 198 +surf1Dwrite(T val, cudaSurfaceObject_t obj, int x, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 199 +{int volatile ___ = 1;(void)val;(void)obj;(void)x;(void)mode; +# 201 +::exit(___);} +#if 0 +# 199 +{ +# 200 +__nv_tex_surf_handler("__isurf1Dwrite_v2", &val, obj, x, mode); +# 201 +} +#endif +# 203 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 204 +surf2Dwrite(T val, cudaSurfaceObject_t obj, int x, int y, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 205 +{int volatile ___ = 1;(void)val;(void)obj;(void)x;(void)y;(void)mode; +# 207 +::exit(___);} +#if 0 +# 205 +{ +# 206 +__nv_tex_surf_handler("__isurf2Dwrite_v2", &val, obj, x, y, mode); +# 207 +} +#endif +# 209 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 210 +surf3Dwrite(T val, cudaSurfaceObject_t obj, int x, int y, int z, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 211 +{int volatile ___ = 1;(void)val;(void)obj;(void)x;(void)y;(void)z;(void)mode; +# 213 +::exit(___);} +#if 0 +# 211 +{ +# 212 +__nv_tex_surf_handler("__isurf3Dwrite_v2", &val, obj, x, y, z, mode); +# 213 +} +#endif +# 215 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 216 +surf1DLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 217 +{int volatile ___ = 1;(void)val;(void)obj;(void)x;(void)layer;(void)mode; +# 219 +::exit(___);} +#if 0 +# 217 +{ +# 218 +__nv_tex_surf_handler("__isurf1DLayeredwrite_v2", &val, obj, x, layer, mode); +# 219 +} +#endif +# 221 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 222 +surf2DLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int y, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 223 +{int volatile ___ = 1;(void)val;(void)obj;(void)x;(void)y;(void)layer;(void)mode; +# 225 +::exit(___);} +#if 0 +# 223 +{ +# 224 +__nv_tex_surf_handler("__isurf2DLayeredwrite_v2", &val, obj, x, y, layer, mode); +# 225 +} +#endif +# 227 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 228 +surfCubemapwrite(T val, cudaSurfaceObject_t obj, int x, int y, int face, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 229 +{int volatile ___ = 1;(void)val;(void)obj;(void)x;(void)y;(void)face;(void)mode; +# 231 +::exit(___);} +#if 0 +# 229 +{ +# 230 +__nv_tex_surf_handler("__isurfCubemapwrite_v2", &val, obj, x, y, face, mode); +# 231 +} +#endif +# 233 "/opt/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template< class T> __attribute__((unused)) static typename __nv_isurf_trait< T> ::type +# 234 +surfCubemapLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int y, int layerface, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +# 235 +{int volatile ___ = 1;(void)val;(void)obj;(void)x;(void)y;(void)layerface;(void)mode; +# 237 +::exit(___);} +#if 0 +# 235 +{ +# 236 +__nv_tex_surf_handler("__isurfCubemapLayeredwrite_v2", &val, obj, x, y, layerface, mode); +# 237 +} +#endif +# 2924 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +extern "C" unsigned __cudaPushCallConfiguration(dim3 gridDim, dim3 blockDim, size_t sharedMem = 0, CUstream_st * stream = 0); +# 2969 "/opt/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +enum { +# 2970 +__NV_ATOMIC_RELAXED, +# 2971 +__NV_ATOMIC_CONSUME, +# 2972 +__NV_ATOMIC_ACQUIRE, +# 2973 +__NV_ATOMIC_RELEASE, +# 2974 +__NV_ATOMIC_ACQ_REL, +# 2975 +__NV_ATOMIC_SEQ_CST +# 2976 +}; +# 2978 +enum { +# 2979 +__NV_THREAD_SCOPE_THREAD, +# 2980 +__NV_THREAD_SCOPE_BLOCK, +# 2981 +__NV_THREAD_SCOPE_CLUSTER, +# 2982 +__NV_THREAD_SCOPE_DEVICE, +# 2983 +__NV_THREAD_SCOPE_SYSTEM +# 2984 +}; +# 68 "/opt/cuda/bin/../targets/x86_64-linux/include/device_launch_parameters.h" +extern "C" { +# 71 +extern const uint3 __device_builtin_variable_threadIdx; +# 72 +extern const uint3 __device_builtin_variable_blockIdx; +# 73 +extern const dim3 __device_builtin_variable_blockDim; +# 74 +extern const dim3 __device_builtin_variable_gridDim; +# 75 +extern const int __device_builtin_variable_warpSize; +# 80 +} +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 66 +namespace rel_ops { +# 86 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 +template< class _Tp> inline bool +# 88 +operator!=(const _Tp &__x, const _Tp &__y) +# 89 +{ return !(__x == __y); } +# 99 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 +template< class _Tp> inline bool +# 101 +operator>(const _Tp &__x, const _Tp &__y) +# 102 +{ return __y < __x; } +# 112 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 +template< class _Tp> inline bool +# 114 +operator<=(const _Tp &__x, const _Tp &__y) +# 115 +{ return !(__y < __x); } +# 125 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/bits/stl_relops.h" 3 +template< class _Tp> inline bool +# 127 +operator>=(const _Tp &__x, const _Tp &__y) +# 128 +{ return !(__x < __y); } +# 129 +} +# 132 +} +# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/initializer_list" 3 +namespace std __attribute((__visibility__("default"))) { +# 44 +template< class _E> +# 45 +class initializer_list { +# 48 +public: typedef _E value_type; +# 49 +typedef const _E &reference; +# 50 +typedef const _E &const_reference; +# 51 +typedef size_t size_type; +# 52 +typedef const _E *iterator; +# 53 +typedef const _E *const_iterator; +# 56 +private: iterator _M_array; +# 57 +size_type _M_len; +# 60 +constexpr initializer_list(const_iterator __a, size_type __l) : _M_array(__a), _M_len(__l) +# 61 +{ } +# 64 +public: constexpr initializer_list() noexcept : _M_array((0)), _M_len((0)) +# 65 +{ } +# 69 +constexpr size_type size() const noexcept { return _M_len; } +# 73 +constexpr const_iterator begin() const noexcept { return _M_array; } +# 77 +constexpr const_iterator end() const noexcept { return begin() + size(); } +# 78 +}; +# 86 +template< class _Tp> constexpr const _Tp * +# 88 +begin(initializer_list< _Tp> __ils) noexcept +# 89 +{ return __ils.begin(); } +# 97 +template< class _Tp> constexpr const _Tp * +# 99 +end(initializer_list< _Tp> __ils) noexcept +# 100 +{ return __ils.end(); } +# 101 +} +# 98 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 +namespace std __attribute((__visibility__("default"))) { +# 104 +template< class _Tp, class _Up = _Tp> inline _Tp +# 107 +exchange(_Tp &__obj, _Up &&__new_val) noexcept(__and_< is_nothrow_move_constructible< _Tp> , is_nothrow_assignable< _Tp &, _Up> > ::value) +# 110 +{ return std::__exchange(__obj, std::forward< _Up> (__new_val)); } +# 114 +template< class _Tp> +# 115 +[[nodiscard]] constexpr add_const_t< _Tp> & +# 117 +as_const(_Tp &__t) noexcept +# 118 +{ return __t; } +# 120 +template < typename _Tp > + void as_const ( const _Tp && ) = delete; +# 231 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/utility" 3 +} +# 207 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 208 +cudaLaunchKernel(T * +# 209 +func, dim3 +# 210 +gridDim, dim3 +# 211 +blockDim, void ** +# 212 +args, size_t +# 213 +sharedMem = 0, cudaStream_t +# 214 +stream = 0) +# 216 +{ +# 217 +return ::cudaLaunchKernel((const void *)func, gridDim, blockDim, args, sharedMem, stream); +# 218 +} +# 279 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class ...ExpTypes, class ...ActTypes> static inline cudaError_t +# 280 +cudaLaunchKernelEx(const cudaLaunchConfig_t * +# 281 +config, void (* +# 282 +kernel)(ExpTypes ...), ActTypes &&... +# 283 +args) +# 285 +{ +# 286 +return [&](ExpTypes ...coercedArgs) { +# 287 +void *pArgs[] = {(&coercedArgs)...}; +# 288 +return ::cudaLaunchKernelExC(config, (const void *)(kernel), pArgs); +# 289 +} (std::forward< ActTypes> (args)...); +# 290 +} +# 348 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class ...ActTypes> static inline cudaError_t +# 349 +cudaLaunchKernelEx(const cudaLaunchConfig_t * +# 350 +config, const cudaKernel_t +# 351 +kernel, ActTypes &&... +# 352 +args) +# 354 +{ +# 355 +void *pArgs[] = {(&args)...}; +# 356 +return ::cudaLaunchKernelExC(config, (const void *)kernel, pArgs); +# 357 +} +# 410 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 411 +cudaLaunchCooperativeKernel(T * +# 412 +func, dim3 +# 413 +gridDim, dim3 +# 414 +blockDim, void ** +# 415 +args, size_t +# 416 +sharedMem = 0, cudaStream_t +# 417 +stream = 0) +# 419 +{ +# 420 +return ::cudaLaunchCooperativeKernel((const void *)func, gridDim, blockDim, args, sharedMem, stream); +# 421 +} +# 454 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static inline cudaError_t cudaEventCreate(cudaEvent_t * +# 455 +event, unsigned +# 456 +flags) +# 458 +{ +# 459 +return ::cudaEventCreateWithFlags(event, flags); +# 460 +} +# 498 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static inline cudaError_t cudaGraphInstantiate(cudaGraphExec_t * +# 499 +pGraphExec, cudaGraph_t +# 500 +graph, cudaGraphNode_t * +# 501 +pErrorNode, char * +# 502 +pLogBuffer, size_t +# 503 +bufferSize) +# 505 +{ +# 506 +(void)pErrorNode; +# 507 +(void)pLogBuffer; +# 508 +(void)bufferSize; +# 509 +return ::cudaGraphInstantiate(pGraphExec, graph, 0); +# 510 +} +# 569 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static inline cudaError_t cudaMallocHost(void ** +# 570 +ptr, size_t +# 571 +size, unsigned +# 572 +flags) +# 574 +{ +# 575 +return ::cudaHostAlloc(ptr, size, flags); +# 576 +} +# 578 +template< class T> static inline cudaError_t +# 579 +cudaHostAlloc(T ** +# 580 +ptr, size_t +# 581 +size, unsigned +# 582 +flags) +# 584 +{ +# 585 +return ::cudaHostAlloc((void **)((void *)ptr), size, flags); +# 586 +} +# 588 +template< class T> static inline cudaError_t +# 589 +cudaHostGetDevicePointer(T ** +# 590 +pDevice, void * +# 591 +pHost, unsigned +# 592 +flags) +# 594 +{ +# 595 +return ::cudaHostGetDevicePointer((void **)((void *)pDevice), pHost, flags); +# 596 +} +# 698 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 699 +cudaMallocManaged(T ** +# 700 +devPtr, size_t +# 701 +size, unsigned +# 702 +flags = 1) +# 704 +{ +# 705 +return ::cudaMallocManaged((void **)((void *)devPtr), size, flags); +# 706 +} +# 716 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> cudaError_t +# 717 +cudaMemAdvise(T * +# 718 +devPtr, size_t +# 719 +count, cudaMemoryAdvise +# 720 +advice, cudaMemLocation +# 721 +location) +# 723 +{ +# 724 +return ::cudaMemAdvise_v2((const void *)devPtr, count, advice, location); +# 725 +} +# 727 +template< class T> static inline cudaError_t +# 728 +cudaMemPrefetchAsync(T * +# 729 +devPtr, size_t +# 730 +count, cudaMemLocation +# 731 +location, unsigned +# 732 +flags, cudaStream_t +# 733 +stream = 0) +# 735 +{ +# 736 +return ::cudaMemPrefetchAsync_v2((const void *)devPtr, count, location, flags, stream); +# 737 +} +# 819 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 820 +cudaStreamAttachMemAsync(cudaStream_t +# 821 +stream, T * +# 822 +devPtr, size_t +# 823 +length = 0, unsigned +# 824 +flags = 4) +# 826 +{ +# 827 +return ::cudaStreamAttachMemAsync(stream, (void *)devPtr, length, flags); +# 828 +} +# 830 +template< class T> inline cudaError_t +# 831 +cudaMalloc(T ** +# 832 +devPtr, size_t +# 833 +size) +# 835 +{ +# 836 +return ::cudaMalloc((void **)((void *)devPtr), size); +# 837 +} +# 839 +template< class T> static inline cudaError_t +# 840 +cudaMallocHost(T ** +# 841 +ptr, size_t +# 842 +size, unsigned +# 843 +flags = 0) +# 845 +{ +# 846 +return cudaMallocHost((void **)((void *)ptr), size, flags); +# 847 +} +# 849 +template< class T> static inline cudaError_t +# 850 +cudaMallocPitch(T ** +# 851 +devPtr, size_t * +# 852 +pitch, size_t +# 853 +width, size_t +# 854 +height) +# 856 +{ +# 857 +return ::cudaMallocPitch((void **)((void *)devPtr), pitch, width, height); +# 858 +} +# 869 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static inline cudaError_t cudaMallocAsync(void ** +# 870 +ptr, size_t +# 871 +size, cudaMemPool_t +# 872 +memPool, cudaStream_t +# 873 +stream) +# 875 +{ +# 876 +return ::cudaMallocFromPoolAsync(ptr, size, memPool, stream); +# 877 +} +# 879 +template< class T> static inline cudaError_t +# 880 +cudaMallocAsync(T ** +# 881 +ptr, size_t +# 882 +size, cudaMemPool_t +# 883 +memPool, cudaStream_t +# 884 +stream) +# 886 +{ +# 887 +return ::cudaMallocFromPoolAsync((void **)((void *)ptr), size, memPool, stream); +# 888 +} +# 890 +template< class T> static inline cudaError_t +# 891 +cudaMallocAsync(T ** +# 892 +ptr, size_t +# 893 +size, cudaStream_t +# 894 +stream) +# 896 +{ +# 897 +return ::cudaMallocAsync((void **)((void *)ptr), size, stream); +# 898 +} +# 900 +template< class T> static inline cudaError_t +# 901 +cudaMallocFromPoolAsync(T ** +# 902 +ptr, size_t +# 903 +size, cudaMemPool_t +# 904 +memPool, cudaStream_t +# 905 +stream) +# 907 +{ +# 908 +return ::cudaMallocFromPoolAsync((void **)((void *)ptr), size, memPool, stream); +# 909 +} +# 919 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T, class U> static inline cudaError_t +# 920 +cudaMemcpyBatchAsync(T ** +# 921 +dsts, U **srcs, size_t *sizes, size_t count, cudaMemcpyAttributes *attrs, size_t * +# 922 +attrsIdxs, size_t numAttrs, size_t *failIdx, cudaStream_t hStream) +# 924 +{ +# 925 +return ::cudaMemcpyBatchAsync((void **)dsts, (void **)srcs, sizes, count, attrs, attrsIdxs, numAttrs, failIdx, hStream); +# 926 +} +# 938 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T, class U> static inline cudaError_t +# 939 +cudaMemcpyBatchAsync(T ** +# 940 +dsts, U **srcs, size_t *sizes, size_t count, cudaMemcpyAttributes attr, size_t *failIdx, cudaStream_t hStream) +# 942 +{ +# 943 +size_t attrsIdxs = (0); +# 944 +return ::cudaMemcpyBatchAsync((void **)dsts, (void **)srcs, sizes, count, &attr, &attrsIdxs, 1, failIdx, hStream); +# 945 +} +# 984 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 985 +cudaMemcpyToSymbol(const T & +# 986 +symbol, const void * +# 987 +src, size_t +# 988 +count, size_t +# 989 +offset = 0, cudaMemcpyKind +# 990 +kind = cudaMemcpyHostToDevice) +# 992 +{ +# 993 +return ::cudaMemcpyToSymbol((const void *)(&symbol), src, count, offset, kind); +# 994 +} +# 1038 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1039 +cudaMemcpyToSymbolAsync(const T & +# 1040 +symbol, const void * +# 1041 +src, size_t +# 1042 +count, size_t +# 1043 +offset = 0, cudaMemcpyKind +# 1044 +kind = cudaMemcpyHostToDevice, cudaStream_t +# 1045 +stream = 0) +# 1047 +{ +# 1048 +return ::cudaMemcpyToSymbolAsync((const void *)(&symbol), src, count, offset, kind, stream); +# 1049 +} +# 1086 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1087 +cudaMemcpyFromSymbol(void * +# 1088 +dst, const T & +# 1089 +symbol, size_t +# 1090 +count, size_t +# 1091 +offset = 0, cudaMemcpyKind +# 1092 +kind = cudaMemcpyDeviceToHost) +# 1094 +{ +# 1095 +return ::cudaMemcpyFromSymbol(dst, (const void *)(&symbol), count, offset, kind); +# 1096 +} +# 1140 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1141 +cudaMemcpyFromSymbolAsync(void * +# 1142 +dst, const T & +# 1143 +symbol, size_t +# 1144 +count, size_t +# 1145 +offset = 0, cudaMemcpyKind +# 1146 +kind = cudaMemcpyDeviceToHost, cudaStream_t +# 1147 +stream = 0) +# 1149 +{ +# 1150 +return ::cudaMemcpyFromSymbolAsync(dst, (const void *)(&symbol), count, offset, kind, stream); +# 1151 +} +# 1209 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1210 +cudaGraphAddMemcpyNodeToSymbol(cudaGraphNode_t * +# 1211 +pGraphNode, cudaGraph_t +# 1212 +graph, const cudaGraphNode_t * +# 1213 +pDependencies, size_t +# 1214 +numDependencies, const T & +# 1215 +symbol, const void * +# 1216 +src, size_t +# 1217 +count, size_t +# 1218 +offset, cudaMemcpyKind +# 1219 +kind) +# 1220 +{ +# 1221 +return ::cudaGraphAddMemcpyNodeToSymbol(pGraphNode, graph, pDependencies, numDependencies, (const void *)(&symbol), src, count, offset, kind); +# 1222 +} +# 1280 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1281 +cudaGraphAddMemcpyNodeFromSymbol(cudaGraphNode_t * +# 1282 +pGraphNode, cudaGraph_t +# 1283 +graph, const cudaGraphNode_t * +# 1284 +pDependencies, size_t +# 1285 +numDependencies, void * +# 1286 +dst, const T & +# 1287 +symbol, size_t +# 1288 +count, size_t +# 1289 +offset, cudaMemcpyKind +# 1290 +kind) +# 1291 +{ +# 1292 +return ::cudaGraphAddMemcpyNodeFromSymbol(pGraphNode, graph, pDependencies, numDependencies, dst, (const void *)(&symbol), count, offset, kind); +# 1293 +} +# 1331 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1332 +cudaGraphMemcpyNodeSetParamsToSymbol(cudaGraphNode_t +# 1333 +node, const T & +# 1334 +symbol, const void * +# 1335 +src, size_t +# 1336 +count, size_t +# 1337 +offset, cudaMemcpyKind +# 1338 +kind) +# 1339 +{ +# 1340 +return ::cudaGraphMemcpyNodeSetParamsToSymbol(node, (const void *)(&symbol), src, count, offset, kind); +# 1341 +} +# 1379 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1380 +cudaGraphMemcpyNodeSetParamsFromSymbol(cudaGraphNode_t +# 1381 +node, void * +# 1382 +dst, const T & +# 1383 +symbol, size_t +# 1384 +count, size_t +# 1385 +offset, cudaMemcpyKind +# 1386 +kind) +# 1387 +{ +# 1388 +return ::cudaGraphMemcpyNodeSetParamsFromSymbol(node, dst, (const void *)(&symbol), count, offset, kind); +# 1389 +} +# 1437 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1438 +cudaGraphExecMemcpyNodeSetParamsToSymbol(cudaGraphExec_t +# 1439 +hGraphExec, cudaGraphNode_t +# 1440 +node, const T & +# 1441 +symbol, const void * +# 1442 +src, size_t +# 1443 +count, size_t +# 1444 +offset, cudaMemcpyKind +# 1445 +kind) +# 1446 +{ +# 1447 +return ::cudaGraphExecMemcpyNodeSetParamsToSymbol(hGraphExec, node, (const void *)(&symbol), src, count, offset, kind); +# 1448 +} +# 1496 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1497 +cudaGraphExecMemcpyNodeSetParamsFromSymbol(cudaGraphExec_t +# 1498 +hGraphExec, cudaGraphNode_t +# 1499 +node, void * +# 1500 +dst, const T & +# 1501 +symbol, size_t +# 1502 +count, size_t +# 1503 +offset, cudaMemcpyKind +# 1504 +kind) +# 1505 +{ +# 1506 +return ::cudaGraphExecMemcpyNodeSetParamsFromSymbol(hGraphExec, node, dst, (const void *)(&symbol), count, offset, kind); +# 1507 +} +# 1510 +static inline cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphNode_t *hErrorNode_out, cudaGraphExecUpdateResult *updateResult_out) +# 1511 +{ +# 1512 +cudaGraphExecUpdateResultInfo resultInfo; +# 1513 +cudaError_t status = cudaGraphExecUpdate(hGraphExec, hGraph, &resultInfo); +# 1514 +if (hErrorNode_out) { +# 1515 +(*hErrorNode_out) = (resultInfo.errorNode); +# 1516 +} +# 1517 +if (updateResult_out) { +# 1518 +(*updateResult_out) = (resultInfo.result); +# 1519 +} +# 1520 +return status; +# 1521 +} +# 1549 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1550 +cudaUserObjectCreate(cudaUserObject_t * +# 1551 +object_out, T * +# 1552 +objectToWrap, unsigned +# 1553 +initialRefcount, unsigned +# 1554 +flags) +# 1555 +{ +# 1556 +return ::cudaUserObjectCreate(object_out, objectToWrap, [](void * +# 1559 +vpObj) { delete (reinterpret_cast< T *>(vpObj)); } , initialRefcount, flags); +# 1562 +} +# 1564 +template< class T> static inline cudaError_t +# 1565 +cudaUserObjectCreate(cudaUserObject_t * +# 1566 +object_out, T * +# 1567 +objectToWrap, unsigned +# 1568 +initialRefcount, cudaUserObjectFlags +# 1569 +flags) +# 1570 +{ +# 1571 +return cudaUserObjectCreate(object_out, objectToWrap, initialRefcount, (unsigned)flags); +# 1572 +} +# 1599 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1600 +cudaGetSymbolAddress(void ** +# 1601 +devPtr, const T & +# 1602 +symbol) +# 1604 +{ +# 1605 +return ::cudaGetSymbolAddress(devPtr, (const void *)(&symbol)); +# 1606 +} +# 1631 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1632 +cudaGetSymbolSize(size_t * +# 1633 +size, const T & +# 1634 +symbol) +# 1636 +{ +# 1637 +return ::cudaGetSymbolSize(size, (const void *)(&symbol)); +# 1638 +} +# 1683 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1684 +cudaFuncSetCacheConfig(T * +# 1685 +func, cudaFuncCache +# 1686 +cacheConfig) +# 1688 +{ +# 1689 +return ::cudaFuncSetCacheConfig((const void *)func, cacheConfig); +# 1690 +} +# 1692 +template< class T> +# 1694 +__attribute((deprecated)) static inline cudaError_t +# 1695 +cudaFuncSetSharedMemConfig(T * +# 1696 +func, cudaSharedMemConfig +# 1697 +config) +# 1699 +{ +# 1701 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 1706 +return ::cudaFuncSetSharedMemConfig((const void *)func, config); +# 1708 +#pragma GCC diagnostic pop +# 1710 +} +# 1743 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> inline cudaError_t +# 1744 +cudaOccupancyMaxActiveBlocksPerMultiprocessor(int * +# 1745 +numBlocks, T +# 1746 +func, int +# 1747 +blockSize, size_t +# 1748 +dynamicSMemSize) +# 1749 +{ +# 1750 +return ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, (const void *)func, blockSize, dynamicSMemSize, 0); +# 1751 +} +# 1796 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> inline cudaError_t +# 1797 +cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int * +# 1798 +numBlocks, T +# 1799 +func, int +# 1800 +blockSize, size_t +# 1801 +dynamicSMemSize, unsigned +# 1802 +flags) +# 1803 +{ +# 1804 +return ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, (const void *)func, blockSize, dynamicSMemSize, flags); +# 1805 +} +# 1810 +class __cudaOccupancyB2DHelper { +# 1811 +size_t n; +# 1813 +public: __cudaOccupancyB2DHelper(size_t n_) : n(n_) { } +# 1814 +size_t operator()(int) +# 1815 +{ +# 1816 +return n; +# 1817 +} +# 1818 +}; +# 1866 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class UnaryFunction, class T> static inline cudaError_t +# 1867 +cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(int * +# 1868 +minGridSize, int * +# 1869 +blockSize, T +# 1870 +func, UnaryFunction +# 1871 +blockSizeToDynamicSMemSize, int +# 1872 +blockSizeLimit = 0, unsigned +# 1873 +flags = 0) +# 1874 +{ +# 1875 +cudaError_t status; +# 1878 +int device; +# 1879 +cudaFuncAttributes attr; +# 1882 +int maxThreadsPerMultiProcessor; +# 1883 +int warpSize; +# 1884 +int devMaxThreadsPerBlock; +# 1885 +int multiProcessorCount; +# 1886 +int funcMaxThreadsPerBlock; +# 1887 +int occupancyLimit; +# 1888 +int granularity; +# 1891 +int maxBlockSize = 0; +# 1892 +int numBlocks = 0; +# 1893 +int maxOccupancy = 0; +# 1896 +int blockSizeToTryAligned; +# 1897 +int blockSizeToTry; +# 1898 +int blockSizeLimitAligned; +# 1899 +int occupancyInBlocks; +# 1900 +int occupancyInThreads; +# 1901 +size_t dynamicSMemSize; +# 1907 +if (((!minGridSize) || (!blockSize)) || (!func)) { +# 1908 +return cudaErrorInvalidValue; +# 1909 +} +# 1915 +status = ::cudaGetDevice(&device); +# 1916 +if (status != (cudaSuccess)) { +# 1917 +return status; +# 1918 +} +# 1920 +status = cudaDeviceGetAttribute(&maxThreadsPerMultiProcessor, cudaDevAttrMaxThreadsPerMultiProcessor, device); +# 1924 +if (status != (cudaSuccess)) { +# 1925 +return status; +# 1926 +} +# 1928 +status = cudaDeviceGetAttribute(&warpSize, cudaDevAttrWarpSize, device); +# 1932 +if (status != (cudaSuccess)) { +# 1933 +return status; +# 1934 +} +# 1936 +status = cudaDeviceGetAttribute(&devMaxThreadsPerBlock, cudaDevAttrMaxThreadsPerBlock, device); +# 1940 +if (status != (cudaSuccess)) { +# 1941 +return status; +# 1942 +} +# 1944 +status = cudaDeviceGetAttribute(&multiProcessorCount, cudaDevAttrMultiProcessorCount, device); +# 1948 +if (status != (cudaSuccess)) { +# 1949 +return status; +# 1950 +} +# 1952 +status = cudaFuncGetAttributes(&attr, func); +# 1953 +if (status != (cudaSuccess)) { +# 1954 +return status; +# 1955 +} +# 1957 +funcMaxThreadsPerBlock = (attr.maxThreadsPerBlock); +# 1963 +occupancyLimit = maxThreadsPerMultiProcessor; +# 1964 +granularity = warpSize; +# 1966 +if (blockSizeLimit == 0) { +# 1967 +blockSizeLimit = devMaxThreadsPerBlock; +# 1968 +} +# 1970 +if (devMaxThreadsPerBlock < blockSizeLimit) { +# 1971 +blockSizeLimit = devMaxThreadsPerBlock; +# 1972 +} +# 1974 +if (funcMaxThreadsPerBlock < blockSizeLimit) { +# 1975 +blockSizeLimit = funcMaxThreadsPerBlock; +# 1976 +} +# 1978 +blockSizeLimitAligned = (((blockSizeLimit + (granularity - 1)) / granularity) * granularity); +# 1980 +for (blockSizeToTryAligned = blockSizeLimitAligned; blockSizeToTryAligned > 0; blockSizeToTryAligned -= granularity) { +# 1984 +if (blockSizeLimit < blockSizeToTryAligned) { +# 1985 +blockSizeToTry = blockSizeLimit; +# 1986 +} else { +# 1987 +blockSizeToTry = blockSizeToTryAligned; +# 1988 +} +# 1990 +dynamicSMemSize = blockSizeToDynamicSMemSize(blockSizeToTry); +# 1992 +status = cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(&occupancyInBlocks, func, blockSizeToTry, dynamicSMemSize, flags); +# 1999 +if (status != (cudaSuccess)) { +# 2000 +return status; +# 2001 +} +# 2003 +occupancyInThreads = (blockSizeToTry * occupancyInBlocks); +# 2005 +if (occupancyInThreads > maxOccupancy) { +# 2006 +maxBlockSize = blockSizeToTry; +# 2007 +numBlocks = occupancyInBlocks; +# 2008 +maxOccupancy = occupancyInThreads; +# 2009 +} +# 2013 +if (occupancyLimit == maxOccupancy) { +# 2014 +break; +# 2015 +} +# 2016 +} +# 2024 +(*minGridSize) = (numBlocks * multiProcessorCount); +# 2025 +(*blockSize) = maxBlockSize; +# 2027 +return status; +# 2028 +} +# 2062 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class UnaryFunction, class T> static inline cudaError_t +# 2063 +cudaOccupancyMaxPotentialBlockSizeVariableSMem(int * +# 2064 +minGridSize, int * +# 2065 +blockSize, T +# 2066 +func, UnaryFunction +# 2067 +blockSizeToDynamicSMemSize, int +# 2068 +blockSizeLimit = 0) +# 2069 +{ +# 2070 +return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, blockSizeToDynamicSMemSize, blockSizeLimit, 0); +# 2071 +} +# 2108 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2109 +cudaOccupancyMaxPotentialBlockSize(int * +# 2110 +minGridSize, int * +# 2111 +blockSize, T +# 2112 +func, size_t +# 2113 +dynamicSMemSize = 0, int +# 2114 +blockSizeLimit = 0) +# 2115 +{ +# 2116 +return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, ((__cudaOccupancyB2DHelper)(dynamicSMemSize)), blockSizeLimit, 0); +# 2117 +} +# 2147 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2148 +cudaOccupancyAvailableDynamicSMemPerBlock(size_t * +# 2149 +dynamicSmemSize, T * +# 2150 +func, int +# 2151 +numBlocks, int +# 2152 +blockSize) +# 2153 +{ +# 2154 +return ::cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, (const void *)func, numBlocks, blockSize); +# 2155 +} +# 2206 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2207 +cudaOccupancyMaxPotentialBlockSizeWithFlags(int * +# 2208 +minGridSize, int * +# 2209 +blockSize, T +# 2210 +func, size_t +# 2211 +dynamicSMemSize = 0, int +# 2212 +blockSizeLimit = 0, unsigned +# 2213 +flags = 0) +# 2214 +{ +# 2215 +return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, ((__cudaOccupancyB2DHelper)(dynamicSMemSize)), blockSizeLimit, flags); +# 2216 +} +# 2251 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2252 +cudaOccupancyMaxPotentialClusterSize(int * +# 2253 +clusterSize, T * +# 2254 +func, const cudaLaunchConfig_t * +# 2255 +config) +# 2256 +{ +# 2257 +return ::cudaOccupancyMaxPotentialClusterSize(clusterSize, (const void *)func, config); +# 2258 +} +# 2295 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2296 +cudaOccupancyMaxActiveClusters(int * +# 2297 +numClusters, T * +# 2298 +func, const cudaLaunchConfig_t * +# 2299 +config) +# 2300 +{ +# 2301 +return ::cudaOccupancyMaxActiveClusters(numClusters, (const void *)func, config); +# 2302 +} +# 2336 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> inline cudaError_t +# 2337 +cudaFuncGetAttributes(cudaFuncAttributes * +# 2338 +attr, T * +# 2339 +entry) +# 2341 +{ +# 2342 +return ::cudaFuncGetAttributes(attr, (const void *)entry); +# 2343 +} +# 2402 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2403 +cudaFuncSetAttribute(T * +# 2404 +func, cudaFuncAttribute +# 2405 +attr, int +# 2406 +value) +# 2408 +{ +# 2409 +return ::cudaFuncSetAttribute((const void *)func, attr, value); +# 2410 +} +# 2435 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2436 +cudaFuncGetName(const char ** +# 2437 +name, T * +# 2438 +func) +# 2440 +{ +# 2441 +return ::cudaFuncGetName(name, (const void *)func); +# 2442 +} +# 2458 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2459 +cudaGetKernel(cudaKernel_t * +# 2460 +kernelPtr, T * +# 2461 +func) +# 2463 +{ +# 2464 +return ::cudaGetKernel(kernelPtr, (const void *)func); +# 2465 +} +# 2496 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2497 +cudaLibraryGetGlobal(T **dptr, size_t *bytes, cudaLibrary_t library, const char *name) +# 2498 +{ +# 2499 +return ::cudaLibraryGetGlobal((void **)((void *)dptr), bytes, library, name); +# 2500 +} +# 2530 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2531 +cudaLibraryGetManaged(T **dptr, size_t *bytes, cudaLibrary_t library, const char *name) +# 2532 +{ +# 2533 +return ::cudaLibraryGetManaged((void **)((void *)dptr), bytes, library, name); +# 2534 +} +# 2560 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2561 +cudaLibraryGetUnifiedFunction(T **fptr, cudaLibrary_t library, const char *symbol) +# 2562 +{ +# 2563 +return ::cudaLibraryGetUnifiedFunction((void **)((void *)fptr), library, symbol); +# 2564 +} +# 2576 "/opt/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +#pragma GCC diagnostic pop +# 477 "CMakeCUDACompilerId.cu" +const char *info_compiler = ("INFO:compiler[NVIDIA]"); +# 479 +const char *info_simulate = ("INFO:simulate[GNU]"); +# 790 "CMakeCUDACompilerId.cu" +const char info_version[] = {'I', 'N', 'F', 'O', ':', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '_', 'v', 'e', 'r', 's', 'i', 'o', 'n', '[', (('0') + ((12 / 10000000) % 10)), (('0') + ((12 / 1000000) % 10)), (('0') + ((12 / 100000) % 10)), (('0') + ((12 / 10000) % 10)), (('0') + ((12 / 1000) % 10)), (('0') + ((12 / 100) % 10)), (('0') + ((12 / 10) % 10)), (('0') + (12 % 10)), '.', (('0') + ((8 / 10000000) % 10)), (('0') + ((8 / 1000000) % 10)), (('0') + ((8 / 100000) % 10)), (('0') + ((8 / 10000) % 10)), (('0') + ((8 / 1000) % 10)), (('0') + ((8 / 100) % 10)), (('0') + ((8 / 10) % 10)), (('0') + (8 % 10)), '.', (('0') + ((93 / 10000000) % 10)), (('0') + ((93 / 1000000) % 10)), (('0') + ((93 / 100000) % 10)), (('0') + ((93 / 10000) % 10)), (('0') + ((93 / 1000) % 10)), (('0') + ((93 / 100) % 10)), (('0') + ((93 / 10) % 10)), (('0') + (93 % 10)), ']', '\000'}; +# 819 "CMakeCUDACompilerId.cu" +const char info_simulate_version[] = {'I', 'N', 'F', 'O', ':', 's', 'i', 'm', 'u', 'l', 'a', 't', 'e', '_', 'v', 'e', 'r', 's', 'i', 'o', 'n', '[', (('0') + ((14 / 10000000) % 10)), (('0') + ((14 / 1000000) % 10)), (('0') + ((14 / 100000) % 10)), (('0') + ((14 / 10000) % 10)), (('0') + ((14 / 1000) % 10)), (('0') + ((14 / 100) % 10)), (('0') + ((14 / 10) % 10)), (('0') + (14 % 10)), '.', (('0') + ((2 / 10000000) % 10)), (('0') + ((2 / 1000000) % 10)), (('0') + ((2 / 100000) % 10)), (('0') + ((2 / 10000) % 10)), (('0') + ((2 / 1000) % 10)), (('0') + ((2 / 100) % 10)), (('0') + ((2 / 10) % 10)), (('0') + (2 % 10)), ']', '\000'}; +# 839 +const char *info_platform = ("INFO:platform[Linux]"); +# 840 +const char *info_arch = ("INFO:arch[]"); +# 845 +const char *info_host_compiler = ("INFO:host_compiler[GNU]"); +# 850 +const char info_host_compiler_version[] = {'I', 'N', 'F', 'O', ':', 'h', 'o', 's', 't', '_', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '_', 'v', 'e', 'r', 's', 'i', 'o', 'n', '[', (('0') + ((14 / 10000000) % 10)), (('0') + ((14 / 1000000) % 10)), (('0') + ((14 / 100000) % 10)), (('0') + ((14 / 10000) % 10)), (('0') + ((14 / 1000) % 10)), (('0') + ((14 / 100) % 10)), (('0') + ((14 / 10) % 10)), (('0') + (14 % 10)), '.', (('0') + ((2 / 10000000) % 10)), (('0') + ((2 / 1000000) % 10)), (('0') + ((2 / 100000) % 10)), (('0') + ((2 / 10000) % 10)), (('0') + ((2 / 1000) % 10)), (('0') + ((2 / 100) % 10)), (('0') + ((2 / 10) % 10)), (('0') + (2 % 10)), '.', (('0') + ((1 / 10000000) % 10)), (('0') + ((1 / 1000000) % 10)), (('0') + ((1 / 100000) % 10)), (('0') + ((1 / 10000) % 10)), (('0') + ((1 / 1000) % 10)), (('0') + ((1 / 100) % 10)), (('0') + ((1 / 10) % 10)), (('0') + (1 % 10)), ']', '\000'}; +# 882 "CMakeCUDACompilerId.cu" +const char *info_language_standard_default = ("INFO:standard_default[17]"); +# 900 +const char *info_language_extensions_default = ("INFO:extensions_default[ON]"); +# 911 +int main(int argc, char *argv[]) +# 912 +{ +# 913 +int require = 0; +# 914 +require += (info_compiler[argc]); +# 915 +require += (info_platform[argc]); +# 917 +require += (info_version[argc]); +# 920 +require += (info_simulate[argc]); +# 923 +require += (info_simulate_version[argc]); +# 926 +require += (info_host_compiler[argc]); +# 929 +require += (info_host_compiler_version[argc]); +# 931 +require += (info_language_standard_default[argc]); +# 932 +require += (info_language_extensions_default[argc]); +# 933 +(void)argv; +# 934 +return require; +# 935 +} + +# 1 "CMakeCUDACompilerId.cudafe1.stub.c" +#define _NV_ANON_NAMESPACE _GLOBAL__N__0fb8cd19_22_CMakeCUDACompilerId_cu_bd57c623 +#ifdef _NV_ANON_NAMESPACE +#endif +# 1 "CMakeCUDACompilerId.cudafe1.stub.c" +#include "CMakeCUDACompilerId.cudafe1.stub.c" +# 1 "CMakeCUDACompilerId.cudafe1.stub.c" +#undef _NV_ANON_NAMESPACE diff --git a/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.gpu b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.gpu new file mode 100644 index 0000000..8087332 --- /dev/null +++ b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.gpu @@ -0,0 +1,467 @@ +typedef char __nv_bool; +# 214 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h" 3 +typedef unsigned long size_t; +#include "crt/device_runtime.h" +# 310 "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu/bits/c++config.h" 3 +typedef unsigned long _ZSt6size_t; +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#include "common_functions.h" +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif +#if !defined(__CUDABE__) +#endif diff --git a/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.stub.c b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.stub.c new file mode 100644 index 0000000..2ebe7e6 --- /dev/null +++ b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.stub.c @@ -0,0 +1,15 @@ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-function" +#pragma GCC diagnostic ignored "-Wcast-qual" +#define __NV_CUBIN_HANDLE_STORAGE__ static +#if !defined(__CUDA_INCLUDE_COMPILER_INTERNAL_HEADERS__) +#define __CUDA_INCLUDE_COMPILER_INTERNAL_HEADERS__ +#endif +#include "crt/host_runtime.h" +#include "CMakeCUDACompilerId.fatbin.c" +static void __nv_cudaEntityRegisterCallback(void **); +static void __sti____cudaRegisterAll(void) __attribute__((__constructor__)); +static void __nv_cudaEntityRegisterCallback(void **__T0){__nv_dummy_param_ref(__T0);__nv_save_fatbinhandle_for_managed_rt(__T0);} +static void __sti____cudaRegisterAll(void){__cudaRegisterBinary(__nv_cudaEntityRegisterCallback);} + +#pragma GCC diagnostic pop diff --git a/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.fatbin b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.fatbin new file mode 100644 index 0000000000000000000000000000000000000000..943e39fe1540d752a96861c3283d8831f58ac54c GIT binary patch literal 1096 zcmcIjO;5r=5S=Xord}XkJT@j?mjo+f;-LpM9E{=O(U1z2l0e(+HUzxrAMuZP@E@6Y z^x)U*cD58SF(Gje``(+*o9XVf-Ph}91~q7JfnF9c<{=A9nKpYB7`R3t)(gByAI>i? zEXEG26tv(49t#QYRwiaFL$~aL2W_x$uV4@0GL)%E{aa)P=aWop?8z`1%z#HzK8o&Q zP5S3F#iSN_`Q2 z5`G}cMOys;%B_XmjHz*~j9eG;sN4;q0UDo?u!HP3{}W~W<=@3T`ZV&Inoy$-MOBXK zvrT%BP~9)4CM0v{kl&$*c}Ft|Q%B7K&#>kX$zRJWX2kdmRxqrlXuj{2^t`ZXV0^0l zW VbAK=pfs{Qtx(}R|YvVFyegH@^b~69~ literal 0 HcmV?d00001 diff --git a/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.fatbin.c b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.fatbin.c new file mode 100644 index 0000000..65e4578 --- /dev/null +++ b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.fatbin.c @@ -0,0 +1,60 @@ +#ifndef __SKIP_INTERNAL_FATBINARY_HEADERS +#include "fatbinary_section.h" +#endif +#define __CUDAFATBINSECTION ".nvFatBinSegment" +#define __CUDAFATBINDATASECTION ".nv_fatbin" +asm( +".section .nv_fatbin, \"a\"\n" +".align 8\n" +"fatbinData:\n" +".quad 0x00100001ba55ed50,0x0000000000000438,0x0000004001010002,0x0000000000000368\n" +".quad 0x0000000000000000,0x0000003400010007,0x0000000000000000,0x0000000000000011\n" +".quad 0x0000000000000000,0x0000000000000000,0x33010102464c457f,0x0000000000000007\n" +".quad 0x0000008000be0002,0x0000000000000000,0x00000000000002f8,0x0000000000000178\n" +".quad 0x0038004000340534,0x0001000600400002,0x7472747368732e00,0x747274732e006261\n" +".quad 0x746d79732e006261,0x746d79732e006261,0x78646e68735f6261,0x666e692e766e2e00\n" +".quad 0x61632e766e2e006f,0x0068706172676c6c,0x746f72702e766e2e,0x6e2e00657079746f\n" +".quad 0x63612e6c65722e76,0x732e00006e6f6974,0x0062617472747368,0x006261747274732e\n" +".quad 0x006261746d79732e,0x5f6261746d79732e,0x6e2e0078646e6873,0x2e006f666e692e76\n" +".quad 0x676c6c61632e766e,0x766e2e0068706172,0x79746f746f72702e,0x722e766e2e006570\n" +".quad 0x6f697463612e6c65,0x000000000000006e,0x0000000000000000,0x0000000000000000\n" +".quad 0x0000000000000000,0x0004000300000032,0x0000000000000000,0x0000000000000000\n" +".quad 0x000500030000004e,0x0000000000000000,0x0000000000000000,0xffffffff00000000\n" +".quad 0xfffffffe00000000,0xfffffffd00000000,0xfffffffc00000000,0x0000000000000073\n" +".quad 0x3605002511000000,0x0000000000000000,0x0000000000000000,0x0000000000000000\n" +".quad 0x0000000000000000,0x0000000000000000,0x0000000000000000,0x0000000000000000\n" +".quad 0x0000000000000000,0x0000000300000001,0x0000000000000000,0x0000000000000000\n" +".quad 0x0000000000000040,0x000000000000005d,0x0000000000000000,0x0000000000000001\n" +".quad 0x0000000000000000,0x000000030000000b,0x0000000000000000,0x0000000000000000\n" +".quad 0x000000000000009d,0x000000000000005d,0x0000000000000000,0x0000000000000001\n" +".quad 0x0000000000000000,0x0000000200000013,0x0000000000000000,0x0000000000000000\n" +".quad 0x0000000000000100,0x0000000000000048,0x0000000300000002,0x0000000000000008\n" +".quad 0x0000000000000018,0x7000000100000032,0x0000000000000000,0x0000000000000000\n" +".quad 0x0000000000000148,0x0000000000000020,0x0000000000000003,0x0000000000000004\n" +".quad 0x0000000000000008,0x7000000b0000004e,0x0000000000000000,0x0000000000000000\n" +".quad 0x0000000000000168,0x0000000000000010,0x0000000000000000,0x0000000000000008\n" +".quad 0x0000000000000008,0x0000000500000006,0x00000000000002f8,0x0000000000000000\n" +".quad 0x0000000000000000,0x0000000000000070,0x0000000000000070,0x0000000000000008\n" +".quad 0x0000000500000001,0x00000000000002f8,0x0000000000000000,0x0000000000000000\n" +".quad 0x0000000000000070,0x0000000000000070,0x0000000000000008,0x0000005001010001\n" +".quad 0x0000000000000040,0x0000004000000039,0x0000003400080007,0x0000000000000000\n" +".quad 0x0000000000002011,0x0000000000000000,0x0000000000000044,0x0000000000000048\n" +".quad 0x0000000000000000,0x22f000032f2f0a3c,0x6f69737265762e0a,0x742e0a372e38206e\n" +".quad 0x6d73207465677261,0x6464612e0a32355f,0x7a69735f73736572,0x0a0a0a0a34362065\n" +".quad 0x0000000000000000\n" +".text\n"); +#ifdef __cplusplus +extern "C" { +#endif +extern const unsigned long long fatbinData[137]; +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +static const __fatBinC_Wrapper_t __fatDeviceText __attribute__ ((aligned (8))) __attribute__ ((section (__CUDAFATBINSECTION)))= + { 0x466243b1, 1, fatbinData, 0 }; +#ifdef __cplusplus +} +#endif diff --git a/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.module_id b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.module_id new file mode 100644 index 0000000..67f279d --- /dev/null +++ b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.module_id @@ -0,0 +1 @@ +_0fb8cd19_22_CMakeCUDACompilerId_cu_bd57c623 \ No newline at end of file diff --git a/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.o b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.o new file mode 100644 index 0000000000000000000000000000000000000000..b58e715357778e1eddb3f7d0b69eed19a282592f GIT binary patch literal 6912 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 F{y$~r1cm?r literal 0 HcmV?d00001 diff --git a/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.ptx b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.ptx new file mode 100644 index 0000000..eca22bd --- /dev/null +++ b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.ptx @@ -0,0 +1,14 @@ +// +// Generated by NVIDIA NVVM Compiler +// +// Compiler Build ID: CL-35583870 +// Cuda compilation tools, release 12.8, V12.8.93 +// Based on NVVM 7.0.1 +// + +.version 8.7 +.target sm_52 +.address_size 64 + + + diff --git a/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.sm_52.cubin b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/CMakeCUDACompilerId.sm_52.cubin new file mode 100644 index 0000000000000000000000000000000000000000..f6416e6f380f5c54e6b5f18685eee88d2e35c83f GIT binary patch literal 872 zcmb<-^>JfjWHe@HfB+_jeGCmyHi-Jc1mRRLLTD3K69xwc3kD`2$;JQ_)GN*?E-5NW zOaiiCbY(7t52oXbGxAa@81(YW^fL3(^1+Pc#GIV;qQrs>Ft4B}za+n;vLF@AD@x7L zOH3}w%+I5-;SdkuAdP_H%nU3TvVLH3Rt#~Fz<(eB(f^?IUnuVdEq98ROdpMwc2`CK; zU!c+gC>Kt7K=ms?MPP1(#RSY8P&@$rfT2GFs$T$ZB7_0c2cy}5!k}1$rEfIlaD!nM L!1RHPCr2LunowYG literal 0 HcmV?d00001 diff --git a/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/a_dlink.fatbin b/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/tmp/a_dlink.fatbin new file mode 100644 index 0000000000000000000000000000000000000000..0f66675178f63daccb9d3dc1fce92e8dbe0e13f4 GIT binary patch literal 952 zcmcIiy-ve05I(!4t<YD?4O%APT8i1Xmwzx_2S(5LCYs&jf?P`@r&^jv7#4# zjSe6fi`W)v92+BdtzvF?#VEkz6A1%kzvZ8~;;;NJ*74P-dpg1!P1vOx+NaNYkCFZ_ ymKH2)m~eid9r;F?g!G{~;2BzZ!}(#|(G$rDcG0FO%KhFbuN%t-lB4$9P~+;ThNT2C7dzuRp^e!s1~e$-2P$#y@`UKDg)zmar$ z;YUuMsdCgT5j3HWj11h=xIUMWvG*hZ|6%<%>%U0HY4pj{YVw=ZJ)DK(u#Q|O@;Kcp zYf*OZ9ixG9{HOns{~5(`YseHv^F$R!5rcVV*gwS@`%9sHc899M`~oAgMmY(|gL9x7 zM)+;!=Z6`MAw1Dj1mhH?zpe0LVwpgANPigKi*kK=?0#J@moF90T)$cUx-h@smfZP5 zsaU#DEET`iOG4cRo|A%b-+u+hWs*MVe@N^U6|1W}hj;MFKukDbD;VKS}jJr4JHz#wSWX{usQ%%DJdTr!+^dVm2L?duQ zp8%{>e$wXXy=)Qg&`TvE{db=LyGL|Pw-c_@OSV~8wI6PjinUr}v*|DUNqMv02`hfs z>;}q!)i4TLoj3`itDVq~wyQ~}t4Sp@zCte-U%WE#L z`|!P|`g}LR%H1Z4a_e!7Cmdx_!OGPE;g+f6`=GTEgcRH8Z5Si$C4oy#eJ)P?#yT=;Q#z75FfRt9bpoBMwz?8HdNY~2Am^>z4nYd{9WOM zMMjR323O8O`tB>nDtA`6cfy!mxhXXEL>%;rZo_6I}LB^p7+kw!}a$ zF+YpJwqw@`!+o;%uflwLU9x`Uf;^-TIc@%c`4JfjWHe@HfB+_jeGCmyHi-Jc1mRRLLTD3K69xwc3kD`2$;JQ_)GN*?E-5NW zOaiiCbY(7t52oXbGxAa@81(YW^fL3(^1+Pc#GIV;qQrs>Ft4B}za+n;vLF@AD@x7L zOH3}w%+I5-;SdkuAdP_H%nU3TvVLH3Rt#~Fz<(eB(f^?IUnuVdEq98ROdpMwc2`CK; zU!c+gC>Kt7K=ms?MPP1(#RSY8P&@$rfT2GFs$T$ZB7_0c2cy}5!k}1$rEfIlaD!nM L!1RHPCr2LunowYG literal 0 HcmV?d00001 diff --git a/build/CMakeFiles/4.0.2-dirty/CompilerIdCXX/CMakeCXXCompilerId.cpp b/build/CMakeFiles/4.0.2-dirty/CompilerIdCXX/CMakeCXXCompilerId.cpp new file mode 100644 index 0000000..94d4310 --- /dev/null +++ b/build/CMakeFiles/4.0.2-dirty/CompilerIdCXX/CMakeCXXCompilerId.cpp @@ -0,0 +1,920 @@ +/* This source file must have a .cpp extension so that all C++ compilers + recognize the extension without flags. Borland does not know .cxx for + example. */ +#ifndef __cplusplus +# error "A C compiler has been selected for C++." +#endif + +#if !defined(__has_include) +/* If the compiler does not have __has_include, pretend the answer is + always no. */ +# define __has_include(x) 0 +#endif + + +/* Version number components: V=Version, R=Revision, P=Patch + Version date components: YYYY=Year, MM=Month, DD=Day */ + +#if defined(__INTEL_COMPILER) || defined(__ICC) +# define COMPILER_ID "Intel" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# if defined(__GNUC__) +# define SIMULATE_ID "GNU" +# endif + /* __INTEL_COMPILER = VRP prior to 2021, and then VVVV for 2021 and later, + except that a few beta releases use the old format with V=2021. */ +# if __INTEL_COMPILER < 2021 || __INTEL_COMPILER == 202110 || __INTEL_COMPILER == 202111 +# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10) +# if defined(__INTEL_COMPILER_UPDATE) +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE) +# else +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10) +# endif +# else +# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER) +# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER_UPDATE) + /* The third version component from --version is an update index, + but no macro is provided for it. */ +# define COMPILER_VERSION_PATCH DEC(0) +# endif +# if defined(__INTEL_COMPILER_BUILD_DATE) + /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */ +# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE) +# endif +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# if defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# elif defined(__GNUG__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif (defined(__clang__) && defined(__INTEL_CLANG_COMPILER)) || defined(__INTEL_LLVM_COMPILER) +# define COMPILER_ID "IntelLLVM" +#if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +#endif +#if defined(__GNUC__) +# define SIMULATE_ID "GNU" +#endif +/* __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and + * later. Look for 6 digit vs. 8 digit version number to decide encoding. + * VVVV is no smaller than the current year when a version is released. + */ +#if __INTEL_LLVM_COMPILER < 1000000L +# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 10) +#else +# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000) +# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 100) +#endif +#if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +#endif +#if defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +#elif defined(__GNUG__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUG__) +#endif +#if defined(__GNUC_MINOR__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +#endif +#if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +#endif + +#elif defined(__PATHCC__) +# define COMPILER_ID "PathScale" +# define COMPILER_VERSION_MAJOR DEC(__PATHCC__) +# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__) +# if defined(__PATHCC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__) +# endif + +#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__) +# define COMPILER_ID "Embarcadero" +# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF) +# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF) +# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF) + +#elif defined(__BORLANDC__) +# define COMPILER_ID "Borland" + /* __BORLANDC__ = 0xVRR */ +# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8) +# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF) + +#elif defined(__WATCOMC__) && __WATCOMC__ < 1200 +# define COMPILER_ID "Watcom" + /* __WATCOMC__ = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__WATCOMC__) +# define COMPILER_ID "OpenWatcom" + /* __WATCOMC__ = VVRP + 1100 */ +# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__SUNPRO_CC) +# define COMPILER_ID "SunPro" +# if __SUNPRO_CC >= 0x5100 + /* __SUNPRO_CC = 0xVRRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# else + /* __SUNPRO_CC = 0xVRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# endif + +#elif defined(__HP_aCC) +# define COMPILER_ID "HP" + /* __HP_aCC = VVRRPP */ +# define COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000) +# define COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__HP_aCC % 100) + +#elif defined(__DECCXX) +# define COMPILER_ID "Compaq" + /* __DECCXX_VER = VVRRTPPPP */ +# define COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000) +# define COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000 % 100) +# define COMPILER_VERSION_PATCH DEC(__DECCXX_VER % 10000) + +#elif defined(__IBMCPP__) && defined(__COMPILER_VER__) +# define COMPILER_ID "zOS" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__open_xl__) && defined(__clang__) +# define COMPILER_ID "IBMClang" +# define COMPILER_VERSION_MAJOR DEC(__open_xl_version__) +# define COMPILER_VERSION_MINOR DEC(__open_xl_release__) +# define COMPILER_VERSION_PATCH DEC(__open_xl_modification__) +# define COMPILER_VERSION_TWEAK DEC(__open_xl_ptf_fix_level__) +# define COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(__ibmxl__) && defined(__clang__) +# define COMPILER_ID "XLClang" +# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__) +# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__) +# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__) +# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__) + + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800 +# define COMPILER_ID "XL" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800 +# define COMPILER_ID "VisualAge" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__NVCOMPILER) +# define COMPILER_ID "NVHPC" +# define COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__) +# define COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__) +# if defined(__NVCOMPILER_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__) +# endif + +#elif defined(__PGI) +# define COMPILER_ID "PGI" +# define COMPILER_VERSION_MAJOR DEC(__PGIC__) +# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__) +# if defined(__PGIC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__) +# endif + +#elif defined(__clang__) && defined(__cray__) +# define COMPILER_ID "CrayClang" +# define COMPILER_VERSION_MAJOR DEC(__cray_major__) +# define COMPILER_VERSION_MINOR DEC(__cray_minor__) +# define COMPILER_VERSION_PATCH DEC(__cray_patchlevel__) +# define COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(_CRAYC) +# define COMPILER_ID "Cray" +# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR) +# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR) + +#elif defined(__TI_COMPILER_VERSION__) +# define COMPILER_ID "TI" + /* __TI_COMPILER_VERSION__ = VVVRRRPPP */ +# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000) +# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000) +# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000) + +#elif defined(__CLANG_FUJITSU) +# define COMPILER_ID "FujitsuClang" +# define COMPILER_VERSION_MAJOR DEC(__FCC_major__) +# define COMPILER_VERSION_MINOR DEC(__FCC_minor__) +# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__) +# define COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(__FUJITSU) +# define COMPILER_ID "Fujitsu" +# if defined(__FCC_version__) +# define COMPILER_VERSION __FCC_version__ +# elif defined(__FCC_major__) +# define COMPILER_VERSION_MAJOR DEC(__FCC_major__) +# define COMPILER_VERSION_MINOR DEC(__FCC_minor__) +# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__) +# endif +# if defined(__fcc_version) +# define COMPILER_VERSION_INTERNAL DEC(__fcc_version) +# elif defined(__FCC_VERSION) +# define COMPILER_VERSION_INTERNAL DEC(__FCC_VERSION) +# endif + + +#elif defined(__ghs__) +# define COMPILER_ID "GHS" +/* __GHS_VERSION_NUMBER = VVVVRP */ +# ifdef __GHS_VERSION_NUMBER +# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100) +# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10) +# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER % 10) +# endif + +#elif defined(__TASKING__) +# define COMPILER_ID "Tasking" + # define COMPILER_VERSION_MAJOR DEC(__VERSION__/1000) + # define COMPILER_VERSION_MINOR DEC(__VERSION__ % 100) +# define COMPILER_VERSION_INTERNAL DEC(__VERSION__) + +#elif defined(__ORANGEC__) +# define COMPILER_ID "OrangeC" +# define COMPILER_VERSION_MAJOR DEC(__ORANGEC_MAJOR__) +# define COMPILER_VERSION_MINOR DEC(__ORANGEC_MINOR__) +# define COMPILER_VERSION_PATCH DEC(__ORANGEC_PATCHLEVEL__) + +#elif defined(__SCO_VERSION__) +# define COMPILER_ID "SCO" + +#elif defined(__ARMCC_VERSION) && !defined(__clang__) +# define COMPILER_ID "ARMCC" +#if __ARMCC_VERSION >= 1000000 + /* __ARMCC_VERSION = VRRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#else + /* __ARMCC_VERSION = VRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#endif + + +#elif defined(__clang__) && defined(__apple_build_version__) +# define COMPILER_ID "AppleClang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__) + +#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION) +# define COMPILER_ID "ARMClang" + # define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION/100 % 100) +# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION) + +#elif defined(__clang__) && defined(__ti__) +# define COMPILER_ID "TIClang" + # define COMPILER_VERSION_MAJOR DEC(__ti_major__) + # define COMPILER_VERSION_MINOR DEC(__ti_minor__) + # define COMPILER_VERSION_PATCH DEC(__ti_patchlevel__) +# define COMPILER_VERSION_INTERNAL DEC(__ti_version__) + +#elif defined(__clang__) +# define COMPILER_ID "Clang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + +#elif defined(__LCC__) && (defined(__GNUC__) || defined(__GNUG__) || defined(__MCST__)) +# define COMPILER_ID "LCC" +# define COMPILER_VERSION_MAJOR DEC(__LCC__ / 100) +# define COMPILER_VERSION_MINOR DEC(__LCC__ % 100) +# if defined(__LCC_MINOR__) +# define COMPILER_VERSION_PATCH DEC(__LCC_MINOR__) +# endif +# if defined(__GNUC__) && defined(__GNUC_MINOR__) +# define SIMULATE_ID "GNU" +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif +# endif + +#elif defined(__GNUC__) || defined(__GNUG__) +# define COMPILER_ID "GNU" +# if defined(__GNUC__) +# define COMPILER_VERSION_MAJOR DEC(__GNUC__) +# else +# define COMPILER_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(_MSC_VER) +# define COMPILER_ID "MSVC" + /* _MSC_VER = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100) +# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100) +# if defined(_MSC_FULL_VER) +# if _MSC_VER >= 1400 + /* _MSC_FULL_VER = VVRRPPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000) +# else + /* _MSC_FULL_VER = VVRRPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000) +# endif +# endif +# if defined(_MSC_BUILD) +# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD) +# endif + +#elif defined(_ADI_COMPILER) +# define COMPILER_ID "ADSP" +#if defined(__VERSIONNUM__) + /* __VERSIONNUM__ = 0xVVRRPPTT */ +# define COMPILER_VERSION_MAJOR DEC(__VERSIONNUM__ >> 24 & 0xFF) +# define COMPILER_VERSION_MINOR DEC(__VERSIONNUM__ >> 16 & 0xFF) +# define COMPILER_VERSION_PATCH DEC(__VERSIONNUM__ >> 8 & 0xFF) +# define COMPILER_VERSION_TWEAK DEC(__VERSIONNUM__ & 0xFF) +#endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# define COMPILER_ID "IAR" +# if defined(__VER__) && defined(__ICCARM__) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000) +# define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000) +# define COMPILER_VERSION_PATCH DEC((__VER__) % 1000) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__) || defined(__ICCSTM8__)) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 100) +# define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100)) +# define COMPILER_VERSION_PATCH DEC(__SUBVERSION__) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# endif + + +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__hpux) || defined(__hpua) +# define COMPILER_ID "HP" + +#else /* unknown compiler */ +# define COMPILER_ID "" +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#ifdef __QNXNTO__ +char const* qnxnto = "INFO" ":" "qnxnto[]"; +#endif + +#if defined(__CRAYXT_COMPUTE_LINUX_TARGET) +char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]"; +#endif + +#define STRINGIFY_HELPER(X) #X +#define STRINGIFY(X) STRINGIFY_HELPER(X) + +/* Identify known platforms by name. */ +#if defined(__linux) || defined(__linux__) || defined(linux) +# define PLATFORM_ID "Linux" + +#elif defined(__MSYS__) +# define PLATFORM_ID "MSYS" + +#elif defined(__CYGWIN__) +# define PLATFORM_ID "Cygwin" + +#elif defined(__MINGW32__) +# define PLATFORM_ID "MinGW" + +#elif defined(__APPLE__) +# define PLATFORM_ID "Darwin" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +# define PLATFORM_ID "Windows" + +#elif defined(__FreeBSD__) || defined(__FreeBSD) +# define PLATFORM_ID "FreeBSD" + +#elif defined(__NetBSD__) || defined(__NetBSD) +# define PLATFORM_ID "NetBSD" + +#elif defined(__OpenBSD__) || defined(__OPENBSD) +# define PLATFORM_ID "OpenBSD" + +#elif defined(__sun) || defined(sun) +# define PLATFORM_ID "SunOS" + +#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__) +# define PLATFORM_ID "AIX" + +#elif defined(__hpux) || defined(__hpux__) +# define PLATFORM_ID "HP-UX" + +#elif defined(__HAIKU__) +# define PLATFORM_ID "Haiku" + +#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS) +# define PLATFORM_ID "BeOS" + +#elif defined(__QNX__) || defined(__QNXNTO__) +# define PLATFORM_ID "QNX" + +#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__) +# define PLATFORM_ID "Tru64" + +#elif defined(__riscos) || defined(__riscos__) +# define PLATFORM_ID "RISCos" + +#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__) +# define PLATFORM_ID "SINIX" + +#elif defined(__UNIX_SV__) +# define PLATFORM_ID "UNIX_SV" + +#elif defined(__bsdos__) +# define PLATFORM_ID "BSDOS" + +#elif defined(_MPRAS) || defined(MPRAS) +# define PLATFORM_ID "MP-RAS" + +#elif defined(__osf) || defined(__osf__) +# define PLATFORM_ID "OSF1" + +#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv) +# define PLATFORM_ID "SCO_SV" + +#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX) +# define PLATFORM_ID "ULTRIX" + +#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX) +# define PLATFORM_ID "Xenix" + +#elif defined(__WATCOMC__) +# if defined(__LINUX__) +# define PLATFORM_ID "Linux" + +# elif defined(__DOS__) +# define PLATFORM_ID "DOS" + +# elif defined(__OS2__) +# define PLATFORM_ID "OS2" + +# elif defined(__WINDOWS__) +# define PLATFORM_ID "Windows3x" + +# elif defined(__VXWORKS__) +# define PLATFORM_ID "VxWorks" + +# else /* unknown platform */ +# define PLATFORM_ID +# endif + +#elif defined(__INTEGRITY) +# if defined(INT_178B) +# define PLATFORM_ID "Integrity178" + +# else /* regular Integrity */ +# define PLATFORM_ID "Integrity" +# endif + +# elif defined(_ADI_COMPILER) +# define PLATFORM_ID "ADSP" + +#else /* unknown platform */ +# define PLATFORM_ID + +#endif + +/* For windows compilers MSVC and Intel we can determine + the architecture of the compiler being used. This is because + the compilers do not have flags that can change the architecture, + but rather depend on which compiler is being used +*/ +#if defined(_WIN32) && defined(_MSC_VER) +# if defined(_M_IA64) +# define ARCHITECTURE_ID "IA64" + +# elif defined(_M_ARM64EC) +# define ARCHITECTURE_ID "ARM64EC" + +# elif defined(_M_X64) || defined(_M_AMD64) +# define ARCHITECTURE_ID "x64" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# elif defined(_M_ARM64) +# define ARCHITECTURE_ID "ARM64" + +# elif defined(_M_ARM) +# if _M_ARM == 4 +# define ARCHITECTURE_ID "ARMV4I" +# elif _M_ARM == 5 +# define ARCHITECTURE_ID "ARMV5I" +# else +# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM) +# endif + +# elif defined(_M_MIPS) +# define ARCHITECTURE_ID "MIPS" + +# elif defined(_M_SH) +# define ARCHITECTURE_ID "SHx" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__WATCOMC__) +# if defined(_M_I86) +# define ARCHITECTURE_ID "I86" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# if defined(__ICCARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__ICCRX__) +# define ARCHITECTURE_ID "RX" + +# elif defined(__ICCRH850__) +# define ARCHITECTURE_ID "RH850" + +# elif defined(__ICCRL78__) +# define ARCHITECTURE_ID "RL78" + +# elif defined(__ICCRISCV__) +# define ARCHITECTURE_ID "RISCV" + +# elif defined(__ICCAVR__) +# define ARCHITECTURE_ID "AVR" + +# elif defined(__ICC430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__ICCV850__) +# define ARCHITECTURE_ID "V850" + +# elif defined(__ICC8051__) +# define ARCHITECTURE_ID "8051" + +# elif defined(__ICCSTM8__) +# define ARCHITECTURE_ID "STM8" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__ghs__) +# if defined(__PPC64__) +# define ARCHITECTURE_ID "PPC64" + +# elif defined(__ppc__) +# define ARCHITECTURE_ID "PPC" + +# elif defined(__ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__x86_64__) +# define ARCHITECTURE_ID "x64" + +# elif defined(__i386__) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__clang__) && defined(__ti__) +# if defined(__ARM_ARCH) +# define ARCHITECTURE_ID "ARM" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__TI_COMPILER_VERSION__) +# if defined(__TI_ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__MSP430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__TMS320C28XX__) +# define ARCHITECTURE_ID "TMS320C28x" + +# elif defined(__TMS320C6X__) || defined(_TMS320C6X) +# define ARCHITECTURE_ID "TMS320C6x" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +# elif defined(__ADSPSHARC__) +# define ARCHITECTURE_ID "SHARC" + +# elif defined(__ADSPBLACKFIN__) +# define ARCHITECTURE_ID "Blackfin" + +#elif defined(__TASKING__) + +# if defined(__CTC__) || defined(__CPTC__) +# define ARCHITECTURE_ID "TriCore" + +# elif defined(__CMCS__) +# define ARCHITECTURE_ID "MCS" + +# elif defined(__CARM__) || defined(__CPARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__CARC__) +# define ARCHITECTURE_ID "ARC" + +# elif defined(__C51__) +# define ARCHITECTURE_ID "8051" + +# elif defined(__CPCP__) +# define ARCHITECTURE_ID "PCP" + +# else +# define ARCHITECTURE_ID "" +# endif + +#else +# define ARCHITECTURE_ID +#endif + +/* Convert integer to decimal digit literals. */ +#define DEC(n) \ + ('0' + (((n) / 10000000)%10)), \ + ('0' + (((n) / 1000000)%10)), \ + ('0' + (((n) / 100000)%10)), \ + ('0' + (((n) / 10000)%10)), \ + ('0' + (((n) / 1000)%10)), \ + ('0' + (((n) / 100)%10)), \ + ('0' + (((n) / 10)%10)), \ + ('0' + ((n) % 10)) + +/* Convert integer to hex digit literals. */ +#define HEX(n) \ + ('0' + ((n)>>28 & 0xF)), \ + ('0' + ((n)>>24 & 0xF)), \ + ('0' + ((n)>>20 & 0xF)), \ + ('0' + ((n)>>16 & 0xF)), \ + ('0' + ((n)>>12 & 0xF)), \ + ('0' + ((n)>>8 & 0xF)), \ + ('0' + ((n)>>4 & 0xF)), \ + ('0' + ((n) & 0xF)) + +/* Construct a string literal encoding the version number. */ +#ifdef COMPILER_VERSION +char const* info_version = "INFO" ":" "compiler_version[" COMPILER_VERSION "]"; + +/* Construct a string literal encoding the version number components. */ +#elif defined(COMPILER_VERSION_MAJOR) +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + COMPILER_VERSION_MAJOR, +# ifdef COMPILER_VERSION_MINOR + '.', COMPILER_VERSION_MINOR, +# ifdef COMPILER_VERSION_PATCH + '.', COMPILER_VERSION_PATCH, +# ifdef COMPILER_VERSION_TWEAK + '.', COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct a string literal encoding the internal version number. */ +#ifdef COMPILER_VERSION_INTERNAL +char const info_version_internal[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_', + 'i','n','t','e','r','n','a','l','[', + COMPILER_VERSION_INTERNAL,']','\0'}; +#elif defined(COMPILER_VERSION_INTERNAL_STR) +char const* info_version_internal = "INFO" ":" "compiler_version_internal[" COMPILER_VERSION_INTERNAL_STR "]"; +#endif + +/* Construct a string literal encoding the version number components. */ +#ifdef SIMULATE_VERSION_MAJOR +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + SIMULATE_VERSION_MAJOR, +# ifdef SIMULATE_VERSION_MINOR + '.', SIMULATE_VERSION_MINOR, +# ifdef SIMULATE_VERSION_PATCH + '.', SIMULATE_VERSION_PATCH, +# ifdef SIMULATE_VERSION_TWEAK + '.', SIMULATE_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]"; +char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]"; + + + +#define CXX_STD_98 199711L +#define CXX_STD_11 201103L +#define CXX_STD_14 201402L +#define CXX_STD_17 201703L +#define CXX_STD_20 202002L +#define CXX_STD_23 202302L + +#if defined(__INTEL_COMPILER) && defined(_MSVC_LANG) +# if _MSVC_LANG > CXX_STD_17 +# define CXX_STD _MSVC_LANG +# elif _MSVC_LANG == CXX_STD_17 && defined(__cpp_aggregate_paren_init) +# define CXX_STD CXX_STD_20 +# elif _MSVC_LANG > CXX_STD_14 && __cplusplus > CXX_STD_17 +# define CXX_STD CXX_STD_20 +# elif _MSVC_LANG > CXX_STD_14 +# define CXX_STD CXX_STD_17 +# elif defined(__INTEL_CXX11_MODE__) && defined(__cpp_aggregate_nsdmi) +# define CXX_STD CXX_STD_14 +# elif defined(__INTEL_CXX11_MODE__) +# define CXX_STD CXX_STD_11 +# else +# define CXX_STD CXX_STD_98 +# endif +#elif defined(_MSC_VER) && defined(_MSVC_LANG) +# if _MSVC_LANG > __cplusplus +# define CXX_STD _MSVC_LANG +# else +# define CXX_STD __cplusplus +# endif +#elif defined(__NVCOMPILER) +# if __cplusplus == CXX_STD_17 && defined(__cpp_aggregate_paren_init) +# define CXX_STD CXX_STD_20 +# else +# define CXX_STD __cplusplus +# endif +#elif defined(__INTEL_COMPILER) || defined(__PGI) +# if __cplusplus == CXX_STD_11 && defined(__cpp_namespace_attributes) +# define CXX_STD CXX_STD_17 +# elif __cplusplus == CXX_STD_11 && defined(__cpp_aggregate_nsdmi) +# define CXX_STD CXX_STD_14 +# else +# define CXX_STD __cplusplus +# endif +#elif (defined(__IBMCPP__) || defined(__ibmxl__)) && defined(__linux__) +# if __cplusplus == CXX_STD_11 && defined(__cpp_aggregate_nsdmi) +# define CXX_STD CXX_STD_14 +# else +# define CXX_STD __cplusplus +# endif +#elif __cplusplus == 1 && defined(__GXX_EXPERIMENTAL_CXX0X__) +# define CXX_STD CXX_STD_11 +#else +# define CXX_STD __cplusplus +#endif + +const char* info_language_standard_default = "INFO" ":" "standard_default[" +#if CXX_STD > CXX_STD_23 + "26" +#elif CXX_STD > CXX_STD_20 + "23" +#elif CXX_STD > CXX_STD_17 + "20" +#elif CXX_STD > CXX_STD_14 + "17" +#elif CXX_STD > CXX_STD_11 + "14" +#elif CXX_STD >= CXX_STD_11 + "11" +#else + "98" +#endif +"]"; + +const char* info_language_extensions_default = "INFO" ":" "extensions_default[" +#if (defined(__clang__) || defined(__GNUC__) || defined(__xlC__) || \ + defined(__TI_COMPILER_VERSION__)) && \ + !defined(__STRICT_ANSI__) + "ON" +#else + "OFF" +#endif +"]"; + +/*--------------------------------------------------------------------------*/ + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; + require += info_arch[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#if defined(COMPILER_VERSION_INTERNAL) || defined(COMPILER_VERSION_INTERNAL_STR) + require += info_version_internal[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#if defined(__CRAYXT_COMPUTE_LINUX_TARGET) + require += info_cray[argc]; +#endif + require += info_language_standard_default[argc]; + require += info_language_extensions_default[argc]; + (void)argv; + return require; +} diff --git a/build/CMakeFiles/4.0.2-dirty/CompilerIdCXX/a.out b/build/CMakeFiles/4.0.2-dirty/CompilerIdCXX/a.out new file mode 100755 index 0000000000000000000000000000000000000000..1a92c3145f40f042d4aacee34dc718462fd05258 GIT binary patch literal 15568 zcmeHOYit}>6~4Q+8;2&b6XMdw6`595qT(!CwW!k+x7ApBTlzjg6j7eC;#j0Z$MIVb#o zUh=7B-fR}?=T9}s&WkHL+R|Bv3s(oQs7c56KNU3|+)abKSwWZe(*JTHFF zi-C?fPJkHi)8r?Igv{vu0f)y08E>!sXUKj7%5HIU!ZG+*>mRRWU;)u`_X zH*+krUy;poY)lR3IgZ=L!ydmX=P~$230NQX^xz>kYJ9EX+1;)2_XuxjyeWK(#-A0w zP2)#}UwlNljn5hXG4>lDFNeNsx9sEPE5zkr_whIvS+U~d`5XyakbxirK?Z^h1Q`f2 z5M&_8zz3UwzchUGpNaXk`oy)mTc?ytd}YxISC$j=FV`=*6JdSioq>hdKA%|lLt_5T z_4A|g$YSJH;(GUOGN?4olhzOIa6GCw-XEvPR_1q! zLcJRQ7f*TNOB;!Wne|uWYb?>EmMLx`IkeI6>)QI7_}W5zjmV|l$e-;b$&Zrs&LO3? zxj((r@><>3c97TNYnPX*`>wjTcw#{dG7w}S$Uu;RAOk@Lf(!&12r>|4Ajm+Ffgl4r zGr-Tc28R1a&L#`FVkVm|jmNTfe(JJE7PGc9St#Yk2l+vykaj6KJuZEEtd~#Or4&8V zo3v-L&UoY@(WGacbiSM^1Z%K#+kT13?CY3J3rTHzjj~{Fo-sY4Q^y9}q-ASYOW|2|fcuZu} zL-O?)H|YPiSt+pmf)o>?M(|O&_~N=mZp)(okSD622;M2k*NfbmJg9!|liqm=jB&dp z5me0SHu%3+@#aIMYq}}2A^!BF*qtx(NSBqa+$j2gh>US0{09!GAKzAblUkK}RM>xxI*sZs)fENf z;U{Sa8^kM(Pm=mD&6AXF!##o$N%woyw$JM%9Z`2GL(UiX9t3gUr2oU=yA<{VoW9RI zjjPxF{#bY;>RICW`Z-M4b18Z`AlG<-wi5)GxdD zR>*cg^If!o>N>IpP^7%*?ct`mA$*Je5%gaQ)z4G?K;l@x9XHd z0Ue4+75i3vxR*-#w+GPg1d=IlomaC@o0{h>n<$q-yx)5OySy^6>uUkZEMLhv_5`6* z@^Bixe8EYZQ~4RQSSl3LCFhDVtJK6yhF-47q?DP-(@O|N|ENKPLT&BnM}{QfmX+!^878k zRI+KB?2kSLw{w{!ja;C}^kEjW)bT=7HkC;`D3{JVzC-+f>hkY3|3-!-3f{{B8o~qc zeF2#&mA3g8<#!tR01O53eF?gUI&>;l$KUI{Fxa!LzYUP^clyo6{9lmqfmm?^`uvl`@|ptvSVsV{{=)oW z2P~35uTdalodRt0hIQXD^Uq&s^*D8SpTHmMBp}vF7+>H11@h&%Sf^Eg59D`&k1v1I z_y0FY>GwCp4|qdMn5e5EpV9pBI|#&j6%P9N-xYsszcR#9@P{G-^zok~1y2$FSdRd4 z{J~!z|EA`@Xn2;uQ8)@B|Db}~`%HKbP9G04@OR|f z;Pb~if3=lJYOwR9EgAf6Qt+{Z@v&~h`;d6=5yuz&upizgU(P@L@jlbyDI%%0cu@U> zKk!}B`2DdyTor$u=Li5l;D+X}qGH+RVV8&i_(9&J4s)14)-_$?uiNun{jG)w=ES_J zg1^qg-;X$UtIpJ!7RO(R@)&V^oMAr53tvBB?$oU|PY|q literal 0 HcmV?d00001 diff --git a/build/CMakeFiles/CMakeConfigureLog.yaml b/build/CMakeFiles/CMakeConfigureLog.yaml new file mode 100644 index 0000000..e41fd71 --- /dev/null +++ b/build/CMakeFiles/CMakeConfigureLog.yaml @@ -0,0 +1,801 @@ + +--- +events: + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineSystem.cmake:205 (message)" + - "CMakeLists.txt:2 (project)" + message: | + The system is: Linux - 6.14.7-arch2-1 - x86_64 + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerId.cmake:17 (message)" + - "/usr/share/cmake/Modules/CMakeDetermineCompilerId.cmake:64 (__determine_compiler_id_test)" + - "/usr/share/cmake/Modules/CMakeDetermineCXXCompiler.cmake:126 (CMAKE_DETERMINE_COMPILER_ID)" + - "CMakeLists.txt:2 (project)" + message: | + Compiling the CXX compiler identification source file "CMakeCXXCompilerId.cpp" succeeded. + Compiler: /usr/bin/clang++ + Build flags: + Id flags: + + The output was: + 0 + + + Compilation of the CXX compiler identification source "CMakeCXXCompilerId.cpp" produced "a.out" + + The CXX compiler identification is Clang, found in: + /home/tobli/abo/pprog/Homework-3/build/CMakeFiles/4.0.2-dirty/CompilerIdCXX/a.out + + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerId.cmake:1271 (message)" + - "/usr/share/cmake/Modules/CMakeDetermineCUDACompiler.cmake:75 (CMAKE_DETERMINE_COMPILER_ID_VENDOR)" + - "CMakeLists.txt:2 (project)" + message: | + Checking whether the CUDA compiler is NVIDIA using "" matched "nvcc: NVIDIA \\(R\\) Cuda compiler driver": + nvcc: NVIDIA (R) Cuda compiler driver + Copyright (c) 2005-2025 NVIDIA Corporation + Built on Fri_Feb_21_20:23:50_PST_2025 + Cuda compilation tools, release 12.8, V12.8.93 + Build cuda_12.8.r12.8/compiler.35583870_0 + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerId.cmake:17 (message)" + - "/usr/share/cmake/Modules/CMakeDetermineCompilerId.cmake:53 (__determine_compiler_id_test)" + - "/usr/share/cmake/Modules/CMakeDetermineCUDACompiler.cmake:136 (CMAKE_DETERMINE_COMPILER_ID)" + - "CMakeLists.txt:2 (project)" + message: | + Compiling the CUDA compiler identification source file "CMakeCUDACompilerId.cu" succeeded. + Compiler: /opt/cuda/bin/nvcc + Build flags: + Id flags: --keep;--keep-dir;tmp -v + + The output was: + 0 + nvcc warning : Support for offline compilation for architectures prior to '_75' will be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning). + #$ _NVVM_BRANCH_=nvvm + #$ _SPACE_= + #$ _CUDART_=cudart + #$ _HERE_=/opt/cuda/bin + #$ _THERE_=/opt/cuda/bin + #$ _TARGET_SIZE_= + #$ _TARGET_DIR_= + #$ _TARGET_DIR_=targets/x86_64-linux + #$ TOP=/opt/cuda/bin/.. + #$ CICC_PATH=/opt/cuda/bin/../nvvm/bin + #$ NVVMIR_LIBRARY_DIR=/opt/cuda/bin/../nvvm/libdevice + #$ LD_LIBRARY_PATH=/opt/cuda/bin/../lib:/opt/cuda/lib64 + #$ PATH=/opt/cuda/bin/../nvvm/bin:/opt/cuda/bin:/opt/cuda/bin/opt/cuda/bin/usr/local/sbin:/usr/local/bin:/usr/bin:/opt/cuda/bin:/opt/cuda/nsight_compute:/opt/cuda/nsight_systems/bin:/usr/lib/jvm/default/bin:/usr/bin/site_perl:/usr/bin/vendor_perl:/usr/bin/core_perl + #$ INCLUDES="-I/opt/cuda/bin/../targets/x86_64-linux/include" + #$ LIBRARIES= "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" + #$ CUDAFE_FLAGS= + #$ PTXAS_FLAGS= + #$ rm tmp/a_dlink.reg.c + #$ "/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -E -x c++ -D__CUDACC__ -D__NVCC__ "-I/opt/cuda/bin/../targets/x86_64-linux/include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=8 -D__CUDACC_VER_BUILD__=93 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=8 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -D__CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp4.ii" + #$ cudafe++ --c++17 --gnu_version=140201 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/CMakeCUDACompilerId.cu" --allow_managed --m64 --parse_templates --gen_c_file_name "tmp/CMakeCUDACompilerId.cudafe1.cpp" --stub_file_name "CMakeCUDACompilerId.cudafe1.stub.c" --gen_module_id_file --module_id_file_name "tmp/CMakeCUDACompilerId.module_id" "tmp/CMakeCUDACompilerId.cpp4.ii" + #$ "/usr/bin"/g++-14 -D__CUDA_ARCH__=520 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -E -x c++ -DCUDA_DOUBLE_MATH_FUNCTIONS -D__CUDACC__ -D__NVCC__ "-I/opt/cuda/bin/../targets/x86_64-linux/include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=8 -D__CUDACC_VER_BUILD__=93 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=8 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -D__CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp1.ii" + #$ "$CICC_PATH/cicc" --c++17 --gnu_version=140201 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/CMakeCUDACompilerId.cu" --allow_managed -arch compute_52 -m64 --no-version-ident -ftz=0 -prec_div=1 -prec_sqrt=1 -fmad=1 --include_file_name "CMakeCUDACompilerId.fatbin.c" -tused --module_id_file_name "tmp/CMakeCUDACompilerId.module_id" --gen_c_file_name "tmp/CMakeCUDACompilerId.cudafe1.c" --stub_file_name "tmp/CMakeCUDACompilerId.cudafe1.stub.c" --gen_device_file_name "tmp/CMakeCUDACompilerId.cudafe1.gpu" "tmp/CMakeCUDACompilerId.cpp1.ii" -o "tmp/CMakeCUDACompilerId.ptx" + #$ ptxas -arch=sm_52 -m64 "tmp/CMakeCUDACompilerId.ptx" -o "tmp/CMakeCUDACompilerId.sm_52.cubin" + #$ fatbinary --create="tmp/CMakeCUDACompilerId.fatbin" -64 --cicc-cmdline="-ftz=0 -prec_div=1 -prec_sqrt=1 -fmad=1 " "--image3=kind=elf,sm=52,file=tmp/CMakeCUDACompilerId.sm_52.cubin" "--image3=kind=ptx,sm=52,file=tmp/CMakeCUDACompilerId.ptx" --embedded-fatbin="tmp/CMakeCUDACompilerId.fatbin.c" + #$ "/usr/bin"/g++-14 -D__CUDA_ARCH__=520 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -c -x c++ -DCUDA_DOUBLE_MATH_FUNCTIONS -Wno-psabi "-I/opt/cuda/bin/../targets/x86_64-linux/include" -m64 "tmp/CMakeCUDACompilerId.cudafe1.cpp" -o "tmp/CMakeCUDACompilerId.o" + #$ nvlink -m64 --arch=sm_52 --register-link-binaries="tmp/a_dlink.reg.c" "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" -cpu-arch=X86_64 "tmp/CMakeCUDACompilerId.o" -lcudadevrt -o "tmp/a_dlink.sm_52.cubin" --host-ccbin "/usr/bin/g++-14" + #$ fatbinary --create="tmp/a_dlink.fatbin" -64 --cicc-cmdline="-ftz=0 -prec_div=1 -prec_sqrt=1 -fmad=1 " -link "--image3=kind=elf,sm=52,file=tmp/a_dlink.sm_52.cubin" --embedded-fatbin="tmp/a_dlink.fatbin.c" + #$ "/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -c -x c++ -DFATBINFILE="\\"tmp/a_dlink.fatbin.c\\"" -DREGISTERLINKBINARYFILE="\\"tmp/a_dlink.reg.c\\"" -I. -D__NV_EXTRA_INITIALIZATION= -D__NV_EXTRA_FINALIZATION= -D__CUDA_INCLUDE_COMPILER_INTERNAL_HEADERS__ -Wno-psabi "-I/opt/cuda/bin/../targets/x86_64-linux/include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=8 -D__CUDACC_VER_BUILD__=93 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=8 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -D__CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -m64 "/opt/cuda/bin/crt/link.stub" -o "tmp/a_dlink.o" + #$ "/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" + + + Compilation of the CUDA compiler identification source "CMakeCUDACompilerId.cu" produced "a.out" + + The CUDA compiler identification is NVIDIA, found in: + /home/tobli/abo/pprog/Homework-3/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/a.out + The host compiler identification is GNU + + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/Internal/CMakeNVCCParseImplicitInfo.cmake:128 (message)" + - "/usr/share/cmake/Modules/CMakeDetermineCUDACompiler.cmake:247 (cmake_nvcc_parse_implicit_info)" + - "CMakeLists.txt:2 (project)" + message: | + Parsed CUDA nvcc implicit link information: + found 'PATH=' string: [/opt/cuda/bin/../nvvm/bin:/opt/cuda/bin:/opt/cuda/bin/opt/cuda/bin/usr/local/sbin:/usr/local/bin:/usr/bin:/opt/cuda/bin:/opt/cuda/nsight_compute:/opt/cuda/nsight_systems/bin:/usr/lib/jvm/default/bin:/usr/bin/site_perl:/usr/bin/vendor_perl:/usr/bin/core_perl] + found 'LIBRARIES=' string: ["-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib"] + found 'INCLUDES=' string: ["-I/opt/cuda/bin/../targets/x86_64-linux/include" ] + considering line: [nvcc warning : Support for offline compilation for architectures prior to '_75' will be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning).] + considering line: [rm tmp/a_dlink.reg.c] + considering line: ["/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -E -x c++ -D__CUDACC__ -D__NVCC__ "-I/opt/cuda/bin/../targets/x86_64-linux/include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=8 -D__CUDACC_VER_BUILD__=93 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=8 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -D__CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp4.ii" ] + considering line: [cudafe++ --c++17 --gnu_version=140201 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/CMakeCUDACompilerId.cu" --allow_managed --m64 --parse_templates --gen_c_file_name "tmp/CMakeCUDACompilerId.cudafe1.cpp" --stub_file_name "CMakeCUDACompilerId.cudafe1.stub.c" --gen_module_id_file --module_id_file_name "tmp/CMakeCUDACompilerId.module_id" "tmp/CMakeCUDACompilerId.cpp4.ii" ] + considering line: ["/usr/bin"/g++-14 -D__CUDA_ARCH__=520 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -E -x c++ -DCUDA_DOUBLE_MATH_FUNCTIONS -D__CUDACC__ -D__NVCC__ "-I/opt/cuda/bin/../targets/x86_64-linux/include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=8 -D__CUDACC_VER_BUILD__=93 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=8 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -D__CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp1.ii" ] + considering line: ["$CICC_PATH/cicc" --c++17 --gnu_version=140201 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/CMakeCUDACompilerId.cu" --allow_managed -arch compute_52 -m64 --no-version-ident -ftz=0 -prec_div=1 -prec_sqrt=1 -fmad=1 --include_file_name "CMakeCUDACompilerId.fatbin.c" -tused --module_id_file_name "tmp/CMakeCUDACompilerId.module_id" --gen_c_file_name "tmp/CMakeCUDACompilerId.cudafe1.c" --stub_file_name "tmp/CMakeCUDACompilerId.cudafe1.stub.c" --gen_device_file_name "tmp/CMakeCUDACompilerId.cudafe1.gpu" "tmp/CMakeCUDACompilerId.cpp1.ii" -o "tmp/CMakeCUDACompilerId.ptx"] + considering line: [ptxas -arch=sm_52 -m64 "tmp/CMakeCUDACompilerId.ptx" -o "tmp/CMakeCUDACompilerId.sm_52.cubin" ] + considering line: [fatbinary --create="tmp/CMakeCUDACompilerId.fatbin" -64 --cicc-cmdline="-ftz=0 -prec_div=1 -prec_sqrt=1 -fmad=1 " "--image3=kind=elf,sm=52,file=tmp/CMakeCUDACompilerId.sm_52.cubin" "--image3=kind=ptx,sm=52,file=tmp/CMakeCUDACompilerId.ptx" --embedded-fatbin="tmp/CMakeCUDACompilerId.fatbin.c" ] + considering line: ["/usr/bin"/g++-14 -D__CUDA_ARCH__=520 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -c -x c++ -DCUDA_DOUBLE_MATH_FUNCTIONS -Wno-psabi "-I/opt/cuda/bin/../targets/x86_64-linux/include" -m64 "tmp/CMakeCUDACompilerId.cudafe1.cpp" -o "tmp/CMakeCUDACompilerId.o" ] + considering line: [nvlink -m64 --arch=sm_52 --register-link-binaries="tmp/a_dlink.reg.c" "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" -cpu-arch=X86_64 "tmp/CMakeCUDACompilerId.o" -lcudadevrt -o "tmp/a_dlink.sm_52.cubin" --host-ccbin "/usr/bin/g++-14"] + ignoring nvlink line + considering line: [fatbinary --create="tmp/a_dlink.fatbin" -64 --cicc-cmdline="-ftz=0 -prec_div=1 -prec_sqrt=1 -fmad=1 " -link "--image3=kind=elf,sm=52,file=tmp/a_dlink.sm_52.cubin" --embedded-fatbin="tmp/a_dlink.fatbin.c" ] + considering line: ["/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -c -x c++ -DFATBINFILE="\\"tmp/a_dlink.fatbin.c\\"" -DREGISTERLINKBINARYFILE="\\"tmp/a_dlink.reg.c\\"" -I. -D__NV_EXTRA_INITIALIZATION= -D__NV_EXTRA_FINALIZATION= -D__CUDA_INCLUDE_COMPILER_INTERNAL_HEADERS__ -Wno-psabi "-I/opt/cuda/bin/../targets/x86_64-linux/include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=8 -D__CUDACC_VER_BUILD__=93 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=8 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -D__CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -m64 "/opt/cuda/bin/crt/link.stub" -o "tmp/a_dlink.o" ] + considering line: ["/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" ] + extracted link line: ["/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" ] + considering line: [] + extracted link launcher absolute path: [/usr/bin/g++-14] + + link line regex: [^( *|.*[/\\])(ld[0-9]*(|\\.[a-rt-z][a-z]*|\\.s[a-np-z][a-z]*|\\.so[a-z]+)|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\\]+-)?ld|collect2)[^/\\]*( |$)] + link line: [cuda-fake-ld "/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" ] + arg [cuda-fake-ld] ==> ignore + arg [/usr/bin/g++-14] ==> ignore + arg [-D__CUDA_ARCH_LIST__=520] ==> ignore + arg [-D__NV_LEGACY_LAUNCH] ==> ignore + arg [-m64] ==> ignore + arg [-Wl,--start-group] ==> ignore + arg [tmp/a_dlink.o] ==> ignore + arg [tmp/CMakeCUDACompilerId.o] ==> ignore + arg [-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs] ==> dir [/opt/cuda/bin/../targets/x86_64-linux/lib/stubs] + arg [-L/opt/cuda/bin/../targets/x86_64-linux/lib] ==> dir [/opt/cuda/bin/../targets/x86_64-linux/lib] + arg [-lcudadevrt] ==> lib [cudadevrt] + arg [-lcudart_static] ==> lib [cudart_static] + arg [-lrt] ==> lib [rt] + arg [-lpthread] ==> lib [pthread] + arg [-ldl] ==> lib [dl] + arg [-Wl,--end-group] ==> ignore + arg [-o] ==> ignore + arg [a.out] ==> ignore + collapse library dir [/opt/cuda/bin/../targets/x86_64-linux/lib/stubs] ==> [/opt/cuda/targets/x86_64-linux/lib/stubs] + collapse library dir [/opt/cuda/bin/../targets/x86_64-linux/lib] ==> [/opt/cuda/targets/x86_64-linux/lib] + implicit libs: [cudadevrt;cudart_static;rt;pthread;dl] + implicit objs: [] + implicit dirs: [/opt/cuda/targets/x86_64-linux/lib/stubs;/opt/cuda/targets/x86_64-linux/lib] + implicit fwks: [] + + + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/Internal/CMakeNVCCParseImplicitInfo.cmake:146 (message)" + - "/usr/share/cmake/Modules/CMakeDetermineCUDACompiler.cmake:247 (cmake_nvcc_parse_implicit_info)" + - "CMakeLists.txt:2 (project)" + message: | + Parsed CUDA nvcc include information: + found 'PATH=' string: [/opt/cuda/bin/../nvvm/bin:/opt/cuda/bin:/opt/cuda/bin/opt/cuda/bin/usr/local/sbin:/usr/local/bin:/usr/bin:/opt/cuda/bin:/opt/cuda/nsight_compute:/opt/cuda/nsight_systems/bin:/usr/lib/jvm/default/bin:/usr/bin/site_perl:/usr/bin/vendor_perl:/usr/bin/core_perl] + found 'LIBRARIES=' string: ["-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib"] + found 'INCLUDES=' string: ["-I/opt/cuda/bin/../targets/x86_64-linux/include" ] + considering line: [nvcc warning : Support for offline compilation for architectures prior to '_75' will be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning).] + considering line: [rm tmp/a_dlink.reg.c] + considering line: ["/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -E -x c++ -D__CUDACC__ -D__NVCC__ "-I/opt/cuda/bin/../targets/x86_64-linux/include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=8 -D__CUDACC_VER_BUILD__=93 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=8 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -D__CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp4.ii" ] + considering line: [cudafe++ --c++17 --gnu_version=140201 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/CMakeCUDACompilerId.cu" --allow_managed --m64 --parse_templates --gen_c_file_name "tmp/CMakeCUDACompilerId.cudafe1.cpp" --stub_file_name "CMakeCUDACompilerId.cudafe1.stub.c" --gen_module_id_file --module_id_file_name "tmp/CMakeCUDACompilerId.module_id" "tmp/CMakeCUDACompilerId.cpp4.ii" ] + considering line: ["/usr/bin"/g++-14 -D__CUDA_ARCH__=520 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -E -x c++ -DCUDA_DOUBLE_MATH_FUNCTIONS -D__CUDACC__ -D__NVCC__ "-I/opt/cuda/bin/../targets/x86_64-linux/include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=8 -D__CUDACC_VER_BUILD__=93 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=8 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -D__CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp1.ii" ] + considering line: ["$CICC_PATH/cicc" --c++17 --gnu_version=140201 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/CMakeCUDACompilerId.cu" --allow_managed -arch compute_52 -m64 --no-version-ident -ftz=0 -prec_div=1 -prec_sqrt=1 -fmad=1 --include_file_name "CMakeCUDACompilerId.fatbin.c" -tused --module_id_file_name "tmp/CMakeCUDACompilerId.module_id" --gen_c_file_name "tmp/CMakeCUDACompilerId.cudafe1.c" --stub_file_name "tmp/CMakeCUDACompilerId.cudafe1.stub.c" --gen_device_file_name "tmp/CMakeCUDACompilerId.cudafe1.gpu" "tmp/CMakeCUDACompilerId.cpp1.ii" -o "tmp/CMakeCUDACompilerId.ptx"] + considering line: [ptxas -arch=sm_52 -m64 "tmp/CMakeCUDACompilerId.ptx" -o "tmp/CMakeCUDACompilerId.sm_52.cubin" ] + considering line: [fatbinary --create="tmp/CMakeCUDACompilerId.fatbin" -64 --cicc-cmdline="-ftz=0 -prec_div=1 -prec_sqrt=1 -fmad=1 " "--image3=kind=elf,sm=52,file=tmp/CMakeCUDACompilerId.sm_52.cubin" "--image3=kind=ptx,sm=52,file=tmp/CMakeCUDACompilerId.ptx" --embedded-fatbin="tmp/CMakeCUDACompilerId.fatbin.c" ] + considering line: ["/usr/bin"/g++-14 -D__CUDA_ARCH__=520 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -c -x c++ -DCUDA_DOUBLE_MATH_FUNCTIONS -Wno-psabi "-I/opt/cuda/bin/../targets/x86_64-linux/include" -m64 "tmp/CMakeCUDACompilerId.cudafe1.cpp" -o "tmp/CMakeCUDACompilerId.o" ] + considering line: [nvlink -m64 --arch=sm_52 --register-link-binaries="tmp/a_dlink.reg.c" "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" -cpu-arch=X86_64 "tmp/CMakeCUDACompilerId.o" -lcudadevrt -o "tmp/a_dlink.sm_52.cubin" --host-ccbin "/usr/bin/g++-14"] + ignoring nvlink line + considering line: [fatbinary --create="tmp/a_dlink.fatbin" -64 --cicc-cmdline="-ftz=0 -prec_div=1 -prec_sqrt=1 -fmad=1 " -link "--image3=kind=elf,sm=52,file=tmp/a_dlink.sm_52.cubin" --embedded-fatbin="tmp/a_dlink.fatbin.c" ] + considering line: ["/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -c -x c++ -DFATBINFILE="\\"tmp/a_dlink.fatbin.c\\"" -DREGISTERLINKBINARYFILE="\\"tmp/a_dlink.reg.c\\"" -I. -D__NV_EXTRA_INITIALIZATION= -D__NV_EXTRA_FINALIZATION= -D__CUDA_INCLUDE_COMPILER_INTERNAL_HEADERS__ -Wno-psabi "-I/opt/cuda/bin/../targets/x86_64-linux/include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=8 -D__CUDACC_VER_BUILD__=93 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=8 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -D__CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -m64 "/opt/cuda/bin/crt/link.stub" -o "tmp/a_dlink.o" ] + considering line: ["/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" ] + extracted link line: ["/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" ] + considering line: [] + extracted link launcher absolute path: [/usr/bin/g++-14] + + link line regex: [^( *|.*[/\\])(ld[0-9]*(|\\.[a-rt-z][a-z]*|\\.s[a-np-z][a-z]*|\\.so[a-z]+)|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\\]+-)?ld|collect2)[^/\\]*( |$)] + link line: [cuda-fake-ld "/usr/bin"/g++-14 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs" "-L/opt/cuda/bin/../targets/x86_64-linux/lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" ] + arg [cuda-fake-ld] ==> ignore + arg [/usr/bin/g++-14] ==> ignore + arg [-D__CUDA_ARCH_LIST__=520] ==> ignore + arg [-D__NV_LEGACY_LAUNCH] ==> ignore + arg [-m64] ==> ignore + arg [-Wl,--start-group] ==> ignore + arg [tmp/a_dlink.o] ==> ignore + arg [tmp/CMakeCUDACompilerId.o] ==> ignore + arg [-L/opt/cuda/bin/../targets/x86_64-linux/lib/stubs] ==> dir [/opt/cuda/bin/../targets/x86_64-linux/lib/stubs] + arg [-L/opt/cuda/bin/../targets/x86_64-linux/lib] ==> dir [/opt/cuda/bin/../targets/x86_64-linux/lib] + arg [-lcudadevrt] ==> lib [cudadevrt] + arg [-lcudart_static] ==> lib [cudart_static] + arg [-lrt] ==> lib [rt] + arg [-lpthread] ==> lib [pthread] + arg [-ldl] ==> lib [dl] + arg [-Wl,--end-group] ==> ignore + arg [-o] ==> ignore + arg [a.out] ==> ignore + collapse library dir [/opt/cuda/bin/../targets/x86_64-linux/lib/stubs] ==> [/opt/cuda/targets/x86_64-linux/lib/stubs] + collapse library dir [/opt/cuda/bin/../targets/x86_64-linux/lib] ==> [/opt/cuda/targets/x86_64-linux/lib] + implicit libs: [cudadevrt;cudart_static;rt;pthread;dl] + implicit objs: [] + implicit dirs: [/opt/cuda/targets/x86_64-linux/lib/stubs;/opt/cuda/targets/x86_64-linux/lib] + implicit fwks: [] + + + - + kind: "try_compile-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerABI.cmake:83 (try_compile)" + - "/usr/share/cmake/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + checks: + - "Detecting CXX compiler ABI info" + directories: + source: "/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/CMakeScratch/TryCompile-SgQPjf" + binary: "/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/CMakeScratch/TryCompile-SgQPjf" + cmakeVariables: + CMAKE_CUDA_ARCHITECTURES: "52" + CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS: "/usr/bin/clang-scan-deps" + CMAKE_CXX_FLAGS: "" + CMAKE_CXX_FLAGS_DEBUG: "-g" + CMAKE_CXX_SCAN_FOR_MODULES: "OFF" + CMAKE_EXE_LINKER_FLAGS: "" + buildResult: + variable: "CMAKE_CXX_ABI_COMPILED" + cached: true + stdout: | + Change Dir: '/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/CMakeScratch/TryCompile-SgQPjf' + + Run Build Command(s): /usr/bin/ninja -v cmTC_cffa6 + [1/2] /usr/bin/clang++ -v -MD -MT CMakeFiles/cmTC_cffa6.dir/CMakeCXXCompilerABI.cpp.o -MF CMakeFiles/cmTC_cffa6.dir/CMakeCXXCompilerABI.cpp.o.d -o CMakeFiles/cmTC_cffa6.dir/CMakeCXXCompilerABI.cpp.o -c /usr/share/cmake/Modules/CMakeCXXCompilerABI.cpp + clang version 19.1.7 + Target: x86_64-pc-linux-gnu + Thread model: posix + InstalledDir: /usr/bin + Found candidate GCC installation: /usr/bin/../lib/gcc/x86_64-pc-linux-gnu/14.2.1 + Found candidate GCC installation: /usr/bin/../lib/gcc/x86_64-pc-linux-gnu/15.1.1 + Found candidate GCC installation: /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/14.2.1 + Found candidate GCC installation: /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1 + Selected GCC installation: /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1 + Candidate multilib: .;@m64 + Candidate multilib: 32;@m32 + Selected multilib: .;@m64 + Found CUDA installation: /opt/cuda, version + (in-process) + "/usr/bin/clang++" -cc1 -triple x86_64-pc-linux-gnu -emit-obj -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name CMakeCXXCompilerABI.cpp -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/CMakeScratch/TryCompile-SgQPjf -v -fcoverage-compilation-dir=/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/CMakeScratch/TryCompile-SgQPjf -resource-dir /usr/lib/clang/19 -dependency-file CMakeFiles/cmTC_cffa6.dir/CMakeCXXCompilerABI.cpp.o.d -MT CMakeFiles/cmTC_cffa6.dir/CMakeCXXCompilerABI.cpp.o -sys-header-deps -internal-isystem /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../include/c++/15.1.1 -internal-isystem /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../include/c++/15.1.1/x86_64-pc-linux-gnu -internal-isystem /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../include/c++/15.1.1/backward -internal-isystem /usr/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../x86_64-pc-linux-gnu/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -fdeprecated-macro -ferror-limit 19 -stack-protector 2 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fcxx-exceptions -fexceptions -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o CMakeFiles/cmTC_cffa6.dir/CMakeCXXCompilerABI.cpp.o -x c++ /usr/share/cmake/Modules/CMakeCXXCompilerABI.cpp + clang -cc1 version 19.1.7 based upon LLVM 19.1.7 default target x86_64-pc-linux-gnu + ignoring nonexistent directory "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../x86_64-pc-linux-gnu/include" + ignoring nonexistent directory "/include" + #include "..." search starts here: + #include <...> search starts here: + /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../include/c++/15.1.1 + /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../include/c++/15.1.1/x86_64-pc-linux-gnu + /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../include/c++/15.1.1/backward + /usr/lib/clang/19/include + /usr/local/include + /usr/include + End of search list. + [2/2] : && /usr/bin/clang++ -v -Wl,-v CMakeFiles/cmTC_cffa6.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_cffa6 && : + clang version 19.1.7 + Target: x86_64-pc-linux-gnu + Thread model: posix + InstalledDir: /usr/bin + Found candidate GCC installation: /usr/bin/../lib/gcc/x86_64-pc-linux-gnu/14.2.1 + Found candidate GCC installation: /usr/bin/../lib/gcc/x86_64-pc-linux-gnu/15.1.1 + Found candidate GCC installation: /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/14.2.1 + Found candidate GCC installation: /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1 + Selected GCC installation: /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1 + Candidate multilib: .;@m64 + Candidate multilib: 32;@m32 + Selected multilib: .;@m64 + Found CUDA installation: /opt/cuda, version + "/usr/bin/ld" --hash-style=gnu --build-id --eh-frame-hdr -m elf_x86_64 -pie -dynamic-linker /lib64/ld-linux-x86-64.so.2 -o cmTC_cffa6 /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../lib64/Scrt1.o /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../lib64/crti.o /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/crtbeginS.o -L/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1 -L/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../lib64 -L/lib/../lib64 -L/usr/lib/../lib64 -L/lib -L/usr/lib -v CMakeFiles/cmTC_cffa6.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/crtendS.o /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../lib64/crtn.o + GNU ld (GNU Binutils) 2.44.0 + + exitCode: 0 + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerABI.cmake:191 (message)" + - "/usr/share/cmake/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + message: | + Parsed CXX implicit include dir info: rv=done + found start of include info + found start of implicit include info + add: [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../include/c++/15.1.1] + add: [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../include/c++/15.1.1/x86_64-pc-linux-gnu] + add: [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../include/c++/15.1.1/backward] + add: [/usr/lib/clang/19/include] + add: [/usr/local/include] + add: [/usr/include] + end of search list found + collapse include dir [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../include/c++/15.1.1] ==> [/usr/include/c++/15.1.1] + collapse include dir [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../include/c++/15.1.1/x86_64-pc-linux-gnu] ==> [/usr/include/c++/15.1.1/x86_64-pc-linux-gnu] + collapse include dir [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../include/c++/15.1.1/backward] ==> [/usr/include/c++/15.1.1/backward] + collapse include dir [/usr/lib/clang/19/include] ==> [/usr/lib/clang/19/include] + collapse include dir [/usr/local/include] ==> [/usr/local/include] + collapse include dir [/usr/include] ==> [/usr/include] + implicit include dirs: [/usr/include/c++/15.1.1;/usr/include/c++/15.1.1/x86_64-pc-linux-gnu;/usr/include/c++/15.1.1/backward;/usr/lib/clang/19/include;/usr/local/include;/usr/include] + + + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerABI.cmake:227 (message)" + - "/usr/share/cmake/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + message: | + Parsed CXX implicit link information: + link line regex: [^( *|.*[/\\])(ld[0-9]*(|\\.[a-rt-z][a-z]*|\\.s[a-np-z][a-z]*|\\.so[a-z]+)|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\\]+-)?ld|collect2)[^/\\]*( |$)] + linker tool regex: [^[ ]*(->|")?[ ]*(([^"]*[/\\])?(ld[0-9]*(|\\.[a-rt-z][a-z]*|\\.s[a-np-z][a-z]*|\\.so[a-z]+)))("|,| |$)] + ignore line: [Change Dir: '/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/CMakeScratch/TryCompile-SgQPjf'] + ignore line: [] + ignore line: [Run Build Command(s): /usr/bin/ninja -v cmTC_cffa6] + ignore line: [[1/2] /usr/bin/clang++ -v -MD -MT CMakeFiles/cmTC_cffa6.dir/CMakeCXXCompilerABI.cpp.o -MF CMakeFiles/cmTC_cffa6.dir/CMakeCXXCompilerABI.cpp.o.d -o CMakeFiles/cmTC_cffa6.dir/CMakeCXXCompilerABI.cpp.o -c /usr/share/cmake/Modules/CMakeCXXCompilerABI.cpp] + ignore line: [clang version 19.1.7] + ignore line: [Target: x86_64-pc-linux-gnu] + ignore line: [Thread model: posix] + ignore line: [InstalledDir: /usr/bin] + ignore line: [Found candidate GCC installation: /usr/bin/../lib/gcc/x86_64-pc-linux-gnu/14.2.1] + ignore line: [Found candidate GCC installation: /usr/bin/../lib/gcc/x86_64-pc-linux-gnu/15.1.1] + ignore line: [Found candidate GCC installation: /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/14.2.1] + ignore line: [Found candidate GCC installation: /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1] + ignore line: [Selected GCC installation: /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1] + ignore line: [Candidate multilib: .] + ignore line: [@m64] + ignore line: [Candidate multilib: 32] + ignore line: [@m32] + ignore line: [Selected multilib: .] + ignore line: [@m64] + ignore line: [Found CUDA installation: /opt/cuda version ] + ignore line: [ (in-process)] + ignore line: [ "/usr/bin/clang++" -cc1 -triple x86_64-pc-linux-gnu -emit-obj -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name CMakeCXXCompilerABI.cpp -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/CMakeScratch/TryCompile-SgQPjf -v -fcoverage-compilation-dir=/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/CMakeScratch/TryCompile-SgQPjf -resource-dir /usr/lib/clang/19 -dependency-file CMakeFiles/cmTC_cffa6.dir/CMakeCXXCompilerABI.cpp.o.d -MT CMakeFiles/cmTC_cffa6.dir/CMakeCXXCompilerABI.cpp.o -sys-header-deps -internal-isystem /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../include/c++/15.1.1 -internal-isystem /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../include/c++/15.1.1/x86_64-pc-linux-gnu -internal-isystem /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../include/c++/15.1.1/backward -internal-isystem /usr/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../x86_64-pc-linux-gnu/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -fdeprecated-macro -ferror-limit 19 -stack-protector 2 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fcxx-exceptions -fexceptions -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o CMakeFiles/cmTC_cffa6.dir/CMakeCXXCompilerABI.cpp.o -x c++ /usr/share/cmake/Modules/CMakeCXXCompilerABI.cpp] + ignore line: [clang -cc1 version 19.1.7 based upon LLVM 19.1.7 default target x86_64-pc-linux-gnu] + ignore line: [ignoring nonexistent directory "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../x86_64-pc-linux-gnu/include"] + ignore line: [ignoring nonexistent directory "/include"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../include/c++/15.1.1] + ignore line: [ /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../include/c++/15.1.1/x86_64-pc-linux-gnu] + ignore line: [ /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../include/c++/15.1.1/backward] + ignore line: [ /usr/lib/clang/19/include] + ignore line: [ /usr/local/include] + ignore line: [ /usr/include] + ignore line: [End of search list.] + ignore line: [[2/2] : && /usr/bin/clang++ -v -Wl -v CMakeFiles/cmTC_cffa6.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_cffa6 && :] + ignore line: [clang version 19.1.7] + ignore line: [Target: x86_64-pc-linux-gnu] + ignore line: [Thread model: posix] + ignore line: [InstalledDir: /usr/bin] + ignore line: [Found candidate GCC installation: /usr/bin/../lib/gcc/x86_64-pc-linux-gnu/14.2.1] + ignore line: [Found candidate GCC installation: /usr/bin/../lib/gcc/x86_64-pc-linux-gnu/15.1.1] + ignore line: [Found candidate GCC installation: /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/14.2.1] + ignore line: [Found candidate GCC installation: /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1] + ignore line: [Selected GCC installation: /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1] + ignore line: [Candidate multilib: .] + ignore line: [@m64] + ignore line: [Candidate multilib: 32] + ignore line: [@m32] + ignore line: [Selected multilib: .] + ignore line: [@m64] + ignore line: [Found CUDA installation: /opt/cuda version ] + link line: [ "/usr/bin/ld" --hash-style=gnu --build-id --eh-frame-hdr -m elf_x86_64 -pie -dynamic-linker /lib64/ld-linux-x86-64.so.2 -o cmTC_cffa6 /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../lib64/Scrt1.o /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../lib64/crti.o /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/crtbeginS.o -L/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1 -L/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../lib64 -L/lib/../lib64 -L/usr/lib/../lib64 -L/lib -L/usr/lib -v CMakeFiles/cmTC_cffa6.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/crtendS.o /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../lib64/crtn.o] + arg [/usr/bin/ld] ==> ignore + arg [--hash-style=gnu] ==> ignore + arg [--build-id] ==> ignore + arg [--eh-frame-hdr] ==> ignore + arg [-m] ==> ignore + arg [elf_x86_64] ==> ignore + arg [-pie] ==> ignore + arg [-dynamic-linker] ==> ignore + arg [/lib64/ld-linux-x86-64.so.2] ==> ignore + arg [-o] ==> ignore + arg [cmTC_cffa6] ==> ignore + arg [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../lib64/Scrt1.o] ==> obj [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../lib64/Scrt1.o] + arg [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../lib64/crti.o] ==> obj [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../lib64/crti.o] + arg [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/crtbeginS.o] ==> obj [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/crtbeginS.o] + arg [-L/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1] ==> dir [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1] + arg [-L/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../lib64] ==> dir [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../lib64] + arg [-L/lib/../lib64] ==> dir [/lib/../lib64] + arg [-L/usr/lib/../lib64] ==> dir [/usr/lib/../lib64] + arg [-L/lib] ==> dir [/lib] + arg [-L/usr/lib] ==> dir [/usr/lib] + arg [-v] ==> ignore + arg [CMakeFiles/cmTC_cffa6.dir/CMakeCXXCompilerABI.cpp.o] ==> ignore + arg [-lstdc++] ==> lib [stdc++] + arg [-lm] ==> lib [m] + arg [-lgcc_s] ==> lib [gcc_s] + arg [-lgcc] ==> lib [gcc] + arg [-lc] ==> lib [c] + arg [-lgcc_s] ==> lib [gcc_s] + arg [-lgcc] ==> lib [gcc] + arg [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/crtendS.o] ==> obj [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/crtendS.o] + arg [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../lib64/crtn.o] ==> obj [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../lib64/crtn.o] + linker tool for 'CXX': /usr/bin/ld + collapse obj [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../lib64/Scrt1.o] ==> [/usr/lib64/Scrt1.o] + collapse obj [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../lib64/crti.o] ==> [/usr/lib64/crti.o] + collapse obj [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/crtbeginS.o] ==> [/usr/lib64/gcc/x86_64-pc-linux-gnu/15.1.1/crtbeginS.o] + collapse obj [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/crtendS.o] ==> [/usr/lib64/gcc/x86_64-pc-linux-gnu/15.1.1/crtendS.o] + collapse obj [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../lib64/crtn.o] ==> [/usr/lib64/crtn.o] + collapse library dir [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1] ==> [/usr/lib64/gcc/x86_64-pc-linux-gnu/15.1.1] + collapse library dir [/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.1.1/../../../../lib64] ==> [/usr/lib64] + collapse library dir [/lib/../lib64] ==> [/lib64] + collapse library dir [/usr/lib/../lib64] ==> [/usr/lib64] + collapse library dir [/lib] ==> [/lib] + collapse library dir [/usr/lib] ==> [/usr/lib] + implicit libs: [stdc++;m;gcc_s;gcc;c;gcc_s;gcc] + implicit objs: [/usr/lib64/Scrt1.o;/usr/lib64/crti.o;/usr/lib64/gcc/x86_64-pc-linux-gnu/15.1.1/crtbeginS.o;/usr/lib64/gcc/x86_64-pc-linux-gnu/15.1.1/crtendS.o;/usr/lib64/crtn.o] + implicit dirs: [/usr/lib64/gcc/x86_64-pc-linux-gnu/15.1.1;/usr/lib64;/lib64;/lib;/usr/lib] + implicit fwks: [] + + + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/Internal/CMakeDetermineLinkerId.cmake:36 (message)" + - "/usr/share/cmake/Modules/CMakeDetermineCompilerABI.cmake:270 (cmake_determine_linker_id)" + - "/usr/share/cmake/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + message: | + Running the CXX compiler's linker: "/usr/bin/ld" "-v" + GNU ld (GNU Binutils) 2.44.0 + - + kind: "try_compile-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerABI.cmake:83 (try_compile)" + - "/usr/share/cmake/Modules/CMakeTestCUDACompiler.cmake:19 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + checks: + - "Detecting CUDA compiler ABI info" + directories: + source: "/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/CMakeScratch/TryCompile-1bJ2lk" + binary: "/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/CMakeScratch/TryCompile-1bJ2lk" + cmakeVariables: + CMAKE_CUDA_ARCHITECTURES: "52" + CMAKE_CUDA_FLAGS: "" + CMAKE_CUDA_FLAGS_DEBUG: "-g" + CMAKE_CUDA_RUNTIME_LIBRARY: "Static" + CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS: "/usr/bin/clang-scan-deps" + CMAKE_EXE_LINKER_FLAGS: "" + buildResult: + variable: "CMAKE_CUDA_ABI_COMPILED" + cached: true + stdout: | + Change Dir: '/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/CMakeScratch/TryCompile-1bJ2lk' + + Run Build Command(s): /usr/bin/ninja -v cmTC_95279 + [1/2] /opt/cuda/bin/nvcc -forward-unknown-to-host-compiler "--generate-code=arch=compute_52,code=[compute_52,sm_52]" -Xcompiler=-v -MD -MT CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o -MF CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o.d -x cu -c /usr/share/cmake/Modules/CMakeCUDACompilerABI.cu -o CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o + nvcc warning : Support for offline compilation for architectures prior to '_75' will be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning). + Using built-in specs. + COLLECT_GCC=/usr/bin/g++-14 + Target: x86_64-pc-linux-gnu + Configured with: /build/gcc14/src/gcc14/configure --enable-languages=c,c++,fortran --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc14/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --disable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror --program-suffix=-14 --enable-version-specific-runtime-libs + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 14.2.1 20250207 (GCC) + COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH__=520' '-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-E' '-D' 'CUDA_DOUBLE_MATH_FUNCTIONS' '-D' '__CUDACC__' '-D' '__NVCC__' '-v' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=8' '-D' '__CUDACC_VER_BUILD__=93' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=8' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-D' '__CUDACC_DEVICE_ATOMIC_BUILTINS__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00002f26_00000000-7_CMakeCUDACompilerABI.cpp1.ii' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/' + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/cc1plus -E -quiet -v -I /opt/cuda/bin/../targets/x86_64-linux/include -D_GNU_SOURCE -D __CUDA_ARCH__=520 -D __CUDA_ARCH_LIST__=520 -D __NV_LEGACY_LAUNCH -D CUDA_DOUBLE_MATH_FUNCTIONS -D __CUDACC__ -D __NVCC__ -D __CUDACC_VER_MAJOR__=12 -D __CUDACC_VER_MINOR__=8 -D __CUDACC_VER_BUILD__=93 -D __CUDA_API_VER_MAJOR__=12 -D __CUDA_API_VER_MINOR__=8 -D __NVCC_DIAG_PRAGMA_SUPPORT__=1 -D __CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -include cuda_runtime.h /usr/share/cmake/Modules/CMakeCUDACompilerABI.cu -o /tmp/tmpxft_00002f26_00000000-7_CMakeCUDACompilerABI.cpp1.ii -m64 -mtune=generic -march=x86-64 -dumpdir /tmp/ -dumpbase tmpxft_00002f26_00000000-7_CMakeCUDACompilerABI.cpp1.cu -dumpbase-ext .cu + ignoring nonexistent directory "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../x86_64-pc-linux-gnu/include" + #include "..." search starts here: + #include <...> search starts here: + /opt/cuda/bin/../targets/x86_64-linux/include + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include + /usr/local/include + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed + /usr/include + End of search list. + COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/ + LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH__=520' '-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-E' '-D' 'CUDA_DOUBLE_MATH_FUNCTIONS' '-D' '__CUDACC__' '-D' '__NVCC__' '-v' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=8' '-D' '__CUDACC_VER_BUILD__=93' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=8' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-D' '__CUDACC_DEVICE_ATOMIC_BUILTINS__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00002f26_00000000-7_CMakeCUDACompilerABI.cpp1.ii' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/tmpxft_00002f26_00000000-7_CMakeCUDACompilerABI.cpp1.' + Using built-in specs. + COLLECT_GCC=/usr/bin/g++-14 + Target: x86_64-pc-linux-gnu + Configured with: /build/gcc14/src/gcc14/configure --enable-languages=c,c++,fortran --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc14/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --disable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror --program-suffix=-14 --enable-version-specific-runtime-libs + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 14.2.1 20250207 (GCC) + COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-E' '-D' '__CUDACC__' '-D' '__NVCC__' '-v' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=8' '-D' '__CUDACC_VER_BUILD__=93' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=8' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-D' '__CUDACC_DEVICE_ATOMIC_BUILTINS__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00002f26_00000000-5_CMakeCUDACompilerABI.cpp4.ii' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/' + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/cc1plus -E -quiet -v -I /opt/cuda/bin/../targets/x86_64-linux/include -D_GNU_SOURCE -D __CUDA_ARCH_LIST__=520 -D __NV_LEGACY_LAUNCH -D __CUDACC__ -D __NVCC__ -D __CUDACC_VER_MAJOR__=12 -D __CUDACC_VER_MINOR__=8 -D __CUDACC_VER_BUILD__=93 -D __CUDA_API_VER_MAJOR__=12 -D __CUDA_API_VER_MINOR__=8 -D __NVCC_DIAG_PRAGMA_SUPPORT__=1 -D __CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -include cuda_runtime.h /usr/share/cmake/Modules/CMakeCUDACompilerABI.cu -o /tmp/tmpxft_00002f26_00000000-5_CMakeCUDACompilerABI.cpp4.ii -m64 -mtune=generic -march=x86-64 -dumpdir /tmp/ -dumpbase tmpxft_00002f26_00000000-5_CMakeCUDACompilerABI.cpp4.cu -dumpbase-ext .cu + ignoring nonexistent directory "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../x86_64-pc-linux-gnu/include" + #include "..." search starts here: + #include <...> search starts here: + /opt/cuda/bin/../targets/x86_64-linux/include + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include + /usr/local/include + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed + /usr/include + End of search list. + COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/ + LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-E' '-D' '__CUDACC__' '-D' '__NVCC__' '-v' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=8' '-D' '__CUDACC_VER_BUILD__=93' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=8' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-D' '__CUDACC_DEVICE_ATOMIC_BUILTINS__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00002f26_00000000-5_CMakeCUDACompilerABI.cpp4.ii' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/tmpxft_00002f26_00000000-5_CMakeCUDACompilerABI.cpp4.' + Using built-in specs. + COLLECT_GCC=/usr/bin/g++-14 + Target: x86_64-pc-linux-gnu + Configured with: /build/gcc14/src/gcc14/configure --enable-languages=c,c++,fortran --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc14/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --disable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror --program-suffix=-14 --enable-version-specific-runtime-libs + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 14.2.1 20250207 (GCC) + COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH__=520' '-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-c' '-D' 'CUDA_DOUBLE_MATH_FUNCTIONS' '-v' '-Wno-psabi' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-m64' '-o' 'CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_95279.dir/' + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/cc1plus -quiet -v -I /opt/cuda/bin/../targets/x86_64-linux/include -D_GNU_SOURCE -D __CUDA_ARCH__=520 -D __CUDA_ARCH_LIST__=520 -D __NV_LEGACY_LAUNCH -D CUDA_DOUBLE_MATH_FUNCTIONS /tmp/tmpxft_00002f26_00000000-6_CMakeCUDACompilerABI.cudafe1.cpp -quiet -dumpdir CMakeFiles/cmTC_95279.dir/ -dumpbase CMakeCUDACompilerABI.cu.cpp -dumpbase-ext .cpp -m64 -mtune=generic -march=x86-64 -Wno-psabi -version -o /tmp/ccDygrw0.s + GNU C++17 (GCC) version 14.2.1 20250207 (x86_64-pc-linux-gnu) + compiled by GNU C version 14.2.1 20250207, GMP version 6.3.0, MPFR version 4.2.2, MPC version 1.3.1, isl version isl-0.27-GMP + + GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072 + ignoring nonexistent directory "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../x86_64-pc-linux-gnu/include" + #include "..." search starts here: + #include <...> search starts here: + /opt/cuda/bin/../targets/x86_64-linux/include + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include + /usr/local/include + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed + /usr/include + End of search list. + Compiler executable checksum: 419730b4853e824d20fe72cd5c71d7dd + COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH__=520' '-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-c' '-D' 'CUDA_DOUBLE_MATH_FUNCTIONS' '-v' '-Wno-psabi' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-m64' '-o' 'CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_95279.dir/' + as -v -I /opt/cuda/bin/../targets/x86_64-linux/include --64 -o CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o /tmp/ccDygrw0.s + GNU assembler version 2.44.0 (x86_64-pc-linux-gnu) using BFD version (GNU Binutils) 2.44.0 + COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/ + LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH__=520' '-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-c' '-D' 'CUDA_DOUBLE_MATH_FUNCTIONS' '-v' '-Wno-psabi' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-m64' '-o' 'CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.' + [2/2] : && /usr/bin/g++-14 -v -Wl,-v CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o -o cmTC_95279 -lcudadevrt -lcudart_static -lrt -lpthread -ldl -L"/opt/cuda/targets/x86_64-linux/lib/stubs" -L"/opt/cuda/targets/x86_64-linux/lib" && : + Using built-in specs. + COLLECT_GCC=/usr/bin/g++-14 + COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper + Target: x86_64-pc-linux-gnu + Configured with: /build/gcc14/src/gcc14/configure --enable-languages=c,c++,fortran --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc14/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --disable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror --program-suffix=-14 --enable-version-specific-runtime-libs + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 14.2.1 20250207 (GCC) + COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/ + LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_95279' '-L/opt/cuda/targets/x86_64-linux/lib/stubs' '-L/opt/cuda/targets/x86_64-linux/lib' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_95279.' + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/collect2 -plugin /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper -plugin-opt=-fresolution=/tmp/ccq3nD3S.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -o cmTC_95279 /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o -L/opt/cuda/targets/x86_64-linux/lib/stubs -L/opt/cuda/targets/x86_64-linux/lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1 -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib -L/lib/../lib -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../.. -v CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o -lcudadevrt -lcudart_static -lrt -lpthread -ldl -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o + collect2 version 14.2.1 20250207 + /usr/bin/ld -plugin /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper -plugin-opt=-fresolution=/tmp/ccq3nD3S.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -o cmTC_95279 /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o -L/opt/cuda/targets/x86_64-linux/lib/stubs -L/opt/cuda/targets/x86_64-linux/lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1 -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib -L/lib/../lib -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../.. -v CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o -lcudadevrt -lcudart_static -lrt -lpthread -ldl -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o + GNU ld (GNU Binutils) 2.44.0 + COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_95279' '-L/opt/cuda/targets/x86_64-linux/lib/stubs' '-L/opt/cuda/targets/x86_64-linux/lib' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_95279.' + + exitCode: 0 + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerABI.cmake:191 (message)" + - "/usr/share/cmake/Modules/CMakeTestCUDACompiler.cmake:19 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + message: | + Parsed CUDA implicit include dir info: rv=done + found start of include info + found start of implicit include info + add: [/opt/cuda/bin/../targets/x86_64-linux/include] + add: [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++] + add: [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu] + add: [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward] + add: [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include] + add: [/usr/local/include] + add: [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed] + add: [/usr/include] + end of search list found + collapse include dir [/opt/cuda/bin/../targets/x86_64-linux/include] ==> [/opt/cuda/targets/x86_64-linux/include] + collapse include dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++] ==> [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++] + collapse include dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu] ==> [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu] + collapse include dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward] ==> [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward] + collapse include dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include] ==> [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include] + collapse include dir [/usr/local/include] ==> [/usr/local/include] + collapse include dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed] ==> [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed] + collapse include dir [/usr/include] ==> [/usr/include] + implicit include dirs: [/opt/cuda/targets/x86_64-linux/include;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include;/usr/local/include;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed;/usr/include] + + + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerABI.cmake:227 (message)" + - "/usr/share/cmake/Modules/CMakeTestCUDACompiler.cmake:19 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + message: | + Parsed CUDA implicit link information: + link line regex: [^( *|.*[/\\])(ld[0-9]*(|\\.[a-rt-z][a-z]*|\\.s[a-np-z][a-z]*|\\.so[a-z]+)|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\\]+-)?ld|collect2)[^/\\]*( |$)] + linker tool regex: [^[ ]*(->|")?[ ]*(([^"]*[/\\])?(ld[0-9]*(|\\.[a-rt-z][a-z]*|\\.s[a-np-z][a-z]*|\\.so[a-z]+)))("|,| |$)] + ignore line: [Change Dir: '/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/CMakeScratch/TryCompile-1bJ2lk'] + ignore line: [] + ignore line: [Run Build Command(s): /usr/bin/ninja -v cmTC_95279] + ignore line: [[1/2] /opt/cuda/bin/nvcc -forward-unknown-to-host-compiler "--generate-code=arch=compute_52 code=[compute_52 sm_52]" -Xcompiler=-v -MD -MT CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o -MF CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o.d -x cu -c /usr/share/cmake/Modules/CMakeCUDACompilerABI.cu -o CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o] + ignore line: [nvcc warning : Support for offline compilation for architectures prior to '_75' will be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning).] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/g++-14] + ignore line: [Target: x86_64-pc-linux-gnu] + ignore line: [Configured with: /build/gcc14/src/gcc14/configure --enable-languages=c c++ fortran --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc14/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --disable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror --program-suffix=-14 --enable-version-specific-runtime-libs] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 14.2.1 20250207 (GCC) ] + ignore line: [COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH__=520' '-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-E' '-D' 'CUDA_DOUBLE_MATH_FUNCTIONS' '-D' '__CUDACC__' '-D' '__NVCC__' '-v' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=8' '-D' '__CUDACC_VER_BUILD__=93' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=8' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-D' '__CUDACC_DEVICE_ATOMIC_BUILTINS__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00002f26_00000000-7_CMakeCUDACompilerABI.cpp1.ii' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/'] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/cc1plus -E -quiet -v -I /opt/cuda/bin/../targets/x86_64-linux/include -D_GNU_SOURCE -D __CUDA_ARCH__=520 -D __CUDA_ARCH_LIST__=520 -D __NV_LEGACY_LAUNCH -D CUDA_DOUBLE_MATH_FUNCTIONS -D __CUDACC__ -D __NVCC__ -D __CUDACC_VER_MAJOR__=12 -D __CUDACC_VER_MINOR__=8 -D __CUDACC_VER_BUILD__=93 -D __CUDA_API_VER_MAJOR__=12 -D __CUDA_API_VER_MINOR__=8 -D __NVCC_DIAG_PRAGMA_SUPPORT__=1 -D __CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -include cuda_runtime.h /usr/share/cmake/Modules/CMakeCUDACompilerABI.cu -o /tmp/tmpxft_00002f26_00000000-7_CMakeCUDACompilerABI.cpp1.ii -m64 -mtune=generic -march=x86-64 -dumpdir /tmp/ -dumpbase tmpxft_00002f26_00000000-7_CMakeCUDACompilerABI.cpp1.cu -dumpbase-ext .cu] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../x86_64-pc-linux-gnu/include"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /opt/cuda/bin/../targets/x86_64-linux/include] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include] + ignore line: [ /usr/local/include] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed] + ignore line: [ /usr/include] + ignore line: [End of search list.] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH__=520' '-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-E' '-D' 'CUDA_DOUBLE_MATH_FUNCTIONS' '-D' '__CUDACC__' '-D' '__NVCC__' '-v' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=8' '-D' '__CUDACC_VER_BUILD__=93' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=8' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-D' '__CUDACC_DEVICE_ATOMIC_BUILTINS__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00002f26_00000000-7_CMakeCUDACompilerABI.cpp1.ii' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/tmpxft_00002f26_00000000-7_CMakeCUDACompilerABI.cpp1.'] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/g++-14] + ignore line: [Target: x86_64-pc-linux-gnu] + ignore line: [Configured with: /build/gcc14/src/gcc14/configure --enable-languages=c c++ fortran --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc14/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --disable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror --program-suffix=-14 --enable-version-specific-runtime-libs] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 14.2.1 20250207 (GCC) ] + ignore line: [COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-E' '-D' '__CUDACC__' '-D' '__NVCC__' '-v' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=8' '-D' '__CUDACC_VER_BUILD__=93' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=8' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-D' '__CUDACC_DEVICE_ATOMIC_BUILTINS__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00002f26_00000000-5_CMakeCUDACompilerABI.cpp4.ii' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/'] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/cc1plus -E -quiet -v -I /opt/cuda/bin/../targets/x86_64-linux/include -D_GNU_SOURCE -D __CUDA_ARCH_LIST__=520 -D __NV_LEGACY_LAUNCH -D __CUDACC__ -D __NVCC__ -D __CUDACC_VER_MAJOR__=12 -D __CUDACC_VER_MINOR__=8 -D __CUDACC_VER_BUILD__=93 -D __CUDA_API_VER_MAJOR__=12 -D __CUDA_API_VER_MINOR__=8 -D __NVCC_DIAG_PRAGMA_SUPPORT__=1 -D __CUDACC_DEVICE_ATOMIC_BUILTINS__=1 -include cuda_runtime.h /usr/share/cmake/Modules/CMakeCUDACompilerABI.cu -o /tmp/tmpxft_00002f26_00000000-5_CMakeCUDACompilerABI.cpp4.ii -m64 -mtune=generic -march=x86-64 -dumpdir /tmp/ -dumpbase tmpxft_00002f26_00000000-5_CMakeCUDACompilerABI.cpp4.cu -dumpbase-ext .cu] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../x86_64-pc-linux-gnu/include"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /opt/cuda/bin/../targets/x86_64-linux/include] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include] + ignore line: [ /usr/local/include] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed] + ignore line: [ /usr/include] + ignore line: [End of search list.] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-E' '-D' '__CUDACC__' '-D' '__NVCC__' '-v' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=8' '-D' '__CUDACC_VER_BUILD__=93' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=8' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-D' '__CUDACC_DEVICE_ATOMIC_BUILTINS__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00002f26_00000000-5_CMakeCUDACompilerABI.cpp4.ii' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/tmpxft_00002f26_00000000-5_CMakeCUDACompilerABI.cpp4.'] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/g++-14] + ignore line: [Target: x86_64-pc-linux-gnu] + ignore line: [Configured with: /build/gcc14/src/gcc14/configure --enable-languages=c c++ fortran --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc14/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --disable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror --program-suffix=-14 --enable-version-specific-runtime-libs] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 14.2.1 20250207 (GCC) ] + ignore line: [COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH__=520' '-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-c' '-D' 'CUDA_DOUBLE_MATH_FUNCTIONS' '-v' '-Wno-psabi' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-m64' '-o' 'CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_95279.dir/'] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/cc1plus -quiet -v -I /opt/cuda/bin/../targets/x86_64-linux/include -D_GNU_SOURCE -D __CUDA_ARCH__=520 -D __CUDA_ARCH_LIST__=520 -D __NV_LEGACY_LAUNCH -D CUDA_DOUBLE_MATH_FUNCTIONS /tmp/tmpxft_00002f26_00000000-6_CMakeCUDACompilerABI.cudafe1.cpp -quiet -dumpdir CMakeFiles/cmTC_95279.dir/ -dumpbase CMakeCUDACompilerABI.cu.cpp -dumpbase-ext .cpp -m64 -mtune=generic -march=x86-64 -Wno-psabi -version -o /tmp/ccDygrw0.s] + ignore line: [GNU C++17 (GCC) version 14.2.1 20250207 (x86_64-pc-linux-gnu)] + ignore line: [ compiled by GNU C version 14.2.1 20250207 GMP version 6.3.0 MPFR version 4.2.2 MPC version 1.3.1 isl version isl-0.27-GMP] + ignore line: [] + ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../x86_64-pc-linux-gnu/include"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /opt/cuda/bin/../targets/x86_64-linux/include] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/x86_64-pc-linux-gnu] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/c++/backward] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include] + ignore line: [ /usr/local/include] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed] + ignore line: [ /usr/include] + ignore line: [End of search list.] + ignore line: [Compiler executable checksum: 419730b4853e824d20fe72cd5c71d7dd] + ignore line: [COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH__=520' '-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-c' '-D' 'CUDA_DOUBLE_MATH_FUNCTIONS' '-v' '-Wno-psabi' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-m64' '-o' 'CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_95279.dir/'] + ignore line: [ as -v -I /opt/cuda/bin/../targets/x86_64-linux/include --64 -o CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o /tmp/ccDygrw0.s] + ignore line: [GNU assembler version 2.44.0 (x86_64-pc-linux-gnu) using BFD version (GNU Binutils) 2.44.0] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH__=520' '-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-c' '-D' 'CUDA_DOUBLE_MATH_FUNCTIONS' '-v' '-Wno-psabi' '-I' '/opt/cuda/bin/../targets/x86_64-linux/include' '-m64' '-o' 'CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.'] + ignore line: [[2/2] : && /usr/bin/g++-14 -v -Wl,-v CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o -o cmTC_95279 -lcudadevrt -lcudart_static -lrt -lpthread -ldl -L"/opt/cuda/targets/x86_64-linux/lib/stubs" -L"/opt/cuda/targets/x86_64-linux/lib" && :] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/g++-14] + ignore line: [COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper] + ignore line: [Target: x86_64-pc-linux-gnu] + ignore line: [Configured with: /build/gcc14/src/gcc14/configure --enable-languages=c c++ fortran --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc14/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --disable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror --program-suffix=-14 --enable-version-specific-runtime-libs] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 14.2.1 20250207 (GCC) ] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_95279' '-L/opt/cuda/targets/x86_64-linux/lib/stubs' '-L/opt/cuda/targets/x86_64-linux/lib' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_95279.'] + link line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/collect2 -plugin /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper -plugin-opt=-fresolution=/tmp/ccq3nD3S.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -o cmTC_95279 /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o -L/opt/cuda/targets/x86_64-linux/lib/stubs -L/opt/cuda/targets/x86_64-linux/lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1 -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib -L/lib/../lib -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../.. -v CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o -lcudadevrt -lcudart_static -lrt -lpthread -ldl -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o] + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/collect2] ==> ignore + arg [-plugin] ==> ignore + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/liblto_plugin.so] ==> ignore + arg [-plugin-opt=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper] ==> ignore + arg [-plugin-opt=-fresolution=/tmp/ccq3nD3S.res] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc] ==> ignore + arg [-plugin-opt=-pass-through=-lc] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc] ==> ignore + arg [--build-id] ==> ignore + arg [--eh-frame-hdr] ==> ignore + arg [--hash-style=gnu] ==> ignore + arg [-m] ==> ignore + arg [elf_x86_64] ==> ignore + arg [-dynamic-linker] ==> ignore + arg [/lib64/ld-linux-x86-64.so.2] ==> ignore + arg [-pie] ==> ignore + arg [-o] ==> ignore + arg [cmTC_95279] ==> ignore + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o] ==> obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o] + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o] ==> obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o] + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o] ==> obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o] + arg [-L/opt/cuda/targets/x86_64-linux/lib/stubs] ==> dir [/opt/cuda/targets/x86_64-linux/lib/stubs] + arg [-L/opt/cuda/targets/x86_64-linux/lib] ==> dir [/opt/cuda/targets/x86_64-linux/lib] + arg [-L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1] ==> dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1] + arg [-L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib] ==> dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib] + arg [-L/lib/../lib] ==> dir [/lib/../lib] + arg [-L/usr/lib/../lib] ==> dir [/usr/lib/../lib] + arg [-L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../..] ==> dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../..] + arg [-v] ==> ignore + arg [CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o] ==> ignore + arg [-lcudadevrt] ==> lib [cudadevrt] + arg [-lcudart_static] ==> lib [cudart_static] + arg [-lrt] ==> lib [rt] + arg [-lpthread] ==> lib [pthread] + arg [-ldl] ==> lib [dl] + arg [-lstdc++] ==> lib [stdc++] + arg [-lm] ==> lib [m] + arg [-lgcc_s] ==> lib [gcc_s] + arg [-lgcc] ==> lib [gcc] + arg [-lc] ==> lib [c] + arg [-lgcc_s] ==> lib [gcc_s] + arg [-lgcc] ==> lib [gcc] + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o] ==> obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o] + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o] ==> obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o] + ignore line: [collect2 version 14.2.1 20250207] + ignore line: [/usr/bin/ld -plugin /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper -plugin-opt=-fresolution=/tmp/ccq3nD3S.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -o cmTC_95279 /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o -L/opt/cuda/targets/x86_64-linux/lib/stubs -L/opt/cuda/targets/x86_64-linux/lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1 -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib -L/lib/../lib -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../.. -v CMakeFiles/cmTC_95279.dir/CMakeCUDACompilerABI.cu.o -lcudadevrt -lcudart_static -lrt -lpthread -ldl -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o] + linker tool for 'CUDA': /usr/bin/ld + collapse obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o] ==> [/usr/lib/Scrt1.o] + collapse obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o] ==> [/usr/lib/crti.o] + collapse obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o] ==> [/usr/lib/crtn.o] + collapse library dir [/opt/cuda/targets/x86_64-linux/lib/stubs] ==> [/opt/cuda/targets/x86_64-linux/lib/stubs] + collapse library dir [/opt/cuda/targets/x86_64-linux/lib] ==> [/opt/cuda/targets/x86_64-linux/lib] + collapse library dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1] ==> [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1] + collapse library dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib] ==> [/usr/lib] + collapse library dir [/lib/../lib] ==> [/lib] + collapse library dir [/usr/lib/../lib] ==> [/usr/lib] + collapse library dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../..] ==> [/usr/lib] + implicit libs: [cudadevrt;cudart_static;rt;pthread;dl;stdc++;m;gcc_s;gcc;c;gcc_s;gcc] + implicit objs: [/usr/lib/Scrt1.o;/usr/lib/crti.o;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o;/usr/lib/crtn.o] + implicit dirs: [/opt/cuda/targets/x86_64-linux/lib/stubs;/opt/cuda/targets/x86_64-linux/lib;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1;/usr/lib;/lib] + implicit fwks: [] + + + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/Internal/CMakeDetermineLinkerId.cmake:36 (message)" + - "/usr/share/cmake/Modules/CMakeDetermineCompilerABI.cmake:270 (cmake_determine_linker_id)" + - "/usr/share/cmake/Modules/CMakeTestCUDACompiler.cmake:19 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + message: | + Running the CUDA compiler's linker: "/usr/bin/ld" "-v" + GNU ld (GNU Binutils) 2.44.0 + - + kind: "try_compile-v1" + backtrace: + - "/usr/share/cmake/Modules/Internal/CheckSourceCompiles.cmake:104 (try_compile)" + - "/usr/share/cmake/Modules/CheckCXXSourceCompiles.cmake:58 (cmake_check_source_compiles)" + - "/usr/share/cmake/Modules/FindThreads.cmake:99 (check_cxx_source_compiles)" + - "/usr/share/cmake/Modules/FindThreads.cmake:163 (_threads_check_libc)" + - "/usr/share/cmake/Modules/FindCUDAToolkit.cmake:1207 (find_package)" + - "CMakeLists.txt:9 (find_package)" + checks: + - "Performing Test CMAKE_HAVE_LIBC_PTHREAD" + directories: + source: "/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/CMakeScratch/TryCompile-bQPacS" + binary: "/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/CMakeScratch/TryCompile-bQPacS" + cmakeVariables: + CMAKE_CUDA_ARCHITECTURES: "52" + CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS: "/usr/bin/clang-scan-deps" + CMAKE_CXX_FLAGS: "" + CMAKE_CXX_FLAGS_DEBUG: "-g" + CMAKE_EXE_LINKER_FLAGS: "" + buildResult: + variable: "CMAKE_HAVE_LIBC_PTHREAD" + cached: true + stdout: | + Change Dir: '/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/CMakeScratch/TryCompile-bQPacS' + + Run Build Command(s): /usr/bin/ninja -v cmTC_2ca95 + [1/2] /usr/bin/clang++ -DCMAKE_HAVE_LIBC_PTHREAD -std=gnu++17 -MD -MT CMakeFiles/cmTC_2ca95.dir/src.cxx.o -MF CMakeFiles/cmTC_2ca95.dir/src.cxx.o.d -o CMakeFiles/cmTC_2ca95.dir/src.cxx.o -c /home/tobli/abo/pprog/Homework-3/build/CMakeFiles/CMakeScratch/TryCompile-bQPacS/src.cxx + [2/2] : && /usr/bin/clang++ CMakeFiles/cmTC_2ca95.dir/src.cxx.o -o cmTC_2ca95 && : + + exitCode: 0 +... diff --git a/build/CMakeFiles/InstallScripts.json b/build/CMakeFiles/InstallScripts.json new file mode 100644 index 0000000..26e19ed --- /dev/null +++ b/build/CMakeFiles/InstallScripts.json @@ -0,0 +1,7 @@ +{ + "InstallScripts" : + [ + "/home/tobli/abo/pprog/Homework-3/build/cmake_install.cmake" + ], + "Parallel" : false +} diff --git a/build/CMakeFiles/TargetDirectories.txt b/build/CMakeFiles/TargetDirectories.txt new file mode 100644 index 0000000..af662ce --- /dev/null +++ b/build/CMakeFiles/TargetDirectories.txt @@ -0,0 +1,3 @@ +/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/app.dir +/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/edit_cache.dir +/home/tobli/abo/pprog/Homework-3/build/CMakeFiles/rebuild_cache.dir diff --git a/build/CMakeFiles/cmake.check_cache b/build/CMakeFiles/cmake.check_cache new file mode 100644 index 0000000..3dccd73 --- /dev/null +++ b/build/CMakeFiles/cmake.check_cache @@ -0,0 +1 @@ +# This file is generated by cmake for dependency checking of the CMakeCache.txt file diff --git a/build/CMakeFiles/rules.ninja b/build/CMakeFiles/rules.ninja new file mode 100644 index 0000000..54abbc4 --- /dev/null +++ b/build/CMakeFiles/rules.ninja @@ -0,0 +1,73 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Ninja" Generator, CMake Version 4.0 + +# This file contains all the rules used to get the outputs files +# built from the input files. +# It is included in the main 'build.ninja'. + +# ============================================================================= +# Project: app +# Configurations: Debug +# ============================================================================= +# ============================================================================= + +############################################# +# Rule for compiling CUDA files. + +rule CUDA_COMPILER__app_unscanned_Debug + depfile = $DEP_FILE + deps = gcc + command = ${LAUNCHER}${CODE_CHECK}/opt/cuda/bin/nvcc -forward-unknown-to-host-compiler $DEFINES $INCLUDES $FLAGS -MD -MT $out -MF $DEP_FILE -x cu -rdc=true -c $in -o $out + description = Building CUDA object $out + + +############################################# +# Rule for linking CUDA executable. + +rule CUDA_EXECUTABLE_DEVICE_LINKER__app_Debug + command = /opt/cuda/bin/nvcc -forward-unknown-to-host-compiler $LANGUAGE_COMPILE_FLAGS $LINK_FLAGS -Xcompiler=-fPIC -Wno-deprecated-gpu-targets -shared -dlink $in -o $TARGET_FILE $LINK_PATH $LINK_LIBRARIES + description = Linking CUDA executable $TARGET_FILE + restat = $RESTAT + + +############################################# +# Rule for linking CUDA executable. + +rule CUDA_EXECUTABLE_LINKER__app_Debug + command = $PRE_LINK && /usr/bin/g++-14 $LINK_FLAGS $in -o $TARGET_FILE $LINK_PATH $LINK_LIBRARIES -L"/opt/cuda/targets/x86_64-linux/lib/stubs" -L"/opt/cuda/targets/x86_64-linux/lib" && $POST_BUILD + description = Linking CUDA executable $TARGET_FILE + restat = $RESTAT + + +############################################# +# Rule for running custom commands. + +rule CUSTOM_COMMAND + command = $COMMAND + description = $DESC + + +############################################# +# Rule for re-running cmake. + +rule RERUN_CMAKE + command = /usr/bin/cmake --regenerate-during-build -S/home/tobli/abo/pprog/Homework-3 -B/home/tobli/abo/pprog/Homework-3/build + description = Re-running CMake... + generator = 1 + + +############################################# +# Rule for cleaning all built files. + +rule CLEAN + command = /usr/bin/ninja $FILE_ARG -t clean $TARGETS + description = Cleaning all built files... + + +############################################# +# Rule for printing all primary targets available. + +rule HELP + command = /usr/bin/ninja -t targets + description = All primary targets available: + diff --git a/build/build.ninja b/build/build.ninja new file mode 100644 index 0000000..e308d67 --- /dev/null +++ b/build/build.ninja @@ -0,0 +1,160 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Ninja" Generator, CMake Version 4.0 + +# This file contains all the build statements describing the +# compilation DAG. + +# ============================================================================= +# Write statements declared in CMakeLists.txt: +# +# Which is the root file. +# ============================================================================= + +# ============================================================================= +# Project: app +# Configurations: Debug +# ============================================================================= + +############################################# +# Minimal version of Ninja required by this file + +ninja_required_version = 1.5 + + +############################################# +# Set configuration variable for custom commands. + +CONFIGURATION = Debug +# ============================================================================= +# Include auxiliary files. + + +############################################# +# Include rules file. + +include CMakeFiles/rules.ninja + +# ============================================================================= + +############################################# +# Logical path to working directory; prefix for absolute paths. + +cmake_ninja_workdir = /home/tobli/abo/pprog/Homework-3/build/ +# ============================================================================= +# Object build statements for EXECUTABLE target app + + +############################################# +# Order-only phony target for app + +build cmake_object_order_depends_target_app: phony || . + +build CMakeFiles/app.dir/main.cu.o: CUDA_COMPILER__app_unscanned_Debug /home/tobli/abo/pprog/Homework-3/main.cu || cmake_object_order_depends_target_app + CONFIG = Debug + DEP_FILE = CMakeFiles/app.dir/main.cu.o.d + FLAGS = -g -std=c++17 "--generate-code=arch=compute_60,code=[compute_60,sm_60]" + INCLUDES = -isystem /opt/cuda/targets/x86_64-linux/include + OBJECT_DIR = CMakeFiles/app.dir + OBJECT_FILE_DIR = CMakeFiles/app.dir + + +# ============================================================================= +# Device Link build statements for EXECUTABLE target app + + +############################################# +# Link the executable CMakeFiles/app.dir/cmake_device_link.o + +build CMakeFiles/app.dir/cmake_device_link.o: CUDA_EXECUTABLE_DEVICE_LINKER__app_Debug CMakeFiles/app.dir/main.cu.o | /opt/cuda/targets/x86_64-linux/lib/libcudart.so /usr/lib/librt.a + LANGUAGE_COMPILE_FLAGS = -g "--generate-code=arch=compute_60,code=[compute_60,sm_60]" + LINK_LIBRARIES = -ldl /usr/lib/librt.a -lcudadevrt -lcudart_static -lrt -lpthread + OBJECT_DIR = CMakeFiles/app.dir + TARGET_FILE = CMakeFiles/app.dir/cmake_device_link.o + +# ============================================================================= +# Link build statements for EXECUTABLE target app + + +############################################# +# Link the executable app + +build app: CUDA_EXECUTABLE_LINKER__app_Debug CMakeFiles/app.dir/main.cu.o CMakeFiles/app.dir/cmake_device_link.o | /opt/cuda/targets/x86_64-linux/lib/libcudart.so /usr/lib/librt.a + CONFIG = Debug + FLAGS = -g "--generate-code=arch=compute_60,code=[compute_60,sm_60]" + LINK_LIBRARIES = /opt/cuda/targets/x86_64-linux/lib/libcudart.so -ldl /usr/lib/librt.a -lcudadevrt -lcudart_static -lrt -lpthread -ldl + OBJECT_DIR = CMakeFiles/app.dir + POST_BUILD = : + PRE_LINK = : + TARGET_FILE = app + TARGET_PDB = app.dbg + + +############################################# +# Utility command for edit_cache + +build CMakeFiles/edit_cache.util: CUSTOM_COMMAND + COMMAND = cd /home/tobli/abo/pprog/Homework-3/build && /usr/bin/ccmake -S/home/tobli/abo/pprog/Homework-3 -B/home/tobli/abo/pprog/Homework-3/build + DESC = Running CMake cache editor... + pool = console + restat = 1 + +build edit_cache: phony CMakeFiles/edit_cache.util + + +############################################# +# Utility command for rebuild_cache + +build CMakeFiles/rebuild_cache.util: CUSTOM_COMMAND + COMMAND = cd /home/tobli/abo/pprog/Homework-3/build && /usr/bin/cmake --regenerate-during-build -S/home/tobli/abo/pprog/Homework-3 -B/home/tobli/abo/pprog/Homework-3/build + DESC = Running CMake to regenerate build system... + pool = console + restat = 1 + +build rebuild_cache: phony CMakeFiles/rebuild_cache.util + +# ============================================================================= +# Target aliases. + +# ============================================================================= +# Folder targets. + +# ============================================================================= + +############################################# +# Folder: /home/tobli/abo/pprog/Homework-3/build + +build all: phony app + +# ============================================================================= +# Built-in targets + + +############################################# +# Re-run CMake if any of its inputs changed. + +build build.ninja /home/tobli/abo/pprog/Homework-3/build/cmake_install.cmake: RERUN_CMAKE | /home/tobli/abo/pprog/Homework-3/CMakeLists.txt /usr/share/cmake/Modules/CMakeCUDAInformation.cmake /usr/share/cmake/Modules/CMakeCXXInformation.cmake /usr/share/cmake/Modules/CMakeCommonLanguageInclude.cmake /usr/share/cmake/Modules/CMakeGenericSystem.cmake /usr/share/cmake/Modules/CMakeInitializeConfigs.cmake /usr/share/cmake/Modules/CMakeLanguageInformation.cmake /usr/share/cmake/Modules/CMakeSystemSpecificInformation.cmake /usr/share/cmake/Modules/CMakeSystemSpecificInitialize.cmake /usr/share/cmake/Modules/CheckCXXSourceCompiles.cmake /usr/share/cmake/Modules/CheckIncludeFileCXX.cmake /usr/share/cmake/Modules/CheckLibraryExists.cmake /usr/share/cmake/Modules/Compiler/CMakeCommonCompilerMacros.cmake /usr/share/cmake/Modules/Compiler/Clang-CXX.cmake /usr/share/cmake/Modules/Compiler/Clang.cmake /usr/share/cmake/Modules/Compiler/GNU.cmake /usr/share/cmake/Modules/Compiler/NVIDIA-CUDA.cmake /usr/share/cmake/Modules/Compiler/NVIDIA.cmake /usr/share/cmake/Modules/FindCUDAToolkit.cmake /usr/share/cmake/Modules/FindPackageHandleStandardArgs.cmake /usr/share/cmake/Modules/FindPackageMessage.cmake /usr/share/cmake/Modules/FindThreads.cmake /usr/share/cmake/Modules/Internal/CMakeCXXLinkerInformation.cmake /usr/share/cmake/Modules/Internal/CMakeCommonLinkerInformation.cmake /usr/share/cmake/Modules/Internal/CheckSourceCompiles.cmake /usr/share/cmake/Modules/Linker/GNU-CXX.cmake /usr/share/cmake/Modules/Linker/GNU.cmake /usr/share/cmake/Modules/Platform/Linker/GNU.cmake /usr/share/cmake/Modules/Platform/Linker/Linux-GNU-CXX.cmake /usr/share/cmake/Modules/Platform/Linker/Linux-GNU.cmake /usr/share/cmake/Modules/Platform/Linux-Clang-CXX.cmake /usr/share/cmake/Modules/Platform/Linux-GNU-CXX.cmake /usr/share/cmake/Modules/Platform/Linux-GNU.cmake /usr/share/cmake/Modules/Platform/Linux-Initialize.cmake /usr/share/cmake/Modules/Platform/Linux-NVIDIA-CUDA.cmake /usr/share/cmake/Modules/Platform/Linux.cmake /usr/share/cmake/Modules/Platform/UnixPaths.cmake CMakeCache.txt CMakeFiles/4.0.2-dirty/CMakeCUDACompiler.cmake CMakeFiles/4.0.2-dirty/CMakeCXXCompiler.cmake CMakeFiles/4.0.2-dirty/CMakeSystem.cmake + pool = console + + +############################################# +# A missing CMake input file is not an error. + +build /home/tobli/abo/pprog/Homework-3/CMakeLists.txt /usr/share/cmake/Modules/CMakeCUDAInformation.cmake /usr/share/cmake/Modules/CMakeCXXInformation.cmake /usr/share/cmake/Modules/CMakeCommonLanguageInclude.cmake /usr/share/cmake/Modules/CMakeGenericSystem.cmake /usr/share/cmake/Modules/CMakeInitializeConfigs.cmake /usr/share/cmake/Modules/CMakeLanguageInformation.cmake /usr/share/cmake/Modules/CMakeSystemSpecificInformation.cmake /usr/share/cmake/Modules/CMakeSystemSpecificInitialize.cmake /usr/share/cmake/Modules/CheckCXXSourceCompiles.cmake /usr/share/cmake/Modules/CheckIncludeFileCXX.cmake /usr/share/cmake/Modules/CheckLibraryExists.cmake /usr/share/cmake/Modules/Compiler/CMakeCommonCompilerMacros.cmake /usr/share/cmake/Modules/Compiler/Clang-CXX.cmake /usr/share/cmake/Modules/Compiler/Clang.cmake /usr/share/cmake/Modules/Compiler/GNU.cmake /usr/share/cmake/Modules/Compiler/NVIDIA-CUDA.cmake /usr/share/cmake/Modules/Compiler/NVIDIA.cmake /usr/share/cmake/Modules/FindCUDAToolkit.cmake /usr/share/cmake/Modules/FindPackageHandleStandardArgs.cmake /usr/share/cmake/Modules/FindPackageMessage.cmake /usr/share/cmake/Modules/FindThreads.cmake /usr/share/cmake/Modules/Internal/CMakeCXXLinkerInformation.cmake /usr/share/cmake/Modules/Internal/CMakeCommonLinkerInformation.cmake /usr/share/cmake/Modules/Internal/CheckSourceCompiles.cmake /usr/share/cmake/Modules/Linker/GNU-CXX.cmake /usr/share/cmake/Modules/Linker/GNU.cmake /usr/share/cmake/Modules/Platform/Linker/GNU.cmake /usr/share/cmake/Modules/Platform/Linker/Linux-GNU-CXX.cmake /usr/share/cmake/Modules/Platform/Linker/Linux-GNU.cmake /usr/share/cmake/Modules/Platform/Linux-Clang-CXX.cmake /usr/share/cmake/Modules/Platform/Linux-GNU-CXX.cmake /usr/share/cmake/Modules/Platform/Linux-GNU.cmake /usr/share/cmake/Modules/Platform/Linux-Initialize.cmake /usr/share/cmake/Modules/Platform/Linux-NVIDIA-CUDA.cmake /usr/share/cmake/Modules/Platform/Linux.cmake /usr/share/cmake/Modules/Platform/UnixPaths.cmake CMakeCache.txt CMakeFiles/4.0.2-dirty/CMakeCUDACompiler.cmake CMakeFiles/4.0.2-dirty/CMakeCXXCompiler.cmake CMakeFiles/4.0.2-dirty/CMakeSystem.cmake: phony + + +############################################# +# Clean all the built files. + +build clean: CLEAN + + +############################################# +# Print all primary targets available. + +build help: HELP + + +############################################# +# Make the all target the default. + +default all diff --git a/build/cmake_install.cmake b/build/cmake_install.cmake new file mode 100644 index 0000000..f494a34 --- /dev/null +++ b/build/cmake_install.cmake @@ -0,0 +1,66 @@ +# Install script for directory: /home/tobli/abo/pprog/Homework-3 + +# Set the install prefix +if(NOT DEFINED CMAKE_INSTALL_PREFIX) + set(CMAKE_INSTALL_PREFIX "/usr/local") +endif() +string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") + +# Set the install configuration name. +if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) + if(BUILD_TYPE) + string(REGEX REPLACE "^[^A-Za-z0-9_]+" "" + CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}") + else() + set(CMAKE_INSTALL_CONFIG_NAME "Debug") + endif() + message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"") +endif() + +# Set the component getting installed. +if(NOT CMAKE_INSTALL_COMPONENT) + if(COMPONENT) + message(STATUS "Install component: \"${COMPONENT}\"") + set(CMAKE_INSTALL_COMPONENT "${COMPONENT}") + else() + set(CMAKE_INSTALL_COMPONENT) + endif() +endif() + +# Install shared libraries without execute permission? +if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE) + set(CMAKE_INSTALL_SO_NO_EXE "0") +endif() + +# Is this installation the result of a crosscompile? +if(NOT DEFINED CMAKE_CROSSCOMPILING) + set(CMAKE_CROSSCOMPILING "FALSE") +endif() + +# Set path to fallback-tool for dependency-resolution. +if(NOT DEFINED CMAKE_OBJDUMP) + set(CMAKE_OBJDUMP "/usr/bin/llvm-objdump") +endif() + +string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT + "${CMAKE_INSTALL_MANIFEST_FILES}") +if(CMAKE_INSTALL_LOCAL_ONLY) + file(WRITE "/home/tobli/abo/pprog/Homework-3/build/install_local_manifest.txt" + "${CMAKE_INSTALL_MANIFEST_CONTENT}") +endif() +if(CMAKE_INSTALL_COMPONENT) + if(CMAKE_INSTALL_COMPONENT MATCHES "^[a-zA-Z0-9_.+-]+$") + set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt") + else() + string(MD5 CMAKE_INST_COMP_HASH "${CMAKE_INSTALL_COMPONENT}") + set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INST_COMP_HASH}.txt") + unset(CMAKE_INST_COMP_HASH) + endif() +else() + set(CMAKE_INSTALL_MANIFEST "install_manifest.txt") +endif() + +if(NOT CMAKE_INSTALL_LOCAL_ONLY) + file(WRITE "/home/tobli/abo/pprog/Homework-3/build/${CMAKE_INSTALL_MANIFEST}" + "${CMAKE_INSTALL_MANIFEST_CONTENT}") +endif() diff --git a/build/compile_commands.json b/build/compile_commands.json new file mode 100644 index 0000000..c67bc93 --- /dev/null +++ b/build/compile_commands.json @@ -0,0 +1,8 @@ +[ +{ + "directory": "/home/tobli/abo/pprog/Homework-3/build", + "command": "/opt/cuda/bin/nvcc -forward-unknown-to-host-compiler -isystem /opt/cuda/targets/x86_64-linux/include -g -std=c++17 \"--generate-code=arch=compute_60,code=[compute_60,sm_60]\" -x cu -rdc=true -c /home/tobli/abo/pprog/Homework-3/main.cu -o CMakeFiles/app.dir/main.cu.o", + "file": "/home/tobli/abo/pprog/Homework-3/main.cu", + "output": "CMakeFiles/app.dir/main.cu.o" +} +] \ No newline at end of file diff --git a/cmake_install.cmake b/cmake_install.cmake new file mode 100644 index 0000000..d7a7ee6 --- /dev/null +++ b/cmake_install.cmake @@ -0,0 +1,66 @@ +# Install script for directory: /home/tobli/abo/pprog/Homework-3 + +# Set the install prefix +if(NOT DEFINED CMAKE_INSTALL_PREFIX) + set(CMAKE_INSTALL_PREFIX "/usr/local") +endif() +string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") + +# Set the install configuration name. +if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) + if(BUILD_TYPE) + string(REGEX REPLACE "^[^A-Za-z0-9_]+" "" + CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}") + else() + set(CMAKE_INSTALL_CONFIG_NAME "") + endif() + message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"") +endif() + +# Set the component getting installed. +if(NOT CMAKE_INSTALL_COMPONENT) + if(COMPONENT) + message(STATUS "Install component: \"${COMPONENT}\"") + set(CMAKE_INSTALL_COMPONENT "${COMPONENT}") + else() + set(CMAKE_INSTALL_COMPONENT) + endif() +endif() + +# Install shared libraries without execute permission? +if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE) + set(CMAKE_INSTALL_SO_NO_EXE "0") +endif() + +# Is this installation the result of a crosscompile? +if(NOT DEFINED CMAKE_CROSSCOMPILING) + set(CMAKE_CROSSCOMPILING "FALSE") +endif() + +# Set path to fallback-tool for dependency-resolution. +if(NOT DEFINED CMAKE_OBJDUMP) + set(CMAKE_OBJDUMP "/usr/bin/objdump") +endif() + +string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT + "${CMAKE_INSTALL_MANIFEST_FILES}") +if(CMAKE_INSTALL_LOCAL_ONLY) + file(WRITE "/home/tobli/abo/pprog/Homework-3/install_local_manifest.txt" + "${CMAKE_INSTALL_MANIFEST_CONTENT}") +endif() +if(CMAKE_INSTALL_COMPONENT) + if(CMAKE_INSTALL_COMPONENT MATCHES "^[a-zA-Z0-9_.+-]+$") + set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt") + else() + string(MD5 CMAKE_INST_COMP_HASH "${CMAKE_INSTALL_COMPONENT}") + set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INST_COMP_HASH}.txt") + unset(CMAKE_INST_COMP_HASH) + endif() +else() + set(CMAKE_INSTALL_MANIFEST "install_manifest.txt") +endif() + +if(NOT CMAKE_INSTALL_LOCAL_ONLY) + file(WRITE "/home/tobli/abo/pprog/Homework-3/${CMAKE_INSTALL_MANIFEST}" + "${CMAKE_INSTALL_MANIFEST_CONTENT}") +endif() diff --git a/data/0/run_cuda.log b/data/0/run_cuda.log new file mode 100644 index 0000000..45d3aec --- /dev/null +++ b/data/0/run_cuda.log @@ -0,0 +1 @@ +./test.sh: line 26: ./main: No such file or directory diff --git a/data/1/run_cuda.log b/data/1/run_cuda.log new file mode 100644 index 0000000..45d3aec --- /dev/null +++ b/data/1/run_cuda.log @@ -0,0 +1 @@ +./test.sh: line 26: ./main: No such file or directory diff --git a/data/2/run_cuda.log b/data/2/run_cuda.log new file mode 100644 index 0000000..45d3aec --- /dev/null +++ b/data/2/run_cuda.log @@ -0,0 +1 @@ +./test.sh: line 26: ./main: No such file or directory diff --git a/data/3/run_cuda.log b/data/3/run_cuda.log new file mode 100644 index 0000000..45d3aec --- /dev/null +++ b/data/3/run_cuda.log @@ -0,0 +1 @@ +./test.sh: line 26: ./main: No such file or directory diff --git a/data/4/run_cuda.log b/data/4/run_cuda.log new file mode 100644 index 0000000..45d3aec --- /dev/null +++ b/data/4/run_cuda.log @@ -0,0 +1 @@ +./test.sh: line 26: ./main: No such file or directory diff --git a/data/5/run_cuda.log b/data/5/run_cuda.log new file mode 100644 index 0000000..45d3aec --- /dev/null +++ b/data/5/run_cuda.log @@ -0,0 +1 @@ +./test.sh: line 26: ./main: No such file or directory diff --git a/data/6/run_cuda.log b/data/6/run_cuda.log new file mode 100644 index 0000000..45d3aec --- /dev/null +++ b/data/6/run_cuda.log @@ -0,0 +1 @@ +./test.sh: line 26: ./main: No such file or directory diff --git a/data/7/run_cuda.log b/data/7/run_cuda.log new file mode 100644 index 0000000..45d3aec --- /dev/null +++ b/data/7/run_cuda.log @@ -0,0 +1 @@ +./test.sh: line 26: ./main: No such file or directory diff --git a/data/8/run_cuda.log b/data/8/run_cuda.log new file mode 100644 index 0000000..45d3aec --- /dev/null +++ b/data/8/run_cuda.log @@ -0,0 +1 @@ +./test.sh: line 26: ./main: No such file or directory diff --git a/data/9/run_cuda.log b/data/9/run_cuda.log new file mode 100644 index 0000000..45d3aec --- /dev/null +++ b/data/9/run_cuda.log @@ -0,0 +1 @@ +./test.sh: line 26: ./main: No such file or directory diff --git a/main.cu b/main.cu index 50df6a1..132ff2a 100644 --- a/main.cu +++ b/main.cu @@ -1,43 +1,200 @@ #include #include #include +#include #include +#include +#include +#include +#include +// Naive CUDA kernel: each thread computes one C(i,j) __global__ void naive_cuda_matmul(float *C, float *A, float *B, uint32_t m, uint32_t n, uint32_t p) { - // TODO: Implement naive CUDA matrix multiplication + uint32_t row = blockIdx.y * blockDim.y + threadIdx.y; + uint32_t col = blockIdx.x * blockDim.x + threadIdx.x; + if (row < m && col < p) { + float sum = 0.0f; + for (uint32_t k = 0; k < n; ++k) { + sum += A[row * n + k] * B[k * p + col]; + } + C[row * p + col] = sum; + } } +// Tiled CUDA kernel: uses shared memory for A and B tiles __global__ void tiled_cuda_matmul(float *C, float *A, float *B, uint32_t m, uint32_t n, uint32_t p, uint32_t tile_width) { - // TODO: Implement tiled CUDA matrix multiplication + extern __shared__ float shared_mem[]; + float* As = shared_mem; + float* Bs = shared_mem + tile_width * tile_width; + + uint32_t row = blockIdx.y * tile_width + threadIdx.y; + uint32_t col = blockIdx.x * tile_width + threadIdx.x; + float sum = 0.0f; + + for (uint32_t t = 0; t < (n + tile_width - 1) / tile_width; ++t) { + // Load tiles into shared memory + uint32_t tiled_row = row; + uint32_t tiled_col = t * tile_width + threadIdx.x; + if (tiled_row < m && tiled_col < n) + As[threadIdx.y * tile_width + threadIdx.x] = A[tiled_row * n + tiled_col]; + else + As[threadIdx.y * tile_width + threadIdx.x] = 0.0f; + + tiled_row = t * tile_width + threadIdx.y; + tiled_col = col; + if (tiled_row < n && tiled_col < p) + Bs[threadIdx.y * tile_width + threadIdx.x] = B[tiled_row * p + tiled_col]; + else + Bs[threadIdx.y * tile_width + threadIdx.x] = 0.0f; + + __syncthreads(); + + for (uint32_t k = 0; k < tile_width; ++k) { + sum += As[threadIdx.y * tile_width + k] * Bs[k * tile_width + threadIdx.x]; + } + __syncthreads(); + } + if (row < m && col < p) + C[row * p + col] = sum; } +// Helper: Read raw float matrix from file +bool read_matrix(const std::string &filename, std::vector &mat, size_t size) { + std::ifstream in(filename, std::ios::binary); + if (!in) return false; + in.read(reinterpret_cast(mat.data()), size * sizeof(float)); + return in.good(); +} + +// Helper: Write raw float matrix to file +bool write_matrix(const std::string &filename, const std::vector &mat, size_t size) { + std::ofstream out(filename, std::ios::binary); + if (!out) return false; + out.write(reinterpret_cast(mat.data()), size * sizeof(float)); + return out.good(); +} + +// Helper: Validate result against reference bool validate_result(const std::string &result_file, const std::string &reference_file) { - // TODO: Implement result validation (same as Assignment 2) + std::ifstream res(result_file, std::ios::binary); + std::ifstream ref(reference_file, std::ios::binary); + if (!res || !ref) return false; + res.seekg(0, std::ios::end); + ref.seekg(0, std::ios::end); + size_t res_size = res.tellg(); + size_t ref_size = ref.tellg(); + if (res_size != ref_size) return false; + res.seekg(0); + ref.seekg(0); + std::vector res_buf(res_size), ref_buf(ref_size); + res.read(res_buf.data(), res_size); + ref.read(ref_buf.data(), ref_size); + return std::memcmp(res_buf.data(), ref_buf.data(), res_size) == 0; } int main(int argc, char *argv[]) { + // Example: ./main 0 1024 1024 1024 + if (argc < 5) { + std::cerr << "Usage: " << argv[0] << "

\n"; + return 1; + } + int case_number = std::stoi(argv[1]); + uint32_t m = std::stoul(argv[2]); + uint32_t n = std::stoul(argv[3]); + uint32_t p = std::stoul(argv[4]); + uint32_t tile_width = 16; // You can experiment with 16, 32, etc. + + std::string case_dir = "data/" + std::to_string(case_number) + "/"; + std::string a_file = case_dir + "input0.raw"; + std::string b_file = case_dir + "input1.raw"; + std::string c_file_naive = case_dir + "result_naive.raw"; + std::string c_file_tiled = case_dir + "result_tiled.raw"; + std::string ref_file = case_dir + "output.raw"; + + size_t size_A = m * n; + size_t size_B = n * p; + size_t size_C = m * p; + + std::vector h_A(size_A), h_B(size_B), h_C_naive(size_C), h_C_tiled(size_C); + + // Read input matrices + if (!read_matrix(a_file, h_A, size_A) || !read_matrix(b_file, h_B, size_B)) { + std::cerr << "Failed to read input files.\n"; + return 1; + } + + // Allocate device memory + float *d_A = nullptr, *d_B = nullptr, *d_C = nullptr; + cudaMalloc(&d_A, size_A * sizeof(float)); + cudaMalloc(&d_B, size_B * sizeof(float)); + cudaMalloc(&d_C, size_C * sizeof(float)); + + // --- Naive CUDA --- + cudaEvent_t start_naive, stop_naive; + cudaEventCreate(&start_naive); + cudaEventCreate(&stop_naive); + + cudaEventRecord(start_naive); + cudaMemcpy(d_A, h_A.data(), size_A * sizeof(float), cudaMemcpyHostToDevice); + cudaMemcpy(d_B, h_B.data(), size_B * sizeof(float), cudaMemcpyHostToDevice); + + dim3 threadsPerBlock(16, 16); + dim3 numBlocks((p + 15) / 16, (m + 15) / 16); + naive_cuda_matmul<<>>(d_C, d_A, d_B, m, n, p); + cudaDeviceSynchronize(); + + cudaMemcpy(h_C_naive.data(), d_C, size_C * sizeof(float), cudaMemcpyDeviceToHost); + cudaEventRecord(stop_naive); + cudaEventSynchronize(stop_naive); + + float naive_cuda_time = 0.0f; + cudaEventElapsedTime(&naive_cuda_time, start_naive, stop_naive); + naive_cuda_time /= 1000.0f; // ms to s + write_matrix(c_file_naive, h_C_naive, size_C); + bool valid_naive = validate_result(c_file_naive, ref_file); - // TODO: Read input0.raw (matrix A) and input1.raw (matrix B) + // --- Tiled CUDA --- + cudaEvent_t start_tiled, stop_tiled; + cudaEventCreate(&start_tiled); + cudaEventCreate(&stop_tiled); - // TODO: Use cudaMalloc and cudaMemcpy for GPU memory + cudaEventRecord(start_tiled); + cudaMemcpy(d_A, h_A.data(), size_A * sizeof(float), cudaMemcpyHostToDevice); + cudaMemcpy(d_B, h_B.data(), size_B * sizeof(float), cudaMemcpyHostToDevice); - // Measure naive CUDA performance - // TODO: Launch naive_cuda_matmul kernel + dim3 threadsPerBlockTiled(tile_width, tile_width); + dim3 numBlocksTiled((p + tile_width - 1) / tile_width, (m + tile_width - 1) / tile_width); + size_t shared_mem_size = 2 * tile_width * tile_width * sizeof(float); + tiled_cuda_matmul<<>>(d_C, d_A, d_B, m, n, p, tile_width); + cudaDeviceSynchronize(); - // TODO: Write naive CUDA result to file and validate - // Measure tiled CUDA performance + cudaMemcpy(h_C_tiled.data(), d_C, size_C * sizeof(float), cudaMemcpyDeviceToHost); + cudaEventRecord(stop_tiled); + cudaEventSynchronize(stop_tiled); - // TODO: Launch tiled_cuda_matmul kernel + float tiled_cuda_time = 0.0f; + cudaEventElapsedTime(&tiled_cuda_time, start_tiled, stop_tiled); + tiled_cuda_time /= 1000.0f; // ms to s - // TODO: Write tiled CUDA result to file and validate + write_matrix(c_file_tiled, h_C_tiled, size_C); + bool valid_tiled = validate_result(c_file_tiled, ref_file); // Print performance results std::cout << "Case " << case_number << " (" << m << "x" << n << "x" << p << "):\n"; - std::cout << "Naive CUDA time: " << naive_cuda_time << " seconds\n"; - std::cout << "Tiled CUDA time: " << tiled_cuda_time << " seconds\n"; + std::cout << "Naive CUDA time: " << naive_cuda_time << " seconds"; + std::cout << (valid_naive ? " [VALID]\n" : " [INVALID]\n"); + std::cout << "Tiled CUDA time: " << tiled_cuda_time << " seconds"; + std::cout << (valid_tiled ? " [VALID]\n" : " [INVALID]\n"); // Clean up + cudaFree(d_A); + cudaFree(d_B); + cudaFree(d_C); + cudaEventDestroy(start_naive); + cudaEventDestroy(stop_naive); + cudaEventDestroy(start_tiled); + cudaEventDestroy(stop_tiled); return 0; } \ No newline at end of file diff --git a/test.sh b/test.sh new file mode 100755 index 0000000..13f9e6d --- /dev/null +++ b/test.sh @@ -0,0 +1,32 @@ +#!/bin/sh + +# Usage: ./test.sh +# This script runs all CUDA test cases (0..9) using main.cu's executable. +# It expects the following directory structure: +# data//input0.raw, input1.raw, output.raw + +# You must provide the correct dimensions for each test case below. +# Fill in the m, n, p values for each case as needed. +# Example: CASE_DIMS[0]="1024 1024 1024" +declare -a CASE_DIMS +CASE_DIMS[0]="1024 1024 1024" +CASE_DIMS[1]="512 512 512" +CASE_DIMS[2]="256 256 256" +CASE_DIMS[3]="128 128 128" +CASE_DIMS[4]="64 64 64" +CASE_DIMS[5]="2048 2048 2048" +CASE_DIMS[6]="1024 2048 512" +CASE_DIMS[7]="512 1024 2048" +CASE_DIMS[8]="2048 512 1024" +CASE_DIMS[9]="4096 4096 4096" + +for i in $(seq 0 9); do + dims=${CASE_DIMS[$i]} + echo "Running CUDA case $i with dims $dims" + ./main $i $dims > data/$i/run_cuda.log 2>&1 + if grep -q "INVALID" data/$i/run_cuda.log; then + echo "Case $i: FAIL (see data/$i/run_cuda.log)" + else + echo "Case $i: PASS" + fi +done \ No newline at end of file From 7f2f37c68bb791800a0d8b8bdd565ea9746f20ae Mon Sep 17 00:00:00 2001 From: toblii Date: Fri, 30 May 2025 10:13:00 +0300 Subject: [PATCH 2/2] tobias.holm: Implemented CUDA matrix multiplication --- main.cu | 14 +++++--------- test.sh | 30 +++++++++++++----------------- 2 files changed, 18 insertions(+), 26 deletions(-) diff --git a/main.cu b/main.cu index 132ff2a..ced4c72 100644 --- a/main.cu +++ b/main.cu @@ -8,7 +8,6 @@ #include #include -// Naive CUDA kernel: each thread computes one C(i,j) __global__ void naive_cuda_matmul(float *C, float *A, float *B, uint32_t m, uint32_t n, uint32_t p) { uint32_t row = blockIdx.y * blockDim.y + threadIdx.y; uint32_t col = blockIdx.x * blockDim.x + threadIdx.x; @@ -21,7 +20,7 @@ __global__ void naive_cuda_matmul(float *C, float *A, float *B, uint32_t m, uint } } -// Tiled CUDA kernel: uses shared memory for A and B tiles +// Tiled CUDA with shared memory for A and B __global__ void tiled_cuda_matmul(float *C, float *A, float *B, uint32_t m, uint32_t n, uint32_t p, uint32_t tile_width) { extern __shared__ float shared_mem[]; float* As = shared_mem; @@ -32,7 +31,6 @@ __global__ void tiled_cuda_matmul(float *C, float *A, float *B, uint32_t m, uint float sum = 0.0f; for (uint32_t t = 0; t < (n + tile_width - 1) / tile_width; ++t) { - // Load tiles into shared memory uint32_t tiled_row = row; uint32_t tiled_col = t * tile_width + threadIdx.x; if (tiled_row < m && tiled_col < n) @@ -58,7 +56,7 @@ __global__ void tiled_cuda_matmul(float *C, float *A, float *B, uint32_t m, uint C[row * p + col] = sum; } -// Helper: Read raw float matrix from file +//Read raw float matrix bool read_matrix(const std::string &filename, std::vector &mat, size_t size) { std::ifstream in(filename, std::ios::binary); if (!in) return false; @@ -66,7 +64,7 @@ bool read_matrix(const std::string &filename, std::vector &mat, size_t si return in.good(); } -// Helper: Write raw float matrix to file +//Write float matrix bool write_matrix(const std::string &filename, const std::vector &mat, size_t size) { std::ofstream out(filename, std::ios::binary); if (!out) return false; @@ -74,7 +72,7 @@ bool write_matrix(const std::string &filename, const std::vector &mat, si return out.good(); } -// Helper: Validate result against reference +// Validate result bool validate_result(const std::string &result_file, const std::string &reference_file) { std::ifstream res(result_file, std::ios::binary); std::ifstream ref(reference_file, std::ios::binary); @@ -93,7 +91,6 @@ bool validate_result(const std::string &result_file, const std::string &referenc } int main(int argc, char *argv[]) { - // Example: ./main 0 1024 1024 1024 if (argc < 5) { std::cerr << "Usage: " << argv[0] << "

\n"; return 1; @@ -154,7 +151,6 @@ int main(int argc, char *argv[]) { write_matrix(c_file_naive, h_C_naive, size_C); bool valid_naive = validate_result(c_file_naive, ref_file); - // --- Tiled CUDA --- cudaEvent_t start_tiled, stop_tiled; cudaEventCreate(&start_tiled); cudaEventCreate(&stop_tiled); @@ -180,7 +176,7 @@ int main(int argc, char *argv[]) { write_matrix(c_file_tiled, h_C_tiled, size_C); bool valid_tiled = validate_result(c_file_tiled, ref_file); - // Print performance results + // Print results std::cout << "Case " << case_number << " (" << m << "x" << n << "x" << p << "):\n"; std::cout << "Naive CUDA time: " << naive_cuda_time << " seconds"; std::cout << (valid_naive ? " [VALID]\n" : " [INVALID]\n"); diff --git a/test.sh b/test.sh index 13f9e6d..2feedc1 100755 --- a/test.sh +++ b/test.sh @@ -1,27 +1,23 @@ #!/bin/sh +# Remember to make file executable with chmod +x test.sh # Usage: ./test.sh # This script runs all CUDA test cases (0..9) using main.cu's executable. -# It expects the following directory structure: -# data//input0.raw, input1.raw, output.raw -# You must provide the correct dimensions for each test case below. -# Fill in the m, n, p values for each case as needed. -# Example: CASE_DIMS[0]="1024 1024 1024" -declare -a CASE_DIMS -CASE_DIMS[0]="1024 1024 1024" -CASE_DIMS[1]="512 512 512" -CASE_DIMS[2]="256 256 256" -CASE_DIMS[3]="128 128 128" -CASE_DIMS[4]="64 64 64" -CASE_DIMS[5]="2048 2048 2048" -CASE_DIMS[6]="1024 2048 512" -CASE_DIMS[7]="512 1024 2048" -CASE_DIMS[8]="2048 512 1024" -CASE_DIMS[9]="4096 4096 4096" +declare -a CASE_DIMENSIONS +CASE_DIMENSIONS[0]="1024 1024 1024" +CASE_DIMENSIONS[1]="512 512 512" +CASE_DIMENSIONS[2]="256 256 256" +CASE_DIMENSIONS[3]="128 128 128" +CASE_DIMENSIONS[4]="64 64 64" +CASE_DIMENSIONS[5]="2048 2048 2048" +CASE_DIMENSIONS[6]="1024 2048 512" +CASE_DIMENSIONS[7]="512 1024 2048" +CASE_DIMENSIONS[8]="2048 512 1024" +CASE_DIMENSIONS[9]="4096 4096 4096" for i in $(seq 0 9); do - dims=${CASE_DIMS[$i]} + dims=${CASE_DIMENSIONS[$i]} echo "Running CUDA case $i with dims $dims" ./main $i $dims > data/$i/run_cuda.log 2>&1 if grep -q "INVALID" data/$i/run_cuda.log; then

KG}uZHN&y$sM#au4=UdSArvX0Z=Bi1c>i=f_ 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 Z?R(pM|M`LAfB#;!JioDbz}}CmzXza+>IDD* literal 0 HcmV?d00001 diff --git a/CMakeFiles/4.0.2-dirty/CMakeSystem.cmake b/CMakeFiles/4.0.2-dirty/CMakeSystem.cmake new file mode 100644 index 0000000..5145244 --- /dev/null +++ b/CMakeFiles/4.0.2-dirty/CMakeSystem.cmake @@ -0,0 +1,15 @@ +set(CMAKE_HOST_SYSTEM "Linux-6.14.7-arch2-1") +set(CMAKE_HOST_SYSTEM_NAME "Linux") +set(CMAKE_HOST_SYSTEM_VERSION "6.14.7-arch2-1") +set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64") + + + +set(CMAKE_SYSTEM "Linux-6.14.7-arch2-1") +set(CMAKE_SYSTEM_NAME "Linux") +set(CMAKE_SYSTEM_VERSION "6.14.7-arch2-1") +set(CMAKE_SYSTEM_PROCESSOR "x86_64") + +set(CMAKE_CROSSCOMPILING "FALSE") + +set(CMAKE_SYSTEM_LOADED 1) diff --git a/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/CMakeCUDACompilerId.cu b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/CMakeCUDACompilerId.cu new file mode 100644 index 0000000..4aaeb34 --- /dev/null +++ b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/CMakeCUDACompilerId.cu @@ -0,0 +1,935 @@ +#ifndef __CUDACC__ +# error "A C or C++ compiler has been selected for CUDA" +#endif + + +/* Version number components: V=Version, R=Revision, P=Patch + Version date components: YYYY=Year, MM=Month, DD=Day */ + +#if defined(__NVCC__) +# define COMPILER_ID "NVIDIA" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# elif defined(__clang__) +# define SIMULATE_ID "Clang" +# elif defined(__GNUC__) +# define SIMULATE_ID "GNU" +# endif +# if defined(__CUDACC_VER_MAJOR__) +# define COMPILER_VERSION_MAJOR DEC(__CUDACC_VER_MAJOR__) +# define COMPILER_VERSION_MINOR DEC(__CUDACC_VER_MINOR__) +# define COMPILER_VERSION_PATCH DEC(__CUDACC_VER_BUILD__) +# endif +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# elif defined(__clang__) +# define SIMULATE_VERSION_MAJOR DEC(__clang_major__) +# define SIMULATE_VERSION_MINOR DEC(__clang_minor__) +# elif defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif + +#elif defined(__clang__) +# define COMPILER_ID "Clang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + + +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__hpux) || defined(__hpua) +# define COMPILER_ID "HP" + +#else /* unknown compiler */ +# define COMPILER_ID "" +#endif + +/* Detect host compiler used by NVCC. */ +#ifdef __NVCC__ + +/* Version number components: V=Version, R=Revision, P=Patch + Version date components: YYYY=Year, MM=Month, DD=Day */ + +#if defined(__INTEL_COMPILER) || defined(__ICC) +# define HOST_COMPILER_ID "Intel" +# if defined(_MSC_VER) +# define HOST_SIMULATE_ID "MSVC" +# endif +# if defined(__GNUC__) +# define HOST_SIMULATE_ID "GNU" +# endif + /* __INTEL_COMPILER = VRP prior to 2021, and then VVVV for 2021 and later, + except that a few beta releases use the old format with V=2021. */ +# if __INTEL_COMPILER < 2021 || __INTEL_COMPILER == 202110 || __INTEL_COMPILER == 202111 +# define HOST_COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100) +# define HOST_COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10) +# if defined(__INTEL_COMPILER_UPDATE) +# define HOST_COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE) +# else +# define HOST_COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10) +# endif +# else +# define HOST_COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER) +# define HOST_COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER_UPDATE) + /* The third version component from --version is an update index, + but no macro is provided for it. */ +# define HOST_COMPILER_VERSION_PATCH DEC(0) +# endif +# if defined(__INTEL_COMPILER_BUILD_DATE) + /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */ +# define HOST_COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE) +# endif +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define HOST_SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define HOST_SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# if defined(__GNUC__) +# define HOST_SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# elif defined(__GNUG__) +# define HOST_SIMULATE_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define HOST_SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define HOST_SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif (defined(__clang__) && defined(__INTEL_CLANG_COMPILER)) || defined(__INTEL_LLVM_COMPILER) +# define HOST_COMPILER_ID "IntelLLVM" +#if defined(_MSC_VER) +# define HOST_SIMULATE_ID "MSVC" +#endif +#if defined(__GNUC__) +# define HOST_SIMULATE_ID "GNU" +#endif +/* __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and + * later. Look for 6 digit vs. 8 digit version number to decide encoding. + * VVVV is no smaller than the current year when a version is released. + */ +#if __INTEL_LLVM_COMPILER < 1000000L +# define HOST_COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100) +# define HOST_COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10) +# define HOST_COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 10) +#else +# define HOST_COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000) +# define HOST_COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100) +# define HOST_COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 100) +#endif +#if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define HOST_SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define HOST_SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +#endif +#if defined(__GNUC__) +# define HOST_SIMULATE_VERSION_MAJOR DEC(__GNUC__) +#elif defined(__GNUG__) +# define HOST_SIMULATE_VERSION_MAJOR DEC(__GNUG__) +#endif +#if defined(__GNUC_MINOR__) +# define HOST_SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +#endif +#if defined(__GNUC_PATCHLEVEL__) +# define HOST_SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +#endif + +#elif defined(__PATHCC__) +# define HOST_COMPILER_ID "PathScale" +# define HOST_COMPILER_VERSION_MAJOR DEC(__PATHCC__) +# define HOST_COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__) +# if defined(__PATHCC_PATCHLEVEL__) +# define HOST_COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__) +# endif + +#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__) +# define HOST_COMPILER_ID "Embarcadero" +# define HOST_COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF) +# define HOST_COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF) +# define HOST_COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF) + +#elif defined(__BORLANDC__) +# define HOST_COMPILER_ID "Borland" + /* __BORLANDC__ = 0xVRR */ +# define HOST_COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8) +# define HOST_COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF) + +#elif defined(__WATCOMC__) && __WATCOMC__ < 1200 +# define HOST_COMPILER_ID "Watcom" + /* __WATCOMC__ = VVRR */ +# define HOST_COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100) +# define HOST_COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define HOST_COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__WATCOMC__) +# define HOST_COMPILER_ID "OpenWatcom" + /* __WATCOMC__ = VVRP + 1100 */ +# define HOST_COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100) +# define HOST_COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define HOST_COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__SUNPRO_CC) +# define HOST_COMPILER_ID "SunPro" +# if __SUNPRO_CC >= 0x5100 + /* __SUNPRO_CC = 0xVRRP */ +# define HOST_COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12) +# define HOST_COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF) +# define HOST_COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# else + /* __SUNPRO_CC = 0xVRP */ +# define HOST_COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8) +# define HOST_COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF) +# define HOST_COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# endif + +#elif defined(__HP_aCC) +# define HOST_COMPILER_ID "HP" + /* __HP_aCC = VVRRPP */ +# define HOST_COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000) +# define HOST_COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100) +# define HOST_COMPILER_VERSION_PATCH DEC(__HP_aCC % 100) + +#elif defined(__DECCXX) +# define HOST_COMPILER_ID "Compaq" + /* __DECCXX_VER = VVRRTPPPP */ +# define HOST_COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000) +# define HOST_COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000 % 100) +# define HOST_COMPILER_VERSION_PATCH DEC(__DECCXX_VER % 10000) + +#elif defined(__IBMCPP__) && defined(__COMPILER_VER__) +# define HOST_COMPILER_ID "zOS" + /* __IBMCPP__ = VRP */ +# define HOST_COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define HOST_COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define HOST_COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__open_xl__) && defined(__clang__) +# define HOST_COMPILER_ID "IBMClang" +# define HOST_COMPILER_VERSION_MAJOR DEC(__open_xl_version__) +# define HOST_COMPILER_VERSION_MINOR DEC(__open_xl_release__) +# define HOST_COMPILER_VERSION_PATCH DEC(__open_xl_modification__) +# define HOST_COMPILER_VERSION_TWEAK DEC(__open_xl_ptf_fix_level__) +# define HOST_COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(__ibmxl__) && defined(__clang__) +# define HOST_COMPILER_ID "XLClang" +# define HOST_COMPILER_VERSION_MAJOR DEC(__ibmxl_version__) +# define HOST_COMPILER_VERSION_MINOR DEC(__ibmxl_release__) +# define HOST_COMPILER_VERSION_PATCH DEC(__ibmxl_modification__) +# define HOST_COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__) + + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800 +# define HOST_COMPILER_ID "XL" + /* __IBMCPP__ = VRP */ +# define HOST_COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define HOST_COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define HOST_COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800 +# define HOST_COMPILER_ID "VisualAge" + /* __IBMCPP__ = VRP */ +# define HOST_COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define HOST_COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define HOST_COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__NVCOMPILER) +# define HOST_COMPILER_ID "NVHPC" +# define HOST_COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__) +# define HOST_COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__) +# if defined(__NVCOMPILER_PATCHLEVEL__) +# define HOST_COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__) +# endif + +#elif defined(__PGI) +# define HOST_COMPILER_ID "PGI" +# define HOST_COMPILER_VERSION_MAJOR DEC(__PGIC__) +# define HOST_COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__) +# if defined(__PGIC_PATCHLEVEL__) +# define HOST_COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__) +# endif + +#elif defined(__clang__) && defined(__cray__) +# define HOST_COMPILER_ID "CrayClang" +# define HOST_COMPILER_VERSION_MAJOR DEC(__cray_major__) +# define HOST_COMPILER_VERSION_MINOR DEC(__cray_minor__) +# define HOST_COMPILER_VERSION_PATCH DEC(__cray_patchlevel__) +# define HOST_COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(_CRAYC) +# define HOST_COMPILER_ID "Cray" +# define HOST_COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR) +# define HOST_COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR) + +#elif defined(__TI_COMPILER_VERSION__) +# define HOST_COMPILER_ID "TI" + /* __TI_COMPILER_VERSION__ = VVVRRRPPP */ +# define HOST_COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000) +# define HOST_COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000) +# define HOST_COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000) + +#elif defined(__CLANG_FUJITSU) +# define HOST_COMPILER_ID "FujitsuClang" +# define HOST_COMPILER_VERSION_MAJOR DEC(__FCC_major__) +# define HOST_COMPILER_VERSION_MINOR DEC(__FCC_minor__) +# define HOST_COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__) +# define HOST_COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(__FUJITSU) +# define HOST_COMPILER_ID "Fujitsu" +# if defined(__FCC_version__) +# define HOST_COMPILER_VERSION __FCC_version__ +# elif defined(__FCC_major__) +# define HOST_COMPILER_VERSION_MAJOR DEC(__FCC_major__) +# define HOST_COMPILER_VERSION_MINOR DEC(__FCC_minor__) +# define HOST_COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__) +# endif +# if defined(__fcc_version) +# define HOST_COMPILER_VERSION_INTERNAL DEC(__fcc_version) +# elif defined(__FCC_VERSION) +# define HOST_COMPILER_VERSION_INTERNAL DEC(__FCC_VERSION) +# endif + + +#elif defined(__ghs__) +# define HOST_COMPILER_ID "GHS" +/* __GHS_VERSION_NUMBER = VVVVRP */ +# ifdef __GHS_VERSION_NUMBER +# define HOST_COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100) +# define HOST_COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10) +# define HOST_COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER % 10) +# endif + +#elif defined(__TASKING__) +# define HOST_COMPILER_ID "Tasking" + # define HOST_COMPILER_VERSION_MAJOR DEC(__VERSION__/1000) + # define HOST_COMPILER_VERSION_MINOR DEC(__VERSION__ % 100) +# define HOST_COMPILER_VERSION_INTERNAL DEC(__VERSION__) + +#elif defined(__ORANGEC__) +# define HOST_COMPILER_ID "OrangeC" +# define HOST_COMPILER_VERSION_MAJOR DEC(__ORANGEC_MAJOR__) +# define HOST_COMPILER_VERSION_MINOR DEC(__ORANGEC_MINOR__) +# define HOST_COMPILER_VERSION_PATCH DEC(__ORANGEC_PATCHLEVEL__) + +#elif defined(__SCO_VERSION__) +# define HOST_COMPILER_ID "SCO" + +#elif defined(__ARMCC_VERSION) && !defined(__clang__) +# define HOST_COMPILER_ID "ARMCC" +#if __ARMCC_VERSION >= 1000000 + /* __ARMCC_VERSION = VRRPPPP */ + # define HOST_COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000) + # define HOST_COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100) + # define HOST_COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#else + /* __ARMCC_VERSION = VRPPPP */ + # define HOST_COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000) + # define HOST_COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10) + # define HOST_COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#endif + + +#elif defined(__clang__) && defined(__apple_build_version__) +# define HOST_COMPILER_ID "AppleClang" +# if defined(_MSC_VER) +# define HOST_SIMULATE_ID "MSVC" +# endif +# define HOST_COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define HOST_COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define HOST_COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define HOST_SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define HOST_SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# define HOST_COMPILER_VERSION_TWEAK DEC(__apple_build_version__) + +#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION) +# define HOST_COMPILER_ID "ARMClang" + # define HOST_COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000) + # define HOST_COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100) + # define HOST_COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION/100 % 100) +# define HOST_COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION) + +#elif defined(__clang__) && defined(__ti__) +# define HOST_COMPILER_ID "TIClang" + # define HOST_COMPILER_VERSION_MAJOR DEC(__ti_major__) + # define HOST_COMPILER_VERSION_MINOR DEC(__ti_minor__) + # define HOST_COMPILER_VERSION_PATCH DEC(__ti_patchlevel__) +# define HOST_COMPILER_VERSION_INTERNAL DEC(__ti_version__) + +#elif defined(__clang__) +# define HOST_COMPILER_ID "Clang" +# if defined(_MSC_VER) +# define HOST_SIMULATE_ID "MSVC" +# endif +# define HOST_COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define HOST_COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define HOST_COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define HOST_SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define HOST_SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + +#elif defined(__LCC__) && (defined(__GNUC__) || defined(__GNUG__) || defined(__MCST__)) +# define HOST_COMPILER_ID "LCC" +# define HOST_COMPILER_VERSION_MAJOR DEC(__LCC__ / 100) +# define HOST_COMPILER_VERSION_MINOR DEC(__LCC__ % 100) +# if defined(__LCC_MINOR__) +# define HOST_COMPILER_VERSION_PATCH DEC(__LCC_MINOR__) +# endif +# if defined(__GNUC__) && defined(__GNUC_MINOR__) +# define HOST_SIMULATE_ID "GNU" +# define HOST_SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# define HOST_SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# if defined(__GNUC_PATCHLEVEL__) +# define HOST_SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif +# endif + +#elif defined(__GNUC__) || defined(__GNUG__) +# define HOST_COMPILER_ID "GNU" +# if defined(__GNUC__) +# define HOST_COMPILER_VERSION_MAJOR DEC(__GNUC__) +# else +# define HOST_COMPILER_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define HOST_COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define HOST_COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(_MSC_VER) +# define HOST_COMPILER_ID "MSVC" + /* _MSC_VER = VVRR */ +# define HOST_COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100) +# define HOST_COMPILER_VERSION_MINOR DEC(_MSC_VER % 100) +# if defined(_MSC_FULL_VER) +# if _MSC_VER >= 1400 + /* _MSC_FULL_VER = VVRRPPPPP */ +# define HOST_COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000) +# else + /* _MSC_FULL_VER = VVRRPPPP */ +# define HOST_COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000) +# endif +# endif +# if defined(_MSC_BUILD) +# define HOST_COMPILER_VERSION_TWEAK DEC(_MSC_BUILD) +# endif + +#elif defined(_ADI_COMPILER) +# define HOST_COMPILER_ID "ADSP" +#if defined(__VERSIONNUM__) + /* __VERSIONNUM__ = 0xVVRRPPTT */ +# define HOST_COMPILER_VERSION_MAJOR DEC(__VERSIONNUM__ >> 24 & 0xFF) +# define HOST_COMPILER_VERSION_MINOR DEC(__VERSIONNUM__ >> 16 & 0xFF) +# define HOST_COMPILER_VERSION_PATCH DEC(__VERSIONNUM__ >> 8 & 0xFF) +# define HOST_COMPILER_VERSION_TWEAK DEC(__VERSIONNUM__ & 0xFF) +#endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# define HOST_COMPILER_ID "IAR" +# if defined(__VER__) && defined(__ICCARM__) +# define HOST_COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000) +# define HOST_COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000) +# define HOST_COMPILER_VERSION_PATCH DEC((__VER__) % 1000) +# define HOST_COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__) || defined(__ICCSTM8__)) +# define HOST_COMPILER_VERSION_MAJOR DEC((__VER__) / 100) +# define HOST_COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100)) +# define HOST_COMPILER_VERSION_PATCH DEC(__SUBVERSION__) +# define HOST_COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# endif + + +#endif +#endif /* __NVCC__ */ + + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#define STRINGIFY_HELPER(X) #X +#define STRINGIFY(X) STRINGIFY_HELPER(X) + +/* Identify known platforms by name. */ +#if defined(__linux) || defined(__linux__) || defined(linux) +# define PLATFORM_ID "Linux" + +#elif defined(__MSYS__) +# define PLATFORM_ID "MSYS" + +#elif defined(__CYGWIN__) +# define PLATFORM_ID "Cygwin" + +#elif defined(__MINGW32__) +# define PLATFORM_ID "MinGW" + +#elif defined(__APPLE__) +# define PLATFORM_ID "Darwin" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +# define PLATFORM_ID "Windows" + +#elif defined(__FreeBSD__) || defined(__FreeBSD) +# define PLATFORM_ID "FreeBSD" + +#elif defined(__NetBSD__) || defined(__NetBSD) +# define PLATFORM_ID "NetBSD" + +#elif defined(__OpenBSD__) || defined(__OPENBSD) +# define PLATFORM_ID "OpenBSD" + +#elif defined(__sun) || defined(sun) +# define PLATFORM_ID "SunOS" + +#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__) +# define PLATFORM_ID "AIX" + +#elif defined(__hpux) || defined(__hpux__) +# define PLATFORM_ID "HP-UX" + +#elif defined(__HAIKU__) +# define PLATFORM_ID "Haiku" + +#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS) +# define PLATFORM_ID "BeOS" + +#elif defined(__QNX__) || defined(__QNXNTO__) +# define PLATFORM_ID "QNX" + +#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__) +# define PLATFORM_ID "Tru64" + +#elif defined(__riscos) || defined(__riscos__) +# define PLATFORM_ID "RISCos" + +#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__) +# define PLATFORM_ID "SINIX" + +#elif defined(__UNIX_SV__) +# define PLATFORM_ID "UNIX_SV" + +#elif defined(__bsdos__) +# define PLATFORM_ID "BSDOS" + +#elif defined(_MPRAS) || defined(MPRAS) +# define PLATFORM_ID "MP-RAS" + +#elif defined(__osf) || defined(__osf__) +# define PLATFORM_ID "OSF1" + +#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv) +# define PLATFORM_ID "SCO_SV" + +#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX) +# define PLATFORM_ID "ULTRIX" + +#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX) +# define PLATFORM_ID "Xenix" + +#elif defined(__WATCOMC__) +# if defined(__LINUX__) +# define PLATFORM_ID "Linux" + +# elif defined(__DOS__) +# define PLATFORM_ID "DOS" + +# elif defined(__OS2__) +# define PLATFORM_ID "OS2" + +# elif defined(__WINDOWS__) +# define PLATFORM_ID "Windows3x" + +# elif defined(__VXWORKS__) +# define PLATFORM_ID "VxWorks" + +# else /* unknown platform */ +# define PLATFORM_ID +# endif + +#elif defined(__INTEGRITY) +# if defined(INT_178B) +# define PLATFORM_ID "Integrity178" + +# else /* regular Integrity */ +# define PLATFORM_ID "Integrity" +# endif + +# elif defined(_ADI_COMPILER) +# define PLATFORM_ID "ADSP" + +#else /* unknown platform */ +# define PLATFORM_ID + +#endif + +/* For windows compilers MSVC and Intel we can determine + the architecture of the compiler being used. This is because + the compilers do not have flags that can change the architecture, + but rather depend on which compiler is being used +*/ +#if defined(_WIN32) && defined(_MSC_VER) +# if defined(_M_IA64) +# define ARCHITECTURE_ID "IA64" + +# elif defined(_M_ARM64EC) +# define ARCHITECTURE_ID "ARM64EC" + +# elif defined(_M_X64) || defined(_M_AMD64) +# define ARCHITECTURE_ID "x64" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# elif defined(_M_ARM64) +# define ARCHITECTURE_ID "ARM64" + +# elif defined(_M_ARM) +# if _M_ARM == 4 +# define ARCHITECTURE_ID "ARMV4I" +# elif _M_ARM == 5 +# define ARCHITECTURE_ID "ARMV5I" +# else +# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM) +# endif + +# elif defined(_M_MIPS) +# define ARCHITECTURE_ID "MIPS" + +# elif defined(_M_SH) +# define ARCHITECTURE_ID "SHx" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__WATCOMC__) +# if defined(_M_I86) +# define ARCHITECTURE_ID "I86" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# if defined(__ICCARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__ICCRX__) +# define ARCHITECTURE_ID "RX" + +# elif defined(__ICCRH850__) +# define ARCHITECTURE_ID "RH850" + +# elif defined(__ICCRL78__) +# define ARCHITECTURE_ID "RL78" + +# elif defined(__ICCRISCV__) +# define ARCHITECTURE_ID "RISCV" + +# elif defined(__ICCAVR__) +# define ARCHITECTURE_ID "AVR" + +# elif defined(__ICC430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__ICCV850__) +# define ARCHITECTURE_ID "V850" + +# elif defined(__ICC8051__) +# define ARCHITECTURE_ID "8051" + +# elif defined(__ICCSTM8__) +# define ARCHITECTURE_ID "STM8" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__ghs__) +# if defined(__PPC64__) +# define ARCHITECTURE_ID "PPC64" + +# elif defined(__ppc__) +# define ARCHITECTURE_ID "PPC" + +# elif defined(__ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__x86_64__) +# define ARCHITECTURE_ID "x64" + +# elif defined(__i386__) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__clang__) && defined(__ti__) +# if defined(__ARM_ARCH) +# define ARCHITECTURE_ID "ARM" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__TI_COMPILER_VERSION__) +# if defined(__TI_ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__MSP430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__TMS320C28XX__) +# define ARCHITECTURE_ID "TMS320C28x" + +# elif defined(__TMS320C6X__) || defined(_TMS320C6X) +# define ARCHITECTURE_ID "TMS320C6x" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +# elif defined(__ADSPSHARC__) +# define ARCHITECTURE_ID "SHARC" + +# elif defined(__ADSPBLACKFIN__) +# define ARCHITECTURE_ID "Blackfin" + +#elif defined(__TASKING__) + +# if defined(__CTC__) || defined(__CPTC__) +# define ARCHITECTURE_ID "TriCore" + +# elif defined(__CMCS__) +# define ARCHITECTURE_ID "MCS" + +# elif defined(__CARM__) || defined(__CPARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__CARC__) +# define ARCHITECTURE_ID "ARC" + +# elif defined(__C51__) +# define ARCHITECTURE_ID "8051" + +# elif defined(__CPCP__) +# define ARCHITECTURE_ID "PCP" + +# else +# define ARCHITECTURE_ID "" +# endif + +#else +# define ARCHITECTURE_ID +#endif + +/* Convert integer to decimal digit literals. */ +#define DEC(n) \ + ('0' + (((n) / 10000000)%10)), \ + ('0' + (((n) / 1000000)%10)), \ + ('0' + (((n) / 100000)%10)), \ + ('0' + (((n) / 10000)%10)), \ + ('0' + (((n) / 1000)%10)), \ + ('0' + (((n) / 100)%10)), \ + ('0' + (((n) / 10)%10)), \ + ('0' + ((n) % 10)) + +/* Convert integer to hex digit literals. */ +#define HEX(n) \ + ('0' + ((n)>>28 & 0xF)), \ + ('0' + ((n)>>24 & 0xF)), \ + ('0' + ((n)>>20 & 0xF)), \ + ('0' + ((n)>>16 & 0xF)), \ + ('0' + ((n)>>12 & 0xF)), \ + ('0' + ((n)>>8 & 0xF)), \ + ('0' + ((n)>>4 & 0xF)), \ + ('0' + ((n) & 0xF)) + +/* Construct a string literal encoding the version number. */ +#ifdef COMPILER_VERSION +char const* info_version = "INFO" ":" "compiler_version[" COMPILER_VERSION "]"; + +/* Construct a string literal encoding the version number components. */ +#elif defined(COMPILER_VERSION_MAJOR) +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + COMPILER_VERSION_MAJOR, +# ifdef COMPILER_VERSION_MINOR + '.', COMPILER_VERSION_MINOR, +# ifdef COMPILER_VERSION_PATCH + '.', COMPILER_VERSION_PATCH, +# ifdef COMPILER_VERSION_TWEAK + '.', COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct a string literal encoding the internal version number. */ +#ifdef COMPILER_VERSION_INTERNAL +char const info_version_internal[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_', + 'i','n','t','e','r','n','a','l','[', + COMPILER_VERSION_INTERNAL,']','\0'}; +#elif defined(COMPILER_VERSION_INTERNAL_STR) +char const* info_version_internal = "INFO" ":" "compiler_version_internal[" COMPILER_VERSION_INTERNAL_STR "]"; +#endif + +/* Construct a string literal encoding the version number components. */ +#ifdef SIMULATE_VERSION_MAJOR +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + SIMULATE_VERSION_MAJOR, +# ifdef SIMULATE_VERSION_MINOR + '.', SIMULATE_VERSION_MINOR, +# ifdef SIMULATE_VERSION_PATCH + '.', SIMULATE_VERSION_PATCH, +# ifdef SIMULATE_VERSION_TWEAK + '.', SIMULATE_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]"; +char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]"; + + + +#ifdef HOST_COMPILER_ID +char const* info_host_compiler = "INFO" ":" "host_compiler[" HOST_COMPILER_ID "]"; +#endif +#ifdef HOST_COMPILER_VERSION +char const* info_host_compiler_version = "INFO" ":" "host_compiler_version[" HOST_COMPILER_VERSION "]"; +#elif defined(HOST_COMPILER_VERSION_MAJOR) +char const info_host_compiler_version[] = { + 'I', 'N', 'F', 'O', ':','h','o','s','t','_', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + HOST_COMPILER_VERSION_MAJOR, +# ifdef HOST_COMPILER_VERSION_MINOR + '.', HOST_COMPILER_VERSION_MINOR, +# ifdef HOST_COMPILER_VERSION_PATCH + '.', HOST_COMPILER_VERSION_PATCH, +# ifdef HOST_COMPILER_VERSION_TWEAK + '.', HOST_COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +#define CXX_STD_11 201103L +#define CXX_STD_14 201402L +#define CXX_STD_17 201703L +#define CXX_STD_20 202002L +#define CXX_STD_23 202302L + +#if defined(_MSC_VER) && defined(_MSVC_LANG) +# if _MSVC_LANG > __cplusplus +# define CXX_STD _MSVC_LANG +# else +# define CXX_STD __cplusplus +# endif +#else +# define CXX_STD __cplusplus +#endif + +const char* info_language_standard_default = "INFO" ":" "standard_default[" +#if CXX_STD > CXX_STD_23 + "26" +#elif CXX_STD > CXX_STD_20 + "23" +#elif CXX_STD > CXX_STD_17 + "20" +#elif CXX_STD > CXX_STD_14 + "17" +#elif CXX_STD > CXX_STD_11 + "14" +#elif CXX_STD >= CXX_STD_11 + "11" +#else + "03" +#endif +"]"; + +const char* info_language_extensions_default = "INFO" ":" "extensions_default[" +#if (defined(__clang__) || defined(__GNUC__)) && \ + !defined(__STRICT_ANSI__) + "ON" +#else + "OFF" +#endif +"]"; + +/*--------------------------------------------------------------------------*/ + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#ifdef HOST_COMPILER_ID + require += info_host_compiler[argc]; +#endif +#ifdef HOST_COMPILER_VERSION_MAJOR + require += info_host_compiler_version[argc]; +#endif + require += info_language_standard_default[argc]; + require += info_language_extensions_default[argc]; + (void)argv; + return require; +} diff --git a/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/a.out b/CMakeFiles/4.0.2-dirty/CompilerIdCUDA/a.out new file mode 100755 index 0000000000000000000000000000000000000000..160c5d9ee0bb4eaa8c936b4b4d91f75ac42ad2c0 GIT binary patch literal 1000048 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