From 7d21ae547f198e1476cbca903aa04e11887a1af8 Mon Sep 17 00:00:00 2001 From: MLRichard <2574597846@qq.com> Date: Sun, 15 Mar 2026 17:13:33 +0800 Subject: [PATCH] =?UTF-8?q?=E6=8F=90=E4=BA=A4=E9=80=89=E9=A2=98=E5=85=AB?= =?UTF-8?q?=E5=86=85=E5=AE=B9=EF=BC=8C=E5=AE=8C=E6=88=90=E8=8B=B1=E4=BC=9F?= =?UTF-8?q?=E8=BE=BE=E7=8E=AF=E5=A2=83=E8=BF=90=E8=A1=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- 08_bilateral_filter/MLRichard/CMakeLists.txt | 53 + .../MLRichard/CMakePresets.json | 143 + 08_bilateral_filter/MLRichard/README.md | 495 + .../MLRichard/build/conda-release/.ninja_deps | Bin 0 -> 50140 bytes .../MLRichard/build/conda-release/.ninja_log | 22 + .../build/conda-release/CMakeCache.txt | 438 + .../CMakeFiles/4.2.3/CMakeCUDACompiler.cmake | 90 + .../CMakeFiles/4.2.3/CMakeCXXCompiler.cmake | 104 + .../4.2.3/CMakeDetermineCompilerABI_CUDA.bin | Bin 0 -> 993728 bytes .../4.2.3/CMakeDetermineCompilerABI_CXX.bin | Bin 0 -> 16048 bytes .../CMakeFiles/4.2.3/CMakeSystem.cmake | 15 + .../CompilerIdCUDA/CMakeCUDACompilerId.cu | 964 + .../CMakeFiles/4.2.3/CompilerIdCUDA/a.out | Bin 0 -> 998136 bytes .../tmp/CMakeCUDACompilerId.cpp1.ii | 34563 +++++++++++++++ .../tmp/CMakeCUDACompilerId.cpp4.ii | 32659 +++++++++++++++ .../tmp/CMakeCUDACompilerId.cudafe1.c | 51 + .../tmp/CMakeCUDACompilerId.cudafe1.cpp | 34730 ++++++++++++++++ .../tmp/CMakeCUDACompilerId.cudafe1.gpu | 379 + .../tmp/CMakeCUDACompilerId.cudafe1.stub.c | 15 + .../tmp/CMakeCUDACompilerId.fatbin | Bin 0 -> 1112 bytes .../tmp/CMakeCUDACompilerId.fatbin.c | 60 + .../tmp/CMakeCUDACompilerId.module_id | 1 + .../CompilerIdCUDA/tmp/CMakeCUDACompilerId.o | Bin 0 -> 6736 bytes .../tmp/CMakeCUDACompilerId.ptx | 14 + .../tmp/CMakeCUDACompilerId.sm_52.cubin | Bin 0 -> 872 bytes .../4.2.3/CompilerIdCUDA/tmp/a_dlink.fatbin | Bin 0 -> 960 bytes .../4.2.3/CompilerIdCUDA/tmp/a_dlink.fatbin.c | 55 + .../4.2.3/CompilerIdCUDA/tmp/a_dlink.o | Bin 0 -> 2920 bytes .../4.2.3/CompilerIdCUDA/tmp/a_dlink.reg.c | 1 + .../CompilerIdCUDA/tmp/a_dlink.sm_52.cubin | Bin 0 -> 872 bytes .../CompilerIdCXX/CMakeCXXCompilerId.cpp | 949 + .../CMakeFiles/4.2.3/CompilerIdCXX/a.out | Bin 0 -> 16096 bytes .../CMakeFiles/CMakeConfigureLog.yaml | 3018 ++ .../CMakeFiles/CTestScript.cmake | 167 + .../CMakeFiles/InstallScripts.json | 7 + .../CMakeFiles/TargetDirectories.txt | 34 + .../bilateral_filter.dir/cmake_device_link.o | Bin 0 -> 332568 bytes .../src/bilateral_filter.cu.o | Bin 0 -> 177248 bytes .../bilateral_filter.dir/src/io.cpp.o | Bin 0 -> 17920 bytes .../bilateral_filter.dir/src/main.cu.o | Bin 0 -> 26840 bytes .../bilateral_filter.dir/src/metrics.cpp.o | Bin 0 -> 2264 bytes .../bilateral_filter.dir/src/reference.cpp.o | Bin 0 -> 5392 bytes .../CMakeFiles/cmake.check_cache | 1 + .../conda-release/CMakeFiles/rules.ninja | 159 + .../test_correctness.dir/cmake_device_link.o | Bin 0 -> 331472 bytes .../src/bilateral_filter.cu.o | Bin 0 -> 177248 bytes .../test_correctness.dir/src/io.cpp.o | Bin 0 -> 17920 bytes .../test_correctness.dir/src/metrics.cpp.o | Bin 0 -> 2264 bytes .../test_correctness.dir/src/reference.cpp.o | Bin 0 -> 5392 bytes .../test/test_correctness.cpp.o | Bin 0 -> 11120 bytes .../test_performance.dir/cmake_device_link.o | Bin 0 -> 331472 bytes .../src/bilateral_filter.cu.o | Bin 0 -> 177248 bytes .../test_performance.dir/src/io.cpp.o | Bin 0 -> 17920 bytes .../test_performance.dir/src/metrics.cpp.o | Bin 0 -> 2264 bytes .../test_performance.dir/src/reference.cpp.o | Bin 0 -> 5392 bytes .../test/test_performance.cpp.o | Bin 0 -> 9736 bytes .../build/conda-release/CTestTestfile.cmake | 10 + .../build/conda-release/DartConfiguration.tcl | 109 + .../Testing/Temporary/CTestCostData.txt | 3 + .../Testing/Temporary/LastTest.log | 54 + .../Testing/Temporary/LastTestsFailed.log | 2 + .../build/conda-release/bilateral_filter | Bin 0 -> 1523376 bytes .../MLRichard/build/conda-release/build.ninja | 822 + .../build/conda-release/cmake_install.cmake | 66 + .../build/conda-release/compile_commands.json | 92 + .../build/conda-release/test_correctness | Bin 0 -> 1513464 bytes .../build/conda-release/test_performance | Bin 0 -> 1508960 bytes .../2026-03-06-bilateral-filter-design.md | 200 + .../plans/2026-03-06-bilateral-filter-impl.md | 1161 + .../2026-03-07-readme-cmake-presets-design.md | 80 + .../plans/2026-03-07-readme-cmake-presets.md | 123 + 08_bilateral_filter/MLRichard/docs/report.md | 228 + 08_bilateral_filter/MLRichard/params.txt | 3 + .../MLRichard/src/bilateral_filter.cu | 290 + .../MLRichard/src/bilateral_filter.cuh | 26 + 08_bilateral_filter/MLRichard/src/io.cpp | 59 + 08_bilateral_filter/MLRichard/src/io.h | 26 + 08_bilateral_filter/MLRichard/src/main.cu | 107 + 08_bilateral_filter/MLRichard/src/metrics.cpp | 20 + 08_bilateral_filter/MLRichard/src/metrics.h | 7 + .../MLRichard/src/reference.cpp | 27 + 08_bilateral_filter/MLRichard/src/reference.h | 18 + 08_bilateral_filter/MLRichard/task.md | 105 + .../MLRichard/test/test_correctness.cpp | 91 + .../MLRichard/test/test_performance.cpp | 85 + .../MLRichard/tools/generate_test_raw.py | 53 + .../MLRichard/tools/img2raw.py | 84 + .../MLRichard/tools/profile_task12.sh | 218 + 88 files changed, 113356 insertions(+) create mode 100644 08_bilateral_filter/MLRichard/CMakeLists.txt create mode 100644 08_bilateral_filter/MLRichard/CMakePresets.json create mode 100644 08_bilateral_filter/MLRichard/README.md create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/.ninja_deps create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/.ninja_log create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeCache.txt create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CMakeCUDACompiler.cmake create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CMakeCXXCompiler.cmake create mode 100755 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CMakeDetermineCompilerABI_CUDA.bin create mode 100755 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CMakeDetermineCompilerABI_CXX.bin create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CMakeSystem.cmake create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/CMakeCUDACompilerId.cu create mode 100755 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/a.out create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp1.ii create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp4.ii create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.c create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.cpp create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.gpu create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.stub.c create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.fatbin create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.fatbin.c create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.module_id create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.o create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.ptx create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.sm_52.cubin create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/a_dlink.fatbin create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/a_dlink.fatbin.c create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/a_dlink.o create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/a_dlink.reg.c create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/a_dlink.sm_52.cubin create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCXX/CMakeCXXCompilerId.cpp create mode 100755 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCXX/a.out create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/CMakeConfigureLog.yaml create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/CTestScript.cmake create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/InstallScripts.json create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/TargetDirectories.txt create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/bilateral_filter.dir/cmake_device_link.o create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/bilateral_filter.dir/src/bilateral_filter.cu.o create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/bilateral_filter.dir/src/io.cpp.o create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/bilateral_filter.dir/src/main.cu.o create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/bilateral_filter.dir/src/metrics.cpp.o create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/bilateral_filter.dir/src/reference.cpp.o create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/cmake.check_cache create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/rules.ninja create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_correctness.dir/cmake_device_link.o create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_correctness.dir/src/bilateral_filter.cu.o create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_correctness.dir/src/io.cpp.o create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_correctness.dir/src/metrics.cpp.o create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_correctness.dir/src/reference.cpp.o create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_correctness.dir/test/test_correctness.cpp.o create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/cmake_device_link.o create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/src/bilateral_filter.cu.o create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/src/io.cpp.o create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/src/metrics.cpp.o create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/src/reference.cpp.o create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/test/test_performance.cpp.o create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/CTestTestfile.cmake create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/DartConfiguration.tcl create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/Testing/Temporary/CTestCostData.txt create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/Testing/Temporary/LastTest.log create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/Testing/Temporary/LastTestsFailed.log create mode 100755 08_bilateral_filter/MLRichard/build/conda-release/bilateral_filter create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/build.ninja create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/cmake_install.cmake create mode 100644 08_bilateral_filter/MLRichard/build/conda-release/compile_commands.json create mode 100755 08_bilateral_filter/MLRichard/build/conda-release/test_correctness create mode 100755 08_bilateral_filter/MLRichard/build/conda-release/test_performance create mode 100644 08_bilateral_filter/MLRichard/docs/plans/2026-03-06-bilateral-filter-design.md create mode 100644 08_bilateral_filter/MLRichard/docs/plans/2026-03-06-bilateral-filter-impl.md create mode 100644 08_bilateral_filter/MLRichard/docs/plans/2026-03-07-readme-cmake-presets-design.md create mode 100644 08_bilateral_filter/MLRichard/docs/plans/2026-03-07-readme-cmake-presets.md create mode 100644 08_bilateral_filter/MLRichard/docs/report.md create mode 100644 08_bilateral_filter/MLRichard/params.txt create mode 100644 08_bilateral_filter/MLRichard/src/bilateral_filter.cu create mode 100644 08_bilateral_filter/MLRichard/src/bilateral_filter.cuh create mode 100644 08_bilateral_filter/MLRichard/src/io.cpp create mode 100644 08_bilateral_filter/MLRichard/src/io.h create mode 100644 08_bilateral_filter/MLRichard/src/main.cu create mode 100644 08_bilateral_filter/MLRichard/src/metrics.cpp create mode 100644 08_bilateral_filter/MLRichard/src/metrics.h create mode 100644 08_bilateral_filter/MLRichard/src/reference.cpp create mode 100644 08_bilateral_filter/MLRichard/src/reference.h create mode 100644 08_bilateral_filter/MLRichard/task.md create mode 100644 08_bilateral_filter/MLRichard/test/test_correctness.cpp create mode 100644 08_bilateral_filter/MLRichard/test/test_performance.cpp create mode 100755 08_bilateral_filter/MLRichard/tools/generate_test_raw.py create mode 100755 08_bilateral_filter/MLRichard/tools/img2raw.py create mode 100755 08_bilateral_filter/MLRichard/tools/profile_task12.sh diff --git a/08_bilateral_filter/MLRichard/CMakeLists.txt b/08_bilateral_filter/MLRichard/CMakeLists.txt new file mode 100644 index 0000000..f57848f --- /dev/null +++ b/08_bilateral_filter/MLRichard/CMakeLists.txt @@ -0,0 +1,53 @@ +cmake_minimum_required(VERSION 3.20) +project(bilateral_filter CUDA CXX) + +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CUDA_STANDARD 17) +set(CMAKE_CUDA_ARCHITECTURES 75;80;86;89) +set(CMAKE_EXPORT_COMPILE_COMMANDS ON) + +find_package(OpenCV REQUIRED) +include(CTest) + +include_directories(${OpenCV_INCLUDE_DIRS} src) + +# 主程序 +add_executable(bilateral_filter + src/main.cu + src/bilateral_filter.cu + src/io.cpp + src/reference.cpp + src/metrics.cpp +) +target_link_libraries(bilateral_filter ${OpenCV_LIBS}) +set_target_properties(bilateral_filter PROPERTIES CUDA_SEPARABLE_COMPILATION ON) + +# 正确性测试 +add_executable(test_correctness + test/test_correctness.cpp + src/bilateral_filter.cu + src/io.cpp + src/reference.cpp + src/metrics.cpp +) +target_link_libraries(test_correctness ${OpenCV_LIBS}) +set_target_properties(test_correctness PROPERTIES CUDA_SEPARABLE_COMPILATION ON) + +# 性能测试 +add_executable(test_performance + test/test_performance.cpp + src/bilateral_filter.cu + src/io.cpp + src/reference.cpp + src/metrics.cpp +) +target_link_libraries(test_performance ${OpenCV_LIBS}) +set_target_properties(test_performance PROPERTIES CUDA_SEPARABLE_COMPILATION ON) + +if(BUILD_TESTING) + add_test(NAME correctness COMMAND test_correctness) + set_tests_properties(correctness PROPERTIES LABELS "correctness") + + add_test(NAME performance COMMAND test_performance) + set_tests_properties(performance PROPERTIES LABELS "performance;benchmark") +endif() diff --git a/08_bilateral_filter/MLRichard/CMakePresets.json b/08_bilateral_filter/MLRichard/CMakePresets.json new file mode 100644 index 0000000..6e8fff4 --- /dev/null +++ b/08_bilateral_filter/MLRichard/CMakePresets.json @@ -0,0 +1,143 @@ +{ + "version": 2, + "cmakeMinimumRequired": { + "major": 3, + "minor": 20, + "patch": 0 + }, + "configurePresets": [ + { + "name": "conda-release", + "displayName": "Conda Release", + "description": "Configure a Release build in an activated Conda environment.", + "generator": "Ninja", + "binaryDir": "${sourceDir}/build/conda-release", + "cacheVariables": { + "CMAKE_BUILD_TYPE": "Release", + "CMAKE_EXPORT_COMPILE_COMMANDS": "ON", + "CUDAToolkit_ROOT": "$env{CONDA_PREFIX}", + "OpenCV_DIR": "$env{CONDA_PREFIX}/lib/cmake/opencv4", + "CMAKE_PREFIX_PATH": "$env{CONDA_PREFIX}" + }, + "environment": { + "PATH": "$env{CONDA_PREFIX}/bin:$penv{PATH}", + "CPATH": "$env{CONDA_PREFIX}/include:$penv{CPATH}", + "LIBRARY_PATH": "$env{CONDA_PREFIX}/lib:$penv{LIBRARY_PATH}", + "LD_LIBRARY_PATH": "$env{CONDA_PREFIX}/lib:/usr/lib/wsl/lib:$penv{LD_LIBRARY_PATH}", + "CUDA_HOME": "$env{CONDA_PREFIX}", + "OpenCV_DIR": "$env{CONDA_PREFIX}/lib/cmake/opencv4" + } + }, + { + "name": "conda-debug", + "displayName": "Conda Debug", + "description": "Configure a Debug build in an activated Conda environment.", + "inherits": "conda-release", + "binaryDir": "${sourceDir}/build/conda-debug", + "cacheVariables": { + "CMAKE_BUILD_TYPE": "Debug", + "CMAKE_EXPORT_COMPILE_COMMANDS": "ON", + "CUDAToolkit_ROOT": "$env{CONDA_PREFIX}", + "OpenCV_DIR": "$env{CONDA_PREFIX}/lib/cmake/opencv4", + "CMAKE_PREFIX_PATH": "$env{CONDA_PREFIX}" + } + } + ], + "testPresets": [ + { + "name": "test-conda-correctness", + "displayName": "Run correctness tests", + "configurePreset": "conda-release", + "output": { + "outputOnFailure": true + }, + "execution": { + "jobs": 1 + }, + "filter": { + "include": { + "label": "correctness" + } + }, + "environment": { + "PATH": "$env{CONDA_PREFIX}/bin:$penv{PATH}", + "CPATH": "$env{CONDA_PREFIX}/include:$penv{CPATH}", + "LIBRARY_PATH": "$env{CONDA_PREFIX}/lib:$penv{LIBRARY_PATH}", + "LD_LIBRARY_PATH": "$env{CONDA_PREFIX}/lib:/usr/lib/wsl/lib:$penv{LD_LIBRARY_PATH}", + "CUDA_HOME": "$env{CONDA_PREFIX}", + "OpenCV_DIR": "$env{CONDA_PREFIX}/lib/cmake/opencv4" + } + }, + { + "name": "test-conda-performance", + "displayName": "Run performance benchmark", + "configurePreset": "conda-release", + "output": { + "outputOnFailure": true + }, + "execution": { + "jobs": 1 + }, + "filter": { + "include": { + "label": "performance" + } + }, + "environment": { + "PATH": "$env{CONDA_PREFIX}/bin:$penv{PATH}", + "CPATH": "$env{CONDA_PREFIX}/include:$penv{CPATH}", + "LIBRARY_PATH": "$env{CONDA_PREFIX}/lib:$penv{LIBRARY_PATH}", + "LD_LIBRARY_PATH": "$env{CONDA_PREFIX}/lib:/usr/lib/wsl/lib:$penv{LD_LIBRARY_PATH}", + "CUDA_HOME": "$env{CONDA_PREFIX}", + "OpenCV_DIR": "$env{CONDA_PREFIX}/lib/cmake/opencv4" + } + }, + { + "name": "test-conda-all", + "displayName": "Run all CTest tests", + "configurePreset": "conda-release", + "output": { + "outputOnFailure": true + }, + "execution": { + "jobs": 1 + }, + "environment": { + "PATH": "$env{CONDA_PREFIX}/bin:$penv{PATH}", + "CPATH": "$env{CONDA_PREFIX}/include:$penv{CPATH}", + "LIBRARY_PATH": "$env{CONDA_PREFIX}/lib:$penv{LIBRARY_PATH}", + "LD_LIBRARY_PATH": "$env{CONDA_PREFIX}/lib:/usr/lib/wsl/lib:$penv{LD_LIBRARY_PATH}", + "CUDA_HOME": "$env{CONDA_PREFIX}", + "OpenCV_DIR": "$env{CONDA_PREFIX}/lib/cmake/opencv4" + } + } + ], + "buildPresets": [ + { + "name": "build-conda-release", + "displayName": "Build Conda Release", + "configurePreset": "conda-release" + }, + { + "name": "build-conda-debug", + "displayName": "Build Conda Debug", + "configurePreset": "conda-debug" + }, + { + "name": "build-test-correctness", + "displayName": "Build test_correctness", + "configurePreset": "conda-release", + "targets": [ + "test_correctness" + ] + }, + { + "name": "build-test-performance", + "displayName": "Build test_performance", + "configurePreset": "conda-release", + "targets": [ + "test_performance" + ] + } + ] +} diff --git a/08_bilateral_filter/MLRichard/README.md b/08_bilateral_filter/MLRichard/README.md new file mode 100644 index 0000000..6717e23 --- /dev/null +++ b/08_bilateral_filter/MLRichard/README.md @@ -0,0 +1,495 @@ +# bilateral_filter + +一个基于 CUDA 的实时双边滤波实验项目，默认适配 **英伟达（NVIDIA）GPU 环境**，支持灰度图与 RGB 图像，提供三阶段 CUDA kernel、CPU 参考实现、正确性测试与性能测试。项目优先面向训练营提供的英伟达环境，同时也可在标准 Linux / WSL + NVIDIA CUDA 环境中复用。 + +## 功能概览 + +- `Phase 1`：朴素 CUDA bilateral filter，作为正确性与性能基线 +- `Phase 2`：Shared Memory 优化版本，减少邻域访问的全局内存开销 +- `Phase 3`：自适应半径 + LUT 版本，结合 Sobel 梯度图进行区域自适应平滑 +- `CPU` 参考实现：基于 OpenCV `cv::bilateralFilter` +- `测试`： + - `test_correctness`：对比 OpenCV 输出，检查 MAE / PSNR + - `test_performance`：统计 GPU / CPU 时间与吞吐量 + +## 目录结构 + +```text +bilateral_filter/ +├── CMakeLists.txt +├── CMakePresets.json +├── README.md +├── params.txt +├── src/ +│ ├── main.cu +│ ├── bilateral_filter.cu +│ ├── bilateral_filter.cuh +│ ├── io.cpp +│ ├── io.h +│ ├── reference.cpp +│ ├── reference.h +│ ├── metrics.cpp +│ └── metrics.h +├── test/ +│ ├── test_correctness.cpp +│ └── test_performance.cpp +└── docs/ + └── plans/ +``` + +## 环境要求 + +本项目默认面向英伟达平台，建议按以下方式准备环境： + +- 如果你使用的是训练营提供的英伟达服务器，优先遵照课程中的英伟达环境文档完成基础配置。 +- 如果你使用的是本地或其他英伟达环境，请确保至少具备： + - 可用的 NVIDIA 驱动与 CUDA 环境 + - `C++17` 编译能力 + - `cmake` + - `ninja` 或其他可用构建工具 + - OpenCV 开发环境 +- 为了与当前 `CMakePresets.json` 保持一致，本文档下面给出一套推荐的 Conda 依赖配置，可直接用于训练营英伟达环境、普通 Linux 服务器或 WSL + NVIDIA CUDA 环境。 + +## NVIDIA 环境配置（推荐） + +如果训练营服务器已经提供好基础环境，可直接跳到“激活环境”或“使用 CMake Presets”部分；以下步骤主要用于补齐本地或其他英伟达环境中的用户态依赖。 + +### 1. 初始化 Conda + +```bash +source ~/miniconda3/etc/profile.d/conda.sh +``` + +### 2. 创建推荐环境 + +```bash +CONDA_NO_PLUGINS=true conda create -y \ + --solver classic \ + --override-channels \ + --strict-channel-priority \ + -n bilateral-cuda124 \ + -c nvidia/label/cuda-12.4.1 \ + -c conda-forge \ + python=3.10 cuda-toolkit opencv cmake ninja +``` + +### 3. 激活环境 + +```bash +conda activate bilateral-cuda124 +``` + +### 4. 基础检查 + +```bash +nvcc --version +cmake --version +python -c "import cv2; print(cv2.__version__)" +nvidia-smi +``` + +预期： + +- `nvcc` 可用 +- `OpenCV` 可导入 +- `nvidia-smi` 可看到 GPU + +## 使用 CMake Presets + +项目当前提供一组基于 Conda 环境的标准预设，可直接复用于英伟达训练营环境和其他标准 NVIDIA 环境： + +- `conda-release` +- `conda-debug` +- `build-conda-release` +- `build-conda-debug` +- `build-test-correctness` +- `build-test-performance` +- `test-conda-correctness` +- `test-conda-performance` +- `test-conda-all` + +### 配置 Release + +```bash +cmake --preset conda-release +``` + +### 构建 Release + +```bash +cmake --build --preset build-conda-release -j"$(nproc)" +``` + +### 仅构建正确性测试 + +```bash +cmake --build --preset build-test-correctness -j"$(nproc)" +``` + +### 仅构建性能测试 + +```bash +cmake --build --preset build-test-performance -j"$(nproc)" +``` + +### 使用 CTest 运行测试 + +运行正确性测试： + +```bash +ctest --preset test-conda-correctness +``` + +运行性能 benchmark： + +```bash +ctest --preset test-conda-performance +``` + +运行全部测试： + +```bash +ctest --preset test-conda-all +``` + +默认构建目录： + +- `build/conda-release` +- `build/conda-debug` + +## 项目使用说明 + +### 主程序 + +```bash +./build/conda-release/bilateral_filter [kernel] +``` + +示例： + +```bash +./build/conda-release/bilateral_filter test.raw out.raw params.txt shared +``` + +其中 `kernel` 可选： + +- `naive` +- `shared` +- `adaptive` + +默认值为 `shared`。 + +### 正确性测试 + +```bash +./build/conda-release/test_correctness +``` + +输出会包含： + +- 图像尺寸与通道数 +- `MAE` +- `PSNR` +- `PASS / FAIL` + +### 性能测试 + +```bash +./build/conda-release/test_performance +``` + +输出会包含： + +- GPU 时间 +- CPU 时间 +- 吞吐量（MPix/s） +- Speedup +- MAE / PSNR + +## 输入 / 输出格式说明 + +### raw 文件格式 + +项目内部使用如下二进制格式： + +```text +[4字节] width (uint32_t, little-endian) +[4字节] height (uint32_t, little-endian) +[4字节] channels (uint32_t, little-endian) +[数据区] width * height * channels 字节，类型 uint8 +``` + +说明： + +- 灰度图：`channels = 1` +- RGB 图：`channels = 3` +- 像素按行主序存储 +- RGB 使用交错布局：`R0,G0,B0,R1,G1,B1,...` + +## 参数文件说明 + +默认参数文件 `params.txt` 内容如下： + +```text +radius = 5 +sigma_spatial = 3.0 +sigma_color = 30.0 +``` + +含义： + +- `radius`：邻域半径 +- `sigma_spatial`：空间高斯权重参数 +- `sigma_color`：颜色权重参数 + +## 数据准备工具 + +项目附带两个辅助脚本，分别用于真实图片转换和基准输入生成。 + +### PNG / JPG 转 raw + +将普通图片转换成项目使用的 raw 格式： + +```bash +python tools/img2raw.py input.png output.raw +python tools/img2raw.py input.jpg output_gray.raw --gray +``` + +说明： + +- 默认输出 RGB 三通道 +- 传入 `--gray` 时输出灰度图 +- 脚本优先使用 `Pillow`，缺失时会回退到 `OpenCV Python` + +### 生成确定性测试输入 + +生成固定随机种子的 raw 文件，适合 correctness / benchmark / profiling： + +```bash +python tools/generate_test_raw.py artifacts/profiling/inputs/test_4k.raw +python tools/generate_test_raw.py tmp/test_gray.raw --width 1024 --height 768 --channels 1 --seed 7 +``` + +说明： + +- 默认生成 `3840x2160 RGB` 测试图 +- 输入内容可复现，便于不同机器之间对比吞吐与误差 +- profiling 脚本会在缺少输入时自动调用这个工具 + +## 典型使用流程 + +```bash +source ~/miniconda3/etc/profile.d/conda.sh +conda activate bilateral-cuda124 + +cmake --preset conda-release +cmake --build --preset build-conda-release -j"$(nproc)" + +ctest --preset test-conda-correctness +ctest --preset test-conda-performance +``` + +## 验收对照 + +本项目按 [task.md](./task.md) 中提取的“方向 8”要求实现，当前可直接用下面的清单自查。 + +| 要求 | 当前实现 | +|------|----------| +| 灰度 / RGB 输入 | 支持，raw 格式 `channels=1/3` | +| `radius >= 5` | 支持，默认 `radius=5` | +| 可配置 `sigma_spatial` / `sigma_color` | 支持，来自 `params.txt` | +| 输出 raw 图像 | 支持，主程序写出 raw 文件 | +| CPU 参考实现 | 支持，基于 OpenCV `bilateralFilter` | +| 正确性指标 | `test_correctness` 检查 `MAE < 1.0` | +| 性能日志 | 主程序和 benchmark 都输出 `GPU Time / CPU Time / Throughput / Speedup` | +| 共享内存优化 | 支持，`shared` kernel | +| 自适应半径 | 支持，`adaptive` kernel | +| profiling | 支持 `ncu / nsys` 脚本链路 | + +推荐在真实 GPU 环境中执行以下命令作为最终验收： + +```bash +source ~/miniconda3/etc/profile.d/conda.sh +conda activate bilateral-cuda124 +cmake --preset conda-release +cmake --build --preset build-conda-release -j"$(nproc)" +ctest --preset test-conda-all +``` + +如果 `ctest --preset test-conda-all` 全部通过，说明当前代码与 README 中记录的默认工作流一致。 + +## Profiling（Task 12 / NVIDIA 环境） + +推荐直接使用统一脚本： + +```bash +source ~/miniconda3/etc/profile.d/conda.sh +conda activate bilateral-cuda124 +bash tools/profile_task12.sh +``` + +默认行为： + +- 自动生成 `artifacts/profiling/inputs/test_4k.raw` +- 运行 `ncu` 采集 `naive / shared / adaptive` +- 运行 `nsys` 采集 `shared` 时间线 +- 自动导出 `timeline.sqlite` +- 按 GPU 名称输出到 `artifacts/profiling//` + +常用变体： + +```bash +# 仅跑 Nsight Systems +bash tools/profile_task12.sh --skip-ncu + +# 使用已有 raw 输入 +bash tools/profile_task12.sh --input /path/to/real_image.raw --skip-generate +``` + +说明： + +- 在 **Windows + WSL + NVIDIA GPU** 下，脚本会自动补充 `/usr/lib/wsl/lib` 到 `LD_LIBRARY_PATH` +- 在 **Linux + NVIDIA GPU** 环境中，可直接复用同一脚本；若该路径不存在，也无需改项目源码 +- 若 `ncu` 遇到 `ERR_NVGPUCTRPERM`，脚本会继续执行 `nsys`，并在输出目录生成 `ncu_permission_hint.txt` + +## NVIDIA Linux 服务器兼容说明 + +项目默认适配英伟达平台。若你使用的是训练营提供的英伟达服务器，通常只需完成课程要求的基础环境配置即可直接复用本项目；若你使用的是其他 Linux 云服务器，也通常不需要修改项目源码。 + +推荐方式： + +1. 服务器具备 NVIDIA GPU 与可用驱动 +2. 安装 Miniconda / Conda +3. 使用与本地相同的 Conda 环境创建命令 +4. 激活环境后直接使用相同的 `cmake --preset conda-release` 与 `cmake --build --preset build-conda-release` + +说明： + +- `CMakePresets.json` 主要依赖 `$env{CONDA_PREFIX}`，因此只要 Conda 环境结构一致，就不需要改路径。 +- `LD_LIBRARY_PATH` 中加入 `/usr/lib/wsl/lib` 只是为了兼容 WSL；在普通 Linux 服务器上该路径通常不存在，也不要求修改项目源代码。 +- 若服务器已有系统级 CUDA，也仍建议优先使用与项目一致的 Conda 环境，减少版本偏差。 + +## 课程提交说明 + +根据 [task.md](./task.md) 中提取的“项目代码要求”，最终交付时建议额外检查以下事项： + +1. 提交仓库应位于 `Learning-CUDA` 的 `2025-winter-project` 分支体系下。 +2. 目录布局应整理为 `/<选题>/<你的ID>/`。 +3. 提交方式应为 `PR`，而不是只保留本地目录。 +4. 最终交付版本应统一命名风格、补充关键注释，并根据课程要求确认是否需要移除测试代码。 + +如果课程原始文档在 `2026-03-03` 之后有更新，以最新的官方要求为准；本仓库中的 `task.md` 是对原始任务页的提取副本。 + +## 常见问题 + +### 1. `Failed to find nvcc` + +说明当前环境中没有可用的 CUDA toolkit。 + +检查： + +```bash +which nvcc +nvcc --version +``` + +处理： + +- 确认已执行 `conda activate bilateral-cuda124` +- 确认环境中安装了 `cuda-toolkit` + +### 2. VS Code / IntelliSense 提示 `#include` 错误 + +项目依赖： + +- `compile_commands.json` +- `.vscode/c_cpp_properties.json` +- `.vscode/settings.json` + +如果仍有报错： + +```text +Developer: Reload Window +C/C++: Reset IntelliSense Database +``` + +并确认你已经先执行过： + +```bash +cmake --preset conda-release +``` + +当前 IntelliSense 默认读取：`build/conda-release/compile_commands.json`。 + +### 3. 可以编译，但某些受限环境里 CUDA 运行失败 + +某些受限执行环境可以访问文件系统与编译器，但不允许真正访问 GPU compute。 + +表现通常为： + +- `cudaGetDeviceCount` 失败 +- `cudaMalloc` 报 `OS call failed or operation not supported on this OS` + +这种情况不是项目代码错误，而是当前执行环境限制。 + +### 4. OpenCV 未找到 + +检查： + +```bash +python -c "import cv2; print(cv2.__version__)" +ls "$CONDA_PREFIX/lib/cmake/opencv4/OpenCVConfig.cmake" +``` + +如缺失，重新安装 `opencv` 包即可。 + +### 5. Nsight Compute 报 `ERR_NVGPUCTRPERM` + +这是 **GPU Performance Counters 权限** 问题，不是项目代码错误。 + +项目已内置降级行为： + +- `tools/profile_task12.sh` 会继续完成 `nsys` 采集 +- 并在输出目录生成 `ncu_permission_hint.txt` + +#### Windows + WSL + NVIDIA GPU 推荐处理步骤 + +根据 NVIDIA 官方说明，WSL 侧通常需要在 **Windows 主机** 开启计数器访问： + +1. 以管理员身份打开 `NVIDIA Control Panel` +2. 勾选 `Desktop -> Enable Developer Settings` +3. 进入 `Developer -> Manage GPU Performance Counters` +4. 选择 `Allow access to the GPU performance counter to all users` +5. 重新打开 WSL 终端后再执行： + +```bash +source ~/miniconda3/etc/profile.d/conda.sh +conda activate bilateral-cuda124 +bash tools/profile_task12.sh +``` + +#### Linux / 云服务器 / A100 永久配置命令 + +```bash +sudo tee /etc/modprobe.d/nvidia-prof.conf >/dev/null <<'EOCONF' +options nvidia NVreg_RestrictProfilingToAdminUsers=0 +EOCONF +sudo update-initramfs -u -k all +sudo reboot +``` + +重启后检查： + +```bash +cat /proc/driver/nvidia/params | grep RmProfilingAdminOnly +``` + +若输出为 `RmProfilingAdminOnly: 0`，说明普通用户可以运行 `ncu`。 + +官方说明：`https://developer.nvidia.com/ERR_NVGPUCTRPERM` + +## 备注 + +- 当前推荐构建入口是 `CMakePresets.json`。 +- 为了获得稳定体验，请始终在激活的 Conda 环境中执行 `cmake` 与 `ninja`。 +- 如果需要更细粒度 profiling，可进一步结合 `ncu` / `nsys` 运行主程序分析 kernel 行为。 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/.ninja_deps b/08_bilateral_filter/MLRichard/build/conda-release/.ninja_deps new file mode 100644 index 0000000000000000000000000000000000000000..e1df19e4291c2fc11e5a9e264ff1ddef78d365d9 GIT binary patch literal 50140 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
7~La{Ly;d z=MMzT`)_*@zF2w5Sc5q|mT)9|VI!HERw`|#cbS$p4+UGlr$czvZcEu@_4!jB!mE8% zh1ncok5b{SPmGf;$r?zc1nram*9iiO))((^>tB z&sWE#mAcxPMBLKnQ(oL*L#%6+iLH%q9@xx9!vx~Ds(lT_VzUk1XT&lyuxdxflTPU| zgxU`o`^7jpRA)MlczN}vaG$K=Nxd1{$~bbpQbU}g^?QoUDB4 zVN-gyknQW z37p4fVDrAo0Kz+#zgebSA$UUGQfXUdS?3SvvU487SLK$EwJps3s0){B!sLzR&CleN z)wbjFGV7KZt2#54qxC0l={7REaMU*0mqOaM#LsJ+vV&*JGIQ5eZSyuOnXeJ$BxhjX zkNA%Dyk$A7ir$wvj>oOeZ^A2?`8W+|fl+m~RWig~H0Z9#fd+mc=)#ipp6BboL1 z-P^d0wP~J_Frt}72Aj7ry`bJ;1hUpFZ06QJGjm`+L$GOEw=rQbNX+cAwn-b)GpkH< zdK;5oroAg?zS~@2pxT{ot&K}(W=G$MxOwfc{UPbk^f zOFNKEC!{;gRFHMrm>%obJq-ix+Rx@oUt#xYS_6E&1#=i1Z6EbVGF-@zTX_4mY zuBRD~uSS}A=dCqnl4VNF9BUm3Q?j2<=wW+()vAP_nRl#K>RG$oNAWy?bV%z!`qSM> zKcUy@37yq&QpZ*y-36;^3ucq{i?1!dU)Gd_`Mm=oSPiRV4Rk`O^(0ZkaJi|)F$df_ z)mU1lrI1Ef*y~Ap^Lqmt(S*5}heL2EWE>;wN9N-&9F7H$H606a1dhZ}koHT~b{vgk zV6XqM*SFYfKuWFsIF`7_;do@Ph4J$56L2C&P0NaTt#Yn24UZ z9e3bP+=aVw5AMZ%xE~MTK|F*Nco>i1Q9Opn@dTd4Q+OKB;8{F}=kWqw#7lS?ui#a@ zhS%{1-o#sY8}Hy_!ytyQ+$Tc@ddubSNIy=;9Go$@9_hE#83Dczu;H= zhTriA{={GS8~@;6tcn`st`TAdA=9`lpW{@OHA2k`Ikx+ZzB1LQ{o@dZ2f`vcVg4qJ)c+Ras_bi8Zdb8xm<4sUY6ae3gkMA(_8;O* zYy4(~v|-vR?QK|l8}@&*4O>O(KK9{!Se2h0@!!?1N&i%;UCVjFfO>bqpPbXO)^#o<2_y4{1$UjD>Z&@k@WARJ0maM^5?kZ z+B(oM#B2T>Wc~Dn;&J+Q(w^md+CG-^r+LqZna8gM%Vp)apLNHK`{VInTrL+$*BfY1 zk0$?2+B01&7nQbk+f%mvCzs1zr62N#nb_pPB$>+agnlHCD%pqZxgBc^BKKC=QSAr9 z1l``xK!cBkHNK#cjQdmOGlbuhkDOO(TgsVl(<4+6SpeY)eb?H!P0ew?ZEf7r#ww#0t97_mB#z^8G@=c$*=kxvd#6-bda1^Q z`SAMNgmpaTRQk+{1j_g=hqTjC)?zWe6Xa}?di<+&)UC6oJ?DmbIz#r^{6E7v!5SiNxylK$G*JkurDfZ zG{&RTOwI=7Ekj)YmkQsausorc3GaA(d1{sGPD4(Pmk8^6`x9v3NSposi=I>mN(RriHh#sOci=0|al9*-rH2GBJ?x)pGn~#hzr$m@y?N+9ZPWT&H%@#}eSurQi`ceo_60cah zrQ)$(uAYAQ3Boy^;;8&8|!6 zdh=8D%r`paWk2WXPp4v5DL>$_Kh1rcS)=TZ?SA6SlDgO8x~6U8cW+eZu~4~FVO}KM zSBX3tl1*7zX!nvwURz^6BCpz-d-!~&+xuxft1knxyDO2t{ro){+*OJ6dFvF5)75zL zPSSV19wgzp)Z|Faf0QVaOZnI1z5BL>}h&FLNSXPaZ| zLztws?(JH_IF4(rfU@rG8p67M{H>enQgBy0Y_EEA5$EMqCAXImp7olerGzbKTqXU# zbW}?!v462RcdpE~<_d(^+yfE+5ilon|*?Rf#B`&A0`VN1ctSeOIb1~_=e!ZoJp}gs_ zzTUpv(k>z&rfS?B^R~z*b4=9O>cWcdmwLud<#Pe~@_jMy+EoI!XukD-)t*grROzMfuz^rimU1DVrE z-_7+NPvJC*$0JfE6-7}k7|w)_2<%E6kKiN{ZN`FNOprFwvh zmz{;QlPZ!vgZzY{p2a?~BI&DV)YZJ@38e4(@%8$nGCzHMMYcWZZ{T51IropNNcy~B zO{L|MLv zfLCFpne$R_5wQ1+_4Jk5H{J);oJYE1d001=DYq1PR7v?27@He0) z4+xW)$1QZf*$n72p9l8IcRcXc1D;(V-pJhi^X`piFG`lh%f8I*>NxRhS{0u!<4JO3 zG1;6(j5PB4S*C1QZXv@sEz0Npa`VXEqyYEB0}bjK_6T8HT@K6#hKc9cKU?L;EQUP( zuFWnLeoi_j?*g-LQy)zDsv`Tqh*G^v!yt_N?SkCcOQmJ)gI%*jeD<{$D~ETco6BjS?42RFG<_87`z|L<@95<2M6_(`a%(zO4DYN zK24}=?N26sub=Poh_NI=GLyk?JbnOqxj843mltzv9Bv-FRn=D8zry=g8{?(iW>(sM z;mPu&8S$uW=52!nj@0Vgykuj`MZ6|cUDE}jky+DD(61r zQJMN8FVD%XoxJCa{M>AdnvY?vysIZ@ubG%mK5q6i@lY&fw$!{+oV49+kLcZ55w5yN z)m}_BA^Y$+iQ(vwiLuRs$ z*%|Ljz7?(Oa^u3Pi@T6lcWJi^T;t076?f+IenmddtVxxCTzKtNDy#}8Z~fu>5eQq+ zx+D8&R~+)2NPbmC_JcLAX<4&B!68ggClq1Em)b|UZ>9o!LgPw>HN&X_8Cxo>q^ma6 z6RII>Me9ev&n1@GT8$yEik<^{6EkD-rWKhZ)1xdWRNdle@|E$ZTi3yP=N{h#7U9dQ ztuIhfec34TtZ1F&p@QuEMv|YK{l2ZB z>&^KJxoETYX9RgITU}eQI?v)Jj7_$Y;8+|7c~-tFHbOUSj7E5I0y?q3YoasO!rGAMtJmS@y6DaCUHG{k*2f0e z5M6N_pY=i?^u=b_9R08jwncwzhiZ5*00S`ygE0g{F$~*dI7VOx?1+&Vh0z#;8jQs_ zjK>5_L{DtQHg&@n{Qf0!-)FIyzkP@A@dGv{to_ak`NE-1u^Bc;cWi+zQAgN%^x*d@ zY=y1S6TNT*pY`TvAM`~(Y=dplAKSqoOf^3}@L~W4Vh~Q_v(vEzb8rljkTx=n1~fsQ z@0y20a46>EM4W_^aSBdF9M|Al+<-H&2xsAJoP%?59?r)FxDXfNVqAhtaTzYh6}TC< zVmWTd9k>&B;cnc6dvPD`#{+l}4`Br!#v^zXkKu7VfsWV^n_yFP#}?QUJy3zNg z!B~vLcuc@VOu|ms8M|Ot?1sshg59wPreaS_!(Nzybh6vH_t zx$mCfdM)pJw_3a~fVWQ!xB9!sNMrDwqk6RWckTV%X4Hkv(H&c0OVm-n+WWiq{%$OF zVI0O|0w!V-c0zl9*WTa#zv}M>wCwMSzI%sTiRz_0+tbfYB~Huh{FQp=j+rEB4I|CT zuB92$hLT>Dq*q{$tj>DAX$WCP=7w=xt6{!qyv{J+6EK+gGFE7jhhuyeS(wX2v_Zs` z>$nziv)5o)8!69L4J7OXTt`1nyP$8k@76M|c!J+M5dTSjF5%~DSRHGi6V^m$tcA6) z4%S5%tOvOcO5hmmgq^Vq*2f0e6}v%>$rS94Js`(@PfWvJn2x=XL<(ti#b($Xy&>0E zjcCGL%)=o#6jBD;U_Oq;aX20up&K@a7bjpTuENzg3WwuFoP?8c3Qk2Fr{Q!A#2{RQ zYhm}j*YW%HxB+Kk5zc~r{Z`HIJK$WLhx2g(F2qF`f&RD{+rfiNAoXb!Mq>dIwU4Ewt8Mt)z0n{YF3!I8KX%W)fep%40ETMWQp48c$g!}iz_<1ii*FcCd*JMO@p zxC?jV9^8xja6cZvgLnul@Gu_1qj(ID;|aWjckv$H#|L<7mF8=$!}#|CEW{Bw8fV~2 zJc+09G@ik;cn;6w1-yut@G@S(t9T8s;|)adCfth3Kh_2WO-S7orzr&i(UJSrM3_?df+feewrs$3>uqAq+3R_`oOv1jHf&H*Q z4!}$th=bt6Ecj82!Q?RnLop0Gf7_m)!!ZIoU`LF^D2&D!)WGd=%-*EA5B9|>=zvwx z5i_tK_QwI3i34#Ee3%74Y7t={0{jd@M;+=Bf`NlE8(~BcMGSGwK>|snkVXR<(S*5} zheL2E=HoCNjs;kVBXA^+!qGSe$Kp5~j}verPQuAJ1*hUPoQ^ZG2xsAJoP%?59?r)F zxDXfNVqAhtaTylla$JEcu>?zT6|TlLxE9ypdfb2;u?#oiX54~Xu^hMIcHDtGaTo5! zJ-8S5;eI@T2k{VA;9)$1M=_k^k$YXu?cx^is+D&-=3ZA1p#PJ3BpqslfF#)7`yK*)Yr(d9DyCMBSvBr zMq>`R;JypBVIjvkaiWe!q(`CUO0l!dh@dnR;CR;jrgZy z3FhD!B#}ZI4QRq#%)=o#6!UQ+PQuAJ1*am8Yj7=Yz?oQtvv4-f!MQjO=i>rgh>LJB zF2SX^442~y$Qa^QEQg!@{{Jui&tdG>0xZPQ7|F35h0z#;8jQs_jK>5_#3by5ov{mc z#cr64DcBu*U@G>+H0*`xc#C{usKhvCZ_?if|JVDvGbn@qZT+3Jp}GBCp?PHcy4q`9 z=RHqZEZzLEe(l$J?bmsQ`d;a83-zmRw)gLl$GdnB@8bhJMZL7!!t8cf`c-L*E73km zyYMug!L#UuHPIPsVQsWu=e1ww1*iu>=%_6R@+WWosey_dX+k!F0mgs>hY=y1SKEK&Mzqy#c;&NPp zE3pJi@!vVWSwr2-z1}O-@8#WK4W!j~*HqIF${f85_f-pI!TcWSPtQxg{P&Or_?}%> zd`Ebk%zm}Ldaq7@(w*AIbmf`t>{PdPVOw+4lm+A4xR9>()tD{HpkGDOjmP_v?u<5+ zt+lPz+pJq`veu_kX;aX>NjtwTx2~>P+a8Ri<<0&rx4l;-(`Wm8l73sxm1M*>Xn-%j z*tc$DnHNh}>h@M`-{!%C3T$&#+qb!3y0XnZT-fHJ1-5z1wx>I+(DB=%?PXCgT`7z1 zq&>9_=ek)p%x~~X8UfWdZ|-`U@%UzKPjm19p7WA#qp-JgQ`ggs$2V~y%|SWaxv}eM z#^c>wNONe;c5c-6G=~k$Nwcf#X~yFllIG+#)Oi_`Q17=N;7h3Y)okEudhz)B?xZ)| z-oEu*O)nnr;!b)a?Co3E)%4==bx5x*;}`oo-FfKGkOlbJ!+^Ehn6~}>^M%r0%Y|}~ z$HxN!A763e33YDcwpwGMus_SOcA~COTs+tc`WBE@fE(tH~1Fc z;d}gmAMq1@#xM94f3Y2Z<9hsqfAJ2M;woH?1a88+xDm_n9^S_-I1<<4100Lva6B4u z0&0+ZU0>)vZh?z#bzR@dIzNA7d%GPvxBdL2JcnU>495uUfE_Usqc9p{P=m1;hw+$z ziRg*n@dy4y`}x^^e(IB0n4k3Kord;z2j_iY&AY8(ou9wApPzYa%G=M+_WrZ2{pS$c z=dAuS?=-Z}&xoII9=6WO)j20+tm494xRos9OVYfxqqg7=&hz8m?GTo6@}K2oZ?Qg|$+>QtEARfXBJd8*1C?3P(cmhx2DLjp5@GPFg^LPO-;w8L{SMVxc!|Qkh rZ{jVy4OugH2C~<%$@Pg`i`ds7AMpDsgz11)(GgGLAO8L?R>gk-CqfDN literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/.ninja_log b/08_bilateral_filter/MLRichard/build/conda-release/.ninja_log new file mode 100644 index 0000000..9a0ef43 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/.ninja_log @@ -0,0 +1,22 @@ +# ninja log v7 +3 225 1773564738627201677 CMakeFiles/bilateral_filter.dir/src/metrics.cpp.o 8fa559955a914ab4 +4 229 1773564738627201677 CMakeFiles/test_correctness.dir/src/metrics.cpp.o f85da7147ab98fc5 +3 401 1773564738627201677 CMakeFiles/test_correctness.dir/test/test_correctness.cpp.o 8b079f6205514c2a +4 470 1773564738627201677 CMakeFiles/test_performance.dir/test/test_performance.cpp.o 2854e6f0a05c2bc8 +405 591 1773564739031198091 CMakeFiles/test_performance.dir/src/metrics.cpp.o 95d19b130e8d0fc9 +2 1968 1773564738627201677 CMakeFiles/bilateral_filter.dir/src/reference.cpp.o c2d103b6a05a3c3f +4 2004 1773564738627201677 CMakeFiles/test_correctness.dir/src/reference.cpp.o 9d447d7213d5e6e7 +2 2054 1773564738627201677 CMakeFiles/bilateral_filter.dir/src/io.cpp.o 4abe2da84b72e48a +229 2133 1773564738855199653 CMakeFiles/test_performance.dir/src/reference.cpp.o 84d515c7d1ef4dd9 +3 2162 1773564738627201677 CMakeFiles/test_correctness.dir/src/io.cpp.o f9a430fc9bf6244b +226 2208 1773564738851199688 CMakeFiles/test_performance.dir/src/io.cpp.o 1a98c94d07bb3c94 +5 3128 1773564738631201641 CMakeFiles/test_performance.dir/src/bilateral_filter.cu.o 7325907243128c3e +3 3132 1773564738627201677 CMakeFiles/test_correctness.dir/src/bilateral_filter.cu.o c670f2f165be05ae +2 3132 1773564738627201677 CMakeFiles/bilateral_filter.dir/src/bilateral_filter.cu.o 85bc60fdacd5e374 +3132 3182 1773564741755173910 CMakeFiles/test_correctness.dir/cmake_device_link.o 3c60f23f528236b +3128 3183 1773564741751173945 CMakeFiles/test_performance.dir/cmake_device_link.o 959f1b5a9762f1f7 +1 3292 1773564738627201677 CMakeFiles/bilateral_filter.dir/src/main.cu.o 3ee1262267863a4b +3292 3345 1773564741915172488 CMakeFiles/bilateral_filter.dir/cmake_device_link.o 93c2a1140a654a6e +3182 3375 1773564741807173448 test_correctness 3a064eb69ab0c5b0 +3183 3379 1773564741807173448 test_performance f44ee17220362917 +3345 3435 1773564741971171992 bilateral_filter 507a6e0a69813547 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeCache.txt b/08_bilateral_filter/MLRichard/build/conda-release/CMakeCache.txt new file mode 100644 index 0000000..1aa87d0 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeCache.txt @@ -0,0 +1,438 @@ +# This is the CMakeCache file. +# For build in directory: /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release +# It was generated by CMake: /home/richard/miniconda3/envs/bilateral-cuda124/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 +######################## + +//Build the testing tree. +BUILD_TESTING:BOOL=ON + +//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=Release + +//CUDA architectures +CMAKE_CUDA_ARCHITECTURES:STRING=52 + +//CUDA compiler +CMAKE_CUDA_COMPILER:FILEPATH=/home/richard/miniconda3/envs/bilateral-cuda124/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-11 + +//A wrapper around 'ranlib' adding the appropriate '--plugin' option +// for the GCC compiler +CMAKE_CXX_COMPILER_RANLIB:FILEPATH=/usr/bin/gcc-ranlib-11 + +//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 build database during the build. +CMAKE_EXPORT_BUILD_DATABASE:BOOL= + +//No help, variable specified on the command line. +CMAKE_EXPORT_COMPILE_COMMANDS:UNINITIALIZED=ON + +//Value Computed by CMake. +CMAKE_FIND_PACKAGE_REDIRECTS_DIR:STATIC=/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/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 + +//Program used to build from build.ninja files. +CMAKE_MAKE_PROGRAM:FILEPATH=/home/richard/miniconda3/envs/bilateral-cuda124/bin/ninja + +//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 + +//No help, variable specified on the command line. +CMAKE_PREFIX_PATH:UNINITIALIZED=/home/richard/miniconda3/envs/bilateral-cuda124 + +//Value Computed by CMake +CMAKE_PROJECT_COMPAT_VERSION:STATIC= + +//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=bilateral_filter + +//Value Computed by CMake +CMAKE_PROJECT_SPDX_LICENSE:STATIC= + +//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 archiver during the creation of static libraries +// during all build types. +CMAKE_STATIC_LINKER_FLAGS:STRING= + +//Flags used by the archiver during the creation of static libraries +// during DEBUG builds. +CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the archiver during the creation of static libraries +// during MINSIZEREL builds. +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the archiver during the creation of static libraries +// during RELEASE builds. +CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the archiver 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 the coverage program that CTest uses for performing coverage +// inspection +COVERAGE_COMMAND:FILEPATH=/usr/bin/gcov + +//Extra command line flags to pass to the coverage tool +COVERAGE_EXTRA_FLAGS:STRING=-l + +//How many times to retry timed-out CTest submissions. +CTEST_SUBMIT_RETRY_COUNT:STRING=3 + +//How long to wait between timed-out CTest submissions. +CTEST_SUBMIT_RETRY_DELAY:STRING=5 + +//No help, variable specified on the command line. +CUDAToolkit_ROOT:UNINITIALIZED=/home/richard/miniconda3/envs/bilateral-cuda124 + +//Maximum time allowed before CTest will kill the test. +DART_TESTING_TIMEOUT:STRING=1500 + +//Command to build the project +MAKECOMMAND:STRING=/home/richard/miniconda3/envs/bilateral-cuda124/bin/cmake --build . --config "${CTEST_CONFIGURATION_TYPE}" + +//Path to the memory checking command, used for memory error detection. +MEMORYCHECK_COMMAND:FILEPATH=/home/richard/miniconda3/envs/bilateral-cuda124/bin/compute-sanitizer + +//File that contains suppressions for the memory checker +MEMORYCHECK_SUPPRESSIONS_FILE:FILEPATH= + +//No help, variable specified on the command line. +OpenCV_DIR:UNINITIALIZED=/home/richard/miniconda3/envs/bilateral-cuda124/lib/cmake/opencv4 + +//Name of the computer/site where compile is being run +SITE:STRING=Desktop + +//Value Computed by CMake +bilateral_filter_BINARY_DIR:STATIC=/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release + +//Value Computed by CMake +bilateral_filter_IS_TOP_LEVEL:STATIC=ON + +//Value Computed by CMake +bilateral_filter_SOURCE_DIR:STATIC=/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard + + +######################## +# 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/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release +//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=2 +//Patch version of cmake used to create the current loaded cache +CMAKE_CACHE_PATCH_VERSION:INTERNAL=3 +//Path to CMake executable. +CMAKE_COMMAND:INTERNAL=/home/richard/miniconda3/envs/bilateral-cuda124/bin/cmake +//Path to cpack program executable. +CMAKE_CPACK_COMMAND:INTERNAL=/home/richard/miniconda3/envs/bilateral-cuda124/bin/cpack +//ADVANCED property for variable: CMAKE_CTEST_COMMAND +CMAKE_CTEST_COMMAND-ADVANCED:INTERNAL=1 +//Path to ctest program executable. +CMAKE_CTEST_COMMAND:INTERNAL=/home/richard/miniconda3/envs/bilateral-cuda124/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=/home/richard/miniconda3/envs/bilateral-cuda124/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_BUILD_DATABASE +CMAKE_EXPORT_BUILD_DATABASE-ADVANCED:INTERNAL=1 +//Name of external makefile project generator. +CMAKE_EXTRA_GENERATOR:INTERNAL= +//Name of generator. +CMAKE_GENERATOR:INTERNAL=Ninja +//Generator instance identifier. +CMAKE_GENERATOR_INSTANCE:INTERNAL= +//Name of generator platform. +CMAKE_GENERATOR_PLATFORM:INTERNAL= +//Name of generator toolset. +CMAKE_GENERATOR_TOOLSET:INTERNAL= +//Source directory with the top level CMakeLists.txt file for this +// project +CMAKE_HOME_DIRECTORY:INTERNAL=/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard +//Install .so files without execute permission. +CMAKE_INSTALL_SO_NO_EXE:INTERNAL=1 +//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=/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2 +//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: COVERAGE_COMMAND +COVERAGE_COMMAND-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: COVERAGE_EXTRA_FLAGS +COVERAGE_EXTRA_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CTEST_SUBMIT_RETRY_COUNT +CTEST_SUBMIT_RETRY_COUNT-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CTEST_SUBMIT_RETRY_DELAY +CTEST_SUBMIT_RETRY_DELAY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: DART_TESTING_TIMEOUT +DART_TESTING_TIMEOUT-ADVANCED:INTERNAL=1 +//Details about finding OpenCV +FIND_PACKAGE_MESSAGE_DETAILS_OpenCV:INTERNAL=[/home/richard/miniconda3/envs/bilateral-cuda124][v4.13.0()] +//ADVANCED property for variable: MAKECOMMAND +MAKECOMMAND-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: MEMORYCHECK_COMMAND +MEMORYCHECK_COMMAND-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: MEMORYCHECK_SUPPRESSIONS_FILE +MEMORYCHECK_SUPPRESSIONS_FILE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: SITE +SITE-ADVANCED:INTERNAL=1 + diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CMakeCUDACompiler.cmake b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CMakeCUDACompiler.cmake new file mode 100644 index 0000000..4e368a9 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CMakeCUDACompiler.cmake @@ -0,0 +1,90 @@ +set(CMAKE_CUDA_COMPILER "/home/richard/miniconda3/envs/bilateral-cuda124/bin/nvcc") +set(CMAKE_CUDA_HOST_COMPILER "") +set(CMAKE_CUDA_HOST_LINK_LAUNCHER "/usr/bin/g++") +set(CMAKE_CUDA_COMPILER_ID "NVIDIA") +set(CMAKE_CUDA_COMPILER_VERSION "12.4.131") +set(CMAKE_CUDA_HOST_COMPILER_ID "GNU") +set(CMAKE_CUDA_HOST_COMPILER_VERSION "11.4.0") +set(CMAKE_CUDA_DEVICE_LINKER "/home/richard/miniconda3/envs/bilateral-cuda124/bin/nvlink") +set(CMAKE_CUDA_FATBINARY "/home/richard/miniconda3/envs/bilateral-cuda124/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 "11.4") +set(CMAKE_CUDA_COMPILER_ARCHITECTURE_ID "x86_64") + + + +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 "x86_64-linux-gnu") + +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 "x86_64-linux-gnu") +endif() + +set(CMAKE_CUDA_COMPILER_TOOLKIT_ROOT "/home/richard/miniconda3/envs/bilateral-cuda124") +set(CMAKE_CUDA_COMPILER_TOOLKIT_LIBRARY_ROOT "/home/richard/miniconda3/envs/bilateral-cuda124") +set(CMAKE_CUDA_COMPILER_TOOLKIT_VERSION "12.4.131") +set(CMAKE_CUDA_COMPILER_LIBRARY_ROOT "/home/richard/miniconda3/envs/bilateral-cuda124") + +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") +set(CMAKE_CUDA_ARCHITECTURES_ALL_MAJOR "50-real;60-real;70-real;80-real;90") +set(CMAKE_CUDA_ARCHITECTURES_NATIVE "89-real") + +set(CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES "/home/richard/miniconda3/envs/bilateral-cuda124/include") + +set(CMAKE_CUDA_HOST_IMPLICIT_LINK_LIBRARIES "") +set(CMAKE_CUDA_HOST_IMPLICIT_LINK_DIRECTORIES "/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs;/home/richard/miniconda3/envs/bilateral-cuda124/lib") +set(CMAKE_CUDA_HOST_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "") + +set(CMAKE_CUDA_IMPLICIT_INCLUDE_DIRECTORIES "/usr/include/c++/11;/usr/include/x86_64-linux-gnu/c++/11;/usr/include/c++/11/backward;/usr/lib/gcc/x86_64-linux-gnu/11/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include") +set(CMAKE_CUDA_IMPLICIT_LINK_LIBRARIES "stdc++;m;gcc_s;gcc;c;gcc_s;gcc") +set(CMAKE_CUDA_IMPLICIT_LINK_DIRECTORIES "/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs;/home/richard/miniconda3/envs/bilateral-cuda124/lib;/usr/lib/gcc/x86_64-linux-gnu/11;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/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.38) +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/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CMakeCXXCompiler.cmake b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CMakeCXXCompiler.cmake new file mode 100644 index 0000000..4633856 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CMakeCXXCompiler.cmake @@ -0,0 +1,104 @@ +set(CMAKE_CXX_COMPILER "/usr/bin/c++") +set(CMAKE_CXX_COMPILER_ARG1 "") +set(CMAKE_CXX_COMPILER_ID "GNU") +set(CMAKE_CXX_COMPILER_VERSION "11.4.0") +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 "23") +set(CMAKE_CXX_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters;cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates;cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates;cxx_std_17;cxx_std_20;cxx_std_23") +set(CMAKE_CXX98_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters") +set(CMAKE_CXX11_COMPILE_FEATURES "cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates") +set(CMAKE_CXX14_COMPILE_FEATURES "cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates") +set(CMAKE_CXX17_COMPILE_FEATURES "cxx_std_17") +set(CMAKE_CXX20_COMPILE_FEATURES "cxx_std_20") +set(CMAKE_CXX23_COMPILE_FEATURES "cxx_std_23") +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_CXX_COMPILER_ARCHITECTURE_ID "x86_64") + + + +set(CMAKE_AR "/usr/bin/ar") +set(CMAKE_CXX_COMPILER_AR "/usr/bin/gcc-ar-11") +set(CMAKE_RANLIB "/usr/bin/ranlib") +set(CMAKE_CXX_COMPILER_RANLIB "/usr/bin/gcc-ranlib-11") +set(CMAKE_LINKER "/usr/bin/ld") +set(CMAKE_LINKER_LINK "") +set(CMAKE_LINKER_LLD "") +set(CMAKE_CXX_COMPILER_LINKER "/usr/bin/ld") +set(CMAKE_CXX_COMPILER_LINKER_ID "GNU") +set(CMAKE_CXX_COMPILER_LINKER_VERSION 2.38) +set(CMAKE_CXX_COMPILER_LINKER_FRONTEND_VARIANT GNU) +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 TRUE) +set(CMAKE_CXX_ABI_COMPILED TRUE) + +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 TRUE) +set(CMAKE_LINKER_PUSHPOP_STATE_SUPPORTED TRUE) +set(CMAKE_CXX_LINKER_PUSHPOP_STATE_SUPPORTED TRUE) + +# Save compiler ABI information. +set(CMAKE_CXX_SIZEOF_DATA_PTR "8") +set(CMAKE_CXX_COMPILER_ABI "ELF") +set(CMAKE_CXX_BYTE_ORDER "LITTLE_ENDIAN") +set(CMAKE_CXX_LIBRARY_ARCHITECTURE "x86_64-linux-gnu") + +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 "x86_64-linux-gnu") +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 "/home/richard/miniconda3/envs/bilateral-cuda124/include;/usr/include/c++/11;/usr/include/x86_64-linux-gnu/c++/11;/usr/include/c++/11/backward;/usr/lib/gcc/x86_64-linux-gnu/11/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include") +set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "stdc++;m;gcc_s;gcc;c;gcc_s;gcc") +set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "/home/richard/miniconda3/envs/bilateral-cuda124/lib;/usr/lib/gcc/x86_64-linux-gnu/11;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib") +set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "") +set(CMAKE_CXX_COMPILER_CLANG_RESOURCE_DIR "") + +set(CMAKE_CXX_COMPILER_IMPORT_STD "") +### Imported target for C++23 standard library +set(CMAKE_CXX23_COMPILER_IMPORT_STD_NOT_FOUND_MESSAGE "Experimental `import std` support not enabled when detecting toolchain; it must be set before `CXX` is enabled (usually a `project()` call)") + + + diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CMakeDetermineCompilerABI_CUDA.bin b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CMakeDetermineCompilerABI_CUDA.bin new file mode 100755 index 0000000000000000000000000000000000000000..aea199361643e309742e727529354da7fb2aabca GIT binary patch literal 993728 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

gLo|DXv!cb#-%U;Gj$G~Z{aU}LRpN4XK z(npcAOxq1}jh)6^<0KiOKs?HY9)?*21A+J@WbE2L=QiGy45B^)0inwz^jd#ky0>X&te0`XEwb*fh1@ zLv+qMO#wWh{NY|J>0~G;%%kkpl)G56!Gqg05_ zSf_g!wcdKOoxv9MvGB^6d7%pt4L=??FR4|m5u35uZ2y>py|~%*BN67E4t!?!?-_0O z1FEcqdm34pQxgqSDzfj2b$3GKk%_2ks(WNFV=4@vSO=e2;x`Moyk9;5v~6n4zPkh6I?QqvbFX*3NP)n4u$R zXDN1ERZ%hd$E`xVigIVtRo{;5AQ_)M3ODe+1RW|R`ENxHc!BIlx#eQ#AIg1~tf(8o z5Gx73+sdx(b=I=!x2T<#n)6Syc3MMuO`WL2rr+yD4mK<-#ZW8Kuf9PlD?ln~2Q}v4 z%u#(CaGpx$Pg$Y+2}7^5vhz#56#t`m!@AIdNdnrK;8l4eFldr9thTTR11j=&0#MU{ zQE%4$>Nk-a#9Qmc5+5XDg#tIzmCEZkbP~GAHh2MZzwnlxAK8a3J$Fb7L%`m`Ey&aq zw$#R}=l-jVebf1tGFkbwQYPNkP327YhRmLH1X+l8@QU7EA!~ra-%+G6^j#p&z;BSg z5djANI}_opw#3}I)iGz{zsyQN?mQ}_Q_^`d>8y>R8BIHndDZ)|s_ukD43n6Io33=T z|4KP^KAo0wro(qntBT#0s7^SE+Q@A)>teUf2``PD45>AOGq9G)VG;|4Rab@a3{T_ho%)k84ptVlY~h)a*G*7cQUG=U{z`jwVu zC{;@%)i_d2t6dtYV|l{-ugg@{cbUerOv^LJC!DA*lf`E0tZC@wzWwi7sO#}`X+5;R zBEOmVsLO@kT@#nemVBKzW_{RE_&w&&{IYc4dEI;VZLpEM+o3!%ALRJ1s=DFaeq zc@!?0i-q%VtQwRJC-QUGyCZrJJWcCmPh^s3y{(hnPL4ObM`w63X*ZHsI;yJ7ZR|a; z@T7iZZ}bwQ=^Tf1&yN>Uv%%E-4y7q73O(;MZD8-&(!hDp1m{hge?#S

$#h;-0NY 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

&VobLKrE#JP|ei4XK&!U2d!WJdRGKt=R7 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 z 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�aM^y}Fl`XQIvzVFsFVcP3!->9E#$8Y1?_5aZ{ z{&xM??885(KeX2`Pxmk5b86e;|IF`liS7Gm&%DXMXXU?TO#P|;w>_TryFc~A`uJR;OHH-EH!vcCTG^tQeJx%cbipZ!JsKznWHI}KZ&fBSvz@A~*}PvhI`-~Y+x1Zc-? z-}g6L<1gN<-`rk*qJ40B-M;?sOyk@0o86nvY+5F!wKe{4f4`1zuOELQ zPiOUS`}p7Ur~K}7?Tep%p?>(I>2>>oZN2{=pUxDY%#L}xIsRJxw&j1@@t3boFZZ~O zzc!7(HXVQKaNYd-S>tnsZTxG~_}8ZKfA_}n(B+3~n{Q`dGB|6mji3F;bpHP|y-pLW z&Ej_6?Y#cd*!APj{&O1l&-L~D?Y>UOZR6YPuWp_H?7P$Wf2*$#w$At3*83N>#y^;L97{&X7u-N~M|&tGdlOs{WE$A4k#_ig-dZvEcJ%fI#4 z<=S2Q?8npbzx7-7lV9?;KQ^`7`M2xJY;WhjHhlKrt3O`e{`$XfetSD^`|KC582?wl OR9F7jw+3vzo&6uAUk0E6 literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CMakeDetermineCompilerABI_CXX.bin b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CMakeDetermineCompilerABI_CXX.bin new file mode 100755 index 0000000000000000000000000000000000000000..0d2fe7406ff5c17cbc37d4f3737c181371bff2f3 GIT binary patch literal 16048 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 literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CMakeSystem.cmake b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CMakeSystem.cmake new file mode 100644 index 0000000..2f7ed46 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CMakeSystem.cmake @@ -0,0 +1,15 @@ +set(CMAKE_HOST_SYSTEM "Linux-6.6.87.2-microsoft-standard-WSL2") +set(CMAKE_HOST_SYSTEM_NAME "Linux") +set(CMAKE_HOST_SYSTEM_VERSION "6.6.87.2-microsoft-standard-WSL2") +set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64") + + + +set(CMAKE_SYSTEM "Linux-6.6.87.2-microsoft-standard-WSL2") +set(CMAKE_SYSTEM_NAME "Linux") +set(CMAKE_SYSTEM_VERSION "6.6.87.2-microsoft-standard-WSL2") +set(CMAKE_SYSTEM_PROCESSOR "x86_64") + +set(CMAKE_CROSSCOMPILING "FALSE") + +set(CMAKE_SYSTEM_LOADED 1) diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/CMakeCUDACompilerId.cu b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/CMakeCUDACompilerId.cu new file mode 100644 index 0000000..e53cca4 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/CMakeCUDACompilerId.cu @@ -0,0 +1,964 @@ +#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(__RENESAS__) +# define HOST_COMPILER_ID "Renesas" +/* __RENESAS_VERSION__ = 0xVVRRPP00 */ +# define HOST_COMPILER_VERSION_MAJOR HEX(__RENESAS_VERSION__ >> 24 & 0xFF) +# define HOST_COMPILER_VERSION_MINOR HEX(__RENESAS_VERSION__ >> 16 & 0xFF) +# define HOST_COMPILER_VERSION_PATCH HEX(__RENESAS_VERSION__ >> 8 & 0xFF) + +#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 + +#elif defined(__DCC__) && defined(_DIAB_TOOL) +# define HOST_COMPILER_ID "Diab" + # define HOST_COMPILER_VERSION_MAJOR DEC(__VERSION_MAJOR_NUMBER__) + # define HOST_COMPILER_VERSION_MINOR DEC(__VERSION_MINOR_NUMBER__) + # define HOST_COMPILER_VERSION_PATCH DEC(__VERSION_ARCH_FEATURE_NUMBER__) + # define HOST_COMPILER_VERSION_TWEAK DEC(__VERSION_BUG_FIX_NUMBER__) + + + +#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 + +#elif defined(__RENESAS__) +# if defined(__CCRX__) +# define ARCHITECTURE_ID "RX" + +# elif defined(__CCRL__) +# define ARCHITECTURE_ID "RL78" + +# elif defined(__CCRH__) +# define ARCHITECTURE_ID "RH850" + +# 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/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/a.out b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/a.out new file mode 100755 index 0000000000000000000000000000000000000000..6d8a1e04d972d498c5afab6f4cd84ffcf8041f2e GIT binary patch literal 998136 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

F!5 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

57#>^Mq+b%MvdPB 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%0A8B>}^; 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

TyV}JTxwZcl- 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

Hvt;48iJnFA}+Y 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 QZ{DaY_X}GCw%*RZ3oRCurvLx| literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp1.ii b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp1.ii new file mode 100644 index 0000000..71886f7 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp1.ii @@ -0,0 +1,34563 @@ +# 0 "CMakeCUDACompilerId.cu" +# 0 "" +# 0 "" +# 1 "/usr/include/stdc-predef.h" 1 3 4 +# 0 "" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 1 +# 61 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +#pragma GCC diagnostic push + + +#pragma GCC diagnostic ignored "-Wunused-function" +# 82 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_config.h" 1 +# 218 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_config.h" +# 1 "/usr/include/features.h" 1 3 4 +# 392 "/usr/include/features.h" 3 4 +# 1 "/usr/include/features-time64.h" 1 3 4 +# 20 "/usr/include/features-time64.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 21 "/usr/include/features-time64.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 1 3 4 +# 19 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 2 3 4 +# 22 "/usr/include/features-time64.h" 2 3 4 +# 393 "/usr/include/features.h" 2 3 4 +# 486 "/usr/include/features.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 1 3 4 +# 559 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 560 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4 +# 561 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4 +# 487 "/usr/include/features.h" 2 3 4 +# 510 "/usr/include/features.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 1 3 4 +# 10 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs-64.h" 1 3 4 +# 11 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 2 3 4 +# 511 "/usr/include/features.h" 2 3 4 +# 219 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_config.h" 2 +# 83 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 + + + + + + + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 56 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_types.h" 1 +# 59 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_types.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 64 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" +# 1 "/usr/include/ctype.h" 1 3 4 +# 26 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types.h" 1 3 4 +# 27 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 1 3 4 +# 19 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 2 3 4 +# 29 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 + + + +# 31 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/bits/types.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/typesizes.h" 1 3 4 +# 142 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/time64.h" 1 3 4 +# 143 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 + + +typedef unsigned long int __dev_t; +typedef unsigned int __uid_t; +typedef unsigned int __gid_t; +typedef unsigned long int __ino_t; +typedef unsigned long int __ino64_t; +typedef unsigned int __mode_t; +typedef unsigned 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/x86_64-linux-gnu/bits/endian.h" 1 3 4 +# 35 "/usr/include/x86_64-linux-gnu/bits/endian.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/endianness.h" 1 3 4 +# 36 "/usr/include/x86_64-linux-gnu/bits/endian.h" 2 3 4 +# 40 "/usr/include/ctype.h" 2 3 4 + + + + + + +enum +{ + _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), + _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), + _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), + _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), + _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), + _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), + _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), + _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), + _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), + _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), + _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), + _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8)) +}; +# 79 "/usr/include/ctype.h" 3 4 +extern const unsigned short int **__ctype_b_loc (void) + noexcept (true) __attribute__ ((__const__)); +extern const __int32_t **__ctype_tolower_loc (void) + noexcept (true) __attribute__ ((__const__)); +extern const __int32_t **__ctype_toupper_loc (void) + noexcept (true) __attribute__ ((__const__)); +# 108 "/usr/include/ctype.h" 3 4 +extern int isalnum (int) noexcept (true); +extern int isalpha (int) noexcept (true); +extern int iscntrl (int) noexcept (true); +extern int isdigit (int) noexcept (true); +extern int islower (int) noexcept (true); +extern int isgraph (int) noexcept (true); +extern int isprint (int) noexcept (true); +extern int ispunct (int) noexcept (true); +extern int isspace (int) noexcept (true); +extern int isupper (int) noexcept (true); +extern int isxdigit (int) noexcept (true); + + + +extern int tolower (int __c) noexcept (true); + + +extern int toupper (int __c) noexcept (true); + + + + +extern int isblank (int) noexcept (true); + + + + +extern int isctype (int __c, int __mask) noexcept (true); + + + + + + +extern int isascii (int __c) noexcept (true); + + + +extern int toascii (int __c) noexcept (true); + + + +extern int _toupper (int) noexcept (true); +extern int _tolower (int) noexcept (true); +# 237 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 1 3 4 +# 22 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h" 1 3 4 +# 27 "/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h" 3 4 +struct __locale_struct +{ + + struct __locale_data *__locales[13]; + + + const unsigned short int *__ctype_b; + const int *__ctype_tolower; + const int *__ctype_toupper; + + + const char *__names[13]; +}; + +typedef struct __locale_struct *__locale_t; +# 23 "/usr/include/x86_64-linux-gnu/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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 2 +# 60 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_types.h" 2 +# 68 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_types.h" + +# 68 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_types.h" +enum __attribute__((device_builtin)) cudaRoundMode +{ + cudaRoundNearest, + cudaRoundZero, + cudaRoundPosInf, + cudaRoundMinInf +}; +# 57 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 2 + + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" 1 +# 59 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 60 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" 2 + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" 1 +# 65 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 66 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" 2 +# 104 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" 2 +# 83 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/limits.h" 1 3 4 +# 34 "/usr/lib/gcc/x86_64-linux-gnu/11/include/limits.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/syslimits.h" 1 3 4 + + + + + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/limits.h" 1 3 4 +# 203 "/usr/lib/gcc/x86_64-linux-gnu/11/include/limits.h" 3 4 +# 1 "/usr/include/limits.h" 1 3 4 +# 26 "/usr/include/limits.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/bits/posix1_lim.h" 1 3 4 +# 27 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 2 3 4 +# 161 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 1 3 4 +# 38 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 3 4 +# 1 "/usr/include/linux/limits.h" 1 3 4 +# 39 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 2 3 4 +# 81 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h" 1 3 4 +# 23 "/usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h" 3 4 + +# 23 "/usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h" 3 4 +extern "C" { +extern long int __sysconf (int __name) noexcept (true); +} +# 82 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 2 3 4 +# 162 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 2 3 4 +# 196 "/usr/include/limits.h" 2 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/posix2_lim.h" 1 3 4 +# 200 "/usr/include/limits.h" 2 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 1 3 4 +# 64 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/uio_lim.h" 1 3 4 +# 65 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 2 3 4 +# 204 "/usr/include/limits.h" 2 3 4 +# 204 "/usr/lib/gcc/x86_64-linux-gnu/11/include/limits.h" 2 3 4 +# 8 "/usr/lib/gcc/x86_64-linux-gnu/11/include/syslimits.h" 2 3 4 +# 35 "/usr/lib/gcc/x86_64-linux-gnu/11/include/limits.h" 2 3 4 +# 84 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" 2 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4 +# 143 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 3 4 +typedef long int ptrdiff_t; +# 209 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 3 4 +typedef long unsigned int size_t; +# 415 "/usr/lib/gcc/x86_64-linux-gnu/11/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)))); +# 426 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 3 4 +} max_align_t; + + + + + + + typedef decltype(nullptr) nullptr_t; +# 85 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" 2 +# 205 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + +# 205 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorAddressOfConstant = 22, +# 345 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorTextureFetchFailed = 23, +# 354 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorTextureNotBound = 24, +# 363 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorSynchronizationError = 25, + + + + + cudaErrorInvalidFilterSetting = 26, + + + + + + cudaErrorInvalidNormSetting = 27, + + + + + + + + cudaErrorMixedDeviceExecution = 28, + + + + + + + + cudaErrorNotYetImplemented = 31, +# 399 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorMemoryValueTooLarge = 32, + + + + + + cudaErrorStubLibrary = 34, + + + + + + + cudaErrorInsufficientDriver = 35, + + + + + + + cudaErrorCallRequiresNewerDriver = 36, + + + + + + cudaErrorInvalidSurface = 37, + + + + + + cudaErrorDuplicateVariableName = 43, + + + + + + cudaErrorDuplicateTextureName = 44, + + + + + + cudaErrorDuplicateSurfaceName = 45, +# 453 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorDevicesUnavailable = 46, +# 466 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorIncompatibleDriverContext = 49, + + + + + + cudaErrorMissingConfiguration = 52, +# 481 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorPriorLaunchFailure = 53, + + + + + + cudaErrorLaunchMaxDepthExceeded = 65, + + + + + + + + cudaErrorLaunchFileScopedTex = 66, + + + + + + + + cudaErrorLaunchFileScopedSurf = 67, +# 519 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorSyncDepthExceeded = 68, +# 531 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorLaunchPendingCountExceeded = 69, + + + + + + cudaErrorInvalidDeviceFunction = 98, + + + + + + cudaErrorNoDevice = 100, + + + + + + + cudaErrorInvalidDevice = 101, + + + + + cudaErrorDeviceNotLicensed = 102, +# 564 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorSoftwareValidityNotEstablished = 103, + + + + + cudaErrorStartupFailure = 127, + + + + + cudaErrorInvalidKernelImage = 200, +# 584 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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, + + + + + cudaErrorInvalidSource = 300, + + + + + cudaErrorFileNotFound = 301, + + + + + cudaErrorSharedObjectSymbolNotFound = 302, + + + + + cudaErrorSharedObjectInitFailed = 303, + + + + + cudaErrorOperatingSystem = 304, + + + + + + + cudaErrorInvalidResourceHandle = 400, + + + + + + cudaErrorIllegalState = 401, + + + + + + + + cudaErrorLossyQuery = 402, + + + + + + + cudaErrorSymbolNotFound = 500, + + + + + + + + cudaErrorNotReady = 600, + + + + + + + + cudaErrorIllegalAddress = 700, +# 786 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorLaunchOutOfResources = 701, +# 797 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorLaunchTimeout = 702, + + + + + + cudaErrorLaunchIncompatibleTexturing = 703, + + + + + + + cudaErrorPeerAccessAlreadyEnabled = 704, + + + + + + + cudaErrorPeerAccessNotEnabled = 705, +# 830 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorSetOnActiveProcess = 708, + + + + + + + cudaErrorContextIsDestroyed = 709, + + + + + + + cudaErrorAssert = 710, + + + + + + + cudaErrorTooManyPeers = 711, + + + + + + cudaErrorHostMemoryAlreadyRegistered = 712, + + + + + + cudaErrorHostMemoryNotRegistered = 713, +# 872 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorHardwareStackError = 714, + + + + + + + + cudaErrorIllegalInstruction = 715, +# 889 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorMisalignedAddress = 716, +# 900 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorInvalidAddressSpace = 717, + + + + + + + + cudaErrorInvalidPc = 718, +# 919 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorLaunchFailure = 719, +# 928 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorCooperativeLaunchTooLarge = 720, + + + + + cudaErrorNotPermitted = 800, + + + + + + cudaErrorNotSupported = 801, +# 948 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorSystemNotReady = 802, + + + + + + + cudaErrorSystemDriverMismatch = 803, +# 964 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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, +# 1080 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorExternalDevice = 911, + + + + + + cudaErrorInvalidClusterSize = 912, + + + + + 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 +}; + + + + +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; +# 1184 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +}; +# 1353 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +struct __attribute__((device_builtin)) cudaAccessPolicyWindow { + void *base_ptr; + size_t num_bytes; + float hitRatio; + enum cudaAccessProperty hitProp; + enum cudaAccessProperty missProp; +}; +# 1371 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 1603 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + int device; + + + + + + void *devicePointer; +# 1618 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 1690 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + int preferredShmemCarveout; + + + + + + int clusterDimMustBeSet; +# 1707 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + int requiredClusterWidth; + int requiredClusterHeight; + int requiredClusterDepth; + + + + + + int clusterSchedulingPolicyPreference; +# 1737 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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, + cudaDevAttrMax +}; + + + + +enum __attribute__((device_builtin)) cudaMemPoolAttr +{ +# 2027 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaMemPoolReuseFollowEventDependencies = 0x1, + + + + + + + cudaMemPoolReuseAllowOpportunistic = 0x2, + + + + + + + + cudaMemPoolReuseAllowInternalDependencies = 0x3, +# 2053 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +}; + + + + +struct __attribute__((device_builtin)) cudaMemPoolProps { + enum cudaMemAllocationType allocType; + enum cudaMemAllocationHandleType handleTypes; + struct cudaMemLocation location; + + + + + + + void *win32SecurityAttributes; + size_t maxSize; + unsigned char reserved[56]; +}; + + + + +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)) 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 reserved2[2]; + int reserved1[1]; + int reserved[60]; +}; +# 2372 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +}; +# 2471 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +struct __attribute__((device_builtin)) cudaExternalMemoryHandleDesc { + + + + enum cudaExternalMemoryHandleType type; + union { + + + + + + int fd; +# 2498 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 2648 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 2712 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 2761 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 2807 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 2858 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + unsigned int flags; + unsigned int reserved[16]; +}; +# 2871 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; + + + + +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, +}; + + + + +struct __attribute__((device_builtin)) cudaConditionalNodeParams { + cudaGraphConditionalHandle handle; + + + enum cudaGraphConditionalNodeType type; + unsigned int size; + cudaGraph_t *phGraph_out; +# 3052 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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, +# 3087 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 3166 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + unsigned char to_port; + + + + + + + unsigned char type; + + + unsigned char reserved[5]; + +} cudaGraphEdgeData; +# 3199 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +} 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 + +}; +# 3365 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +typedef __attribute__((device_builtin)) enum cudaLaunchMemSyncDomain { + cudaLaunchMemSyncDomainDefault = 0, + cudaLaunchMemSyncDomainRemote = 1 +} cudaLaunchMemSyncDomain; +# 3381 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +# 3411 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + , cudaLaunchAttributeProgrammaticEvent = 7 +# 3437 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + , cudaLaunchAttributePriority = 8 + + , cudaLaunchAttributeMemSyncDomainMap = 9 + + , cudaLaunchAttributeMemSyncDomain = 10 + + , cudaLaunchAttributeLaunchCompletionEvent = 12 +# 3465 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + , cudaLaunchAttributeDeviceUpdatableKernelNode = 13 +# 3493 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +} cudaLaunchAttributeID; + + + + +typedef __attribute__((device_builtin)) union cudaLaunchAttributeValue { + char pad[64]; + struct cudaAccessPolicyWindow accessPolicyWindow; + int cooperative; + + enum cudaSynchronizationPolicy syncPolicy; +# 3517 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + struct { + unsigned int x; + unsigned int y; + unsigned int z; + } clusterDim; + enum cudaClusterSchedulingPolicy clusterSchedulingPolicyPreference; + + + int programmaticStreamSerializationAllowed; + + struct { + cudaEvent_t event; + int flags; + + int triggerAtBlockStart; + } programmaticEvent; + int priority; + cudaLaunchMemSyncDomainMap memSyncDomainMap; + + + cudaLaunchMemSyncDomain memSyncDomain; + + struct { + cudaEvent_t event; + int flags; + + } launchCompletionEvent; + + struct { + int deviceUpdatable; + cudaGraphDeviceNode_t devNode; + } deviceUpdatableKernelNode; +} 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; +# 3593 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 2 + + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/surface_types.h" 1 +# 86 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/texture_types.h" 1 +# 86 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 2 +# 91 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/library_types.h" 1 +# 57 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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_E5M2 = 29, +} cudaDataType; + + +typedef enum libraryPropertyType_t +{ + MAJOR_VERSION, + MINOR_VERSION, + PATCH_LEVEL +} libraryPropertyType; +# 92 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 + + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/channel_descriptor.h" 1 +# 61 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/channel_descriptor.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" 1 +# 148 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 149 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" 2 + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 151 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" 2 + + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" 1 +# 54 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +# 1 "/usr/include/c++/11/stdlib.h" 1 3 +# 36 "/usr/include/c++/11/stdlib.h" 3 +# 1 "/usr/include/c++/11/cstdlib" 1 3 +# 39 "/usr/include/c++/11/cstdlib" 3 + +# 40 "/usr/include/c++/11/cstdlib" 3 + +# 1 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 1 3 +# 278 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 3 + +# 278 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 3 +namespace std +{ + typedef long unsigned int size_t; + typedef long int ptrdiff_t; + + + typedef decltype(nullptr) nullptr_t; + +} +# 300 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 3 +namespace std +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +namespace __gnu_cxx +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +# 586 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 3 +# 1 "/usr/include/x86_64-linux-gnu/c++/11/bits/os_defines.h" 1 3 +# 587 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 2 3 + + +# 1 "/usr/include/x86_64-linux-gnu/c++/11/bits/cpu_defines.h" 1 3 +# 590 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 2 3 +# 777 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 3 +# 1 "/usr/include/c++/11/pstl/pstl_config.h" 1 3 +# 778 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 2 3 +# 42 "/usr/include/c++/11/cstdlib" 2 3 +# 75 "/usr/include/c++/11/cstdlib" 3 +# 1 "/usr/include/stdlib.h" 1 3 4 +# 26 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/stdlib.h" 2 3 4 + + + + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4 +# 33 "/usr/include/stdlib.h" 2 3 4 + +extern "C" { + + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 1 3 4 +# 41 "/usr/include/stdlib.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 1 3 4 +# 42 "/usr/include/stdlib.h" 2 3 4 +# 56 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 1 3 4 +# 74 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4 +typedef _Complex float __cfloat128 __attribute__ ((__mode__ (__TC__))); +# 86 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4 +typedef __float128 _Float128; +# 119 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4 +# 25 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 2 3 4 +# 214 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4 +typedef float _Float32; +# 251 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4 +typedef double _Float64; +# 268 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4 +typedef double _Float32x; +# 285 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4 +typedef long double _Float64x; +# 120 "/usr/include/x86_64-linux-gnu/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 int strfromd (char *__dest, size_t __size, const char *__format, + double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfromf (char *__dest, size_t __size, const char *__format, + float __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfroml (char *__dest, size_t __size, const char *__format, + long double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 233 "/usr/include/stdlib.h" 3 4 +extern int strfromf32 (char *__dest, size_t __size, const char * __format, + _Float32 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64 (char *__dest, size_t __size, const char * __format, + _Float64 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf128 (char *__dest, size_t __size, const char * __format, + _Float128 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf32x (char *__dest, size_t __size, const char * __format, + _Float32x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64x (char *__dest, size_t __size, const char * __format, + _Float64x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 275 "/usr/include/stdlib.h" 3 4 +extern long int strtol_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +extern unsigned long int strtoul_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +extern double strtod_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern float strtof_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern long double strtold_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 317 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64 strtof64_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float128 strtof128_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float32x strtof32x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64x strtof64x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 386 "/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/x86_64-linux-gnu/sys/types.h" 1 3 4 +# 27 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 +extern "C" { + + + + + +typedef __u_char u_char; +typedef __u_short u_short; +typedef __u_int u_int; +typedef __u_long u_long; +typedef __quad_t quad_t; +typedef __u_quad_t u_quad_t; +typedef __fsid_t fsid_t; + + +typedef __loff_t loff_t; + + + + +typedef __ino_t ino_t; + + + + + + +typedef __ino64_t ino64_t; + + + + +typedef __dev_t dev_t; + + + + +typedef __gid_t gid_t; + + + + +typedef __mode_t mode_t; + + + + +typedef __nlink_t nlink_t; + + + + +typedef __uid_t uid_t; + + + + + +typedef __off_t off_t; + + + + + + +typedef __off64_t off64_t; + + + + +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/x86_64-linux-gnu/bits/types/clock_t.h" 1 3 4 + + + + + + +typedef __clock_t clock_t; +# 127 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h" 1 3 4 + + + + + + +typedef __clockid_t clockid_t; +# 129 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types/time_t.h" 1 3 4 +# 10 "/usr/include/x86_64-linux-gnu/bits/types/time_t.h" 3 4 +typedef __time_t time_t; +# 130 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types/timer_t.h" 1 3 4 + + + + + + +typedef __timer_t timer_t; +# 131 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + + +typedef __useconds_t useconds_t; + + + +typedef __suseconds_t suseconds_t; + + + + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4 +# 145 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + + +typedef unsigned long int ulong; +typedef unsigned short int ushort; +typedef unsigned int uint; + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 3 4 +typedef __int8_t int8_t; +typedef __int16_t int16_t; +typedef __int32_t int32_t; +typedef __int64_t int64_t; +# 156 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/sys/types.h" 3 4 +# 1 "/usr/include/endian.h" 1 3 4 +# 35 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 1 3 4 +# 33 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4 +static __inline __uint16_t +__bswap_16 (__uint16_t __bsx) +{ + + return __builtin_bswap16 (__bsx); + + + +} + + + + + + +static __inline __uint32_t +__bswap_32 (__uint32_t __bsx) +{ + + return __builtin_bswap32 (__bsx); + + + +} +# 69 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4 +__extension__ static __inline __uint64_t +__bswap_64 (__uint64_t __bsx) +{ + + return __builtin_bswap64 (__bsx); + + + +} +# 36 "/usr/include/endian.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 1 3 4 +# 32 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 3 4 +static __inline __uint16_t +__uint16_identity (__uint16_t __x) +{ + return __x; +} + +static __inline __uint32_t +__uint32_identity (__uint32_t __x) +{ + return __x; +} + +static __inline __uint64_t +__uint64_identity (__uint64_t __x) +{ + return __x; +} +# 37 "/usr/include/endian.h" 2 3 4 +# 177 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + +# 1 "/usr/include/x86_64-linux-gnu/sys/select.h" 1 3 4 +# 30 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/select.h" 1 3 4 +# 31 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 + + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 1 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/bits/types/sigset_t.h" 2 3 4 + + +typedef __sigset_t sigset_t; +# 34 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h" 1 3 4 + + + + + + + +struct timeval +{ + + + + + __time_t tv_sec; + __suseconds_t tv_usec; + +}; +# 38 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 1 3 4 +# 11 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4 +struct timespec +{ + + + + __time_t tv_sec; + + + + + __syscall_slong_t tv_nsec; +# 31 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4 +}; +# 40 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 +# 49 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +typedef long int __fd_mask; +# 59 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +typedef struct + { + + + + __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; + + + + + + } fd_set; + + + + + + +typedef __fd_mask fd_mask; +# 91 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +extern "C" { +# 102 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +extern int select (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + struct timeval *__restrict __timeout); +# 127 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +extern int pselect (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + const struct timespec *__restrict __timeout, + const __sigset_t *__restrict __sigmask); +# 153 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +} +# 180 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + + + + +typedef __blksize_t blksize_t; + + + + + + +typedef __blkcnt_t blkcnt_t; + + + +typedef __fsblkcnt_t fsblkcnt_t; + + + +typedef __fsfilcnt_t fsfilcnt_t; +# 219 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 +typedef __blkcnt64_t blkcnt64_t; +typedef __fsblkcnt64_t fsblkcnt64_t; +typedef __fsfilcnt64_t fsfilcnt64_t; + + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 1 3 4 +# 23 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 1 3 4 +# 44 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 1 3 4 +# 21 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 22 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 2 3 4 +# 45 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4 + +# 1 "/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h" 1 3 4 +# 25 "/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h" 3 4 +typedef union +{ + __extension__ unsigned long long int __value64; + struct + { + unsigned int __low; + unsigned int __high; + } __value32; +} __atomic_wide_counter; +# 47 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4 + + + + +typedef struct __pthread_internal_list +{ + struct __pthread_internal_list *__prev; + struct __pthread_internal_list *__next; +} __pthread_list_t; + +typedef struct __pthread_internal_slist +{ + struct __pthread_internal_slist *__next; +} __pthread_slist_t; +# 76 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 1 3 4 +# 22 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/bits/struct_mutex.h" 3 4 +}; +# 77 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4 +# 89 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 1 3 4 +# 23 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4 +struct __pthread_rwlock_arch_t +{ + unsigned int __readers; + unsigned int __writers; + unsigned int __wrphase_futex; + unsigned int __writers_futex; + unsigned int __pad3; + unsigned int __pad4; + + int __cur_writer; + int __shared; + signed char __rwelision; + + + + + unsigned char __pad1[7]; + + + unsigned long int __pad2; + + + unsigned int __flags; +# 55 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4 +}; +# 90 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4 + + + + +struct __pthread_cond_s +{ + __atomic_wide_counter __wseq; + __atomic_wide_counter __g1_start; + unsigned int __g_refs[2] ; + unsigned int __g_size[2]; + unsigned int __g1_orig_size; + unsigned int __wrefs; + unsigned int __g_signals[2]; +}; + +typedef unsigned int __tss_t; +typedef unsigned long int __thrd_t; + +typedef struct +{ + int __data ; +} __once_flag; +# 24 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 2 3 4 + + + +typedef unsigned long int pthread_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_mutexattr_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_condattr_t; + + + +typedef unsigned int pthread_key_t; + + + +typedef int pthread_once_t; + + +union pthread_attr_t +{ + char __size[56]; + long int __align; +}; + +typedef union pthread_attr_t pthread_attr_t; + + + + +typedef union +{ + struct __pthread_mutex_s __data; + char __size[40]; + long int __align; +} pthread_mutex_t; + + +typedef union +{ + struct __pthread_cond_s __data; + char __size[48]; + __extension__ long long int __align; +} pthread_cond_t; + + + + + +typedef union +{ + struct __pthread_rwlock_arch_t __data; + char __size[56]; + long int __align; +} pthread_rwlock_t; + +typedef union +{ + char __size[8]; + long int __align; +} pthread_rwlockattr_t; + + + + + +typedef volatile int pthread_spinlock_t; + + + + +typedef union +{ + char __size[32]; + long int __align; +} pthread_barrier_t; + +typedef union +{ + char __size[4]; + int __align; +} pthread_barrierattr_t; +# 228 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + +} +# 396 "/usr/include/stdlib.h" 2 3 4 + + + + + + +extern long int random (void) noexcept (true); + + +extern void srandom (unsigned int __seed) noexcept (true); + + + + + +extern char *initstate (unsigned int __seed, char *__statebuf, + size_t __statelen) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern char *setstate (char *__statebuf) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + + +struct random_data + { + int32_t *fptr; + int32_t *rptr; + int32_t *state; + int rand_type; + int rand_deg; + int rand_sep; + int32_t *end_ptr; + }; + +extern int random_r (struct random_data *__restrict __buf, + int32_t *__restrict __result) noexcept (true) __attribute__ ((__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 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-linux-gnu/11/include/stddef.h" 1 3 4 +# 25 "/usr/include/alloca.h" 2 3 4 + +extern "C" { + + + + + +extern void *alloca (size_t __size) noexcept (true); + + + + + +} +# 575 "/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__)); + + + +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))); +# 617 "/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); +# 682 "/usr/include/stdlib.h" 3 4 +extern char *mktemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))); +# 695 "/usr/include/stdlib.h" 3 4 +extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 705 "/usr/include/stdlib.h" 3 4 +extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 717 "/usr/include/stdlib.h" 3 4 +extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; +# 727 "/usr/include/stdlib.h" 3 4 +extern int mkstemps64 (char *__template, int __suffixlen) + __attribute__ ((__nonnull__ (1))) ; +# 738 "/usr/include/stdlib.h" 3 4 +extern char *mkdtemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))) ; +# 749 "/usr/include/stdlib.h" 3 4 +extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 759 "/usr/include/stdlib.h" 3 4 +extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 769 "/usr/include/stdlib.h" 3 4 +extern int mkostemps (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 781 "/usr/include/stdlib.h" 3 4 +extern int mkostemps64 (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 791 "/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))) ; +# 808 "/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__)) ; +# 880 "/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))) ; +# 967 "/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))); +# 1023 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/stdlib-float.h" 1 3 4 +# 1024 "/usr/include/stdlib.h" 2 3 4 +# 1035 "/usr/include/stdlib.h" 3 4 +} +# 76 "/usr/include/c++/11/cstdlib" 2 3 + +# 1 "/usr/include/c++/11/bits/std_abs.h" 1 3 +# 33 "/usr/include/c++/11/bits/std_abs.h" 3 + +# 34 "/usr/include/c++/11/bits/std_abs.h" 3 +# 46 "/usr/include/c++/11/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/include/c++/11/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); } + + + + inline constexpr __int128 + abs(__int128 __x) { return __x >= 0 ? __x : -__x; } +# 107 "/usr/include/c++/11/bits/std_abs.h" 3 + +} +} +# 78 "/usr/include/c++/11/cstdlib" 2 3 +# 121 "/usr/include/c++/11/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) { return ldiv(__i, __j); } + + + + +} +# 195 "/usr/include/c++/11/cstdlib" 3 +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + using ::lldiv_t; + + + + + + using ::_Exit; + + + + using ::llabs; + + inline lldiv_t + div(long long __n, long long __d) + { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; } + + using ::lldiv; +# 227 "/usr/include/c++/11/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; +} + + + +} +# 37 "/usr/include/c++/11/stdlib.h" 2 3 + +using std::abort; +using std::atexit; +using std::exit; + + + using std::at_quick_exit; + + + using std::quick_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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" 2 +# 72 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" + +# 72 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +extern "C" { + + +struct cudaFuncAttributes; +# 109 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +} + + + + +} +# 169 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 170 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" 2 +# 180 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +extern "C" +{ + + + + + +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaDeviceSynchronizeDeprecationAvoidance(void); +# 236 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 301 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +} +# 336 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 364 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetEnabled(cudaGraphDeviceNode_t node, bool enable); +# 391 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetGridDim(cudaGraphDeviceNode_t node, dim3 gridDim); +# 420 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeUpdatesApply(const cudaGraphKernelNodeUpdate *updates, size_t updateCount); +# 438 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +static inline __attribute__((device)) __attribute__((cudart_builtin)) void cudaTriggerProgrammaticLaunchCompletion(void) +{ + asm volatile("griddepcontrol.launch_dependents;":::); +} +# 454 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +static inline __attribute__((device)) __attribute__((cudart_builtin)) void cudaGridDependencySynchronize(void) +{ + asm volatile("griddepcontrol.wait;":::"memory"); +} +# 466 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); + + + + + + + +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); +} +# 695 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 781 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); + } +# 843 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 876 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" 2 +# 283 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern "C" { +# 323 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceReset(void); +# 345 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceSynchronize(void); +# 431 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetLimit(enum cudaLimit limit, size_t value); +# 467 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetLimit(size_t *pValue, enum cudaLimit limit); +# 490 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t *maxWidthInElements, const struct cudaChannelFormatDesc *fmtDesc, int device); +# 524 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetCacheConfig(enum cudaFuncCache *pCacheConfig); +# 561 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority); +# 605 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetCacheConfig(enum cudaFuncCache cacheConfig); +# 632 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetByPCIBusId(int *device, const char *pciBusId); +# 662 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetPCIBusId(char *pciBusId, int len, int device); +# 712 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t *handle, cudaEvent_t event); +# 755 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcOpenEventHandle(cudaEvent_t *event, cudaIpcEventHandle_t handle); +# 799 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t *handle, void *devPtr); +# 865 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcOpenMemHandle(void **devPtr, cudaIpcMemHandle_t handle, unsigned int flags); +# 903 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcCloseMemHandle(void *devPtr); +# 935 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(enum cudaFlushGPUDirectRDMAWritesTarget target, enum cudaFlushGPUDirectRDMAWritesScope scope); +# 973 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback); +# 996 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback); +# 1043 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetSharedMemConfig(enum cudaSharedMemConfig *pConfig); +# 1089 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaDeviceSetSharedMemConfig(enum cudaSharedMemConfig config); +# 1130 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadExit(void); +# 1156 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSynchronize(void); +# 1205 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSetLimit(enum cudaLimit limit, size_t value); +# 1238 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadGetLimit(size_t *pValue, enum cudaLimit limit); +# 1274 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadGetCacheConfig(enum cudaFuncCache *pCacheConfig); +# 1321 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSetCacheConfig(enum cudaFuncCache cacheConfig); +# 1386 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetLastError(void); +# 1437 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaPeekAtLastError(void); +# 1453 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) const char* cudaGetErrorName(cudaError_t error); +# 1469 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) const char* cudaGetErrorString(cudaError_t error); +# 1498 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceCount(int *count); +# 1803 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceProperties_v2(struct cudaDeviceProp *prop, int device); +# 2005 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device); +# 2023 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t *memPool, int device); +# 2047 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool); +# 2067 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetMemPool(cudaMemPool_t *memPool, int device); +# 2129 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetNvSciSyncAttributes(void *nvSciSyncAttrList, int device, int flags); +# 2169 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetP2PAttribute(int *value, enum cudaDeviceP2PAttr attr, int srcDevice, int dstDevice); +# 2191 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaChooseDevice(int *device, const struct cudaDeviceProp *prop); +# 2220 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags); +# 2266 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetDevice(int device); +# 2288 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDevice(int *device); +# 2319 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetValidDevices(int *device_arr, int len); +# 2389 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetDeviceFlags( unsigned int flags ); +# 2434 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetDeviceFlags( unsigned int *flags ); +# 2474 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamCreate(cudaStream_t *pStream); +# 2506 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithFlags(cudaStream_t *pStream, unsigned int flags); +# 2554 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithPriority(cudaStream_t *pStream, unsigned int flags, int priority); +# 2581 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int *priority); +# 2606 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int *flags); +# 2643 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetId(cudaStream_t hStream, unsigned long long *streamId); +# 2658 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaCtxResetPersistingL2Cache(void); +# 2678 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src); +# 2699 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetAttribute( + cudaStream_t hStream, cudaLaunchAttributeID attr, + cudaLaunchAttributeValue *value_out); +# 2723 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamSetAttribute( + cudaStream_t hStream, cudaLaunchAttributeID attr, + const cudaLaunchAttributeValue *value); +# 2757 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamDestroy(cudaStream_t stream); +# 2788 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 2863 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamAddCallback(cudaStream_t stream, + cudaStreamCallback_t callback, void *userData, unsigned int flags); +# 2887 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamSynchronize(cudaStream_t stream); +# 2912 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamQuery(cudaStream_t stream); +# 2996 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3035 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamBeginCapture(cudaStream_t stream, enum cudaStreamCaptureMode mode); +# 3076 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3127 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaThreadExchangeStreamCaptureMode(enum cudaStreamCaptureMode *mode); +# 3156 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t *pGraph); +# 3194 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamIsCapturing(cudaStream_t stream, enum cudaStreamCaptureStatus *pCaptureStatus); +# 3243 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3302 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3342 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t *dependencies, size_t numDependencies, unsigned int flags = 0); +# 3377 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3414 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventCreate(cudaEvent_t *event); +# 3451 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventCreateWithFlags(cudaEvent_t *event, unsigned int flags); +# 3492 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream = 0); +# 3540 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3573 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventQuery(cudaEvent_t event); +# 3604 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventSynchronize(cudaEvent_t event); +# 3634 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventDestroy(cudaEvent_t event); +# 3679 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventElapsedTime(float *ms, cudaEvent_t start, cudaEvent_t end); +# 3860 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaImportExternalMemory(cudaExternalMemory_t *extMem_out, const struct cudaExternalMemoryHandleDesc *memHandleDesc); +# 3915 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaExternalMemoryGetMappedBuffer(void **devPtr, cudaExternalMemory_t extMem, const struct cudaExternalMemoryBufferDesc *bufferDesc); +# 3975 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t *mipmap, cudaExternalMemory_t extMem, const struct cudaExternalMemoryMipmappedArrayDesc *mipmapDesc); +# 3999 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem); +# 4153 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t *extSem_out, const struct cudaExternalSemaphoreHandleDesc *semHandleDesc); +# 4236 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 4312 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 4335 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem); +# 4402 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 4464 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchKernelExC(const cudaLaunchConfig_t *config, const void *func, void **args); +# 4521 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 4622 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaLaunchCooperativeKernelMultiDevice(struct cudaLaunchParams *launchParamsList, unsigned int numDevices, unsigned int flags = 0); +# 4667 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFuncSetCacheConfig(const void *func, enum cudaFuncCache cacheConfig); +# 4700 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetAttributes(struct cudaFuncAttributes *attr, const void *func); +# 4737 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncSetAttribute(const void *func, enum cudaFuncAttribute attr, int value); +# 4761 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetName(const char **name, const void *func); +# 4783 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 4807 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaSetDoubleForDevice(double *d); +# 4831 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaSetDoubleForHost(double *d); +# 4897 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void *userData); +# 4971 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaFuncSetSharedMemConfig(const void *func, enum cudaSharedMemConfig config); +# 5027 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func, int blockSize, size_t dynamicSMemSize); +# 5056 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t *dynamicSmemSize, const void *func, int numBlocks, int blockSize); +# 5101 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 5136 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxPotentialClusterSize(int *clusterSize, const void *func, const cudaLaunchConfig_t *launchConfig); +# 5175 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveClusters(int *numClusters, const void *func, const cudaLaunchConfig_t *launchConfig); +# 5295 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMallocManaged(void **devPtr, size_t size, unsigned int flags = 0x01); +# 5328 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMalloc(void **devPtr, size_t size); +# 5365 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocHost(void **ptr, size_t size); +# 5408 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocPitch(void **devPtr, size_t *pitch, size_t width, size_t height); +# 5460 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 5498 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFree(void *devPtr); +# 5521 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeHost(void *ptr); +# 5544 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeArray(cudaArray_t array); +# 5567 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray); +# 5633 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostAlloc(void **pHost, size_t size, unsigned int flags); +# 5730 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostRegister(void *ptr, size_t size, unsigned int flags); +# 5753 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostUnregister(void *ptr); +# 5798 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostGetDevicePointer(void **pDevice, void *pHost, unsigned int flags); +# 5820 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostGetFlags(unsigned int *pFlags, void *pHost); +# 5859 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMalloc3D(struct cudaPitchedPtr* pitchedDevPtr, struct cudaExtent extent); +# 6004 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 6149 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 6182 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t *levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level); +# 6287 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3D(const struct cudaMemcpy3DParms *p); +# 6319 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3DPeer(const struct cudaMemcpy3DPeerParms *p); +# 6437 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy3DAsync(const struct cudaMemcpy3DParms *p, cudaStream_t stream = 0); +# 6464 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3DPeerAsync(const struct cudaMemcpy3DPeerParms *p, cudaStream_t stream = 0); +# 6498 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemGetInfo(size_t *free, size_t *total); +# 6524 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetInfo(struct cudaChannelFormatDesc *desc, struct cudaExtent *extent, unsigned int *flags, cudaArray_t array); +# 6553 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetPlane(cudaArray_t *pPlaneArray, cudaArray_t hArray, unsigned int planeIdx); +# 6576 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetMemoryRequirements(struct cudaArrayMemoryRequirements *memoryRequirements, cudaArray_t array, int device); +# 6600 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMipmappedArrayGetMemoryRequirements(struct cudaArrayMemoryRequirements *memoryRequirements, cudaMipmappedArray_t mipmap, int device); +# 6628 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaArrayGetSparseProperties(struct cudaArraySparseProperties *sparseProperties, cudaArray_t array); +# 6658 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaMipmappedArrayGetSparseProperties(struct cudaArraySparseProperties *sparseProperties, cudaMipmappedArray_t mipmap); +# 6703 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind); +# 6738 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyPeer(void *dst, int dstDevice, const void *src, int srcDevice, size_t count); +# 6787 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 6837 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 6887 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 6934 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 6977 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7021 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7078 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7113 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7176 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7234 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7291 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7342 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7393 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7422 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset(void *devPtr, int value, size_t count); +# 7456 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset2D(void *devPtr, size_t pitch, int value, size_t width, size_t height); +# 7502 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset3D(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent); +# 7538 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7579 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7632 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7660 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSymbolAddress(void **devPtr, const void *symbol); +# 7687 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSymbolSize(size_t *size, const void *symbol); +# 7757 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPrefetchAsync(const void *devPtr, size_t count, int dstDevice, cudaStream_t stream = 0); + +extern __attribute__((host)) cudaError_t cudaMemPrefetchAsync_v2(const void *devPtr, size_t count, struct cudaMemLocation location, unsigned int flags, cudaStream_t stream = 0); +# 7873 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemAdvise(const void *devPtr, size_t count, enum cudaMemoryAdvise advice, int device); +# 7996 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemAdvise_v2(const void *devPtr, size_t count, enum cudaMemoryAdvise advice, struct cudaMemLocation location); +# 8078 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 8121 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 8181 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 8223 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 8266 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 8317 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 8367 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 8436 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocAsync(void **devPtr, size_t size, cudaStream_t hStream); +# 8462 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeAsync(void *devPtr, cudaStream_t hStream); +# 8487 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep); +# 8531 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, enum cudaMemPoolAttr attr, void *value ); +# 8579 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, enum cudaMemPoolAttr attr, void *value ); +# 8594 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const struct cudaMemAccessDesc *descList, size_t count); +# 8607 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolGetAccess(enum cudaMemAccessFlags *flags, cudaMemPool_t memPool, struct cudaMemLocation *location); +# 8645 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolCreate(cudaMemPool_t *memPool, const struct cudaMemPoolProps *poolProps); +# 8667 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool); +# 8703 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocFromPoolAsync(void **ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream); +# 8728 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolExportToShareableHandle( + void *shareableHandle, + cudaMemPool_t memPool, + enum cudaMemAllocationHandleType handleType, + unsigned int flags); +# 8755 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolImportFromShareableHandle( + cudaMemPool_t *memPool, + void *shareableHandle, + enum cudaMemAllocationHandleType handleType, + unsigned int flags); +# 8778 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolExportPointer(struct cudaMemPoolPtrExportData *exportData, void *ptr); +# 8807 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolImportPointer(void **ptr, cudaMemPool_t memPool, struct cudaMemPoolPtrExportData *exportData); +# 8960 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaPointerGetAttributes(struct cudaPointerAttributes *attributes, const void *ptr); +# 9001 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceCanAccessPeer(int *canAccessPeer, int device, int peerDevice); +# 9043 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags); +# 9065 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceDisablePeerAccess(int peerDevice); +# 9129 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource); +# 9164 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags); +# 9203 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t *resources, cudaStream_t stream = 0); +# 9238 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t *resources, cudaStream_t stream = 0); +# 9270 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceGetMappedPointer(void **devPtr, size_t *size, cudaGraphicsResource_t resource); +# 9308 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t *array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel); +# 9337 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t *mipmappedArray, cudaGraphicsResource_t resource); +# 9372 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetChannelDesc(struct cudaChannelFormatDesc *desc, cudaArray_const_t array); +# 9402 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) struct cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, enum cudaChannelFormatKind f); +# 9626 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 9646 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject); +# 9666 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectResourceDesc(struct cudaResourceDesc *pResDesc, cudaTextureObject_t texObject); +# 9686 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectTextureDesc(struct cudaTextureDesc *pTexDesc, cudaTextureObject_t texObject); +# 9707 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectResourceViewDesc(struct cudaResourceViewDesc *pResViewDesc, cudaTextureObject_t texObject); +# 9752 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t *pSurfObject, const struct cudaResourceDesc *pResDesc); +# 9772 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject); +# 9791 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSurfaceObjectResourceDesc(struct cudaResourceDesc *pResDesc, cudaSurfaceObject_t surfObject); +# 9825 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDriverGetVersion(int *driverVersion); +# 9854 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaRuntimeGetVersion(int *runtimeVersion); +# 9901 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphCreate(cudaGraph_t *pGraph, unsigned int flags); +# 9999 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10032 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, struct cudaKernelNodeParams *pNodeParams); +# 10058 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const struct cudaKernelNodeParams *pNodeParams); +# 10078 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeCopyAttributes( + cudaGraphNode_t hSrc, + cudaGraphNode_t hDst); +# 10101 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeGetAttribute( + cudaGraphNode_t hNode, + cudaLaunchAttributeID attr, + cudaLaunchAttributeValue *value_out); +# 10125 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeSetAttribute( + cudaGraphNode_t hNode, + cudaLaunchAttributeID attr, + const cudaLaunchAttributeValue *value); +# 10176 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10235 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10304 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10372 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10404 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, struct cudaMemcpy3DParms *pNodeParams); +# 10431 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const struct cudaMemcpy3DParms *pNodeParams); +# 10470 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10516 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10562 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10610 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10633 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, struct cudaMemsetParams *pNodeParams); +# 10657 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const struct cudaMemsetParams *pNodeParams); +# 10699 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10722 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, struct cudaHostNodeParams *pNodeParams); +# 10746 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const struct cudaHostNodeParams *pNodeParams); +# 10787 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10814 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t *pGraph); +# 10852 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies); +# 10896 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10923 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t *event_out); +# 10951 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event); +# 10998 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11025 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t *event_out); +# 11053 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event); +# 11103 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11136 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, struct cudaExternalSemaphoreSignalNodeParams *params_out); +# 11164 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const struct cudaExternalSemaphoreSignalNodeParams *nodeParams); +# 11214 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11247 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, struct cudaExternalSemaphoreWaitNodeParams *params_out); +# 11275 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const struct cudaExternalSemaphoreWaitNodeParams *nodeParams); +# 11353 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11380 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, struct cudaMemAllocNodeParams *params_out); +# 11441 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11465 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void *dptr_out); +# 11493 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGraphMemTrim(int device); +# 11530 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetGraphMemAttribute(int device, enum cudaGraphMemAttributeType attr, void* value); +# 11564 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetGraphMemAttribute(int device, enum cudaGraphMemAttributeType attr, void* value); +# 11592 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphClone(cudaGraph_t *pGraphClone, cudaGraph_t originalGraph); +# 11620 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t *pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph); +# 11651 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, enum cudaGraphNodeType *pType); +# 11682 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t *nodes, size_t *numNodes); +# 11713 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t *pRootNodes, size_t *pNumRootNodes); +# 11747 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t *from, cudaGraphNode_t *to, size_t *numEdges); +# 11787 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11818 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t *pDependencies, size_t *pNumDependencies); +# 11855 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependencies_v2(cudaGraphNode_t node, cudaGraphNode_t *pDependencies, cudaGraphEdgeData *edgeData, size_t *pNumDependencies); +# 11887 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t *pDependentNodes, size_t *pNumDependentNodes); +# 11925 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependentNodes_v2(cudaGraphNode_t node, cudaGraphNode_t *pDependentNodes, cudaGraphEdgeData *edgeData, size_t *pNumDependentNodes); +# 11956 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11988 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 12019 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 12054 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 12084 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node); +# 12155 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiate(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, unsigned long long flags = 0); +# 12228 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, unsigned long long flags = 0); +# 12335 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiateWithParams(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams *instantiateParams); +# 12360 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long *flags); +# 12419 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaKernelNodeParams *pNodeParams); +# 12470 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaMemcpy3DParms *pNodeParams); +# 12525 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 12588 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 12649 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 12704 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaMemsetParams *pNodeParams); +# 12744 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaHostNodeParams *pNodeParams); +# 12791 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph); +# 12836 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event); +# 12881 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event); +# 12929 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const struct cudaExternalSemaphoreSignalNodeParams *nodeParams); +# 12977 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const struct cudaExternalSemaphoreWaitNodeParams *nodeParams); +# 13017 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled); +# 13051 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int *isEnabled); +# 13143 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo *resultInfo); +# 13168 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream); +# 13199 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream); +# 13222 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec); +# 13243 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDestroy(cudaGraph_t graph); +# 13262 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char *path, unsigned int flags); +# 13298 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 13322 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned int count = 1); +# 13350 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned int count = 1); +# 13378 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 13403 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count = 1); +# 13445 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 13489 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 13518 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeSetParams(cudaGraphNode_t node, struct cudaGraphNodeParams *nodeParams); +# 13567 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, struct cudaGraphNodeParams *nodeParams); +# 13593 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 13671 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetDriverEntryPoint(const char *symbol, void **funcPtr, unsigned long long flags, enum cudaDriverEntryPointQueryResult *driverStatus = +# 13671 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" 3 4 + __null +# 13671 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + ); + + + + + + + +extern __attribute__((host)) cudaError_t cudaGetExportTable(const void **ppExportTable, const cudaUUID_t *pExportTableId); +# 13858 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetFuncBySymbol(cudaFunction_t* functionPtr, const void* symbolPtr); +# 13874 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetKernel(cudaKernel_t *kernelPtr, const void *entryFuncAddr); +# 14044 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +} +# 62 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/channel_descriptor.h" 2 +# 117 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 389 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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(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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_functions.h" 1 +# 53 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 54 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 55 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_functions.h" 2 +# 79 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 + + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 100 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 + + + + + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_functions.h" 1 +# 77 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_functions.hpp" 1 +# 73 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_functions.h" 2 +# 106 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 +# 117 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 1 +# 71 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 72 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 73 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 2 +# 85 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" +# 1 "/usr/include/string.h" 1 3 4 +# 26 "/usr/include/string.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/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-linux-gnu/11/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-linux-gnu/11/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 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))); +# 539 "/usr/include/string.h" 3 4 +} +# 86 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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-linux-gnu/11/include/stddef.h" 1 3 4 +# 30 "/usr/include/time.h" 2 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/time.h" 1 3 4 +# 73 "/usr/include/x86_64-linux-gnu/bits/time.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/timex.h" 1 3 4 +# 26 "/usr/include/x86_64-linux-gnu/bits/timex.h" 3 4 +struct timex +{ +# 58 "/usr/include/x86_64-linux-gnu/bits/timex.h" 3 4 + unsigned int modes; + __syscall_slong_t offset; + __syscall_slong_t freq; + __syscall_slong_t maxerror; + __syscall_slong_t esterror; + int status; + __syscall_slong_t constant; + __syscall_slong_t precision; + __syscall_slong_t tolerance; + struct timeval time; + __syscall_slong_t tick; + __syscall_slong_t ppsfreq; + __syscall_slong_t jitter; + int shift; + __syscall_slong_t stabil; + __syscall_slong_t jitcnt; + __syscall_slong_t calcnt; + __syscall_slong_t errcnt; + __syscall_slong_t stbcnt; + + int tai; + + + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; + +}; +# 74 "/usr/include/x86_64-linux-gnu/bits/time.h" 2 3 4 + +extern "C" { + + +extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) noexcept (true); +# 90 "/usr/include/x86_64-linux-gnu/bits/time.h" 3 4 +} +# 34 "/usr/include/time.h" 2 3 4 + + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_tm.h" 1 3 4 + + + + + + +struct tm +{ + int tm_sec; + int tm_min; + int tm_hour; + int tm_mday; + int tm_mon; + int tm_year; + int tm_wday; + int tm_yday; + int tm_isdst; + + + long int tm_gmtoff; + const char *tm_zone; + + + + +}; +# 40 "/usr/include/time.h" 2 3 4 +# 48 "/usr/include/time.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h" 1 3 4 + + + + + + + +struct itimerspec + { + struct timespec it_interval; + struct timespec it_value; + }; +# 49 "/usr/include/time.h" 2 3 4 +struct sigevent; +# 68 "/usr/include/time.h" 3 4 +extern "C" { + + + +extern clock_t clock (void) noexcept (true); + + + +extern time_t time (time_t *__timer) noexcept (true); + + +extern double difftime (time_t __time1, time_t __time0) + noexcept (true) __attribute__ ((__const__)); + + +extern time_t mktime (struct tm *__tp) noexcept (true); +# 100 "/usr/include/time.h" 3 4 +extern size_t strftime (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp) noexcept (true); + + + + +extern char *strptime (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp) + noexcept (true); + + + + + + +extern size_t strftime_l (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp, + locale_t __loc) noexcept (true); + + + +extern char *strptime_l (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp, + locale_t __loc) noexcept (true); + + + + + + +extern struct tm *gmtime (const time_t *__timer) noexcept (true); + + + +extern struct tm *localtime (const time_t *__timer) noexcept (true); +# 154 "/usr/include/time.h" 3 4 +extern struct tm *gmtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) noexcept (true); + + + +extern struct tm *localtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) noexcept (true); +# 179 "/usr/include/time.h" 3 4 +extern char *asctime (const struct tm *__tp) noexcept (true); + + + +extern char *ctime (const time_t *__timer) noexcept (true); +# 197 "/usr/include/time.h" 3 4 +extern char *asctime_r (const struct tm *__restrict __tp, + char *__restrict __buf) noexcept (true); + + + +extern char *ctime_r (const time_t *__restrict __timer, + char *__restrict __buf) noexcept (true); +# 217 "/usr/include/time.h" 3 4 +extern char *__tzname[2]; +extern int __daylight; +extern long int __timezone; + + + + +extern char *tzname[2]; + + + +extern void tzset (void) noexcept (true); + + + +extern int daylight; +extern long int timezone; +# 249 "/usr/include/time.h" 3 4 +extern time_t timegm (struct tm *__tp) noexcept (true); + +extern time_t timelocal (struct tm *__tp) noexcept (true); +# 262 "/usr/include/time.h" 3 4 +extern int dysize (int __year) noexcept (true) __attribute__ ((__const__)); +# 272 "/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); + + +extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp) + noexcept (true); +# 311 "/usr/include/time.h" 3 4 +extern int clock_nanosleep (clockid_t __clock_id, int __flags, + const struct timespec *__req, + struct timespec *__rem); +# 326 "/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); +# 364 "/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))); +# 387 "/usr/include/time.h" 3 4 +extern int timespec_getres (struct timespec *__ts, int __base) + noexcept (true); +# 413 "/usr/include/time.h" 3 4 +extern int getdate_err; +# 422 "/usr/include/time.h" 3 4 +extern struct tm *getdate (const char *__string); +# 436 "/usr/include/time.h" 3 4 +extern int getdate_r (const char *__restrict __string, + struct tm *__restrict __resbufp); + + +} +# 87 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 2 + + +# 88 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" +extern "C" +{ + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) clock_t clock(void) + + + + +# 95 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 3 4 +noexcept (true) +# 95 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void* memset(void*, int, size_t) +# 96 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 3 4 + noexcept (true) +# 96 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void* memcpy(void*, const void*, size_t) +# 97 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 3 4 + noexcept (true) +# 97 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" + ; + +} +# 111 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" +# 1 "/usr/include/c++/11/new" 1 3 +# 38 "/usr/include/c++/11/new" 3 + +# 39 "/usr/include/c++/11/new" 3 + + +# 1 "/usr/include/c++/11/bits/exception.h" 1 3 +# 34 "/usr/include/c++/11/bits/exception.h" 3 + +# 35 "/usr/include/c++/11/bits/exception.h" 3 + +#pragma GCC visibility push(default) + + + + +# 40 "/usr/include/c++/11/bits/exception.h" 3 +extern "C++" { + +namespace std +{ +# 61 "/usr/include/c++/11/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; + }; + + + +} + +} + +#pragma GCC visibility pop +# 42 "/usr/include/c++/11/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; + +} +# 126 "/usr/include/c++/11/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; +} +# 230 "/usr/include/c++/11/new" 3 +#pragma GCC visibility pop +# 112 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 2 +# 125 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" + +# 125 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +# 27 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4 +# 28 "/usr/include/stdio.h" 2 3 4 + + +# 29 "/usr/include/stdio.h" 3 4 +extern "C" { + + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4 +# 34 "/usr/include/stdio.h" 2 3 4 + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stdarg.h" 1 3 4 +# 40 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stdarg.h" 3 4 +typedef __builtin_va_list __gnuc_va_list; +# 37 "/usr/include/stdio.h" 2 3 4 + + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h" 1 3 4 + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h" 1 3 4 +# 13 "/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h" 3 4 +typedef struct +{ + int __count; + union + { + unsigned int __wch; + char __wchb[4]; + } __value; +} __mbstate_t; +# 6 "/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h" 2 3 4 + + + + +typedef struct _G_fpos_t +{ + __off_t __pos; + __mbstate_t __state; +} __fpos_t; +# 40 "/usr/include/stdio.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h" 1 3 4 +# 10 "/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h" 3 4 +typedef struct _G_fpos64_t +{ + __off64_t __pos; + __mbstate_t __state; +} __fpos64_t; +# 41 "/usr/include/stdio.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types/__FILE.h" 1 3 4 + + + +struct _IO_FILE; +typedef struct _IO_FILE __FILE; +# 42 "/usr/include/stdio.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/bits/types/struct_FILE.h" 1 3 4 +# 35 "/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h" 3 4 +struct _IO_FILE; +struct _IO_marker; +struct _IO_codecvt; +struct _IO_wide_data; + + + + +typedef void _IO_lock_t; + + + + + +struct _IO_FILE +{ + int _flags; + + + char *_IO_read_ptr; + char *_IO_read_end; + char *_IO_read_base; + char *_IO_write_base; + char *_IO_write_ptr; + char *_IO_write_end; + char *_IO_buf_base; + char *_IO_buf_end; + + + char *_IO_save_base; + char *_IO_backup_base; + char *_IO_save_end; + + struct _IO_marker *_markers; + + struct _IO_FILE *_chain; + + int _fileno; + int _flags2; + __off_t _old_offset; + + + unsigned short _cur_column; + signed char _vtable_offset; + char _shortbuf[1]; + + _IO_lock_t *_lock; + + + + + + + + __off64_t _offset; + + struct _IO_codecvt *_codecvt; + struct _IO_wide_data *_wide_data; + struct _IO_FILE *_freeres_list; + void *_freeres_buf; + size_t __pad5; + int _mode; + + char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)]; +}; +# 44 "/usr/include/stdio.h" 2 3 4 + + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h" 1 3 4 +# 27 "/usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h" 3 4 +typedef __ssize_t cookie_read_function_t (void *__cookie, char *__buf, + size_t __nbytes); + + + + + + + +typedef __ssize_t cookie_write_function_t (void *__cookie, const char *__buf, + size_t __nbytes); + + + + + + + +typedef int cookie_seek_function_t (void *__cookie, __off64_t *__pos, int __w); + + +typedef int cookie_close_function_t (void *__cookie); + + + + + + +typedef struct _IO_cookie_io_functions_t +{ + cookie_read_function_t *read; + cookie_write_function_t *write; + cookie_seek_function_t *seek; + cookie_close_function_t *close; +} cookie_io_functions_t; +# 47 "/usr/include/stdio.h" 2 3 4 + + + + + +typedef __gnuc_va_list va_list; +# 84 "/usr/include/stdio.h" 3 4 +typedef __fpos_t fpos_t; + + + + +typedef __fpos64_t fpos64_t; +# 133 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/stdio_lim.h" 1 3 4 +# 134 "/usr/include/stdio.h" 2 3 4 +# 143 "/usr/include/stdio.h" 3 4 +extern FILE *stdin; +extern FILE *stdout; +extern FILE *stderr; + + + + + + +extern int remove (const char *__filename) noexcept (true); + +extern int rename (const char *__old, const char *__new) noexcept (true); + + + +extern int renameat (int __oldfd, const char *__old, int __newfd, + const char *__new) noexcept (true); +# 170 "/usr/include/stdio.h" 3 4 +extern int renameat2 (int __oldfd, const char *__old, int __newfd, + const char *__new, unsigned int __flags) noexcept (true); + + + + + + +extern int fclose (FILE *__stream); +# 188 "/usr/include/stdio.h" 3 4 +extern FILE *tmpfile (void) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; +# 200 "/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) ; +# 222 "/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); +# 239 "/usr/include/stdio.h" 3 4 +extern int fflush_unlocked (FILE *__stream); +# 249 "/usr/include/stdio.h" 3 4 +extern int fcloseall (void); +# 258 "/usr/include/stdio.h" 3 4 +extern FILE *fopen (const char *__restrict __filename, + const char *__restrict __modes) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; + + + + +extern FILE *freopen (const char *__restrict __filename, + const char *__restrict __modes, + FILE *__restrict __stream) ; +# 283 "/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) ; + + + + +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))) ; +# 328 "/usr/include/stdio.h" 3 4 +extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) noexcept (true); + + + +extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, + int __modes, size_t __n) noexcept (true); + + + + +extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf, + size_t __size) noexcept (true); + + +extern void setlinebuf (FILE *__stream) noexcept (true); + + + + + + + +extern int fprintf (FILE *__restrict __stream, + const char *__restrict __format, ...); + + + + +extern int printf (const char *__restrict __format, ...); + +extern int sprintf (char *__restrict __s, + const char *__restrict __format, ...) noexcept (true); + + + + + +extern int vfprintf (FILE *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg); + + + + +extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg); + +extern int vsprintf (char *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg) noexcept (true); + + + +extern int snprintf (char *__restrict __s, size_t __maxlen, + const char *__restrict __format, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 3, 4))); + +extern int vsnprintf (char *__restrict __s, size_t __maxlen, + const char *__restrict __format, __gnuc_va_list __arg) + noexcept (true) __attribute__ ((__format__ (__printf__, 3, 0))); + + + + + +extern int vasprintf (char **__restrict __ptr, const char *__restrict __f, + __gnuc_va_list __arg) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))) ; +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, ...) ; + + + + +extern int scanf (const char *__restrict __format, ...) ; + +extern int sscanf (const char *__restrict __s, + const char *__restrict __format, ...) noexcept (true); +# 434 "/usr/include/stdio.h" 3 4 +extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc99_fscanf") + + ; +extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc99_scanf") + ; +extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc99_sscanf") + + ; +# 459 "/usr/include/stdio.h" 3 4 +extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg) + __attribute__ ((__format__ (__scanf__, 2, 0))) ; + + + + + +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__ ("" "__isoc99_vfscanf") + + + + __attribute__ ((__format__ (__scanf__, 2, 0))) ; +extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vscanf") + + __attribute__ ((__format__ (__scanf__, 1, 0))) ; +extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc99_vsscanf") + + + + __attribute__ ((__format__ (__scanf__, 2, 0))); +# 513 "/usr/include/stdio.h" 3 4 +extern int fgetc (FILE *__stream); +extern int getc (FILE *__stream); + + + + + +extern int getchar (void); + + + + + + +extern int getc_unlocked (FILE *__stream); +extern int getchar_unlocked (void); +# 538 "/usr/include/stdio.h" 3 4 +extern int fgetc_unlocked (FILE *__stream); +# 549 "/usr/include/stdio.h" 3 4 +extern int fputc (int __c, FILE *__stream); +extern int putc (int __c, FILE *__stream); + + + + + +extern int putchar (int __c); +# 565 "/usr/include/stdio.h" 3 4 +extern int fputc_unlocked (int __c, FILE *__stream); + + + + + + + +extern int putc_unlocked (int __c, FILE *__stream); +extern int putchar_unlocked (int __c); + + + + + + +extern int getw (FILE *__stream); + + +extern int putw (int __w, FILE *__stream); + + + + + + + +extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream) + __attribute__ ((__access__ (__write_only__, 1, 2))); +# 615 "/usr/include/stdio.h" 3 4 +extern char *fgets_unlocked (char *__restrict __s, int __n, + FILE *__restrict __stream) + __attribute__ ((__access__ (__write_only__, 1, 2))); +# 632 "/usr/include/stdio.h" 3 4 +extern __ssize_t __getdelim (char **__restrict __lineptr, + size_t *__restrict __n, int __delimiter, + FILE *__restrict __stream) ; +extern __ssize_t getdelim (char **__restrict __lineptr, + size_t *__restrict __n, int __delimiter, + FILE *__restrict __stream) ; + + + + + + + +extern __ssize_t getline (char **__restrict __lineptr, + size_t *__restrict __n, + FILE *__restrict __stream) ; + + + + + + + +extern int fputs (const char *__restrict __s, FILE *__restrict __stream); + + + + + +extern int puts (const char *__s); + + + + + + +extern int ungetc (int __c, FILE *__stream); + + + + + + +extern size_t fread (void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream) ; + + + + +extern size_t fwrite (const void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __s); +# 691 "/usr/include/stdio.h" 3 4 +extern int fputs_unlocked (const char *__restrict __s, + FILE *__restrict __stream); +# 702 "/usr/include/stdio.h" 3 4 +extern size_t fread_unlocked (void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream) ; +extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream); + + + + + + + +extern int fseek (FILE *__stream, long int __off, int __whence); + + + + +extern long int ftell (FILE *__stream) ; + + + + +extern void rewind (FILE *__stream); +# 736 "/usr/include/stdio.h" 3 4 +extern int fseeko (FILE *__stream, __off_t __off, int __whence); + + + + +extern __off_t ftello (FILE *__stream) ; +# 760 "/usr/include/stdio.h" 3 4 +extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos); + + + + +extern int fsetpos (FILE *__stream, const fpos_t *__pos); +# 779 "/usr/include/stdio.h" 3 4 +extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence); +extern __off64_t ftello64 (FILE *__stream) ; +extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos); +extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos); + + + +extern void clearerr (FILE *__stream) noexcept (true); + +extern int feof (FILE *__stream) noexcept (true) ; + +extern int ferror (FILE *__stream) noexcept (true) ; + + + +extern void clearerr_unlocked (FILE *__stream) noexcept (true); +extern int feof_unlocked (FILE *__stream) noexcept (true) ; +extern int ferror_unlocked (FILE *__stream) noexcept (true) ; + + + + + + + +extern void perror (const char *__s); + + + + +extern int fileno (FILE *__stream) noexcept (true) ; + + + + +extern int fileno_unlocked (FILE *__stream) noexcept (true) ; +# 823 "/usr/include/stdio.h" 3 4 +extern int pclose (FILE *__stream); + + + + + +extern FILE *popen (const char *__command, const char *__modes) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (pclose, 1))) ; + + + + + + +extern char *ctermid (char *__s) noexcept (true) + __attribute__ ((__access__ (__write_only__, 1))); + + + + + +extern char *cuserid (char *__s) + __attribute__ ((__access__ (__write_only__, 1))); + + + + +struct obstack; + + +extern int obstack_printf (struct obstack *__restrict __obstack, + const char *__restrict __format, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))); +extern int obstack_vprintf (struct obstack *__restrict __obstack, + const char *__restrict __format, + __gnuc_va_list __args) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))); + + + + + + + +extern void flockfile (FILE *__stream) noexcept (true); + + + +extern int ftrylockfile (FILE *__stream) noexcept (true) ; + + +extern void funlockfile (FILE *__stream) noexcept (true); +# 885 "/usr/include/stdio.h" 3 4 +extern int __uflow (FILE *); +extern int __overflow (FILE *, int); +# 902 "/usr/include/stdio.h" 3 4 +} +# 137 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 2 +# 1 "/usr/include/c++/11/stdlib.h" 1 3 +# 138 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 2 + + + + + + +# 143 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 3 4 + noexcept (true) +# 157 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void free(void*) +# 158 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 3 4 + noexcept (true) +# 158 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" + ; +# 168 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" +} + + + + + +# 1 "/usr/include/assert.h" 1 3 4 +# 66 "/usr/include/assert.h" 3 4 + +# 66 "/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__)); + + +extern void __assert_perror_fail (int __errnum, const char *__file, + unsigned int __line, const char *__function) + noexcept (true) __attribute__ ((__noreturn__)); + + + + +extern void __assert (const char *__assertion, const char *__file, int __line) + noexcept (true) __attribute__ ((__noreturn__)); + + +} +# 175 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 2 + + + +# 177 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" +extern "C" +{ +# 205 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 3 4 + noexcept (true) +# 207 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" + ; + + + + +} +# 267 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 1 +# 112 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 113 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 114 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 2 +# 124 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern "C" +{ +# 222 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) int abs(int a) +# 222 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 222 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; + + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) long int labs(long int a) +# 230 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 230 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; + + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) long long int llabs(long long int a) +# 238 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 238 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 288 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fabs(double x) +# 288 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 288 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 331 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fabsf(float x) +# 331 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 331 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 341 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 383 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fminf(float x, float y) +# 383 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 383 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 403 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmin(double x, double y) +# 403 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 403 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 416 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 459 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmaxf(float x, float y) +# 459 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 459 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 479 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmax(double, double) +# 479 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 479 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 523 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sin(double x) +# 523 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 523 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 556 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cos(double x) +# 556 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 556 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 575 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincos(double x, double *sptr, double *cptr) +# 575 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 575 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 591 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincosf(float x, float *sptr, float *cptr) +# 591 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 591 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 636 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tan(double x) +# 636 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 636 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 705 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sqrt(double x) +# 705 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 705 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 777 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rsqrt(double x); +# 847 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rsqrtf(float x); +# 903 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log2(double x) +# 903 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 903 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 968 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp2(double x) +# 968 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 968 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1033 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float exp2f(float x) +# 1033 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1033 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1100 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp10(double x) +# 1100 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1100 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1163 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float exp10f(float x) +# 1163 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1163 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1256 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double expm1(double x) +# 1256 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1256 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1348 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float expm1f(float x) +# 1348 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1348 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1404 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log2f(float x) +# 1404 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1404 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1458 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log10(double x) +# 1458 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1458 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1528 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log(double x) +# 1528 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1528 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1624 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log1p(double x) +# 1624 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1624 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1723 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log1pf(float x) +# 1723 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1723 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1787 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double floor(double x) +# 1787 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1787 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1866 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp(double x) +# 1866 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1866 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1907 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cosh(double x) +# 1907 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1907 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1957 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sinh(double x) +# 1957 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1957 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2007 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tanh(double x) +# 2007 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2007 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2062 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double acosh(double x) +# 2062 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2062 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2120 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float acoshf(float x) +# 2120 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2120 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2173 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double asinh(double x) +# 2173 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2173 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2226 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float asinhf(float x) +# 2226 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2226 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2280 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atanh(double x) +# 2280 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2280 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2334 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atanhf(float x) +# 2334 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2334 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2383 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double ldexp(double x, int exp) +# 2383 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2383 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2429 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ldexpf(float x, int exp) +# 2429 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2429 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2481 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double logb(double x) +# 2481 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2481 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2536 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float logbf(float x) +# 2536 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2536 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2576 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int ilogb(double x) +# 2576 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2576 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2616 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int ilogbf(float x) +# 2616 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2616 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2692 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double scalbn(double x, int n) +# 2692 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2692 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2768 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float scalbnf(float x, int n) +# 2768 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2768 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2844 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double scalbln(double x, long int n) +# 2844 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2844 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2920 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float scalblnf(float x, long int n) +# 2920 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2920 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2997 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double frexp(double x, int *nptr) +# 2997 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2997 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3071 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float frexpf(float x, int *nptr) +# 3071 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3071 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3123 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double round(double x) +# 3123 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3123 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3178 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float roundf(float x) +# 3178 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3178 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3196 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lround(double x) +# 3196 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3196 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3214 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lroundf(float x) +# 3214 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3214 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3232 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llround(double x) +# 3232 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3232 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3250 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llroundf(float x) +# 3250 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3250 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3324 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rint(double x) +# 3324 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3324 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3378 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rintf(float x) +# 3378 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3378 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3395 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lrint(double x) +# 3395 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3395 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3412 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lrintf(float x) +# 3412 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3412 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3429 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llrint(double x) +# 3429 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3429 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3446 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llrintf(float x) +# 3446 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3446 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3499 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nearbyint(double x) +# 3499 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3499 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3552 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nearbyintf(float x) +# 3552 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3552 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3614 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double ceil(double x) +# 3614 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3614 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3664 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double trunc(double x) +# 3664 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3664 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3717 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float truncf(float x) +# 3717 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3717 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3743 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fdim(double x, double y) +# 3743 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3743 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3769 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fdimf(float x, float y) +# 3769 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3769 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4069 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atan2(double y, double x) +# 4069 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4069 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4140 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atan(double x) +# 4140 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4140 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4163 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double acos(double x) +# 4163 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4163 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4214 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double asin(double x) +# 4214 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4214 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4282 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double hypot(double x, double y) +# 4282 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4282 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4337 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rhypot(double x, double y) +# 4337 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4337 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4405 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float hypotf(float x, float y) +# 4405 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4405 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4460 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rhypotf(float x, float y) +# 4460 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4460 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4504 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double norm3d(double a, double b, double c) +# 4504 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4504 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4555 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm3d(double a, double b, double c) +# 4555 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4555 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4604 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double norm4d(double a, double b, double c, double d) +# 4604 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4604 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4660 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm4d(double a, double b, double c, double d) +# 4660 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4660 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4717 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + __attribute__((device)) __attribute__((device_builtin)) double norm(int dim, double const * p) +# 4717 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4717 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4781 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm(int dim, double const * p) +# 4781 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4781 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4846 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnormf(int dim, float const * p) +# 4846 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4846 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4903 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + __attribute__((device)) __attribute__((device_builtin)) float normf(int dim, float const * p) +# 4903 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4903 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4948 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float norm3df(float a, float b, float c) +# 4948 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4948 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4999 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnorm3df(float a, float b, float c) +# 4999 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4999 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 5048 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float norm4df(float a, float b, float c, float d) +# 5048 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 5048 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 5104 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnorm4df(float a, float b, float c, float d) +# 5104 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 5104 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 5191 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cbrt(double x) +# 5191 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 5191 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 5277 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cbrtf(float x) +# 5277 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 5277 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 5332 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rcbrt(double x); +# 5382 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rcbrtf(float x); +# 5442 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sinpi(double x); +# 5502 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinpif(float x); +# 5554 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cospi(double x); +# 5606 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cospif(float x); +# 5636 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincospi(double x, double *sptr, double *cptr); +# 5666 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincospif(float x, float *sptr, float *cptr); +# 5999 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double pow(double x, double y) +# 5999 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 5999 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6055 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double modf(double x, double *iptr) +# 6055 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6055 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6114 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmod(double x, double y) +# 6114 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6114 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6210 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double remainder(double x, double y) +# 6210 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6210 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6309 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float remainderf(float x, float y) +# 6309 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6309 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6381 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double remquo(double x, double y, int *quo) +# 6381 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6381 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6453 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float remquof(float x, float y, int *quo) +# 6453 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6453 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6494 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double j0(double x) +# 6494 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6494 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6536 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float j0f(float x) +# 6536 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6536 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6605 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double j1(double x) +# 6605 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6605 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6674 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float j1f(float x) +# 6674 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6674 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6717 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double jn(int n, double x) +# 6717 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6717 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6760 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float jnf(int n, float x) +# 6760 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6760 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6821 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double y0(double x) +# 6821 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6821 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6882 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float y0f(float x) +# 6882 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6882 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6943 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double y1(double x) +# 6943 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6943 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7004 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float y1f(float x) +# 7004 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7004 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7067 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double yn(int n, double x) +# 7067 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7067 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7130 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ynf(int n, float x) +# 7130 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7130 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7157 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double cyl_bessel_i0(double x) +# 7157 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7157 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7183 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float cyl_bessel_i0f(float x) +# 7183 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7183 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7210 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double cyl_bessel_i1(double x) +# 7210 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7210 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7236 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float cyl_bessel_i1f(float x) +# 7236 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7236 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7319 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erf(double x) +# 7319 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7319 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7401 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erff(float x) +# 7401 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7401 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7473 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfinv(double x); +# 7538 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfinvf(float x); +# 7577 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfc(double x) +# 7577 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7577 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7615 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcf(float x) +# 7615 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7615 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7732 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double lgamma(double x) +# 7732 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7732 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7794 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfcinv(double x); +# 7849 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcinvf(float x); +# 7917 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double normcdfinv(double x); +# 7985 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normcdfinvf(float x); +# 8028 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double normcdf(double x); +# 8071 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normcdff(float x); +# 8135 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfcx(double x); +# 8199 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcxf(float x); +# 8318 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float lgammaf(float x) +# 8318 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8318 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8416 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tgamma(double x) +# 8416 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8416 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8514 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tgammaf(float x) +# 8514 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8514 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8527 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double copysign(double x, double y) +# 8527 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8527 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8540 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float copysignf(float x, float y) +# 8540 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8540 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8559 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nextafter(double x, double y) +# 8559 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8559 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8578 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nextafterf(float x, float y) +# 8578 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8578 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8594 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nan(const char *tagp) +# 8594 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8594 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8610 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nanf(const char *tagp) +# 8610 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8610 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinff(float) +# 8617 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8617 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnanf(float) +# 8618 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8618 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8628 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finite(double) +# 8628 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8628 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finitef(float) +# 8629 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8629 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbit(double) +# 8630 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8630 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnan(double) +# 8631 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8631 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinf(double) +# 8632 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8632 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitf(float) +# 8635 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8635 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8794 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fma(double x, double y, double z) +# 8794 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8794 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8952 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmaf(float x, float y, float z) +# 8952 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8952 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8963 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitl(long double) +# 8963 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8963 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finitel(long double) +# 8969 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8969 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinfl(long double) +# 8970 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8970 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnanl(long double) +# 8971 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8971 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9021 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float acosf(float x) +# 9021 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9021 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9080 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float asinf(float x) +# 9080 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9080 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9160 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atanf(float x) +# 9160 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9160 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9457 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atan2f(float y, float x) +# 9457 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9457 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9491 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cosf(float x) +# 9491 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9491 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9533 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinf(float x) +# 9533 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9533 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9575 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tanf(float x) +# 9575 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9575 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9616 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float coshf(float x) +# 9616 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9616 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9666 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinhf(float x) +# 9666 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9666 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9716 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tanhf(float x) +# 9716 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9716 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9768 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float logf(float x) +# 9768 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9768 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9848 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float expf(float x) +# 9848 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9848 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9900 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log10f(float x) +# 9900 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9900 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9955 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float modff(float x, float *iptr) +# 9955 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9955 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 10285 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float powf(float x, float y) +# 10285 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 10285 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 10354 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sqrtf(float x) +# 10354 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 10354 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 10413 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ceilf(float x) +# 10413 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 10413 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 10474 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float floorf(float x) +# 10474 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 10474 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 10532 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmodf(float x, float y) +# 10532 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 10532 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 10547 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +} + + +# 1 "/usr/include/c++/11/math.h" 1 3 +# 36 "/usr/include/c++/11/math.h" 3 +# 1 "/usr/include/c++/11/cmath" 1 3 +# 39 "/usr/include/c++/11/cmath" 3 + +# 40 "/usr/include/c++/11/cmath" 3 + + +# 1 "/usr/include/c++/11/bits/cpp_type_traits.h" 1 3 +# 35 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 + +# 36 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 +# 67 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 + +# 67 "/usr/include/c++/11/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; + }; +# 184 "/usr/include/c++/11/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; + }; +# 270 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 +template<> struct __is_integer<__int128> { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; +# 287 "/usr/include/c++/11/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; + }; + + + + + 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; + }; +# 423 "/usr/include/c++/11/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; + }; +# 532 "/usr/include/c++/11/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; } + + +} +} +# 43 "/usr/include/c++/11/cmath" 2 3 +# 1 "/usr/include/c++/11/ext/type_traits.h" 1 3 +# 32 "/usr/include/c++/11/ext/type_traits.h" 3 + +# 33 "/usr/include/c++/11/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 + inline bool + __is_null_pointer(_Type* __ptr) + { return __ptr == 0; } + + template + inline bool + __is_null_pointer(_Type) + { return false; } + + + inline 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; }; + + + template + using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); + + + template::__type, + typename _Up2 = typename __promote<_Up>::__type> + struct __promote_2 + { + typedef __typeof__(_Tp2() + _Up2()) __type; + }; + + template::__type, + typename _Up2 = typename __promote<_Up>::__type, + typename _Vp2 = typename __promote<_Vp>::__type> + struct __promote_3 + { + typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type; + }; + + template::__type, + typename _Up2 = typename __promote<_Up>::__type, + typename _Vp2 = typename __promote<_Vp>::__type, + typename _Wp2 = typename __promote<_Wp>::__type> + struct __promote_4 + { + typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type; + }; + + +} +} +# 44 "/usr/include/c++/11/cmath" 2 3 + +# 1 "/usr/include/math.h" 1 3 4 +# 27 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4 +# 28 "/usr/include/math.h" 2 3 4 + + + + + + +extern "C" { + + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 1 3 4 +# 25 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h" 1 3 4 +# 26 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 2 3 4 +# 41 "/usr/include/math.h" 2 3 4 +# 152 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h" 1 3 4 +# 153 "/usr/include/math.h" 2 3 4 +# 163 "/usr/include/math.h" 3 4 +typedef float float_t; +typedef double double_t; +# 204 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/fp-logb.h" 1 3 4 +# 205 "/usr/include/math.h" 2 3 4 +# 247 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/fp-fast.h" 1 3 4 +# 248 "/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, + }; +# 312 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassify (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbit (double __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinf (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finite (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnan (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsig (double __x, double __y) noexcept (true); + + +extern int __issignaling (double __value) noexcept (true) + __attribute__ ((__const__)); +# 313 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/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 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 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 __ceil (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double fabs (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 __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); +# 183 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern int finite (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern double drem (double __x, double __y) noexcept (true); extern double __drem (double __x, double __y) noexcept (true); + + + +extern double significand (double __x) noexcept (true); extern double __significand (double __x) noexcept (true); + + + + + + +extern double copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__)); 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); +# 220 "/usr/include/x86_64-linux-gnu/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 __round (double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern double trunc (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 __fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + +extern double fma (double __x, double __y, double __z) noexcept (true); extern double __fma (double __x, double __y, double __z) noexcept (true); + + + + +extern double roundeven (double __x) noexcept (true) __attribute__ ((__const__)); 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 __fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern double fmaximum (double __x, double __y) noexcept (true) __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 __fminimum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_num (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 __fminimum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_mag (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 __fminimum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum_mag_num (double __x, 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); +# 314 "/usr/include/math.h" 2 3 4 +# 329 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyf (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitf (float __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinff (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitef (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanf (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigf (float __x, float __y) noexcept (true); + + +extern int __issignalingf (float __value) noexcept (true) + __attribute__ ((__const__)); +# 330 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/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 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 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 __ceilf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float fabsf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __fabsf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float floorf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __floorf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float fmodf (float __x, float __y) noexcept (true); extern float __fmodf (float __x, float __y) noexcept (true); +# 177 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern int isinff (float __value) noexcept (true) + __attribute__ ((__const__)); + + + + +extern int finitef (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern float dremf (float __x, float __y) noexcept (true); extern float __dremf (float __x, float __y) noexcept (true); + + + +extern float significandf (float __x) noexcept (true); extern float __significandf (float __x) noexcept (true); + + + + + + +extern float copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern float nanf (const char *__tagb) noexcept (true); extern float __nanf (const char *__tagb) noexcept (true); +# 213 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern int isnanf (float __value) noexcept (true) + __attribute__ ((__const__)); + + + + + +extern float j0f (float) noexcept (true); extern float __j0f (float) 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 __roundf (float __x) noexcept (true) __attribute__ ((__const__)); + + + +extern float truncf (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 __fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + +extern float fmaf (float __x, float __y, float __z) noexcept (true); extern float __fmaf (float __x, float __y, float __z) noexcept (true); + + + + +extern float roundevenf (float __x) noexcept (true) __attribute__ ((__const__)); 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 __fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminmagf (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 __fmaximumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_numf (float __x, float __y) noexcept (true) __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 __fminimum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_magf (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 __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 __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 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); +# 331 "/usr/include/math.h" 2 3 4 +# 398 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinfl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitel (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigl (long double __x, long double __y) noexcept (true); + + +extern int __issignalingl (long double __value) noexcept (true) + __attribute__ ((__const__)); +# 399 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/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 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 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 __ceill (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double floorl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __floorl (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmodl (long double __x, long double __y) noexcept (true); extern long double __fmodl (long double __x, long double __y) noexcept (true); +# 177 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern int isinfl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + + +extern int finitel (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern long double dreml (long double __x, long double __y) noexcept (true); extern long double __dreml (long double __x, long double __y) noexcept (true); + + + +extern long double significandl (long double __x) noexcept (true); extern long double __significandl (long double __x) noexcept (true); + + + + + + +extern long double copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __copysignl (long 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); +# 213 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern int isnanl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + + + +extern long double j0l (long double) noexcept (true); extern long double __j0l (long double) noexcept (true); +extern long double j1l (long double) noexcept (true); extern long double __j1l (long double) noexcept (true); +extern long double jnl (int, long double) noexcept (true); extern long 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 __roundl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern long double truncl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __truncl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double remquol (long double __x, long double __y, int *__quo) noexcept (true); extern long double __remquol (long double __x, long double __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintl (long double __x) noexcept (true); extern long int __lrintl (long double __x) noexcept (true); +__extension__ +extern long long int llrintl (long double __x) noexcept (true); extern 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 __fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + +extern long double fmal (long double __x, long double __y, long double __z) noexcept (true); extern long double __fmal (long double __x, long double __y, long double __z) noexcept (true); + + + + +extern long double roundevenl (long double __x) noexcept (true) __attribute__ ((__const__)); 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 __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 __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 __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 __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 __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 __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 __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 __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 __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 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); +# 400 "/usr/include/math.h" 2 3 4 +# 450 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 + extern _Float32 acosf32 (_Float32 __x) noexcept (true); extern _Float32 __acosf32 (_Float32 __x) noexcept (true); + + extern _Float32 asinf32 (_Float32 __x) noexcept (true); extern _Float32 __asinf32 (_Float32 __x) noexcept (true); + + extern _Float32 atanf32 (_Float32 __x) noexcept (true); extern _Float32 __atanf32 (_Float32 __x) noexcept (true); + + extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); 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 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 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 __ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fabsf32 (_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 __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); +# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); 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); +# 220 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32 j0f32 (_Float32) noexcept (true); extern _Float32 __j0f32 (_Float32) noexcept (true); +extern _Float32 j1f32 (_Float32) noexcept (true); extern _Float32 __j1f32 (_Float32) noexcept (true); +extern _Float32 jnf32 (int, _Float32) noexcept (true); extern _Float32 __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); +# 252 "/usr/include/x86_64-linux-gnu/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 __roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32 truncf32 (_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 __fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminf32 (_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 _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 __fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminmagf32 (_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 __fmaximumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimumf32 (_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 __fmaximum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_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 __fmaximum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_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 __fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) 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); +# 451 "/usr/include/math.h" 2 3 4 +# 467 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 + extern _Float64 acosf64 (_Float64 __x) noexcept (true); extern _Float64 __acosf64 (_Float64 __x) noexcept (true); + + extern _Float64 asinf64 (_Float64 __x) noexcept (true); extern _Float64 __asinf64 (_Float64 __x) noexcept (true); + + extern _Float64 atanf64 (_Float64 __x) noexcept (true); extern _Float64 __atanf64 (_Float64 __x) noexcept (true); + + extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); 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 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 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 __ceilf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fabsf64 (_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 __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); +# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); 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); +# 220 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64 j0f64 (_Float64) noexcept (true); extern _Float64 __j0f64 (_Float64) noexcept (true); +extern _Float64 j1f64 (_Float64) noexcept (true); extern _Float64 __j1f64 (_Float64) noexcept (true); +extern _Float64 jnf64 (int, _Float64) noexcept (true); extern _Float64 __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); +# 252 "/usr/include/x86_64-linux-gnu/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 __roundf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64 truncf64 (_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 __fmaxf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminf64 (_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 _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 __fmaxmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminmagf64 (_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 __fmaximumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimumf64 (_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 __fmaximum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_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 __fmaximum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_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 __fmaximum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminimum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf64 (const _Float64 *__x, const _Float64 *__y) 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); +# 468 "/usr/include/math.h" 2 3 4 +# 481 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/x86_64-linux-gnu/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__)); +# 482 "/usr/include/math.h" 2 3 4 + + +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/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 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 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 __ceilf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fabsf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fabsf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 floorf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); extern _Float128 __floorf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmodf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __fmodf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float128 copysignf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); 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); +# 220 "/usr/include/x86_64-linux-gnu/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); +# 252 "/usr/include/x86_64-linux-gnu/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 __roundf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float128 truncf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); extern _Float128 __truncf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 remquof128 (_Float128 __x, _Float128 __y, int *__quo) 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 __fmaxf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminf128 (_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 _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 __fmaxmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fminmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 fmaximumf128 (_Float128 __x, _Float128 __y) noexcept (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 __fminimumf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmaximum_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fmaximum_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_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 __fmaximum_magf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_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 __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 _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); +# 485 "/usr/include/math.h" 2 3 4 +# 501 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/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 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 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 __ceilf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x floorf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __floorf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); +# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); 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); +# 220 "/usr/include/x86_64-linux-gnu/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); +# 252 "/usr/include/x86_64-linux-gnu/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 __roundf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32x truncf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __truncf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) 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 __fmaxf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminf32x (_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 _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 __fmaxmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x fmaximumf32x (_Float32x __x, _Float32x __y) noexcept (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 __fminimumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaximum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_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 __fmaximum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_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 __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 _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); +# 502 "/usr/include/math.h" 2 3 4 +# 518 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/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 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 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 __ceilf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x floorf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __floorf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); 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); +# 220 "/usr/include/x86_64-linux-gnu/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); +# 252 "/usr/include/x86_64-linux-gnu/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 __roundf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64x truncf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __truncf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) 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 __fmaxf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminf64x (_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 _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 __fmaxmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x fmaximumf64x (_Float64x __x, _Float64x __y) noexcept (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 __fminimumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaximum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_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 __fmaximum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_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 __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 _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); +# 519 "/usr/include/math.h" 2 3 4 +# 566 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern float fadd (double __x, double __y) noexcept (true); + + +extern float fdiv (double __x, double __y) noexcept (true); + + +extern float ffma (double __x, double __y, double __z) noexcept (true); + + +extern float fmul (double __x, double __y) noexcept (true); + + +extern float fsqrt (double __x) noexcept (true); + + +extern float fsub (double __x, double __y) noexcept (true); +# 567 "/usr/include/math.h" 2 3 4 +# 587 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern float faddl (long double __x, long double __y) noexcept (true); + + +extern float fdivl (long double __x, long double __y) noexcept (true); + + +extern float ffmal (long double __x, long double __y, long double __z) 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); +# 588 "/usr/include/math.h" 2 3 4 +# 616 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern double daddl (long double __x, long double __y) noexcept (true); + + +extern double ddivl (long double __x, long double __y) noexcept (true); + + +extern double dfmal (long double __x, long double __y, long double __z) 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); +# 617 "/usr/include/math.h" 2 3 4 +# 697 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32divf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) 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); +# 698 "/usr/include/math.h" 2 3 4 +# 707 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32divf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) 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); +# 708 "/usr/include/math.h" 2 3 4 +# 717 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32divf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) 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); +# 718 "/usr/include/math.h" 2 3 4 +# 727 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32divf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) 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); +# 728 "/usr/include/math.h" 2 3 4 +# 747 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xdivf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xfmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) 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); +# 748 "/usr/include/math.h" 2 3 4 +# 757 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xdivf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xfmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + +extern _Float32x f32xmulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xsqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float32x f32xsubf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 758 "/usr/include/math.h" 2 3 4 +# 767 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xdivf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xfmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float32x f32xmulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xsqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float32x f32xsubf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 768 "/usr/include/math.h" 2 3 4 +# 787 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float64 f64addf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64divf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) 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); +# 788 "/usr/include/math.h" 2 3 4 +# 797 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float64 f64addf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64divf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) 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); +# 798 "/usr/include/math.h" 2 3 4 +# 817 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float64x f64xaddf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xdivf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xfmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float64x f64xmulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xsqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float64x f64xsubf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 818 "/usr/include/math.h" 2 3 4 +# 854 "/usr/include/math.h" 3 4 +extern int signgam; +# 934 "/usr/include/math.h" 3 4 +enum + { + FP_NAN = + + 0, + FP_INFINITE = + + 1, + FP_ZERO = + + 2, + FP_SUBNORMAL = + + 3, + FP_NORMAL = + + 4 + }; +# 1054 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/iscanonical.h" 1 3 4 +# 23 "/usr/include/x86_64-linux-gnu/bits/iscanonical.h" 3 4 +extern int __iscanonicall (long double __x) + noexcept (true) __attribute__ ((__const__)); +# 46 "/usr/include/x86_64-linux-gnu/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); } + +} +# 1055 "/usr/include/math.h" 2 3 4 +# 1066 "/usr/include/math.h" 3 4 +extern "C++" { +inline int issignaling (float __val) { return __issignalingf (__val); } +inline int issignaling (double __val) { return __issignaling (__val); } +inline int +issignaling (long double __val) +{ + + + + return __issignalingl (__val); + +} + + + +inline int issignaling (_Float128 __val) { return __issignalingf128 (__val); } + +} +# 1097 "/usr/include/math.h" 3 4 +extern "C++" { +# 1128 "/usr/include/math.h" 3 4 +template inline bool +iszero (__T __val) +{ + return __val == 0; +} + +} +# 1363 "/usr/include/math.h" 3 4 +extern "C++" { +template struct __iseqsig_type; + +template<> struct __iseqsig_type +{ + static int __call (float __x, float __y) throw () + { + return __iseqsigf (__x, __y); + } +}; + +template<> struct __iseqsig_type +{ + static int __call (double __x, double __y) throw () + { + return __iseqsig (__x, __y); + } +}; + +template<> struct __iseqsig_type +{ + static int __call (long double __x, long double __y) throw () + { + + return __iseqsigl (__x, __y); + + + + } +}; + + + + +template<> struct __iseqsig_type<_Float128> +{ + static int __call (_Float128 __x, _Float128 __y) throw () + { + return __iseqsigf128 (__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); +} + +} + + + + +} +# 46 "/usr/include/c++/11/cmath" 2 3 +# 77 "/usr/include/c++/11/cmath" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::acos; + + + inline constexpr float + acos(float __x) + { return __builtin_acosf(__x); } + + inline constexpr long double + acos(long double __x) + { return __builtin_acosl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acos(_Tp __x) + { return __builtin_acos(__x); } + + using ::asin; + + + inline constexpr float + asin(float __x) + { return __builtin_asinf(__x); } + + inline constexpr long double + asin(long double __x) + { return __builtin_asinl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asin(_Tp __x) + { return __builtin_asin(__x); } + + using ::atan; + + + inline constexpr float + atan(float __x) + { return __builtin_atanf(__x); } + + inline constexpr long double + atan(long double __x) + { return __builtin_atanl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atan(_Tp __x) + { return __builtin_atan(__x); } + + using ::atan2; + + + inline constexpr float + atan2(float __y, float __x) + { return __builtin_atan2f(__y, __x); } + + inline constexpr long double + atan2(long double __y, long double __x) + { return __builtin_atan2l(__y, __x); } + + + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + atan2(_Tp __y, _Up __x) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return atan2(__type(__y), __type(__x)); + } + + using ::ceil; + + + inline constexpr float + ceil(float __x) + { return __builtin_ceilf(__x); } + + inline constexpr long double + ceil(long double __x) + { return __builtin_ceill(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ceil(_Tp __x) + { return __builtin_ceil(__x); } + + using ::cos; + + + inline constexpr float + cos(float __x) + { return __builtin_cosf(__x); } + + inline constexpr long double + cos(long double __x) + { return __builtin_cosl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cos(_Tp __x) + { return __builtin_cos(__x); } + + using ::cosh; + + + inline constexpr float + cosh(float __x) + { return __builtin_coshf(__x); } + + inline constexpr long double + cosh(long double __x) + { return __builtin_coshl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cosh(_Tp __x) + { return __builtin_cosh(__x); } + + using ::exp; + + + inline constexpr float + exp(float __x) + { return __builtin_expf(__x); } + + inline constexpr long double + exp(long double __x) + { return __builtin_expl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp(_Tp __x) + { return __builtin_exp(__x); } + + using ::fabs; + + + inline constexpr float + fabs(float __x) + { return __builtin_fabsf(__x); } + + inline constexpr long double + fabs(long double __x) + { return __builtin_fabsl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + fabs(_Tp __x) + { return __builtin_fabs(__x); } + + using ::floor; + + + inline constexpr float + floor(float __x) + { return __builtin_floorf(__x); } + + inline constexpr long double + floor(long double __x) + { return __builtin_floorl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + floor(_Tp __x) + { return __builtin_floor(__x); } + + using ::fmod; + + + inline constexpr float + fmod(float __x, float __y) + { return __builtin_fmodf(__x, __y); } + + inline constexpr long double + fmod(long double __x, long double __y) + { return __builtin_fmodl(__x, __y); } + + + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmod(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmod(__type(__x), __type(__y)); + } + + using ::frexp; + + + inline float + frexp(float __x, int* __exp) + { return __builtin_frexpf(__x, __exp); } + + inline long double + frexp(long double __x, int* __exp) + { return __builtin_frexpl(__x, __exp); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + frexp(_Tp __x, int* __exp) + { return __builtin_frexp(__x, __exp); } + + using ::ldexp; + + + inline constexpr float + ldexp(float __x, int __exp) + { return __builtin_ldexpf(__x, __exp); } + + inline constexpr long double + ldexp(long double __x, int __exp) + { return __builtin_ldexpl(__x, __exp); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ldexp(_Tp __x, int __exp) + { return __builtin_ldexp(__x, __exp); } + + using ::log; + + + inline constexpr float + log(float __x) + { return __builtin_logf(__x); } + + inline constexpr long double + log(long double __x) + { return __builtin_logl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log(_Tp __x) + { return __builtin_log(__x); } + + using ::log10; + + + inline constexpr float + log10(float __x) + { return __builtin_log10f(__x); } + + inline constexpr long double + log10(long double __x) + { return __builtin_log10l(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log10(_Tp __x) + { return __builtin_log10(__x); } + + using ::modf; + + + inline float + modf(float __x, float* __iptr) + { return __builtin_modff(__x, __iptr); } + + inline long double + modf(long double __x, long double* __iptr) + { return __builtin_modfl(__x, __iptr); } + + + using ::pow; + + + inline constexpr float + pow(float __x, float __y) + { return __builtin_powf(__x, __y); } + + inline constexpr long double + pow(long double __x, long double __y) + { return __builtin_powl(__x, __y); } +# 412 "/usr/include/c++/11/cmath" 3 + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + pow(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return pow(__type(__x), __type(__y)); + } + + using ::sin; + + + inline constexpr float + sin(float __x) + { return __builtin_sinf(__x); } + + inline constexpr long double + sin(long double __x) + { return __builtin_sinl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sin(_Tp __x) + { return __builtin_sin(__x); } + + using ::sinh; + + + inline constexpr float + sinh(float __x) + { return __builtin_sinhf(__x); } + + inline constexpr long double + sinh(long double __x) + { return __builtin_sinhl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sinh(_Tp __x) + { return __builtin_sinh(__x); } + + using ::sqrt; + + + inline constexpr float + sqrt(float __x) + { return __builtin_sqrtf(__x); } + + inline constexpr long double + sqrt(long double __x) + { return __builtin_sqrtl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sqrt(_Tp __x) + { return __builtin_sqrt(__x); } + + using ::tan; + + + inline constexpr float + tan(float __x) + { return __builtin_tanf(__x); } + + inline constexpr long double + tan(long double __x) + { return __builtin_tanl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tan(_Tp __x) + { return __builtin_tan(__x); } + + using ::tanh; + + + inline constexpr float + tanh(float __x) + { return __builtin_tanhf(__x); } + + inline constexpr long double + tanh(long double __x) + { return __builtin_tanhl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tanh(_Tp __x) + { return __builtin_tanh(__x); } +# 536 "/usr/include/c++/11/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 __x) + { return true; } + + + + constexpr bool + isinf(float __x) + { return __builtin_isinf(__x); } + + + + + + constexpr bool + isinf(double __x) + { return __builtin_isinf(__x); } + + + constexpr bool + isinf(long double __x) + { return __builtin_isinf(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isinf(_Tp __x) + { return false; } + + + + constexpr bool + isnan(float __x) + { return __builtin_isnan(__x); } + + + + + + constexpr bool + isnan(double __x) + { return __builtin_isnan(__x); } + + + constexpr bool + isnan(long double __x) + { return __builtin_isnan(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isnan(_Tp __x) + { return false; } + + + + constexpr bool + isnormal(float __x) + { return __builtin_isnormal(__x); } + + constexpr bool + isnormal(double __x) + { return __builtin_isnormal(__x); } + + constexpr bool + isnormal(long double __x) + { return __builtin_isnormal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isnormal(_Tp __x) + { return __x != 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)); + } +# 1065 "/usr/include/c++/11/cmath" 3 + using ::double_t; + using ::float_t; + + + using ::acosh; + using ::acoshf; + using ::acoshl; + + using ::asinh; + using ::asinhf; + using ::asinhl; + + using ::atanh; + using ::atanhf; + using ::atanhl; + + using ::cbrt; + using ::cbrtf; + using ::cbrtl; + + using ::copysign; + using ::copysignf; + using ::copysignl; + + using ::erf; + using ::erff; + using ::erfl; + + using ::erfc; + using ::erfcf; + using ::erfcl; + + using ::exp2; + using ::exp2f; + using ::exp2l; + + using ::expm1; + using ::expm1f; + using ::expm1l; + + using ::fdim; + using ::fdimf; + using ::fdiml; + + using ::fma; + using ::fmaf; + using ::fmal; + + using ::fmax; + using ::fmaxf; + using ::fmaxl; + + using ::fmin; + using ::fminf; + using ::fminl; + + using ::hypot; + using ::hypotf; + using ::hypotl; + + using ::ilogb; + using ::ilogbf; + using ::ilogbl; + + using ::lgamma; + using ::lgammaf; + using ::lgammal; + + + using ::llrint; + using ::llrintf; + using ::llrintl; + + using ::llround; + using ::llroundf; + using ::llroundl; + + + using ::log1p; + using ::log1pf; + using ::log1pl; + + using ::log2; + using ::log2f; + using ::log2l; + + using ::logb; + using ::logbf; + using ::logbl; + + using ::lrint; + using ::lrintf; + using ::lrintl; + + using ::lround; + using ::lroundf; + using ::lroundl; + + using ::nan; + using ::nanf; + using ::nanl; + + using ::nearbyint; + using ::nearbyintf; + using ::nearbyintl; + + using ::nextafter; + using ::nextafterf; + using ::nextafterl; + + using ::nexttoward; + using ::nexttowardf; + using ::nexttowardl; + + using ::remainder; + using ::remainderf; + using ::remainderl; + + using ::remquo; + using ::remquof; + using ::remquol; + + using ::rint; + using ::rintf; + using ::rintl; + + using ::round; + using ::roundf; + using ::roundl; + + using ::scalbln; + using ::scalblnf; + using ::scalblnl; + + using ::scalbn; + using ::scalbnf; + using ::scalbnl; + + using ::tgamma; + using ::tgammaf; + using ::tgammal; + + using ::trunc; + using ::truncf; + using ::truncl; + + + + constexpr float + acosh(float __x) + { return __builtin_acoshf(__x); } + + constexpr long double + acosh(long double __x) + { return __builtin_acoshl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acosh(_Tp __x) + { return __builtin_acosh(__x); } + + + + constexpr float + asinh(float __x) + { return __builtin_asinhf(__x); } + + constexpr long double + asinh(long double __x) + { return __builtin_asinhl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asinh(_Tp __x) + { return __builtin_asinh(__x); } + + + + constexpr float + atanh(float __x) + { return __builtin_atanhf(__x); } + + constexpr long double + atanh(long double __x) + { return __builtin_atanhl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atanh(_Tp __x) + { return __builtin_atanh(__x); } + + + + constexpr float + cbrt(float __x) + { return __builtin_cbrtf(__x); } + + constexpr long double + cbrt(long double __x) + { return __builtin_cbrtl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cbrt(_Tp __x) + { return __builtin_cbrt(__x); } + + + + constexpr float + copysign(float __x, float __y) + { return __builtin_copysignf(__x, __y); } + + constexpr long double + copysign(long double __x, long double __y) + { return __builtin_copysignl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + copysign(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return copysign(__type(__x), __type(__y)); + } + + + + constexpr float + erf(float __x) + { return __builtin_erff(__x); } + + constexpr long double + erf(long double __x) + { return __builtin_erfl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erf(_Tp __x) + { return __builtin_erf(__x); } + + + + constexpr float + erfc(float __x) + { return __builtin_erfcf(__x); } + + constexpr long double + erfc(long double __x) + { return __builtin_erfcl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erfc(_Tp __x) + { return __builtin_erfc(__x); } + + + + constexpr float + exp2(float __x) + { return __builtin_exp2f(__x); } + + constexpr long double + exp2(long double __x) + { return __builtin_exp2l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp2(_Tp __x) + { return __builtin_exp2(__x); } + + + + constexpr float + expm1(float __x) + { return __builtin_expm1f(__x); } + + constexpr long double + expm1(long double __x) + { return __builtin_expm1l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + expm1(_Tp __x) + { return __builtin_expm1(__x); } + + + + constexpr float + fdim(float __x, float __y) + { return __builtin_fdimf(__x, __y); } + + constexpr long double + fdim(long double __x, long double __y) + { return __builtin_fdiml(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fdim(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fdim(__type(__x), __type(__y)); + } + + + + constexpr float + fma(float __x, float __y, float __z) + { return __builtin_fmaf(__x, __y, __z); } + + constexpr long double + fma(long double __x, long double __y, long double __z) + { return __builtin_fmal(__x, __y, __z); } + + + + template + constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type + fma(_Tp __x, _Up __y, _Vp __z) + { + typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; + return fma(__type(__x), __type(__y), __type(__z)); + } + + + + constexpr float + fmax(float __x, float __y) + { return __builtin_fmaxf(__x, __y); } + + constexpr long double + fmax(long double __x, long double __y) + { return __builtin_fmaxl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmax(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmax(__type(__x), __type(__y)); + } + + + + constexpr float + fmin(float __x, float __y) + { return __builtin_fminf(__x, __y); } + + constexpr long double + fmin(long double __x, long double __y) + { return __builtin_fminl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmin(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmin(__type(__x), __type(__y)); + } + + + + constexpr float + hypot(float __x, float __y) + { return __builtin_hypotf(__x, __y); } + + constexpr long double + hypot(long double __x, long double __y) + { return __builtin_hypotl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + hypot(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return hypot(__type(__x), __type(__y)); + } + + + + constexpr int + ilogb(float __x) + { return __builtin_ilogbf(__x); } + + constexpr int + ilogb(long double __x) + { return __builtin_ilogbl(__x); } + + + + template + constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + int>::__type + ilogb(_Tp __x) + { return __builtin_ilogb(__x); } + + + + constexpr float + lgamma(float __x) + { return __builtin_lgammaf(__x); } + + constexpr long double + lgamma(long double __x) + { return __builtin_lgammal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + lgamma(_Tp __x) + { return __builtin_lgamma(__x); } + + + + constexpr long long + llrint(float __x) + { return __builtin_llrintf(__x); } + + constexpr long long + llrint(long double __x) + { return __builtin_llrintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llrint(_Tp __x) + { return __builtin_llrint(__x); } + + + + constexpr long long + llround(float __x) + { return __builtin_llroundf(__x); } + + constexpr long long + llround(long double __x) + { return __builtin_llroundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llround(_Tp __x) + { return __builtin_llround(__x); } + + + + constexpr float + log1p(float __x) + { return __builtin_log1pf(__x); } + + constexpr long double + log1p(long double __x) + { return __builtin_log1pl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log1p(_Tp __x) + { return __builtin_log1p(__x); } + + + + + constexpr float + log2(float __x) + { return __builtin_log2f(__x); } + + constexpr long double + log2(long double __x) + { return __builtin_log2l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log2(_Tp __x) + { return __builtin_log2(__x); } + + + + constexpr float + logb(float __x) + { return __builtin_logbf(__x); } + + constexpr long double + logb(long double __x) + { return __builtin_logbl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + logb(_Tp __x) + { return __builtin_logb(__x); } + + + + constexpr long + lrint(float __x) + { return __builtin_lrintf(__x); } + + constexpr long + lrint(long double __x) + { return __builtin_lrintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lrint(_Tp __x) + { return __builtin_lrint(__x); } + + + + constexpr long + lround(float __x) + { return __builtin_lroundf(__x); } + + constexpr long + lround(long double __x) + { return __builtin_lroundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lround(_Tp __x) + { return __builtin_lround(__x); } + + + + constexpr float + nearbyint(float __x) + { return __builtin_nearbyintf(__x); } + + constexpr long double + nearbyint(long double __x) + { return __builtin_nearbyintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nearbyint(_Tp __x) + { return __builtin_nearbyint(__x); } + + + + constexpr float + nextafter(float __x, float __y) + { return __builtin_nextafterf(__x, __y); } + + constexpr long double + nextafter(long double __x, long double __y) + { return __builtin_nextafterl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + nextafter(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return nextafter(__type(__x), __type(__y)); + } + + + + constexpr float + nexttoward(float __x, long double __y) + { return __builtin_nexttowardf(__x, __y); } + + constexpr long double + nexttoward(long double __x, long double __y) + { return __builtin_nexttowardl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nexttoward(_Tp __x, long double __y) + { return __builtin_nexttoward(__x, __y); } + + + + constexpr float + remainder(float __x, float __y) + { return __builtin_remainderf(__x, __y); } + + constexpr long double + remainder(long double __x, long double __y) + { return __builtin_remainderl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remainder(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remainder(__type(__x), __type(__y)); + } + + + + inline float + remquo(float __x, float __y, int* __pquo) + { return __builtin_remquof(__x, __y, __pquo); } + + inline long double + remquo(long double __x, long double __y, int* __pquo) + { return __builtin_remquol(__x, __y, __pquo); } + + + + template + inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remquo(_Tp __x, _Up __y, int* __pquo) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remquo(__type(__x), __type(__y), __pquo); + } + + + + constexpr float + rint(float __x) + { return __builtin_rintf(__x); } + + constexpr long double + rint(long double __x) + { return __builtin_rintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + rint(_Tp __x) + { return __builtin_rint(__x); } + + + + constexpr float + round(float __x) + { return __builtin_roundf(__x); } + + constexpr long double + round(long double __x) + { return __builtin_roundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + round(_Tp __x) + { return __builtin_round(__x); } + + + + constexpr float + scalbln(float __x, long __ex) + { return __builtin_scalblnf(__x, __ex); } + + constexpr long double + scalbln(long double __x, long __ex) + { return __builtin_scalblnl(__x, __ex); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbln(_Tp __x, long __ex) + { return __builtin_scalbln(__x, __ex); } + + + + constexpr float + scalbn(float __x, int __ex) + { return __builtin_scalbnf(__x, __ex); } + + constexpr long double + scalbn(long double __x, int __ex) + { return __builtin_scalbnl(__x, __ex); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbn(_Tp __x, int __ex) + { return __builtin_scalbn(__x, __ex); } + + + + constexpr float + tgamma(float __x) + { return __builtin_tgammaf(__x); } + + constexpr long double + tgamma(long double __x) + { return __builtin_tgammal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tgamma(_Tp __x) + { return __builtin_tgamma(__x); } + + + + constexpr float + trunc(float __x) + { return __builtin_truncf(__x); } + + constexpr long double + trunc(long double __x) + { return __builtin_truncl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + trunc(_Tp __x) + { return __builtin_trunc(__x); } +# 1852 "/usr/include/c++/11/cmath" 3 + 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); + } +# 1931 "/usr/include/c++/11/cmath" 3 + +} + + +# 1 "/usr/include/c++/11/bits/specfun.h" 1 3 +# 33 "/usr/include/c++/11/bits/specfun.h" 3 +#pragma GCC visibility push(default) +# 45 "/usr/include/c++/11/bits/specfun.h" 3 +# 1 "/usr/include/c++/11/bits/stl_algobase.h" 1 3 +# 60 "/usr/include/c++/11/bits/stl_algobase.h" 3 +# 1 "/usr/include/c++/11/bits/functexcept.h" 1 3 +# 40 "/usr/include/c++/11/bits/functexcept.h" 3 +# 1 "/usr/include/c++/11/bits/exception_defines.h" 1 3 +# 41 "/usr/include/c++/11/bits/functexcept.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + void + __throw_bad_exception(void) __attribute__((__noreturn__)); + + + void + __throw_bad_alloc(void) __attribute__((__noreturn__)); + + void + __throw_bad_array_new_length(void) __attribute__((__noreturn__)); + + + void + __throw_bad_cast(void) __attribute__((__noreturn__)); + + void + __throw_bad_typeid(void) __attribute__((__noreturn__)); + + + void + __throw_logic_error(const char*) __attribute__((__noreturn__)); + + void + __throw_domain_error(const char*) __attribute__((__noreturn__)); + + void + __throw_invalid_argument(const char*) __attribute__((__noreturn__)); + + void + __throw_length_error(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__)) + __attribute__((__format__(__gnu_printf__, 1, 2))); + + void + __throw_runtime_error(const char*) __attribute__((__noreturn__)); + + void + __throw_range_error(const char*) __attribute__((__noreturn__)); + + void + __throw_overflow_error(const char*) __attribute__((__noreturn__)); + + void + __throw_underflow_error(const char*) __attribute__((__noreturn__)); + + + void + __throw_ios_failure(const char*) __attribute__((__noreturn__)); + + void + __throw_ios_failure(const char*, int) __attribute__((__noreturn__)); + + + void + __throw_system_error(int) __attribute__((__noreturn__)); + + + void + __throw_future_error(int) __attribute__((__noreturn__)); + + + void + __throw_bad_function_call() __attribute__((__noreturn__)); + + +} +# 61 "/usr/include/c++/11/bits/stl_algobase.h" 2 3 + + +# 1 "/usr/include/c++/11/ext/numeric_traits.h" 1 3 +# 32 "/usr/include/c++/11/ext/numeric_traits.h" 3 + +# 33 "/usr/include/c++/11/ext/numeric_traits.h" 3 + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 50 "/usr/include/c++/11/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; +# 135 "/usr/include/c++/11/ext/numeric_traits.h" 3 + template + using __int_traits = __numeric_traits_integer<_Tp>; +# 155 "/usr/include/c++/11/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 + { }; +# 236 "/usr/include/c++/11/ext/numeric_traits.h" 3 + +} +# 64 "/usr/include/c++/11/bits/stl_algobase.h" 2 3 +# 1 "/usr/include/c++/11/bits/stl_pair.h" 1 3 +# 59 "/usr/include/c++/11/bits/stl_pair.h" 3 +# 1 "/usr/include/c++/11/bits/move.h" 1 3 +# 38 "/usr/include/c++/11/bits/move.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + inline constexpr _Tp* + __addressof(_Tp& __r) noexcept + { return __builtin_addressof(__r); } + + + + +} + +# 1 "/usr/include/c++/11/type_traits" 1 3 +# 32 "/usr/include/c++/11/type_traits" 3 + +# 33 "/usr/include/c++/11/type_traits" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + class tuple; + + template + class reference_wrapper; +# 64 "/usr/include/c++/11/type_traits" 3 + template + struct integral_constant + { + static constexpr _Tp value = __v; + typedef _Tp value_type; + typedef integral_constant<_Tp, __v> type; + constexpr operator value_type() const noexcept { return value; } + + + + + constexpr value_type operator()() const noexcept { return value; } + + }; + + template + constexpr _Tp integral_constant<_Tp, __v>::value; + + + using true_type = integral_constant; + + + using false_type = integral_constant; + + + + template + using __bool_constant = integral_constant; + + + + + + + template + using bool_constant = integral_constant; + + + + + template + struct conditional; + + + template + struct __type_identity + { using type = _Type; }; + + template + using __type_identity_t = typename __type_identity<_Tp>::type; + + template + struct __or_; + + template<> + struct __or_<> + : public false_type + { }; + + template + struct __or_<_B1> + : public _B1 + { }; + + template + struct __or_<_B1, _B2> + : public conditional<_B1::value, _B1, _B2>::type + { }; + + template + struct __or_<_B1, _B2, _B3, _Bn...> + : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type + { }; + + template + struct __and_; + + template<> + struct __and_<> + : public true_type + { }; + + template + struct __and_<_B1> + : public _B1 + { }; + + template + struct __and_<_B1, _B2> + : public conditional<_B1::value, _B2, _B1>::type + { }; + + template + struct __and_<_B1, _B2, _B3, _Bn...> + : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type + { }; + + template + struct __not_ + : public __bool_constant + { }; + + + + + + template + inline constexpr bool __or_v = __or_<_Bn...>::value; + template + inline constexpr bool __and_v = __and_<_Bn...>::value; + + + + + template + struct conjunction + : __and_<_Bn...> + { }; + + template + struct disjunction + : __or_<_Bn...> + { }; + + template + struct negation + : __not_<_Pp> + { }; + + + + + 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 + struct __success_type + { typedef _Tp type; }; + + struct __failure_type + { }; + + + template + using __remove_cv_t = typename remove_cv<_Tp>::type; + + + + template + struct __is_void_helper + : public false_type { }; + + template<> + struct __is_void_helper + : public true_type { }; + + + + template + struct is_void + : public __is_void_helper<__remove_cv_t<_Tp>>::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 { }; +# 310 "/usr/include/c++/11/type_traits" 3 + 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<__int128> + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; +# 391 "/usr/include/c++/11/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 { }; +# 421 "/usr/include/c++/11/type_traits" 3 + template + struct is_floating_point + : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_array + : public false_type { }; + + template + struct is_array<_Tp[_Size]> + : public true_type { }; + + template + struct is_array<_Tp[]> + : public true_type { }; + + template + struct __is_pointer_helper + : public false_type { }; + + template + struct __is_pointer_helper<_Tp*> + : public true_type { }; + + + template + struct is_pointer + : public __is_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_lvalue_reference + : public false_type { }; + + template + struct is_lvalue_reference<_Tp&> + : public true_type { }; + + + template + struct is_rvalue_reference + : public false_type { }; + + template + struct is_rvalue_reference<_Tp&&> + : public true_type { }; + + template + struct __is_member_object_pointer_helper + : public false_type { }; + + template + struct __is_member_object_pointer_helper<_Tp _Cp::*> + : public __not_>::type { }; + + + template + struct is_member_object_pointer + : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + template + struct __is_member_function_pointer_helper + : public false_type { }; + + template + struct __is_member_function_pointer_helper<_Tp _Cp::*> + : public is_function<_Tp>::type { }; + + + template + struct is_member_function_pointer + : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_enum + : public integral_constant + { }; + + + template + struct is_union + : public integral_constant + { }; + + + template + struct is_class + : public integral_constant + { }; + + + template + struct is_function + : public __bool_constant::value> { }; + + template + struct is_function<_Tp&> + : public false_type { }; + + template + struct is_function<_Tp&&> + : public false_type { }; + + + + template + struct __is_null_pointer_helper + : public false_type { }; + + template<> + struct __is_null_pointer_helper + : public true_type { }; + + + template + struct is_null_pointer + : public __is_null_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + + template + struct __is_nullptr_t + : public is_null_pointer<_Tp> + { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead"))); + + + + + template + struct is_reference + : public __or_, + is_rvalue_reference<_Tp>>::type + { }; + + + template + struct is_arithmetic + : public __or_, is_floating_point<_Tp>>::type + { }; + + + template + struct is_fundamental + : public __or_, is_void<_Tp>, + is_null_pointer<_Tp>>::type + { }; + + + template + struct is_object + : public __not_<__or_, is_reference<_Tp>, + is_void<_Tp>>>::type + { }; + + template + struct is_member_pointer; + + + template + struct is_scalar + : public __or_, is_enum<_Tp>, is_pointer<_Tp>, + is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type + { }; + + + template + struct is_compound + : public __not_>::type { }; + + + template + struct __is_member_pointer_helper + : public false_type { }; + + template + struct __is_member_pointer_helper<_Tp _Cp::*> + : public true_type { }; + + + + template + struct is_member_pointer + : public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + template + struct is_same; + + + template + using __is_one_of = __or_...>; + + + 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 +# 637 "/usr/include/c++/11/type_traits" 3 + >; + + + 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 +# 656 "/usr/include/c++/11/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_referenceable + : public false_type + { }; + + template + struct __is_referenceable<_Tp, __void_t<_Tp&>> + : public true_type + { }; + + + + + + template + struct is_const + : public false_type { }; + + template + struct is_const<_Tp const> + : public true_type { }; + + + template + struct is_volatile + : public false_type { }; + + template + struct is_volatile<_Tp volatile> + : public true_type { }; + + + template + struct is_trivial + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copyable + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_standard_layout + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct + + is_pod + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + template + struct + [[__deprecated__]] + is_literal_type + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_empty + : public integral_constant + { }; + + + template + struct is_polymorphic + : public integral_constant + { }; + + + + + + template + struct is_final + : public integral_constant + { }; + + + + template + struct is_abstract + : public integral_constant + { }; + + + template::value> + struct __is_signed_helper + : public false_type { }; + + template + struct __is_signed_helper<_Tp, true> + : public integral_constant + { }; + + + + template + struct is_signed + : public __is_signed_helper<_Tp>::type + { }; + + + template + struct is_unsigned + : public __and_, __not_>> + { }; + + + template + _Up + __declval(int); + + template + _Tp + __declval(long); + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)); + + template + struct extent; + + template + struct remove_all_extents; + + + template + struct __is_array_known_bounds + : public integral_constant::value > 0)> + { }; + + template + struct __is_array_unknown_bounds + : public __and_, __not_>> + { }; +# 842 "/usr/include/c++/11/type_traits" 3 + struct __do_is_destructible_impl + { + template().~_Tp())> + static true_type __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_destructible_impl + : public __do_is_destructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_destructible_safe; + + template + struct __is_destructible_safe<_Tp, false, false> + : public __is_destructible_impl::type>::type + { }; + + template + struct __is_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_destructible + : public __is_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + + struct __do_is_nt_destructible_impl + { + template + static __bool_constant().~_Tp())> + __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_nt_destructible_impl + : public __do_is_nt_destructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __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 + struct __is_constructible_impl + : public __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>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template::value> + struct __is_copy_constructible_impl; + + template + struct __is_copy_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_copy_constructible_impl<_Tp, true> + : public __is_constructible_impl<_Tp, const _Tp&> + { }; + + + + template + struct is_copy_constructible + : public __is_copy_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::value> + struct __is_move_constructible_impl; + + template + struct __is_move_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_move_constructible_impl<_Tp, true> + : public __is_constructible_impl<_Tp, _Tp&&> + { }; + + + + template + struct is_move_constructible + : public __is_move_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_constructible_impl + = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>; + + + + template + struct is_nothrow_constructible + : public __is_nothrow_constructible_impl<_Tp, _Args...>::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_default_constructible + : public __bool_constant<__is_nothrow_constructible(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template::value> + struct __is_nothrow_copy_constructible_impl; + + template + struct __is_nothrow_copy_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_nothrow_copy_constructible_impl<_Tp, true> + : public __is_nothrow_constructible_impl<_Tp, const _Tp&> + { }; + + + + template + struct is_nothrow_copy_constructible + : public __is_nothrow_copy_constructible_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::value> + struct __is_nothrow_move_constructible_impl; + + template + struct __is_nothrow_move_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_nothrow_move_constructible_impl<_Tp, true> + : public __is_nothrow_constructible_impl<_Tp, _Tp&&> + { }; + + + + template + struct is_nothrow_move_constructible + : public __is_nothrow_move_constructible_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_assignable + : public __bool_constant<__is_assignable(_Tp, _Up)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + template::value> + struct __is_copy_assignable_impl; + + template + struct __is_copy_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_copy_assignable_impl<_Tp, true> + : public __bool_constant<__is_assignable(_Tp&, const _Tp&)> + { }; + + + template + struct is_copy_assignable + : public __is_copy_assignable_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::value> + struct __is_move_assignable_impl; + + template + struct __is_move_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_move_assignable_impl<_Tp, true> + : public __bool_constant<__is_assignable(_Tp&, _Tp&&)> + { }; + + + template + struct is_move_assignable + : public __is_move_assignable_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 + 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::value> + struct __is_nt_copy_assignable_impl; + + template + struct __is_nt_copy_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_nt_copy_assignable_impl<_Tp, true> + : public __is_nothrow_assignable_impl<_Tp&, const _Tp&> + { }; + + + template + struct is_nothrow_copy_assignable + : public __is_nt_copy_assignable_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + template::value> + struct __is_nt_move_assignable_impl; + + template + struct __is_nt_move_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_nt_move_assignable_impl<_Tp, true> + : public __is_nothrow_assignable_impl<_Tp&, _Tp&&> + { }; + + + template + struct is_nothrow_move_assignable + : public __is_nt_move_assignable_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_trivially_constructible + : public __bool_constant<__is_trivially_constructible(_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 __bool_constant<__is_trivially_constructible(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + struct __do_is_implicitly_default_constructible_impl + { + template + static void __helper(const _Tp&); + + template + static true_type __test(const _Tp&, + decltype(__helper({}))* = 0); + + static false_type __test(...); + }; + + template + struct __is_implicitly_default_constructible_impl + : public __do_is_implicitly_default_constructible_impl + { + typedef decltype(__test(declval<_Tp>())) type; + }; + + template + struct __is_implicitly_default_constructible_safe + : public __is_implicitly_default_constructible_impl<_Tp>::type + { }; + + template + struct __is_implicitly_default_constructible + : public __and_<__is_constructible_impl<_Tp>, + __is_implicitly_default_constructible_safe<_Tp>> + { }; + + template::value> + struct __is_trivially_copy_constructible_impl; + + template + struct __is_trivially_copy_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_trivially_copy_constructible_impl<_Tp, true> + : public __and_<__is_copy_constructible_impl<_Tp>, + integral_constant> + { }; + + + template + struct is_trivially_copy_constructible + : public __is_trivially_copy_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::value> + struct __is_trivially_move_constructible_impl; + + template + struct __is_trivially_move_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_trivially_move_constructible_impl<_Tp, true> + : public __and_<__is_move_constructible_impl<_Tp>, + integral_constant> + { }; + + + template + struct is_trivially_move_constructible + : public __is_trivially_move_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_trivially_assignable + : public __bool_constant<__is_trivially_assignable(_Tp, _Up)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + template::value> + struct __is_trivially_copy_assignable_impl; + + template + struct __is_trivially_copy_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_trivially_copy_assignable_impl<_Tp, true> + : public __bool_constant<__is_trivially_assignable(_Tp&, const _Tp&)> + { }; + + + template + struct is_trivially_copy_assignable + : public __is_trivially_copy_assignable_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + template::value> + struct __is_trivially_move_assignable_impl; + + template + struct __is_trivially_move_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_trivially_move_assignable_impl<_Tp, true> + : public __bool_constant<__is_trivially_assignable(_Tp&, _Tp&&)> + { }; + + + template + struct is_trivially_move_assignable + : public __is_trivially_move_assignable_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_trivially_destructible + : public __and_<__is_destructible_safe<_Tp>, + __bool_constant<__has_trivial_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 has_virtual_destructor + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct alignment_of + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct rank + : public integral_constant { }; + + template + struct rank<_Tp[_Size]> + : public integral_constant::value> { }; + + template + struct rank<_Tp[]> + : public integral_constant::value> { }; + + + template + struct extent + : public integral_constant { }; + + template + struct extent<_Tp[_Size], _Uint> + : public integral_constant::value> + { }; + + template + struct extent<_Tp[], _Uint> + : public integral_constant::value> + { }; + + + + + + template + struct is_same + + : public integral_constant + + + + { }; +# 1420 "/usr/include/c++/11/type_traits" 3 + template + struct is_base_of + : public integral_constant + { }; + + template, is_function<_To>, + is_array<_To>>::value> + struct __is_convertible_helper + { + typedef typename is_void<_To>::type type; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + template + class __is_convertible_helper<_From, _To, false> + { + template + static void __test_aux(_To1) noexcept; + + template(std::declval<_From1>()))> + static true_type + __test(int); + + template + static false_type + __test(...); + + public: + typedef decltype(__test<_From, _To>(0)) type; + }; +#pragma GCC diagnostic pop + + + template + struct is_convertible + : public __is_convertible_helper<_From, _To>::type + { }; + + + template + using __is_array_convertible + = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; + + template, is_function<_To>, + is_array<_To>>::value> + struct __is_nt_convertible_helper + : is_void<_To> + { }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + template + class __is_nt_convertible_helper<_From, _To, false> + { + template + static void __test_aux(_To1) noexcept; + + template + static + __bool_constant(std::declval<_From1>()))> + __test(int); + + template + static false_type + __test(...); + + public: + using type = decltype(__test<_From, _To>(0)); + }; +#pragma GCC diagnostic pop +# 1512 "/usr/include/c++/11/type_traits" 3 + template + struct remove_const + { typedef _Tp type; }; + + template + struct remove_const<_Tp const> + { typedef _Tp type; }; + + + template + struct remove_volatile + { typedef _Tp type; }; + + template + struct remove_volatile<_Tp volatile> + { typedef _Tp type; }; + + + template + struct remove_cv + { using type = _Tp; }; + + template + struct remove_cv + { using type = _Tp; }; + + template + struct remove_cv + { using type = _Tp; }; + + template + struct remove_cv + { using type = _Tp; }; + + + template + struct add_const + { typedef _Tp const type; }; + + + template + struct add_volatile + { typedef _Tp volatile type; }; + + + template + struct add_cv + { + typedef typename + add_const::type>::type type; + }; + + + + + + + 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 + { typedef _Tp type; }; + + template + struct remove_reference<_Tp&> + { typedef _Tp type; }; + + template + struct remove_reference<_Tp&&> + { typedef _Tp type; }; + + template::value> + struct __add_lvalue_reference_helper + { typedef _Tp type; }; + + template + struct __add_lvalue_reference_helper<_Tp, true> + { typedef _Tp& type; }; + + + template + struct add_lvalue_reference + : public __add_lvalue_reference_helper<_Tp> + { }; + + template::value> + struct __add_rvalue_reference_helper + { typedef _Tp type; }; + + template + struct __add_rvalue_reference_helper<_Tp, true> + { typedef _Tp&& type; }; + + + template + struct add_rvalue_reference + : public __add_rvalue_reference_helper<_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> + { typedef _Unqualified __type; }; + + template + struct __cv_selector<_Unqualified, false, true> + { typedef volatile _Unqualified __type; }; + + template + struct __cv_selector<_Unqualified, true, false> + { typedef const _Unqualified __type; }; + + template + struct __cv_selector<_Unqualified, true, true> + { typedef const volatile _Unqualified __type; }; + + template::value, + bool _IsVol = is_volatile<_Qualified>::value> + class __match_cv_qualifiers + { + typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match; + + public: + typedef typename __match::__type __type; + }; + + + template + struct __make_unsigned + { typedef _Tp __type; }; + + template<> + struct __make_unsigned + { typedef unsigned char __type; }; + + template<> + struct __make_unsigned + { typedef unsigned char __type; }; + + template<> + struct __make_unsigned + { typedef unsigned short __type; }; + + template<> + struct __make_unsigned + { typedef unsigned int __type; }; + + template<> + struct __make_unsigned + { typedef unsigned long __type; }; + + template<> + struct __make_unsigned + { typedef unsigned long long __type; }; + + + template<> + struct __make_unsigned<__int128> + { typedef unsigned __int128 __type; }; +# 1736 "/usr/include/c++/11/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + 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; + }; +# 1812 "/usr/include/c++/11/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 + { typedef typename __make_unsigned_selector<_Tp>::__type type; }; + + + template<> + struct make_unsigned; + + + + + template + struct __make_signed + { typedef _Tp __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed short __type; }; + + template<> + struct __make_signed + { typedef signed int __type; }; + + template<> + struct __make_signed + { typedef signed long __type; }; + + template<> + struct __make_signed + { typedef signed long long __type; }; + + + template<> + struct __make_signed + { typedef __int128 __type; }; +# 1892 "/usr/include/c++/11/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + 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> + { + typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type; + + public: + typedef typename __make_signed_selector<__unsigned_type>::__type __type; + }; + + + + + + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; +# 1940 "/usr/include/c++/11/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 + { typedef typename __make_signed_selector<_Tp>::__type type; }; + + + 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 + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[_Size]> + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[]> + { typedef _Tp type; }; + + + template + struct remove_all_extents + { typedef _Tp type; }; + + template + struct remove_all_extents<_Tp[_Size]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + template + struct remove_all_extents<_Tp[]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + + + template + using remove_extent_t = typename remove_extent<_Tp>::type; + + + template + using remove_all_extents_t = typename remove_all_extents<_Tp>::type; + + + + + template + struct __remove_pointer_helper + { typedef _Tp type; }; + + template + struct __remove_pointer_helper<_Tp, _Up*> + { typedef _Up type; }; + + + template + struct remove_pointer + : public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>> + { }; + + template, + is_void<_Tp>>::value> + struct __add_pointer_helper + { typedef _Tp type; }; + + template + struct __add_pointer_helper<_Tp, true> + { typedef typename remove_reference<_Tp>::type* type; }; + + + template + struct add_pointer + : public __add_pointer_helper<_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; + }; + }; +# 2076 "/usr/include/c++/11/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; + }; +# 2115 "/usr/include/c++/11/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; + + typedef typename aligned_storage<_S_len, alignment_value>::type type; + }; + + template + const size_t aligned_union<_Len, _Types...>::alignment_value; + + + + + + template::value, + bool _IsFunction = is_function<_Up>::value> + struct __decay_selector; + + + template + struct __decay_selector<_Up, false, false> + { typedef __remove_cv_t<_Up> __type; }; + + template + struct __decay_selector<_Up, true, false> + { typedef typename remove_extent<_Up>::type* __type; }; + + template + struct __decay_selector<_Up, false, true> + { typedef typename add_pointer<_Up>::type __type; }; + + + + template + class decay + { + typedef typename remove_reference<_Tp>::type __remove_type; + + public: + typedef typename __decay_selector<__remove_type>::__type type; + }; + + + + + template + struct __strip_reference_wrapper + { + typedef _Tp __type; + }; + + template + struct __strip_reference_wrapper > + { + typedef _Tp& __type; + }; + + + template + using __decay_t = typename decay<_Tp>::type; + + template + using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; + + + + + template + struct enable_if + { }; + + + template + struct enable_if + { typedef _Tp type; }; + + + + + template + using __enable_if_t = typename enable_if<_Cond, _Tp>::type; + + + template + using _Require = __enable_if_t<__and_<_Cond...>::value>; + + + template + using __remove_cvref_t + = typename remove_cv::type>::type; + + + + + template + struct conditional + { typedef _Iftrue type; }; + + + template + struct conditional + { typedef _Iffalse type; }; + + + template + struct common_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); +# 2255 "/usr/include/c++/11/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::value> + 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 + { + typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; + }; + + + struct __result_of_memfun_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_deref + : private __result_of_memfun_deref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; + }; + + + struct __result_of_memobj_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>() + ), __invoke_memobj_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_ref + : private __result_of_memobj_ref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + + struct __result_of_memobj_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>() + ), __invoke_memobj_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_deref + : private __result_of_memobj_deref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + template + struct __result_of_memobj; + + template + struct __result_of_memobj<_Res _Class::*, _Arg> + { + typedef __remove_cvref_t<_Arg> _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename conditional<__or_, + is_base_of<_Class, _Argval>>::value, + __result_of_memobj_ref<_MemPtr, _Arg>, + __result_of_memobj_deref<_MemPtr, _Arg> + >::type::type type; + }; + + template + struct __result_of_memfun; + + template + struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> + { + typedef typename remove_reference<_Arg>::type _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename conditional::value, + __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, + __result_of_memfun_deref<_MemPtr, _Arg, _Args...> + >::type::type type; + }; + + + + + + + template> + struct __inv_unwrap + { + using type = _Tp; + }; + + template + struct __inv_unwrap<_Tp, reference_wrapper<_Up>> + { + using type = _Up&; + }; + + template + struct __result_of_impl + { + typedef __failure_type type; + }; + + template + struct __result_of_impl + : public __result_of_memobj<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type> + { }; + + template + struct __result_of_impl + : public __result_of_memfun<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type, _Args...> + { }; + + + struct __result_of_other_impl + { + template + static __result_of_success()(std::declval<_Args>()...) + ), __invoke_other> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_impl + : private __result_of_other_impl + { + typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; + }; + + + template + struct __invoke_result + : public __result_of_impl< + is_member_object_pointer< + typename remove_reference<_Functor>::type + >::value, + is_member_function_pointer< + typename remove_reference<_Functor>::type + >::value, + _Functor, _ArgTypes... + >::type + { }; + + + template + struct result_of<_Functor(_ArgTypes...)> + : public __invoke_result<_Functor, _ArgTypes...> + { }; + + + + template::__type)> + using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; + + template + using aligned_union_t = typename aligned_union<_Len, _Types...>::type; + + + 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; + + + + + + template class _Op, typename... _Args> + struct __detector + { + using value_t = false_type; + using type = _Default; + }; + + + template class _Op, + typename... _Args> + struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> + { + using value_t = true_type; + using type = _Op<_Args...>; + }; + + + 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; +# 2649 "/usr/include/c++/11/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_impl> : true_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 + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_nothrow_swappable_impl + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_swappable + : public __is_swappable_impl<_Tp>::type + { }; + + template + struct __is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { }; + + + + + + + + template + struct is_swappable + : public __is_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_v = + 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 + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct __is_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + template + struct __is_nothrow_swappable_with_impl + : public __swappable_with_details::__do_is_nothrow_swappable_with_impl + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + + + template + struct is_swappable_with + : public __is_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable_with + : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_with_v = + is_swappable_with<_Tp, _Up>::value; + + + template + inline constexpr bool is_nothrow_swappable_with_v = + is_nothrow_swappable_with<_Tp, _Up>::value; +# 2876 "/usr/include/c++/11/type_traits" 3 + template::value, typename = void> + struct __is_invocable_impl + : false_type + { + using __nothrow_type = false_type; + }; + + + template + struct __is_invocable_impl<_Result, _Ret, + true, + __void_t> + : true_type + { + using __nothrow_type = true_type; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + + template + struct __is_invocable_impl<_Result, _Ret, + false, + __void_t> + { + private: + + + + static typename _Result::type _S_get() noexcept; + + template + static void _S_conv(_Tp) noexcept; + + + template(_S_get())), + bool _Noex = noexcept(_S_conv<_Tp>(_S_get()))> + static __bool_constant<_Check_Noex ? _Noex : true> + _S_test(int); + + template + static false_type + _S_test(...); + + public: + + using type = decltype(_S_test<_Ret>(1)); + + + using __nothrow_type = decltype(_S_test<_Ret, true>(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_type; + + + + 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"); + }; +# 3094 "/usr/include/c++/11/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>::value; +template + inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; +template + inline constexpr bool is_lvalue_reference_v = + is_lvalue_reference<_Tp>::value; +template + inline constexpr bool is_rvalue_reference_v = + is_rvalue_reference<_Tp>::value; +template + inline constexpr bool is_member_object_pointer_v = + is_member_object_pointer<_Tp>::value; +template + inline constexpr bool is_member_function_pointer_v = + is_member_function_pointer<_Tp>::value; +template + inline constexpr bool is_enum_v = is_enum<_Tp>::value; +template + inline constexpr bool is_union_v = is_union<_Tp>::value; +template + inline constexpr bool is_class_v = is_class<_Tp>::value; +template + inline constexpr bool is_function_v = is_function<_Tp>::value; +template + inline constexpr bool is_reference_v = is_reference<_Tp>::value; +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>::value; +template + inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; +template + inline constexpr bool is_compound_v = is_compound<_Tp>::value; +template + inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; +template + inline constexpr bool is_const_v = is_const<_Tp>::value; +template + inline constexpr bool is_volatile_v = is_volatile<_Tp>::value; +template + inline constexpr bool is_trivial_v = is_trivial<_Tp>::value; +template + inline constexpr bool is_trivially_copyable_v = + is_trivially_copyable<_Tp>::value; +template + inline constexpr bool is_standard_layout_v = is_standard_layout<_Tp>::value; +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +template + + inline constexpr bool is_pod_v = is_pod<_Tp>::value; +template + [[__deprecated__]] + inline constexpr bool is_literal_type_v = is_literal_type<_Tp>::value; +#pragma GCC diagnostic pop + template + inline constexpr bool is_empty_v = is_empty<_Tp>::value; +template + inline constexpr bool is_polymorphic_v = is_polymorphic<_Tp>::value; +template + inline constexpr bool is_abstract_v = is_abstract<_Tp>::value; +template + inline constexpr bool is_final_v = is_final<_Tp>::value; +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...>::value; +template + inline constexpr bool is_default_constructible_v = + is_default_constructible<_Tp>::value; +template + inline constexpr bool is_copy_constructible_v = + is_copy_constructible<_Tp>::value; +template + inline constexpr bool is_move_constructible_v = + is_move_constructible<_Tp>::value; +template + inline constexpr bool is_assignable_v = is_assignable<_Tp, _Up>::value; +template + inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value; +template + inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value; +template + inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; +template + inline constexpr bool is_trivially_constructible_v = + is_trivially_constructible<_Tp, _Args...>::value; +template + inline constexpr bool is_trivially_default_constructible_v = + is_trivially_default_constructible<_Tp>::value; +template + inline constexpr bool is_trivially_copy_constructible_v = + is_trivially_copy_constructible<_Tp>::value; +template + inline constexpr bool is_trivially_move_constructible_v = + is_trivially_move_constructible<_Tp>::value; +template + inline constexpr bool is_trivially_assignable_v = + is_trivially_assignable<_Tp, _Up>::value; +template + inline constexpr bool is_trivially_copy_assignable_v = + is_trivially_copy_assignable<_Tp>::value; +template + inline constexpr bool is_trivially_move_assignable_v = + is_trivially_move_assignable<_Tp>::value; +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...>::value; +template + inline constexpr bool is_nothrow_default_constructible_v = + is_nothrow_default_constructible<_Tp>::value; +template + inline constexpr bool is_nothrow_copy_constructible_v = + is_nothrow_copy_constructible<_Tp>::value; +template + inline constexpr bool is_nothrow_move_constructible_v = + is_nothrow_move_constructible<_Tp>::value; +template + inline constexpr bool is_nothrow_assignable_v = + is_nothrow_assignable<_Tp, _Up>::value; +template + inline constexpr bool is_nothrow_copy_assignable_v = + is_nothrow_copy_assignable<_Tp>::value; +template + inline constexpr bool is_nothrow_move_assignable_v = + is_nothrow_move_assignable<_Tp>::value; +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>::value; +template + inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; +template + inline constexpr size_t rank_v = rank<_Tp>::value; +template + inline constexpr size_t extent_v = extent<_Tp, _Idx>::value; + +template + inline constexpr bool is_same_v = __is_same(_Tp, _Up); + + + + +template + inline constexpr bool is_base_of_v = is_base_of<_Base, _Derived>::value; +template + inline constexpr bool is_convertible_v = is_convertible<_From, _To>::value; +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<_Tp>::value; +# 3598 "/usr/include/c++/11/type_traits" 3 + +} +# 58 "/usr/include/c++/11/bits/move.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 74 "/usr/include/c++/11/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Tp&&>(__t); } + + + + + + + + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type&& __t) noexcept + { + static_assert(!std::is_lvalue_reference<_Tp>::value, + "std::forward must not be used to convert an rvalue to an lvalue"); + return static_cast<_Tp&&>(__t); + } + + + + + + + template + [[__nodiscard__]] + constexpr typename std::remove_reference<_Tp>::type&& + move(_Tp&& __t) noexcept + { return static_cast::type&&>(__t); } + + + template + struct __move_if_noexcept_cond + : public __and_<__not_>, + is_copy_constructible<_Tp>>::type { }; +# 121 "/usr/include/c++/11/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr typename + conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type + move_if_noexcept(_Tp& __x) noexcept + { return std::move(__x); } +# 142 "/usr/include/c++/11/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; + } +# 186 "/usr/include/c++/11/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]); + } + + + +} +# 60 "/usr/include/c++/11/bits/stl_pair.h" 2 3 +# 69 "/usr/include/c++/11/bits/stl_pair.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 80 "/usr/include/c++/11/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 + class tuple; + + template + struct _Index_tuple; + + + + + + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return __and_, + is_constructible<_T2, const _U2&>>::value; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return __and_, + is_convertible>::value; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return __and_, + is_constructible<_T2, _U2&&>>::value; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return __and_, + is_convertible<_U2&&, _T2>>::value; + } + + template + static constexpr bool _CopyMovePair() + { + using __do_converts = __and_, + is_convertible<_U2&&, _T2>>; + using __converts = typename conditional<__implicit, + __do_converts, + __not_<__do_converts>>::type; + return __and_, + is_constructible<_T2, _U2&&>, + __converts + >::value; + } + + template + static constexpr bool _MoveCopyPair() + { + using __do_converts = __and_, + is_convertible>; + using __converts = typename conditional<__implicit, + __do_converts, + __not_<__do_converts>>::type; + return __and_, + is_constructible<_T2, const _U2&&>, + __converts + >::value; + } + }; + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return false; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return false; + } + }; + + + template class __pair_base + { + + template friend struct pair; + __pair_base() = default; + ~__pair_base() = default; + __pair_base(const __pair_base&) = default; + __pair_base& operator=(const __pair_base&) = delete; + + }; +# 210 "/usr/include/c++/11/bits/stl_pair.h" 3 + template + struct pair + : private __pair_base<_T1, _T2> + { + typedef _T1 first_type; + typedef _T2 second_type; + + _T1 first; + _T2 second; + + + + + + + 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() { } +# 256 "/usr/include/c++/11/bits/stl_pair.h" 3 + 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) { } +# 288 "/usr/include/c++/11/bits/stl_pair.h" 3 + 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) { } + + + + constexpr pair(const pair&) = default; + constexpr pair(pair&&) = default; + + + template(), + bool>::type=true> + constexpr pair(_U1&& __x, const _T2& __y) + : first(std::forward<_U1>(__x)), second(__y) { } + + template(), + bool>::type=false> + explicit constexpr pair(_U1&& __x, const _T2& __y) + : first(std::forward<_U1>(__x)), second(__y) { } + + template(), + bool>::type=true> + constexpr pair(const _T1& __x, _U2&& __y) + : first(__x), second(std::forward<_U2>(__y)) { } + + template(), + bool>::type=false> + explicit pair(const _T1& __x, _U2&& __y) + : first(__x), 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)) { } + + template + + pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); + + pair& + operator=(typename conditional< + __and_, + is_copy_assignable<_T2>>::value, + const pair&, const __nonesuch&>::type __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + pair& + operator=(typename conditional< + __and_, + is_move_assignable<_T2>>::value, + pair&&, __nonesuch&&>::type __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; + } + + + 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); + } + + private: + template + + pair(tuple<_Args1...>&, tuple<_Args2...>&, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); + + }; + + + + + template pair(_T1, _T2) -> pair<_T1, _T2>; + + + + template + inline constexpr bool + operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first == __y.first && __x.second == __y.second; } +# 487 "/usr/include/c++/11/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); } +# 524 "/usr/include/c++/11/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); } + + + template + typename enable_if, + __is_swappable<_T2>>::value>::type + swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete; +# 564 "/usr/include/c++/11/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)); + } +# 583 "/usr/include/c++/11/bits/stl_pair.h" 3 + +} +# 65 "/usr/include/c++/11/bits/stl_algobase.h" 2 3 +# 1 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 1 3 +# 62 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 3 + +# 63 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 3 +# 74 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 93 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 3 + struct input_iterator_tag { }; + + + struct output_iterator_tag { }; + + + struct forward_iterator_tag : public input_iterator_tag { }; + + + + struct bidirectional_iterator_tag : public forward_iterator_tag { }; + + + + struct random_access_iterator_tag : public bidirectional_iterator_tag { }; +# 125 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 3 + template + struct iterator + { + + typedef _Category iterator_category; + + typedef _Tp value_type; + + typedef _Distance difference_type; + + typedef _Pointer pointer; + + typedef _Reference reference; + }; +# 149 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits; + + + + + template> + struct __iterator_traits { }; + + + + template + struct __iterator_traits<_Iterator, + __void_t> + { + typedef typename _Iterator::iterator_category iterator_category; + typedef typename _Iterator::value_type value_type; + typedef typename _Iterator::difference_type difference_type; + typedef typename _Iterator::pointer pointer; + typedef typename _Iterator::reference reference; + }; + + + template + struct iterator_traits + : public __iterator_traits<_Iterator> { }; +# 209 "/usr/include/c++/11/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 + inline constexpr + typename iterator_traits<_Iter>::iterator_category + __iterator_category(const _Iter&) + { return typename iterator_traits<_Iter>::iterator_category(); } + + + + + template + using __iterator_category_t + = typename iterator_traits<_Iter>::iterator_category; + + template + using _RequireInputIter = + __enable_if_t, + input_iterator_tag>::value>; + + template> + struct __is_random_access_iter + : is_base_of + { + typedef is_base_of _Base; + enum { __value = _Base::value }; + }; + + + + + + + + +} +# 66 "/usr/include/c++/11/bits/stl_algobase.h" 2 3 +# 1 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 1 3 +# 62 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 3 + +# 63 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 3 + +# 1 "/usr/include/c++/11/bits/concept_check.h" 1 3 +# 33 "/usr/include/c++/11/bits/concept_check.h" 3 + +# 34 "/usr/include/c++/11/bits/concept_check.h" 3 +# 65 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 2 3 +# 1 "/usr/include/c++/11/debug/assertions.h" 1 3 +# 66 "/usr/include/c++/11/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 + 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); +# 135 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 3 + template + 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 (__builtin_is_constant_evaluated() && !bool(__n >= 0)) __builtin_unreachable(); } 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; + } +# 200 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 3 + template + 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 + inline constexpr _InputIterator + next(_InputIterator __x, typename + iterator_traits<_InputIterator>::difference_type __n = 1) + { + + + std::advance(__x, __n); + return __x; + } + + template + inline constexpr _BidirectionalIterator + prev(_BidirectionalIterator __x, typename + iterator_traits<_BidirectionalIterator>::difference_type __n = 1) + { + + + + std::advance(__x, -__n); + return __x; + } + + + + +} +# 67 "/usr/include/c++/11/bits/stl_algobase.h" 2 3 +# 1 "/usr/include/c++/11/bits/stl_iterator.h" 1 3 +# 67 "/usr/include/c++/11/bits/stl_iterator.h" 3 +# 1 "/usr/include/c++/11/bits/ptr_traits.h" 1 3 +# 42 "/usr/include/c++/11/bits/ptr_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + class __undefined; + + + template + struct __replace_first_arg + { }; + + template class _Template, typename _Up, + typename _Tp, typename... _Types> + struct __replace_first_arg<_Template<_Tp, _Types...>, _Up> + { using type = _Template<_Up, _Types...>; }; + + template + using __replace_first_arg_t = typename __replace_first_arg<_Tp, _Up>::type; + + template + using __make_not_void + = typename conditional::value, __undefined, _Tp>::type; + + template + struct __ptr_traits_elem_1 + { }; + + template class _SomePointer, typename _Tp, + typename... _Args> + struct __ptr_traits_elem_1<_SomePointer<_Tp, _Args...>> + { + using element_type = _Tp; + using pointer = _SomePointer<_Tp, _Args...>; + + static pointer + pointer_to(__make_not_void& __e) + { return pointer::pointer_to(__e); } + }; + + template + struct __ptr_traits_elem : __ptr_traits_elem_1<_Ptr> + { }; + + template + struct __ptr_traits_elem<_Ptr, __void_t> + { + using element_type = typename _Ptr::element_type; + + static _Ptr + pointer_to(__make_not_void& __e) + { return _Ptr::pointer_to(__e); } + }; + + + + + + template + struct pointer_traits : __ptr_traits_elem<_Ptr> + { + private: + template + using __difference_type = typename _Tp::difference_type; + + template + struct __rebind : __replace_first_arg<_Tp, _Up> { }; + + template + struct __rebind<_Tp, _Up, __void_t>> + { using type = typename _Tp::template rebind<_Up>; }; + + public: + + using pointer = _Ptr; + + + using difference_type + = __detected_or_t; + + + template + using rebind = typename __rebind<_Ptr, _Up>::type; + }; + + + + + + template + struct pointer_traits<_Tp*> + { + + typedef _Tp* pointer; + + typedef _Tp element_type; + + typedef ptrdiff_t difference_type; + + template + using rebind = _Up*; + + + + + + + static pointer + pointer_to(__make_not_void& __r) noexcept + { return std::addressof(__r); } + }; + + + 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->()); } +# 214 "/usr/include/c++/11/bits/ptr_traits.h" 3 + +} +# 68 "/usr/include/c++/11/bits/stl_iterator.h" 2 3 +# 88 "/usr/include/c++/11/bits/stl_iterator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 127 "/usr/include/c++/11/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; +# 146 "/usr/include/c++/11/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; +# 177 "/usr/include/c++/11/bits/stl_iterator.h" 3 + constexpr + reverse_iterator() : current() { } + + + + + explicit constexpr + reverse_iterator(iterator_type __x) : current(__x) { } + + + + + constexpr + reverse_iterator(const reverse_iterator& __x) + : current(__x.current) { } + + + reverse_iterator& operator=(const reverse_iterator&) = default; + + + + + + + template + + + + constexpr + reverse_iterator(const reverse_iterator<_Iter>& __x) + : current(__x.current) { } + + + template + + + + + constexpr + reverse_iterator& + operator=(const reverse_iterator<_Iter>& __x) + { + current = __x.current; + return *this; + } + + + + + + constexpr iterator_type + base() const + { return current; } +# 241 "/usr/include/c++/11/bits/stl_iterator.h" 3 + constexpr reference + operator*() const + { + _Iterator __tmp = current; + return *--__tmp; + } + + + + + + + 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; + } + + + + + + + constexpr reverse_iterator + operator+(difference_type __n) const + { return reverse_iterator(current - __n); } + + + + + + + + constexpr reverse_iterator& + operator+=(difference_type __n) + { + current -= __n; + return *this; + } + + + + + + + constexpr reverse_iterator + operator-(difference_type __n) const + { return reverse_iterator(current + __n); } + + + + + + + + constexpr reverse_iterator& + operator-=(difference_type __n) + { + current += __n; + return *this; + } + + + + + + + constexpr reference + operator[](difference_type __n) const + { return *(*this + __n); } +# 395 "/usr/include/c++/11/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->(); } + }; +# 418 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + inline constexpr bool + operator==(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } + + template + inline constexpr bool + operator<(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y.base() < __x.base(); } + + template + inline constexpr bool + operator!=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + inline constexpr bool + operator>(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y < __x; } + + template + inline constexpr bool + operator<=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + inline constexpr bool + operator>=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + + template + 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 + 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 + 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(); } +# 575 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + 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 + 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 + inline constexpr reverse_iterator<_Iterator> + make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } +# 616 "/usr/include/c++/11/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())); } +# 647 "/usr/include/c++/11/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)) { } +# 687 "/usr/include/c++/11/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; + } + + + + + back_insert_iterator& + operator*() + { return *this; } + + + + back_insert_iterator& + operator++() + { return *this; } + + + + back_insert_iterator + operator++(int) + { return *this; } + }; +# 734 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + + inline back_insert_iterator<_Container> + back_inserter(_Container& __x) + { return back_insert_iterator<_Container>(__x); } +# 750 "/usr/include/c++/11/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)) { } +# 790 "/usr/include/c++/11/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; + } + + + + + front_insert_iterator& + operator*() + { return *this; } + + + + front_insert_iterator& + operator++() + { return *this; } + + + + front_insert_iterator + operator++(int) + { return *this; } + }; +# 837 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + + inline front_insert_iterator<_Container> + front_inserter(_Container& __x) + { return front_insert_iterator<_Container>(__x); } +# 857 "/usr/include/c++/11/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; +# 889 "/usr/include/c++/11/bits/stl_iterator.h" 3 + + insert_iterator(_Container& __x, _Iter __i) + : container(std::__addressof(__x)), iter(__i) {} +# 925 "/usr/include/c++/11/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; + } + + + + + insert_iterator& + operator*() + { return *this; } + + + + insert_iterator& + operator++() + { return *this; } + + + + insert_iterator& + operator++(int) + { return *this; } + }; +# 981 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + inline insert_iterator<_Container> + inserter(_Container& __x, typename _Container::iterator __i) + { return insert_iterator<_Container>(__x, __i); } + + + + + +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 1003 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + class __normal_iterator + { + protected: + _Iterator _M_current; + + typedef std::iterator_traits<_Iterator> __traits_type; + + 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, + typename __enable_if< + (std::__are_same<_Iter, typename _Container::pointer>::__value), + _Container>::__type>& __i) noexcept + : _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; } + }; +# 1152 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + + inline bool + operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + + inline bool + operator==(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + + inline bool + operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + template + + inline bool + operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + + template + inline bool + operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + + inline bool + operator<(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + inline bool + operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + + inline bool + operator>(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + inline bool + operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + + inline bool + operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + inline bool + operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + template + + inline bool + operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + + + + + + template + + + + 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 + + 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 + + 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(); } +# 1342 "/usr/include/c++/11/bits/stl_iterator.h" 3 + namespace __detail + { +# 1358 "/usr/include/c++/11/bits/stl_iterator.h" 3 + } +# 1369 "/usr/include/c++/11/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; +# 1408 "/usr/include/c++/11/bits/stl_iterator.h" 3 + public: + using iterator_type = _Iterator; +# 1422 "/usr/include/c++/11/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; + + + typedef typename conditional::value, + typename remove_reference<__base_ref>::type&&, + __base_ref>::type reference; + + + 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; + } + + + constexpr iterator_type + base() const + { return _M_current; } +# 1476 "/usr/include/c++/11/bits/stl_iterator.h" 3 + constexpr reference + operator*() const + + + + { return static_cast(*_M_current); } + + + 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; + } + + 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; + } + + 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; + } + + constexpr reference + operator[](difference_type __n) const + + + + { return std::move(_M_current[__n]); } +# 1581 "/usr/include/c++/11/bits/stl_iterator.h" 3 + }; + + template + inline constexpr bool + operator==(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() == __y.base(); } +# 1600 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + inline constexpr bool + operator!=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return !(__x == __y); } + + + template + inline constexpr bool + operator<(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() < __y.base(); } + + template + inline constexpr bool + operator<=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__y < __x); } + + template + inline constexpr bool + operator>(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __y < __x; } + + template + inline constexpr bool + operator>=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__x < __y); } + + + + + template + inline constexpr bool + operator==(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } +# 1659 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + inline constexpr bool + operator!=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + inline constexpr bool + operator<(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() < __y.base(); } + + template + inline constexpr bool + operator<=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + inline constexpr bool + operator>(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __y < __x; } + + template + inline constexpr bool + operator>=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + template + 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 + inline constexpr move_iterator<_Iterator> + operator+(typename move_iterator<_Iterator>::difference_type __n, + const move_iterator<_Iterator>& __x) + { return __x + __n; } + + template + 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>>::type> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Iterator __i) + { return _ReturnType(__i); } + + + + template::value, + const _Tp*, move_iterator<_Tp*>>::type> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Tp* __i) + { return _ReturnType(__i); } +# 2447 "/usr/include/c++/11/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()); } +# 2479 "/usr/include/c++/11/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/include/c++/11/bits/stl_algobase.h" 2 3 + +# 1 "/usr/include/c++/11/debug/debug.h" 1 3 +# 48 "/usr/include/c++/11/debug/debug.h" 3 +namespace std +{ + namespace __debug { } +} + + + + +namespace __gnu_debug +{ + using namespace std::__debug; + + template + struct _Safe_iterator; +} +# 70 "/usr/include/c++/11/bits/stl_algobase.h" 2 3 + +# 1 "/usr/include/c++/11/bits/predefined_ops.h" 1 3 +# 35 "/usr/include/c++/11/bits/predefined_ops.h" 3 +namespace __gnu_cxx +{ +namespace __ops +{ + struct _Iter_less_iter + { + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 < *__it2; } + }; + + constexpr + inline _Iter_less_iter + __iter_less_iter() + { return _Iter_less_iter(); } + + struct _Iter_less_val + { + + constexpr _Iter_less_val() = default; + + + + + + explicit + _Iter_less_val(_Iter_less_iter) { } + + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it < __val; } + }; + + + inline _Iter_less_val + __iter_less_val() + { return _Iter_less_val(); } + + + inline _Iter_less_val + __iter_comp_val(_Iter_less_iter) + { return _Iter_less_val(); } + + struct _Val_less_iter + { + + constexpr _Val_less_iter() = default; + + + + + + explicit + _Val_less_iter(_Iter_less_iter) { } + + template + + bool + operator()(_Value& __val, _Iterator __it) const + { return __val < *__it; } + }; + + + inline _Val_less_iter + __val_less_iter() + { return _Val_less_iter(); } + + + inline _Val_less_iter + __val_comp_iter(_Iter_less_iter) + { return _Val_less_iter(); } + + struct _Iter_equal_to_iter + { + template + + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 == *__it2; } + }; + + + inline _Iter_equal_to_iter + __iter_equal_to_iter() + { return _Iter_equal_to_iter(); } + + struct _Iter_equal_to_val + { + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it == __val; } + }; + + + inline _Iter_equal_to_val + __iter_equal_to_val() + { return _Iter_equal_to_val(); } + + + inline _Iter_equal_to_val + __iter_comp_val(_Iter_equal_to_iter) + { return _Iter_equal_to_val(); } + + template + struct _Iter_comp_iter + { + _Compare _M_comp; + + explicit constexpr + _Iter_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) + { return bool(_M_comp(*__it1, *__it2)); } + }; + + template + constexpr + inline _Iter_comp_iter<_Compare> + __iter_comp_iter(_Compare __comp) + { return _Iter_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_comp_val + { + _Compare _M_comp; + + + explicit + _Iter_comp_val(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Iterator __it, _Value& __val) + { return bool(_M_comp(*__it, __val)); } + }; + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Compare __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Iter_comp_iter<_Compare> __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + struct _Val_comp_iter + { + _Compare _M_comp; + + + explicit + _Val_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Value& __val, _Iterator __it) + { return bool(_M_comp(__val, *__it)); } + }; + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Compare __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Iter_comp_iter<_Compare> __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_equals_val + { + _Value& _M_value; + + + explicit + _Iter_equals_val(_Value& __value) + : _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return *__it == _M_value; } + }; + + template + + inline _Iter_equals_val<_Value> + __iter_equals_val(_Value& __val) + { return _Iter_equals_val<_Value>(__val); } + + template + struct _Iter_equals_iter + { + _Iterator1 _M_it1; + + + explicit + _Iter_equals_iter(_Iterator1 __it1) + : _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return *__it2 == *_M_it1; } + }; + + template + + inline _Iter_equals_iter<_Iterator> + __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) + { return _Iter_equals_iter<_Iterator>(__it); } + + template + struct _Iter_pred + { + _Predicate _M_pred; + + + explicit + _Iter_pred(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_pred<_Predicate> + __pred_iter(_Predicate __pred) + { return _Iter_pred<_Predicate>(std::move(__pred)); } + + template + struct _Iter_comp_to_val + { + _Compare _M_comp; + _Value& _M_value; + + + _Iter_comp_to_val(_Compare __comp, _Value& __value) + : _M_comp(std::move(__comp)), _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_comp(*__it, _M_value)); } + }; + + template + _Iter_comp_to_val<_Compare, _Value> + + __iter_comp_val(_Compare __comp, _Value &__val) + { + return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val); + } + + template + struct _Iter_comp_to_iter + { + _Compare _M_comp; + _Iterator1 _M_it1; + + + _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) + : _M_comp(std::move(__comp)), _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return bool(_M_comp(*__it2, *_M_it1)); } + }; + + template + + inline _Iter_comp_to_iter<_Compare, _Iterator> + __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) + { + return _Iter_comp_to_iter<_Compare, _Iterator>( + std::move(__comp._M_comp), __it); + } + + template + struct _Iter_negate + { + _Predicate _M_pred; + + + explicit + _Iter_negate(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return !bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_negate<_Predicate> + __negate(_Iter_pred<_Predicate> __pred) + { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } + +} +} +# 72 "/usr/include/c++/11/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"); +# 105 "/usr/include/c++/11/bits/stl_algobase.h" 3 + return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); + } +# 149 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline void + iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) + { + + + + +# 182 "/usr/include/c++/11/bits/stl_algobase.h" 3 + swap(*__a, *__b); + + } +# 198 "/usr/include/c++/11/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; + } +# 227 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b) + { + + + + if (__b < __a) + return __b; + return __a; + } +# 251 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b) + { + + + + if (__a < __b) + return __b; + return __a; + } +# 275 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__b, __a)) + return __b; + return __a; + } +# 297 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__a, __b)) + return __b; + return __a; + } + + + + template + + inline _Iterator + __niter_base(_Iterator __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it; } + + template + _Ite + __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, + std::random_access_iterator_tag>&); + + + + + template + + inline _From + __niter_wrap(_From __from, _To __res) + { return __from + (__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<> + 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 + struct __copy_move<_IsMove, true, random_access_iterator_tag> + { + template + + static _Tp* + __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result) + { + + using __assignable = conditional<_IsMove, + is_move_assignable<_Tp>, + is_copy_assignable<_Tp>>; + + static_assert( __assignable::type::value, "type is not assignable" ); + + const ptrdiff_t _Num = __last - __first; + if (_Num) + __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); + 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); +# 608 "/usr/include/c++/11/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); + } +# 641 "/usr/include/c++/11/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 _Tp* + __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result) + { + + using __assignable = conditional<_IsMove, + is_move_assignable<_Tp>, + is_copy_assignable<_Tp>>; + + static_assert( __assignable::type::value, "type is not assignable" ); + + const ptrdiff_t _Num = __last - __first; + if (_Num) + __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); + 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>&); +# 845 "/usr/include/c++/11/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); + } +# 881 "/usr/include/c++/11/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; +# 943 "/usr/include/c++/11/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&); +# 989 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline void + fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) + { + + + + ; + + std::__fill_a(__first, __last, __value); + } + + + inline constexpr int + __size_to_integer(int __n) { return __n; } + inline constexpr unsigned + __size_to_integer(unsigned __n) { return __n; } + inline constexpr long + __size_to_integer(long __n) { return __n; } + inline constexpr unsigned long + __size_to_integer(unsigned long __n) { return __n; } + inline constexpr long long + __size_to_integer(long long __n) { return __n; } + inline constexpr unsigned long long + __size_to_integer(unsigned long long __n) { return __n; } + + + inline constexpr __int128 + __size_to_integer(__int128 __n) { return __n; } + inline constexpr unsigned __int128 + __size_to_integer(unsigned __int128 __n) { return __n; } +# 1041 "/usr/include/c++/11/bits/stl_algobase.h" 3 + inline constexpr long long + __size_to_integer(float __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(double __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(long double __n) { return (long long)__n; } + + + + + + template + + 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; + } +# 1141 "/usr/include/c++/11/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; + } +# 1487 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline _ForwardIterator + lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + + + + + ; + + return std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val()); + } + + + + inline constexpr int + __lg(int __n) + { return (int)sizeof(int) * 8 - 1 - __builtin_clz(__n); } + + inline constexpr unsigned + __lg(unsigned __n) + { return (int)sizeof(int) * 8 - 1 - __builtin_clz(__n); } + + inline constexpr long + __lg(long __n) + { return (int)sizeof(long) * 8 - 1 - __builtin_clzl(__n); } + + inline constexpr unsigned long + __lg(unsigned long __n) + { return (int)sizeof(long) * 8 - 1 - __builtin_clzl(__n); } + + inline constexpr long long + __lg(long long __n) + { return (int)sizeof(long long) * 8 - 1 - __builtin_clzll(__n); } + + inline constexpr unsigned long long + __lg(unsigned long long __n) + { return (int)sizeof(long long) * 8 - 1 - __builtin_clzll(__n); } + + +# 1543 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + + + + + + + ; + + return std::__equal_aux(__first1, __last1, __first2); + } +# 1574 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + 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; + } + + + + 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 (_RAIters()) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + return std::equal(__first1, __last1, __first2); + } + + 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 (_RAIters()) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + return std::equal(__first1, __last1, __first2, + __binary_pred); + } + + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return __first1 == __last1 && __first2 == __last2; + } +# 1664 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + + + + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2); + } +# 1697 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2, + __binary_pred); + } +# 1729 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + + + + + + + + + + ; + ; + + return std::__lexicographical_compare_aux(__first1, __last1, + __first2, __last2); + } +# 1764 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + 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)); + } +# 1877 "/usr/include/c++/11/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); + } +# 1905 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2) + { + + + + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 1939 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + 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); + } +# 1988 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + 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()); + } +# 2024 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + 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 + + 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; + } +# 2181 "/usr/include/c++/11/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()); + } + + + +} +# 46 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/limits" 1 3 +# 40 "/usr/include/c++/11/limits" 3 + +# 41 "/usr/include/c++/11/limits" 3 +# 158 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/limits" 3 + template + struct numeric_limits : public __numeric_limits_base + { + + + static constexpr _Tp + min() noexcept { return _Tp(); } + + + static constexpr _Tp + max() noexcept { return _Tp(); } + + + + + static constexpr _Tp + lowest() noexcept { return _Tp(); } + + + + + static constexpr _Tp + epsilon() noexcept { return _Tp(); } + + + static constexpr _Tp + round_error() noexcept { return _Tp(); } + + + static constexpr _Tp + infinity() noexcept { return _Tp(); } + + + + static constexpr _Tp + quiet_NaN() noexcept { return _Tp(); } + + + + static constexpr _Tp + signaling_NaN() noexcept { return _Tp(); } + + + + + static constexpr _Tp + denorm_min() noexcept { return _Tp(); } + }; + + + + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; +# 383 "/usr/include/c++/11/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/include/c++/11/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; + }; +# 1635 "/usr/include/c++/11/limits" 3 + 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; }; 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; }; +# 1667 "/usr/include/c++/11/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; + }; + + + + + + +} +# 47 "/usr/include/c++/11/bits/specfun.h" 2 3 + + +# 1 "/usr/include/c++/11/tr1/gamma.tcc" 1 3 +# 49 "/usr/include/c++/11/tr1/gamma.tcc" 3 +# 1 "/usr/include/c++/11/tr1/special_function_util.h" 1 3 +# 39 "/usr/include/c++/11/tr1/special_function_util.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 50 "/usr/include/c++/11/tr1/special_function_util.h" 3 + namespace __detail + { + + + + template + struct __floating_point_constant + { + static const _Tp __value; + }; + + + + template + struct __numeric_constants + { + + static _Tp __pi() throw() + { return static_cast<_Tp>(3.1415926535897932384626433832795029L); } + + static _Tp __pi_2() throw() + { return static_cast<_Tp>(1.5707963267948966192313216916397514L); } + + static _Tp __pi_3() throw() + { return static_cast<_Tp>(1.0471975511965977461542144610931676L); } + + static _Tp __pi_4() throw() + { return static_cast<_Tp>(0.7853981633974483096156608458198757L); } + + static _Tp __1_pi() throw() + { return static_cast<_Tp>(0.3183098861837906715377675267450287L); } + + static _Tp __2_sqrtpi() throw() + { return static_cast<_Tp>(1.1283791670955125738961589031215452L); } + + static _Tp __sqrt2() throw() + { return static_cast<_Tp>(1.4142135623730950488016887242096981L); } + + static _Tp __sqrt3() throw() + { return static_cast<_Tp>(1.7320508075688772935274463415058723L); } + + static _Tp __sqrtpio2() throw() + { return static_cast<_Tp>(1.2533141373155002512078826424055226L); } + + static _Tp __sqrt1_2() throw() + { return static_cast<_Tp>(0.7071067811865475244008443621048490L); } + + static _Tp __lnpi() throw() + { return static_cast<_Tp>(1.1447298858494001741434273513530587L); } + + static _Tp __gamma_e() throw() + { return static_cast<_Tp>(0.5772156649015328606065120900824024L); } + + static _Tp __euler() throw() + { return static_cast<_Tp>(2.7182818284590452353602874713526625L); } + }; +# 114 "/usr/include/c++/11/tr1/special_function_util.h" 3 + template + inline bool __isnan(_Tp __x) + { return std::isnan(__x); } +# 133 "/usr/include/c++/11/tr1/special_function_util.h" 3 + } + + + + + +} +# 50 "/usr/include/c++/11/tr1/gamma.tcc" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/include/c++/11/tr1/gamma.tcc" 3 + namespace __detail + { +# 76 "/usr/include/c++/11/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/include/c++/11/tr1/gamma.tcc" 3 + template + inline _Tp + __bernoulli(int __n) + { return __bernoulli_series<_Tp>(__n); } +# 153 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/gamma.tcc" 3 + template + inline _Tp + __gamma(_Tp __x) + { return std::exp(__log_gamma(__x)); } +# 356 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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; + } + } + } + + + + + + +} +# 50 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/bessel_function.tcc" 1 3 +# 55 "/usr/include/c++/11/tr1/bessel_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 71 "/usr/include/c++/11/tr1/bessel_function.tcc" 3 + namespace __detail + { +# 98 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_bessel_j(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_j.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x * __x < _Tp(10) * (__nu + _Tp(1))) + return __cyl_bessel_ij_series(__nu, __x, -_Tp(1), 200); + else if (__x > _Tp(1000)) + { + _Tp __J_nu, __N_nu; + __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); + return __J_nu; + } + else + { + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + return __J_nu; + } + } +# 532 "/usr/include/c++/11/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_neumann_n(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_neumann_n.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x > _Tp(1000)) + { + _Tp __J_nu, __N_nu; + __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); + return __N_nu; + } + else + { + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + return __N_nu; + } + } +# 569 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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; + } + } + } + + + + + + +} +# 51 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/beta_function.tcc" 1 3 +# 49 "/usr/include/c++/11/tr1/beta_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/include/c++/11/tr1/beta_function.tcc" 3 + namespace __detail + { +# 79 "/usr/include/c++/11/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/include/c++/11/tr1/beta_function.tcc" 3 + return __bet; + } +# 127 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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); + } + } + + + + + + +} +# 52 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/ell_integral.tcc" 1 3 +# 45 "/usr/include/c++/11/tr1/ell_integral.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 59 "/usr/include/c++/11/tr1/ell_integral.tcc" 3 + namespace __detail + { +# 76 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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); + } + } + } + + + + + +} +# 53 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/exp_integral.tcc" 1 3 +# 50 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 64 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 + namespace __detail + { + template _Tp __expint_E1(_Tp); +# 81 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_Ei(_Tp __x) + { + if (__x < _Tp(0)) + return -__expint_E1(-__x); + else if (__x < -std::log(std::numeric_limits<_Tp>::epsilon())) + return __expint_Ei_series(__x); + else + return __expint_Ei_asymp(__x); + } +# 378 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_E1(_Tp __x) + { + if (__x < _Tp(0)) + return -__expint_Ei(-__x); + else if (__x < _Tp(1)) + return __expint_E1_series(__x); + else if (__x < _Tp(100)) + return __expint_En_cont_frac(1, __x); + else + return __expint_E1_asymp(__x); + } +# 408 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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); + } + } + + + + + +} +# 54 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/hypergeometric.tcc" 1 3 +# 44 "/usr/include/c++/11/tr1/hypergeometric.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 60 "/usr/include/c++/11/tr1/hypergeometric.tcc" 3 + namespace __detail + { +# 83 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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); + } + } + + + + + + +} +# 55 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/legendre_function.tcc" 1 3 +# 49 "/usr/include/c++/11/tr1/legendre_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/include/c++/11/tr1/legendre_function.tcc" 3 + namespace __detail + { +# 80 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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; + } + } + } + } + + + + + + +} +# 56 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/modified_bessel_func.tcc" 1 3 +# 51 "/usr/include/c++/11/tr1/modified_bessel_func.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/include/c++/11/tr1/modified_bessel_func.tcc" 3 + namespace __detail + { +# 83 "/usr/include/c++/11/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/include/c++/11/tr1/modified_bessel_func.tcc" 3 + template + _Tp + __cyl_bessel_i(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_i.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x * __x < _Tp(10) * (__nu + _Tp(1))) + return __cyl_bessel_ij_series(__nu, __x, +_Tp(1), 200); + else + { + _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + return __I_nu; + } + } +# 303 "/usr/include/c++/11/tr1/modified_bessel_func.tcc" 3 + template + _Tp + __cyl_bessel_k(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_k.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + { + _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + return __K_nu; + } + } +# 337 "/usr/include/c++/11/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/include/c++/11/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; + } + } + + + + + +} +# 57 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/poly_hermite.tcc" 1 3 +# 42 "/usr/include/c++/11/tr1/poly_hermite.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 56 "/usr/include/c++/11/tr1/poly_hermite.tcc" 3 + namespace __detail + { +# 72 "/usr/include/c++/11/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/include/c++/11/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); + } + } + + + + + +} +# 58 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/poly_laguerre.tcc" 1 3 +# 44 "/usr/include/c++/11/tr1/poly_laguerre.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 60 "/usr/include/c++/11/tr1/poly_laguerre.tcc" 3 + namespace __detail + { +# 75 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/poly_laguerre.tcc" 3 + template + inline _Tp + __assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x) + { return __poly_laguerre(__n, __m, __x); } +# 316 "/usr/include/c++/11/tr1/poly_laguerre.tcc" 3 + template + inline _Tp + __laguerre(unsigned int __n, _Tp __x) + { return __poly_laguerre(__n, 0, __x); } + } + + + + + + +} +# 59 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/riemann_zeta.tcc" 1 3 +# 47 "/usr/include/c++/11/tr1/riemann_zeta.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 63 "/usr/include/c++/11/tr1/riemann_zeta.tcc" 3 + namespace __detail + { +# 78 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/riemann_zeta.tcc" 3 + template + inline _Tp + __hurwitz_zeta(_Tp __a, _Tp __s) + { return __hurwitz_zeta_glob(__a, __s); } + } + + + + + + +} +# 60 "/usr/include/c++/11/bits/specfun.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 205 "/usr/include/c++/11/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); } +# 250 "/usr/include/c++/11/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); + } +# 266 "/usr/include/c++/11/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); } +# 296 "/usr/include/c++/11/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); + } +# 311 "/usr/include/c++/11/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); } +# 341 "/usr/include/c++/11/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); + } +# 357 "/usr/include/c++/11/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); } +# 389 "/usr/include/c++/11/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); + } +# 405 "/usr/include/c++/11/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); } +# 436 "/usr/include/c++/11/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); + } +# 452 "/usr/include/c++/11/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); } +# 487 "/usr/include/c++/11/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); + } +# 503 "/usr/include/c++/11/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); } +# 533 "/usr/include/c++/11/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); + } +# 549 "/usr/include/c++/11/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); } +# 579 "/usr/include/c++/11/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); + } +# 595 "/usr/include/c++/11/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); } +# 631 "/usr/include/c++/11/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); + } +# 647 "/usr/include/c++/11/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); } +# 679 "/usr/include/c++/11/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); + } +# 695 "/usr/include/c++/11/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); } +# 727 "/usr/include/c++/11/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); + } +# 743 "/usr/include/c++/11/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); } +# 775 "/usr/include/c++/11/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); + } +# 791 "/usr/include/c++/11/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); } +# 828 "/usr/include/c++/11/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); + } +# 843 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + expintf(float __x) + { return __detail::__expint(__x); } + + + + + + + + inline long double + expintl(long double __x) + { return __detail::__expint(__x); } +# 868 "/usr/include/c++/11/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); + } +# 884 "/usr/include/c++/11/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); } +# 916 "/usr/include/c++/11/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); + } +# 932 "/usr/include/c++/11/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); } +# 960 "/usr/include/c++/11/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); + } +# 976 "/usr/include/c++/11/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); } +# 1005 "/usr/include/c++/11/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); + } +# 1021 "/usr/include/c++/11/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); } +# 1056 "/usr/include/c++/11/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); + } +# 1072 "/usr/include/c++/11/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); } +# 1100 "/usr/include/c++/11/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); + } +# 1116 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + sph_legendref(unsigned int __l, unsigned int __m, float __theta) + { return __detail::__sph_legendre(__l, __m, __theta); } +# 1127 "/usr/include/c++/11/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); } +# 1147 "/usr/include/c++/11/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); + } +# 1163 "/usr/include/c++/11/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); } +# 1191 "/usr/include/c++/11/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"))) +{ + +# 1218 "/usr/include/c++/11/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; + } +# 1294 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + conf_hypergf(float __a, float __c, float __x) + { return std::__detail::__conf_hyperg(__a, __c, __x); } +# 1305 "/usr/include/c++/11/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); } +# 1325 "/usr/include/c++/11/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); + } +# 1342 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + hypergf(float __a, float __b, float __c, float __x) + { return std::__detail::__hyperg(__a, __b, __c, __x); } +# 1353 "/usr/include/c++/11/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); } +# 1374 "/usr/include/c++/11/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); + } + + + +} + + +#pragma GCC visibility pop +# 1936 "/usr/include/c++/11/cmath" 2 3 + + +} +# 37 "/usr/include/c++/11/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; +# 10551 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 2 +# 1 "/usr/include/c++/11/stdlib.h" 1 3 +# 10552 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 2 + + +# 1 "/usr/include/c++/11/cmath" 1 3 +# 39 "/usr/include/c++/11/cmath" 3 + +# 40 "/usr/include/c++/11/cmath" 3 +# 10555 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 2 +# 1 "/usr/include/c++/11/cstdlib" 1 3 +# 39 "/usr/include/c++/11/cstdlib" 3 + +# 40 "/usr/include/c++/11/cstdlib" 3 +# 10556 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 2 +# 10626 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + +# 10626 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 10805 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 11206 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +namespace std { +# 11215 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int abs(long long int); +# 11225 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int abs(long int); +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); +# 11350 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +} +# 11456 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 11595 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11736 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float min(const float a, const float b); +# 11747 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(const double a, const double b); +# 11757 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(const float a, const double b); +# 11767 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11866 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float max(const float a, const float b); +# 11877 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const double a, const double b); +# 11887 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const float a, const double b); +# 11897 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const double a, const float b); +# 11909 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +} +# 12199 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.hpp" 1 +# 77 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.hpp" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 78 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.hpp" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 79 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.hpp" 2 +# 758 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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)); +} +# 12200 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 2 +# 304 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 2 +# 118 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 1 +# 81 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 82 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_types.h" 1 +# 83 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 84 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 95 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +extern "C" +{ +# 106 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __mulhi(int x, int y); +# 116 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __umulhi(unsigned int x, unsigned int y); +# 126 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int_as_float(int x); +# 154 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float_as_int(float x); +# 163 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint_as_float(unsigned int x); +# 172 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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(); +# 207 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __saturatef(float x); +# 276 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __sad(int x, int y, unsigned int z); +# 344 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 354 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __mul24(int x, int y); +# 364 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __umul24(unsigned int x, unsigned int y); +# 377 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float fdividef(float x, float y); +# 450 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 463 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __sinf(float x) +# 463 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 3 4 + noexcept (true) +# 463 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" + ; +# 474 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __cosf(float x) +# 474 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 3 4 + noexcept (true) +# 474 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" + ; +# 487 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __tanf(float x) +# 487 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 3 4 + noexcept (true) +# 487 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" + ; +# 502 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void __sincosf(float x, float *sptr, float *cptr) +# 502 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 3 4 + noexcept (true) +# 502 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" + ; +# 551 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __expf(float x) +# 551 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 3 4 + noexcept (true) +# 551 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" + ; +# 582 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __exp10f(float x) +# 582 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 3 4 + noexcept (true) +# 582 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" + ; +# 607 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __log2f(float x) +# 607 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 3 4 + noexcept (true) +# 607 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" + ; +# 634 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __log10f(float x) +# 634 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 3 4 + noexcept (true) +# 634 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" + ; +# 677 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __logf(float x) +# 677 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 3 4 + noexcept (true) +# 677 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" + ; +# 719 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __powf(float x, float y) +# 719 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 3 4 + noexcept (true) +# 719 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" + ; +# 728 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rn(float x); +# 737 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rz(float x); +# 746 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_ru(float); +# 755 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rd(float x); +# 764 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rn(float x); +# 773 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rz(float x); +# 782 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_ru(float x); +# 791 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rd(float x); +# 800 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rn(int x); +# 809 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rz(int x); +# 818 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_ru(int x); +# 827 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rd(int x); +# 836 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rn(unsigned int x); +# 845 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rz(unsigned int x); +# 854 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_ru(unsigned int x); +# 863 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rd(unsigned int x); +# 872 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rn(float x); +# 881 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rz(float x); +# 890 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_ru(float x); +# 899 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rd(float x); +# 908 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rn(float x); +# 917 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rz(float x); +# 926 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_ru(float x); +# 935 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rd(float x); +# 944 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rn(long long int x); +# 953 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rz(long long int x); +# 962 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_ru(long long int x); +# 971 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rd(long long int x); +# 980 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rn(unsigned long long int x); +# 989 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rz(unsigned long long int x); +# 998 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_ru(unsigned long long int x); +# 1007 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rd(unsigned long long int x); +# 1019 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rn(float x, float y); +# 1031 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rz(float x, float y); +# 1043 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_ru(float x, float y); +# 1055 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rd(float x, float y); +# 1067 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rn(float x, float y); +# 1079 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rz(float x, float y); +# 1091 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_ru(float x, float y); +# 1103 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rd(float x, float y); +# 1115 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rn(float x, float y); +# 1127 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rz(float x, float y); +# 1139 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_ru(float x, float y); +# 1151 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rd(float x, float y); +# 1304 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rn(float x, float y, float z); +# 1457 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rz(float x, float y, float z); +# 1610 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_ru(float x, float y, float z); +# 1763 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rd(float x, float y, float z); +# 1796 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rn(float x); +# 1829 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rz(float x); +# 1862 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_ru(float x); +# 1895 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rd(float x); +# 1926 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rn(float x); +# 1957 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rz(float x); +# 1988 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_ru(float x); +# 2019 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rd(float x); +# 2058 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frsqrt_rn(float x); +# 2069 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rn(float x, float y); +# 2080 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rz(float x, float y); +# 2091 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_ru(float x, float y); +# 2102 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rd(float x, float y); +# 2111 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __clz(int x); +# 2122 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __ffs(int x); +# 2131 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __popc(unsigned int x); +# 2140 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __brev(unsigned int x); +# 2149 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __clzll(long long int x); +# 2160 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __ffsll(long long int x); +# 2171 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __popcll(unsigned long long int x); +# 2180 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __brevll(unsigned long long int x); +# 2203 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 2215 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __hadd(int x, int y); +# 2228 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __rhadd(int x, int y); +# 2240 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __uhadd(unsigned int x, unsigned int y); +# 2253 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __urhadd(unsigned int x, unsigned int y); +# 2263 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __double2int_rz(double x); +# 2272 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __double2uint_rz(double x); +# 2281 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __double2ll_rz(double x); +# 2290 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 2320 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabs2(unsigned int a); +# 2331 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsss2(unsigned int a); +# 2342 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vadd2(unsigned int a, unsigned int b); +# 2353 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddss2 (unsigned int a, unsigned int b); +# 2363 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddus2 (unsigned int a, unsigned int b); +# 2374 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgs2(unsigned int a, unsigned int b); +# 2385 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgu2(unsigned int a, unsigned int b); +# 2396 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vhaddu2(unsigned int a, unsigned int b); +# 2407 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpeq2(unsigned int a, unsigned int b); +# 2418 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpges2(unsigned int a, unsigned int b); +# 2429 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgeu2(unsigned int a, unsigned int b); +# 2440 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgts2(unsigned int a, unsigned int b); +# 2451 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgtu2(unsigned int a, unsigned int b); +# 2462 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmples2(unsigned int a, unsigned int b); +# 2474 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpleu2(unsigned int a, unsigned int b); +# 2485 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmplts2(unsigned int a, unsigned int b); +# 2496 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpltu2(unsigned int a, unsigned int b); +# 2507 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpne2(unsigned int a, unsigned int b); +# 2518 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffu2(unsigned int a, unsigned int b); +# 2529 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxs2(unsigned int a, unsigned int b); +# 2540 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxu2(unsigned int a, unsigned int b); +# 2551 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmins2(unsigned int a, unsigned int b); +# 2562 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vminu2(unsigned int a, unsigned int b); +# 2573 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vseteq2(unsigned int a, unsigned int b); +# 2584 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetges2(unsigned int a, unsigned int b); +# 2595 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgeu2(unsigned int a, unsigned int b); +# 2606 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgts2(unsigned int a, unsigned int b); +# 2617 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgtu2(unsigned int a, unsigned int b); +# 2628 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetles2(unsigned int a, unsigned int b); +# 2639 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetleu2(unsigned int a, unsigned int b); +# 2650 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetlts2(unsigned int a, unsigned int b); +# 2661 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetltu2(unsigned int a, unsigned int b); +# 2672 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetne2(unsigned int a, unsigned int b); +# 2683 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsadu2(unsigned int a, unsigned int b); +# 2694 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsub2(unsigned int a, unsigned int b); +# 2705 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubss2 (unsigned int a, unsigned int b); +# 2716 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubus2 (unsigned int a, unsigned int b); +# 2726 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vneg2(unsigned int a); +# 2736 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vnegss2(unsigned int a); +# 2747 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffs2(unsigned int a, unsigned int b); +# 2758 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsads2(unsigned int a, unsigned int b); +# 2768 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabs4(unsigned int a); +# 2779 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsss4(unsigned int a); +# 2790 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vadd4(unsigned int a, unsigned int b); +# 2801 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddss4 (unsigned int a, unsigned int b); +# 2811 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddus4 (unsigned int a, unsigned int b); +# 2822 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgs4(unsigned int a, unsigned int b); +# 2833 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgu4(unsigned int a, unsigned int b); +# 2844 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vhaddu4(unsigned int a, unsigned int b); +# 2855 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpeq4(unsigned int a, unsigned int b); +# 2866 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpges4(unsigned int a, unsigned int b); +# 2877 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgeu4(unsigned int a, unsigned int b); +# 2888 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgts4(unsigned int a, unsigned int b); +# 2899 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgtu4(unsigned int a, unsigned int b); +# 2910 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmples4(unsigned int a, unsigned int b); +# 2921 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpleu4(unsigned int a, unsigned int b); +# 2932 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmplts4(unsigned int a, unsigned int b); +# 2943 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpltu4(unsigned int a, unsigned int b); +# 2954 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpne4(unsigned int a, unsigned int b); +# 2965 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffu4(unsigned int a, unsigned int b); +# 2976 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxs4(unsigned int a, unsigned int b); +# 2987 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxu4(unsigned int a, unsigned int b); +# 2998 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmins4(unsigned int a, unsigned int b); +# 3009 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vminu4(unsigned int a, unsigned int b); +# 3020 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vseteq4(unsigned int a, unsigned int b); +# 3031 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetles4(unsigned int a, unsigned int b); +# 3042 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetleu4(unsigned int a, unsigned int b); +# 3053 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetlts4(unsigned int a, unsigned int b); +# 3064 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetltu4(unsigned int a, unsigned int b); +# 3075 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetges4(unsigned int a, unsigned int b); +# 3086 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgeu4(unsigned int a, unsigned int b); +# 3097 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgts4(unsigned int a, unsigned int b); +# 3108 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgtu4(unsigned int a, unsigned int b); +# 3119 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetne4(unsigned int a, unsigned int b); +# 3130 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsadu4(unsigned int a, unsigned int b); +# 3141 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsub4(unsigned int a, unsigned int b); +# 3152 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubss4(unsigned int a, unsigned int b); +# 3163 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubus4(unsigned int a, unsigned int b); +# 3173 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vneg4(unsigned int a); +# 3183 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vnegss4(unsigned int a); +# 3194 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffs4(unsigned int a, unsigned int b); +# 3205 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsads4(unsigned int a, unsigned int b); +# 3215 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax_s32_relu(const int a, const int b); +# 3227 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3236 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin_s32_relu(const int a, const int b); +# 3248 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3257 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3269 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3278 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3290 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3299 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3311 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3320 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3332 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3341 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3353 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3362 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3374 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3383 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3395 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3404 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3416 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3425 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3437 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3446 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3458 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3468 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3480 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3490 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3502 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3511 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3520 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3529 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3538 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3552 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3566 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3580 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3594 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); + + + + + + +} +# 3617 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" 1 +# 81 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 82 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" 2 + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 84 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" 2 +# 108 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +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); +# 159 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 213 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 226 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 243 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + short cS_lo = *(short*)& cU_lo; + short cS_hi = *(short*)& cU_hi; + + + short ansS_lo = (short)max(max(aS_lo, bS_lo), cS_lo); + short ansS_hi = (short)max(max(aS_hi, bS_hi), cS_hi); + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + res = ((unsigned int) ansU_lo) | (((unsigned int) 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){ +# 286 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 319 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 332 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 348 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + short cS_lo = *(short*)& cU_lo; + short cS_hi = *(short*)& cU_hi; + + + short ansS_lo = (short)min(min(aS_lo, bS_lo), cS_lo); + short ansS_hi = (short)min(min(aS_hi, bS_hi), cS_hi); + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + res = ((unsigned int) ansU_lo) | (((unsigned int) 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){ +# 392 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 425 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 438 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 456 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + short cS_lo = *(short*)& cU_lo; + short cS_hi = *(short*)& cU_hi; + + + short ansS_lo = (short)max(max(aS_lo, bS_lo), cS_lo); + short ansS_hi = (short)max(max(aS_hi, bS_hi), cS_hi); + + + if(ansS_lo < 0){ansS_lo = 0;} + if(ansS_hi < 0){ansS_hi = 0;} + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_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_relu(const int a, const int b, const int c){ +# 504 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 522 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + short cS_lo = *(short*)& cU_lo; + short cS_hi = *(short*)& cU_hi; + + + short ansS_lo = (short)min(min(aS_lo, bS_lo), cS_lo); + short ansS_hi = (short)min(min(aS_hi, bS_hi), cS_hi); + + + if(ansS_lo < 0){ansS_lo = 0;} + if(ansS_hi < 0){ansS_hi = 0;} + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_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(const int a, const int b, const int c){ +# 570 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 617 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 630 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 663 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 676 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 723 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 736 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 769 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 782 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 834 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 847 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 899 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 918 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 939 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 961 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 983 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 1012 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + + short ansS_lo = (short)max(aS_lo, bS_lo); + short ansS_hi = (short)max(aS_hi, bS_hi); + + *pred_hi = (aS_hi >= bS_hi); + *pred_lo = (aS_lo >= bS_lo); + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + 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 __vibmax_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 1065 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 1107 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + + short ansS_lo = (short)min(aS_lo, bS_lo); + short ansS_hi = (short)min(aS_hi, bS_hi); + + *pred_hi = (aS_hi <= bS_hi); + *pred_lo = (aS_lo <= bS_lo); + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + 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_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 1160 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; + +} +# 3618 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 + + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_atomic_functions.h" 1 +# 89 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_atomic_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_atomic_functions.hpp" 1 +# 62 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_atomic_functions.h" 2 +# 3621 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" 1 +# 83 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 84 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" 2 + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 86 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" 2 + + + + +extern "C" +{ +# 100 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double_as_longlong(double x); +# 109 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __longlong_as_double(long long int x); +# 266 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rn(double x, double y, double z); +# 423 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rz(double x, double y, double z); +# 580 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_ru(double x, double y, double z); +# 737 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rd(double x, double y, double z); +# 749 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rn(double x, double y); +# 761 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rz(double x, double y); +# 773 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_ru(double x, double y); +# 785 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rd(double x, double y); +# 797 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rn(double x, double y); +# 809 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rz(double x, double y); +# 821 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_ru(double x, double y); +# 833 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rd(double x, double y); +# 845 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rn(double x, double y); +# 857 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rz(double x, double y); +# 869 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_ru(double x, double y); +# 881 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rd(double x, double y); +# 890 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rn(double x); +# 899 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rz(double x); +# 908 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_ru(double x); +# 917 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rd(double x); +# 926 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rn(double x); +# 935 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_ru(double x); +# 944 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rd(double x); +# 953 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rn(double x); +# 962 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_ru(double x); +# 971 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rd(double x); +# 980 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rn(double x); +# 989 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_ru(double x); +# 998 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rd(double x); +# 1007 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rn(double x); +# 1016 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_ru(double x); +# 1025 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rn(long long int x); +# 1059 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rz(long long int x); +# 1068 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_ru(long long int x); +# 1077 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rd(long long int x); +# 1086 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rn(unsigned long long int x); +# 1095 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rz(unsigned long long int x); +# 1104 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_ru(unsigned long long int x); +# 1113 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rd(unsigned long long int x); +# 1122 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2hiint(double x); +# 1131 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2loint(double x); +# 1141 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.hpp" 1 +# 83 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.hpp" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 84 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.hpp" 2 + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 86 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" 2 +# 3622 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_atomic_functions.h" 1 +# 88 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_atomic_functions.h" +static __inline__ __attribute__((device)) float atomicAdd(float *address, float val) ; + + + + + + + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_atomic_functions.hpp" 1 +# 54 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_atomic_functions.hpp" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) float __fAtomicAdd(float *address, float val); +} +# 82 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_atomic_functions.hpp" +static __inline__ __attribute__((device)) float atomicAdd(float *address, float val) +{ + return __fAtomicAdd(address, val); +} +# 97 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_atomic_functions.h" 2 +# 3623 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_atomic_functions.h" 1 +# 89 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_atomic_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_atomic_functions.hpp" 1 +# 54 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_atomic_functions.h" 2 +# 3624 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_35_atomic_functions.h" 1 +# 56 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_35_atomic_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_atomic_functions.h" 1 +# 57 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_35_atomic_functions.h" 2 +# 3625 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_60_atomic_functions.h" 1 +# 325 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_60_atomic_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_60_atomic_functions.hpp" 1 +# 61 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_60_atomic_functions.h" 2 +# 3626 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" 1 +# 95 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) void __threadfence_system(void); +# 109 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rn(double x, double y); +# 121 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rz(double x, double y); +# 133 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_ru(double x, double y); +# 145 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rd(double x, double y); +# 179 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rn(double x); +# 213 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rz(double x); +# 247 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_ru(double x); +# 281 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rd(double x); +# 313 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rn(double x); +# 345 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rz(double x); +# 377 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_ru(double x); +# 409 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 424 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rn(float x, float y, float z); +# 433 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rd(float x, float y, float z); +# 442 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_ru(float x, float y, float z); +# 451 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rz(float x, float y, float z); +# 464 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double_as_longlong(double x); +# 473 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __longlong_as_double(long long int x); +# 630 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rn(double x, double y, double z); +# 787 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rz(double x, double y, double z); +# 944 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_ru(double x, double y, double z); +# 1101 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rd(double x, double y, double z); +# 1113 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rn(double x, double y); +# 1125 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rz(double x, double y); +# 1137 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_ru(double x, double y); +# 1149 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rd(double x, double y); +# 1161 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rn(double x, double y); +# 1173 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rz(double x, double y); +# 1185 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_ru(double x, double y); +# 1197 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rd(double x, double y); +# 1209 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rn(double x, double y); +# 1221 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rz(double x, double y); +# 1233 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_ru(double x, double y); +# 1245 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rd(double x, double y); +# 1254 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rn(double x); +# 1263 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rz(double x); +# 1272 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_ru(double x); +# 1281 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rd(double x); +# 1290 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rn(double x); +# 1299 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_ru(double x); +# 1308 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rd(double x); +# 1317 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rn(double x); +# 1326 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_ru(double x); +# 1335 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rd(double x); +# 1344 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rn(double x); +# 1353 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_ru(double x); +# 1362 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rd(double x); +# 1371 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rn(double x); +# 1380 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_ru(double x); +# 1389 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 1414 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rn(long long int x); +# 1423 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rz(long long int x); +# 1432 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_ru(long long int x); +# 1441 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rd(long long int x); +# 1450 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rn(unsigned long long int x); +# 1459 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rz(unsigned long long int x); +# 1468 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_ru(unsigned long long int x); +# 1477 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rd(unsigned long long int x); +# 1486 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2hiint(double x); +# 1495 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2loint(double x); +# 1505 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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) ; +# 1554 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.hpp" 1 +# 75 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 131 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 1555 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" 2 +# 3627 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_30_intrinsics.h" 1 +# 123 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_30_intrinsics.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_30_intrinsics.hpp" 1 +# 73 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_30_intrinsics.hpp" +extern "C" +{ +} +# 89 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_30_intrinsics.h" 2 +# 3628 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_intrinsics.h" 1 +# 91 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_l(unsigned int lo, unsigned int hi, unsigned int shift) ; +# 477 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_lc(unsigned int lo, unsigned int hi, unsigned int shift) ; +# 490 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_r(unsigned int lo, unsigned int hi, unsigned int shift) ; +# 502 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_rc(unsigned int lo, unsigned int hi, unsigned int shift) ; +# 512 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_intrinsics.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_intrinsics.hpp" 1 +# 73 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_intrinsics.hpp" +extern "C" +{ + + +} +# 101 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_intrinsics.h" 2 +# 3629 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_35_intrinsics.h" 1 +# 3630 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_61_intrinsics.h" 1 +# 235 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_61_intrinsics.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_61_intrinsics.hpp" 1 +# 236 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_61_intrinsics.h" 2 +# 3631 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_70_rt.h" 1 +# 128 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_70_rt.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_70_rt.hpp" 1 +# 129 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_70_rt.h" 2 +# 3632 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_80_rt.h" 1 +# 156 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_80_rt.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_80_rt.hpp" 1 +# 157 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_80_rt.h" 2 +# 3633 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_90_rt.h" 1 +# 273 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_90_rt.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_90_rt.hpp" 1 +# 274 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_90_rt.h" 2 +# 3634 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/texture_indirect_functions.h" 1 +# 65 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +} +# 3636 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/surface_indirect_functions.h" 1 +# 58 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 3637 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/cudacc_ext.h" 1 +# 3639 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 119 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_launch_parameters.h" 1 +# 68 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 +# 148 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +# 1 "/usr/include/c++/11/utility" 1 3 +# 58 "/usr/include/c++/11/utility" 3 + +# 59 "/usr/include/c++/11/utility" 3 +# 69 "/usr/include/c++/11/utility" 3 +# 1 "/usr/include/c++/11/bits/stl_relops.h" 1 3 +# 67 "/usr/include/c++/11/bits/stl_relops.h" 3 + +# 67 "/usr/include/c++/11/bits/stl_relops.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + namespace rel_ops + { +# 85 "/usr/include/c++/11/bits/stl_relops.h" 3 + template + inline bool + operator!=(const _Tp& __x, const _Tp& __y) + { return !(__x == __y); } +# 98 "/usr/include/c++/11/bits/stl_relops.h" 3 + template + inline bool + operator>(const _Tp& __x, const _Tp& __y) + { return __y < __x; } +# 111 "/usr/include/c++/11/bits/stl_relops.h" 3 + template + inline bool + operator<=(const _Tp& __x, const _Tp& __y) + { return !(__y < __x); } +# 124 "/usr/include/c++/11/bits/stl_relops.h" 3 + template + inline bool + operator>=(const _Tp& __x, const _Tp& __y) + { return !(__x < __y); } + } + + +} +# 70 "/usr/include/c++/11/utility" 2 3 + + + + + + +# 1 "/usr/include/c++/11/initializer_list" 1 3 +# 33 "/usr/include/c++/11/initializer_list" 3 + +# 34 "/usr/include/c++/11/initializer_list" 3 + + + + + +#pragma GCC visibility push(default) + + + +namespace std +{ + + 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(); } +} + +#pragma GCC visibility pop +# 77 "/usr/include/c++/11/utility" 2 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 + struct tuple_element; + + + template + using __tuple_element_t = typename tuple_element<__i, _Tp>::type; + + template + struct tuple_element<__i, const _Tp> + { + typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type; + }; + + template + struct tuple_element<__i, volatile _Tp> + { + typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type; + }; + + template + struct tuple_element<__i, const volatile _Tp> + { + typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type; + }; + + + + + + + + template + using tuple_element_t = typename tuple_element<__i, _Tp>::type; + + + + + + 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 __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); } + + + + + template + + inline _Tp + exchange(_Tp& __obj, _Up&& __new_val) + { return std::__exchange(__obj, std::forward<_Up>(__new_val)); } + + + + + + template struct _Index_tuple { }; + + + template + struct _Build_index_tuple + { +# 312 "/usr/include/c++/11/utility" 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 + [[nodiscard]] + constexpr add_const_t<_Tp>& + as_const(_Tp& __t) noexcept + { return __t; } + + template + void as_const(const _Tp&&) = delete; +# 476 "/usr/include/c++/11/utility" 3 + +} +# 149 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 +# 206 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" + +# 206 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchKernel( + const 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); +} +# 277 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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)...); +} +# 340 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchCooperativeKernel( + const 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); +} +# 384 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaEventCreate( + cudaEvent_t *event, + unsigned int flags +) +{ + return ::cudaEventCreateWithFlags(event, flags); +} +# 428 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 499 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 628 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 646 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 749 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 799 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 878 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 932 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 980 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 1034 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 1103 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 1174 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 1225 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 1273 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 1331 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 1390 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +} +# 1443 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 1493 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetSymbolAddress( + void **devPtr, + const T &symbol +) +{ + return ::cudaGetSymbolAddress(devPtr, (const void*)&symbol); +} +# 1525 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetSymbolSize( + size_t *size, + const T &symbol +) +{ + return ::cudaGetSymbolSize(size, (const void*)&symbol); +} +# 1577 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 + +} +# 1636 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 1688 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; + } +}; +# 1758 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +} +# 1954 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 2000 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 2038 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 2097 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 2141 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 2184 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 2224 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncGetAttributes( + struct cudaFuncAttributes *attr, + T *entry +) +{ + return ::cudaFuncGetAttributes(attr, (const void*)entry); +} +# 2286 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncSetAttribute( + T *entry, + enum cudaFuncAttribute attr, + int value +) +{ + return ::cudaFuncSetAttribute((const void*)entry, attr, value); +} +# 2318 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncGetName( + const char **name, + const T *func +) +{ + return ::cudaFuncGetName(name, (const void *)func); +} +# 2341 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetKernel( + cudaKernel_t *kernelPtr, + const T *entryFuncAddr +) +{ + return ::cudaGetKernel(kernelPtr, (const void *)entryFuncAddr); +} +# 2359 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +#pragma GCC diagnostic pop +# 0 "" 2 +# 1 "CMakeCUDACompilerId.cu" +# 492 "CMakeCUDACompilerId.cu" +char const* info_compiler = "INFO" ":" "compiler[" "NVIDIA" "]"; + +char const* info_simulate = "INFO" ":" "simulate[" "GNU" "]"; +# 819 "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' + (((4) / 10000000)%10)), ('0' + (((4) / 1000000)%10)), ('0' + (((4) / 100000)%10)), ('0' + (((4) / 10000)%10)), ('0' + (((4) / 1000)%10)), ('0' + (((4) / 100)%10)), ('0' + (((4) / 10)%10)), ('0' + ((4) % 10)), + + '.', ('0' + (((131) / 10000000)%10)), ('0' + (((131) / 1000000)%10)), ('0' + (((131) / 100000)%10)), ('0' + (((131) / 10000)%10)), ('0' + (((131) / 1000)%10)), ('0' + (((131) / 100)%10)), ('0' + (((131) / 10)%10)), ('0' + ((131) % 10)), + + + + + + ']','\0'}; +# 848 "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' + (((11) / 10000000)%10)), ('0' + (((11) / 1000000)%10)), ('0' + (((11) / 100000)%10)), ('0' + (((11) / 10000)%10)), ('0' + (((11) / 1000)%10)), ('0' + (((11) / 100)%10)), ('0' + (((11) / 10)%10)), ('0' + ((11) % 10)), + + '.', ('0' + (((4) / 10000000)%10)), ('0' + (((4) / 1000000)%10)), ('0' + (((4) / 100000)%10)), ('0' + (((4) / 10000)%10)), ('0' + (((4) / 1000)%10)), ('0' + (((4) / 100)%10)), ('0' + (((4) / 10)%10)), ('0' + ((4) % 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' + (((11) / 10000000)%10)), ('0' + (((11) / 1000000)%10)), ('0' + (((11) / 100000)%10)), ('0' + (((11) / 10000)%10)), ('0' + (((11) / 1000)%10)), ('0' + (((11) / 100)%10)), ('0' + (((11) / 10)%10)), ('0' + ((11) % 10)), + + '.', ('0' + (((4) / 10000000)%10)), ('0' + (((4) / 1000000)%10)), ('0' + (((4) / 100000)%10)), ('0' + (((4) / 10000)%10)), ('0' + (((4) / 1000)%10)), ('0' + (((4) / 100)%10)), ('0' + (((4) / 10)%10)), ('0' + ((4) % 10)), + + '.', ('0' + (((0) / 10000000)%10)), ('0' + (((0) / 1000000)%10)), ('0' + (((0) / 100000)%10)), ('0' + (((0) / 10000)%10)), ('0' + (((0) / 1000)%10)), ('0' + (((0) / 100)%10)), ('0' + (((0) / 10)%10)), ('0' + ((0) % 10)), + + + + + + ']','\0'}; +# 911 "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/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp4.ii b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp4.ii new file mode 100644 index 0000000..0e1e782 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp4.ii @@ -0,0 +1,32659 @@ +# 0 "CMakeCUDACompilerId.cu" +# 0 "" +# 0 "" +# 1 "/usr/include/stdc-predef.h" 1 3 4 +# 0 "" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 1 +# 61 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +#pragma GCC diagnostic push + + +#pragma GCC diagnostic ignored "-Wunused-function" +# 82 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_config.h" 1 +# 218 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_config.h" +# 1 "/usr/include/features.h" 1 3 4 +# 392 "/usr/include/features.h" 3 4 +# 1 "/usr/include/features-time64.h" 1 3 4 +# 20 "/usr/include/features-time64.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 21 "/usr/include/features-time64.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 1 3 4 +# 19 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 2 3 4 +# 22 "/usr/include/features-time64.h" 2 3 4 +# 393 "/usr/include/features.h" 2 3 4 +# 486 "/usr/include/features.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 1 3 4 +# 559 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 560 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4 +# 561 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4 +# 487 "/usr/include/features.h" 2 3 4 +# 510 "/usr/include/features.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 1 3 4 +# 10 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs-64.h" 1 3 4 +# 11 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 2 3 4 +# 511 "/usr/include/features.h" 2 3 4 +# 219 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_config.h" 2 +# 83 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 + + + + + + + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 56 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_types.h" 1 +# 59 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_types.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 64 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" +# 1 "/usr/include/ctype.h" 1 3 4 +# 26 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types.h" 1 3 4 +# 27 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 1 3 4 +# 19 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 2 3 4 +# 29 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 + + + +# 31 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/bits/types.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/typesizes.h" 1 3 4 +# 142 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/time64.h" 1 3 4 +# 143 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 + + +typedef unsigned long int __dev_t; +typedef unsigned int __uid_t; +typedef unsigned int __gid_t; +typedef unsigned long int __ino_t; +typedef unsigned long int __ino64_t; +typedef unsigned int __mode_t; +typedef unsigned 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/x86_64-linux-gnu/bits/endian.h" 1 3 4 +# 35 "/usr/include/x86_64-linux-gnu/bits/endian.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/endianness.h" 1 3 4 +# 36 "/usr/include/x86_64-linux-gnu/bits/endian.h" 2 3 4 +# 40 "/usr/include/ctype.h" 2 3 4 + + + + + + +enum +{ + _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), + _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), + _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), + _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), + _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), + _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), + _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), + _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), + _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), + _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), + _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), + _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8)) +}; +# 79 "/usr/include/ctype.h" 3 4 +extern const unsigned short int **__ctype_b_loc (void) + noexcept (true) __attribute__ ((__const__)); +extern const __int32_t **__ctype_tolower_loc (void) + noexcept (true) __attribute__ ((__const__)); +extern const __int32_t **__ctype_toupper_loc (void) + noexcept (true) __attribute__ ((__const__)); +# 108 "/usr/include/ctype.h" 3 4 +extern int isalnum (int) noexcept (true); +extern int isalpha (int) noexcept (true); +extern int iscntrl (int) noexcept (true); +extern int isdigit (int) noexcept (true); +extern int islower (int) noexcept (true); +extern int isgraph (int) noexcept (true); +extern int isprint (int) noexcept (true); +extern int ispunct (int) noexcept (true); +extern int isspace (int) noexcept (true); +extern int isupper (int) noexcept (true); +extern int isxdigit (int) noexcept (true); + + + +extern int tolower (int __c) noexcept (true); + + +extern int toupper (int __c) noexcept (true); + + + + +extern int isblank (int) noexcept (true); + + + + +extern int isctype (int __c, int __mask) noexcept (true); + + + + + + +extern int isascii (int __c) noexcept (true); + + + +extern int toascii (int __c) noexcept (true); + + + +extern int _toupper (int) noexcept (true); +extern int _tolower (int) noexcept (true); +# 237 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 1 3 4 +# 22 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h" 1 3 4 +# 27 "/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h" 3 4 +struct __locale_struct +{ + + struct __locale_data *__locales[13]; + + + const unsigned short int *__ctype_b; + const int *__ctype_tolower; + const int *__ctype_toupper; + + + const char *__names[13]; +}; + +typedef struct __locale_struct *__locale_t; +# 23 "/usr/include/x86_64-linux-gnu/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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 2 +# 60 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_types.h" 2 +# 68 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_types.h" + +# 68 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_types.h" +enum __attribute__((device_builtin)) cudaRoundMode +{ + cudaRoundNearest, + cudaRoundZero, + cudaRoundPosInf, + cudaRoundMinInf +}; +# 57 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 2 + + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" 1 +# 59 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 60 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" 2 + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" 1 +# 65 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 66 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" 2 +# 104 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" 2 +# 83 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/limits.h" 1 3 4 +# 34 "/usr/lib/gcc/x86_64-linux-gnu/11/include/limits.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/syslimits.h" 1 3 4 + + + + + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/limits.h" 1 3 4 +# 203 "/usr/lib/gcc/x86_64-linux-gnu/11/include/limits.h" 3 4 +# 1 "/usr/include/limits.h" 1 3 4 +# 26 "/usr/include/limits.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/bits/posix1_lim.h" 1 3 4 +# 27 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 2 3 4 +# 161 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 1 3 4 +# 38 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 3 4 +# 1 "/usr/include/linux/limits.h" 1 3 4 +# 39 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 2 3 4 +# 81 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h" 1 3 4 +# 23 "/usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h" 3 4 + +# 23 "/usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h" 3 4 +extern "C" { +extern long int __sysconf (int __name) noexcept (true); +} +# 82 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 2 3 4 +# 162 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 2 3 4 +# 196 "/usr/include/limits.h" 2 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/posix2_lim.h" 1 3 4 +# 200 "/usr/include/limits.h" 2 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 1 3 4 +# 64 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/uio_lim.h" 1 3 4 +# 65 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 2 3 4 +# 204 "/usr/include/limits.h" 2 3 4 +# 204 "/usr/lib/gcc/x86_64-linux-gnu/11/include/limits.h" 2 3 4 +# 8 "/usr/lib/gcc/x86_64-linux-gnu/11/include/syslimits.h" 2 3 4 +# 35 "/usr/lib/gcc/x86_64-linux-gnu/11/include/limits.h" 2 3 4 +# 84 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" 2 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4 +# 143 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 3 4 +typedef long int ptrdiff_t; +# 209 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 3 4 +typedef long unsigned int size_t; +# 415 "/usr/lib/gcc/x86_64-linux-gnu/11/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)))); +# 426 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 3 4 +} max_align_t; + + + + + + + typedef decltype(nullptr) nullptr_t; +# 85 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" 2 +# 205 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + +# 205 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorAddressOfConstant = 22, +# 345 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorTextureFetchFailed = 23, +# 354 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorTextureNotBound = 24, +# 363 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorSynchronizationError = 25, + + + + + cudaErrorInvalidFilterSetting = 26, + + + + + + cudaErrorInvalidNormSetting = 27, + + + + + + + + cudaErrorMixedDeviceExecution = 28, + + + + + + + + cudaErrorNotYetImplemented = 31, +# 399 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorMemoryValueTooLarge = 32, + + + + + + cudaErrorStubLibrary = 34, + + + + + + + cudaErrorInsufficientDriver = 35, + + + + + + + cudaErrorCallRequiresNewerDriver = 36, + + + + + + cudaErrorInvalidSurface = 37, + + + + + + cudaErrorDuplicateVariableName = 43, + + + + + + cudaErrorDuplicateTextureName = 44, + + + + + + cudaErrorDuplicateSurfaceName = 45, +# 453 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorDevicesUnavailable = 46, +# 466 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorIncompatibleDriverContext = 49, + + + + + + cudaErrorMissingConfiguration = 52, +# 481 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorPriorLaunchFailure = 53, + + + + + + cudaErrorLaunchMaxDepthExceeded = 65, + + + + + + + + cudaErrorLaunchFileScopedTex = 66, + + + + + + + + cudaErrorLaunchFileScopedSurf = 67, +# 519 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorSyncDepthExceeded = 68, +# 531 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorLaunchPendingCountExceeded = 69, + + + + + + cudaErrorInvalidDeviceFunction = 98, + + + + + + cudaErrorNoDevice = 100, + + + + + + + cudaErrorInvalidDevice = 101, + + + + + cudaErrorDeviceNotLicensed = 102, +# 564 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorSoftwareValidityNotEstablished = 103, + + + + + cudaErrorStartupFailure = 127, + + + + + cudaErrorInvalidKernelImage = 200, +# 584 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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, + + + + + cudaErrorInvalidSource = 300, + + + + + cudaErrorFileNotFound = 301, + + + + + cudaErrorSharedObjectSymbolNotFound = 302, + + + + + cudaErrorSharedObjectInitFailed = 303, + + + + + cudaErrorOperatingSystem = 304, + + + + + + + cudaErrorInvalidResourceHandle = 400, + + + + + + cudaErrorIllegalState = 401, + + + + + + + + cudaErrorLossyQuery = 402, + + + + + + + cudaErrorSymbolNotFound = 500, + + + + + + + + cudaErrorNotReady = 600, + + + + + + + + cudaErrorIllegalAddress = 700, +# 786 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorLaunchOutOfResources = 701, +# 797 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorLaunchTimeout = 702, + + + + + + cudaErrorLaunchIncompatibleTexturing = 703, + + + + + + + cudaErrorPeerAccessAlreadyEnabled = 704, + + + + + + + cudaErrorPeerAccessNotEnabled = 705, +# 830 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorSetOnActiveProcess = 708, + + + + + + + cudaErrorContextIsDestroyed = 709, + + + + + + + cudaErrorAssert = 710, + + + + + + + cudaErrorTooManyPeers = 711, + + + + + + cudaErrorHostMemoryAlreadyRegistered = 712, + + + + + + cudaErrorHostMemoryNotRegistered = 713, +# 872 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorHardwareStackError = 714, + + + + + + + + cudaErrorIllegalInstruction = 715, +# 889 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorMisalignedAddress = 716, +# 900 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorInvalidAddressSpace = 717, + + + + + + + + cudaErrorInvalidPc = 718, +# 919 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorLaunchFailure = 719, +# 928 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorCooperativeLaunchTooLarge = 720, + + + + + cudaErrorNotPermitted = 800, + + + + + + cudaErrorNotSupported = 801, +# 948 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorSystemNotReady = 802, + + + + + + + cudaErrorSystemDriverMismatch = 803, +# 964 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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, +# 1080 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaErrorExternalDevice = 911, + + + + + + cudaErrorInvalidClusterSize = 912, + + + + + 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 +}; + + + + +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; +# 1184 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +}; +# 1353 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +struct __attribute__((device_builtin)) cudaAccessPolicyWindow { + void *base_ptr; + size_t num_bytes; + float hitRatio; + enum cudaAccessProperty hitProp; + enum cudaAccessProperty missProp; +}; +# 1371 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 1603 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + int device; + + + + + + void *devicePointer; +# 1618 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 1690 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + int preferredShmemCarveout; + + + + + + int clusterDimMustBeSet; +# 1707 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + int requiredClusterWidth; + int requiredClusterHeight; + int requiredClusterDepth; + + + + + + int clusterSchedulingPolicyPreference; +# 1737 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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, + cudaDevAttrMax +}; + + + + +enum __attribute__((device_builtin)) cudaMemPoolAttr +{ +# 2027 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + cudaMemPoolReuseFollowEventDependencies = 0x1, + + + + + + + cudaMemPoolReuseAllowOpportunistic = 0x2, + + + + + + + + cudaMemPoolReuseAllowInternalDependencies = 0x3, +# 2053 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +}; + + + + +struct __attribute__((device_builtin)) cudaMemPoolProps { + enum cudaMemAllocationType allocType; + enum cudaMemAllocationHandleType handleTypes; + struct cudaMemLocation location; + + + + + + + void *win32SecurityAttributes; + size_t maxSize; + unsigned char reserved[56]; +}; + + + + +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)) 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 reserved2[2]; + int reserved1[1]; + int reserved[60]; +}; +# 2372 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +}; +# 2471 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +struct __attribute__((device_builtin)) cudaExternalMemoryHandleDesc { + + + + enum cudaExternalMemoryHandleType type; + union { + + + + + + int fd; +# 2498 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 2648 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 2712 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 2761 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 2807 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 2858 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + unsigned int flags; + unsigned int reserved[16]; +}; +# 2871 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; + + + + +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, +}; + + + + +struct __attribute__((device_builtin)) cudaConditionalNodeParams { + cudaGraphConditionalHandle handle; + + + enum cudaGraphConditionalNodeType type; + unsigned int size; + cudaGraph_t *phGraph_out; +# 3052 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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, +# 3087 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 3166 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + unsigned char to_port; + + + + + + + unsigned char type; + + + unsigned char reserved[5]; + +} cudaGraphEdgeData; +# 3199 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +} 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 + +}; +# 3365 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +typedef __attribute__((device_builtin)) enum cudaLaunchMemSyncDomain { + cudaLaunchMemSyncDomainDefault = 0, + cudaLaunchMemSyncDomainRemote = 1 +} cudaLaunchMemSyncDomain; +# 3381 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +# 3411 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + , cudaLaunchAttributeProgrammaticEvent = 7 +# 3437 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + , cudaLaunchAttributePriority = 8 + + , cudaLaunchAttributeMemSyncDomainMap = 9 + + , cudaLaunchAttributeMemSyncDomain = 10 + + , cudaLaunchAttributeLaunchCompletionEvent = 12 +# 3465 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + , cudaLaunchAttributeDeviceUpdatableKernelNode = 13 +# 3493 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +} cudaLaunchAttributeID; + + + + +typedef __attribute__((device_builtin)) union cudaLaunchAttributeValue { + char pad[64]; + struct cudaAccessPolicyWindow accessPolicyWindow; + int cooperative; + + enum cudaSynchronizationPolicy syncPolicy; +# 3517 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" + struct { + unsigned int x; + unsigned int y; + unsigned int z; + } clusterDim; + enum cudaClusterSchedulingPolicy clusterSchedulingPolicyPreference; + + + int programmaticStreamSerializationAllowed; + + struct { + cudaEvent_t event; + int flags; + + int triggerAtBlockStart; + } programmaticEvent; + int priority; + cudaLaunchMemSyncDomainMap memSyncDomainMap; + + + cudaLaunchMemSyncDomain memSyncDomain; + + struct { + cudaEvent_t event; + int flags; + + } launchCompletionEvent; + + struct { + int deviceUpdatable; + cudaGraphDeviceNode_t devNode; + } deviceUpdatableKernelNode; +} 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; +# 3593 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 2 + + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/surface_types.h" 1 +# 86 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/texture_types.h" 1 +# 86 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 2 +# 91 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/library_types.h" 1 +# 57 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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_E5M2 = 29, +} cudaDataType; + + +typedef enum libraryPropertyType_t +{ + MAJOR_VERSION, + MINOR_VERSION, + PATCH_LEVEL +} libraryPropertyType; +# 92 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 + + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/channel_descriptor.h" 1 +# 61 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/channel_descriptor.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" 1 +# 148 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 149 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" 2 + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 151 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" 2 + + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" 1 +# 54 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +# 1 "/usr/include/c++/11/stdlib.h" 1 3 +# 36 "/usr/include/c++/11/stdlib.h" 3 +# 1 "/usr/include/c++/11/cstdlib" 1 3 +# 39 "/usr/include/c++/11/cstdlib" 3 + +# 40 "/usr/include/c++/11/cstdlib" 3 + +# 1 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 1 3 +# 278 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 3 + +# 278 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 3 +namespace std +{ + typedef long unsigned int size_t; + typedef long int ptrdiff_t; + + + typedef decltype(nullptr) nullptr_t; + +} +# 300 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 3 +namespace std +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +namespace __gnu_cxx +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +# 586 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 3 +# 1 "/usr/include/x86_64-linux-gnu/c++/11/bits/os_defines.h" 1 3 +# 587 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 2 3 + + +# 1 "/usr/include/x86_64-linux-gnu/c++/11/bits/cpu_defines.h" 1 3 +# 590 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 2 3 +# 777 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 3 +# 1 "/usr/include/c++/11/pstl/pstl_config.h" 1 3 +# 778 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 2 3 +# 42 "/usr/include/c++/11/cstdlib" 2 3 +# 75 "/usr/include/c++/11/cstdlib" 3 +# 1 "/usr/include/stdlib.h" 1 3 4 +# 26 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/stdlib.h" 2 3 4 + + + + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4 +# 33 "/usr/include/stdlib.h" 2 3 4 + +extern "C" { + + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 1 3 4 +# 41 "/usr/include/stdlib.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 1 3 4 +# 42 "/usr/include/stdlib.h" 2 3 4 +# 56 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 1 3 4 +# 74 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4 +typedef _Complex float __cfloat128 __attribute__ ((__mode__ (__TC__))); +# 86 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4 +typedef __float128 _Float128; +# 119 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4 +# 25 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 2 3 4 +# 214 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4 +typedef float _Float32; +# 251 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4 +typedef double _Float64; +# 268 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4 +typedef double _Float32x; +# 285 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4 +typedef long double _Float64x; +# 120 "/usr/include/x86_64-linux-gnu/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 int strfromd (char *__dest, size_t __size, const char *__format, + double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfromf (char *__dest, size_t __size, const char *__format, + float __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfroml (char *__dest, size_t __size, const char *__format, + long double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 233 "/usr/include/stdlib.h" 3 4 +extern int strfromf32 (char *__dest, size_t __size, const char * __format, + _Float32 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64 (char *__dest, size_t __size, const char * __format, + _Float64 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf128 (char *__dest, size_t __size, const char * __format, + _Float128 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf32x (char *__dest, size_t __size, const char * __format, + _Float32x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64x (char *__dest, size_t __size, const char * __format, + _Float64x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 275 "/usr/include/stdlib.h" 3 4 +extern long int strtol_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +extern unsigned long int strtoul_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +extern double strtod_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern float strtof_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern long double strtold_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 317 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64 strtof64_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float128 strtof128_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float32x strtof32x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64x strtof64x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 386 "/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/x86_64-linux-gnu/sys/types.h" 1 3 4 +# 27 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 +extern "C" { + + + + + +typedef __u_char u_char; +typedef __u_short u_short; +typedef __u_int u_int; +typedef __u_long u_long; +typedef __quad_t quad_t; +typedef __u_quad_t u_quad_t; +typedef __fsid_t fsid_t; + + +typedef __loff_t loff_t; + + + + +typedef __ino_t ino_t; + + + + + + +typedef __ino64_t ino64_t; + + + + +typedef __dev_t dev_t; + + + + +typedef __gid_t gid_t; + + + + +typedef __mode_t mode_t; + + + + +typedef __nlink_t nlink_t; + + + + +typedef __uid_t uid_t; + + + + + +typedef __off_t off_t; + + + + + + +typedef __off64_t off64_t; + + + + +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/x86_64-linux-gnu/bits/types/clock_t.h" 1 3 4 + + + + + + +typedef __clock_t clock_t; +# 127 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h" 1 3 4 + + + + + + +typedef __clockid_t clockid_t; +# 129 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types/time_t.h" 1 3 4 +# 10 "/usr/include/x86_64-linux-gnu/bits/types/time_t.h" 3 4 +typedef __time_t time_t; +# 130 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types/timer_t.h" 1 3 4 + + + + + + +typedef __timer_t timer_t; +# 131 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + + +typedef __useconds_t useconds_t; + + + +typedef __suseconds_t suseconds_t; + + + + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4 +# 145 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + + +typedef unsigned long int ulong; +typedef unsigned short int ushort; +typedef unsigned int uint; + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 3 4 +typedef __int8_t int8_t; +typedef __int16_t int16_t; +typedef __int32_t int32_t; +typedef __int64_t int64_t; +# 156 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/sys/types.h" 3 4 +# 1 "/usr/include/endian.h" 1 3 4 +# 35 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 1 3 4 +# 33 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4 +static __inline __uint16_t +__bswap_16 (__uint16_t __bsx) +{ + + return __builtin_bswap16 (__bsx); + + + +} + + + + + + +static __inline __uint32_t +__bswap_32 (__uint32_t __bsx) +{ + + return __builtin_bswap32 (__bsx); + + + +} +# 69 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4 +__extension__ static __inline __uint64_t +__bswap_64 (__uint64_t __bsx) +{ + + return __builtin_bswap64 (__bsx); + + + +} +# 36 "/usr/include/endian.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 1 3 4 +# 32 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 3 4 +static __inline __uint16_t +__uint16_identity (__uint16_t __x) +{ + return __x; +} + +static __inline __uint32_t +__uint32_identity (__uint32_t __x) +{ + return __x; +} + +static __inline __uint64_t +__uint64_identity (__uint64_t __x) +{ + return __x; +} +# 37 "/usr/include/endian.h" 2 3 4 +# 177 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + +# 1 "/usr/include/x86_64-linux-gnu/sys/select.h" 1 3 4 +# 30 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/select.h" 1 3 4 +# 31 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 + + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 1 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/bits/types/sigset_t.h" 2 3 4 + + +typedef __sigset_t sigset_t; +# 34 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h" 1 3 4 + + + + + + + +struct timeval +{ + + + + + __time_t tv_sec; + __suseconds_t tv_usec; + +}; +# 38 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 1 3 4 +# 11 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4 +struct timespec +{ + + + + __time_t tv_sec; + + + + + __syscall_slong_t tv_nsec; +# 31 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4 +}; +# 40 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 +# 49 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +typedef long int __fd_mask; +# 59 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +typedef struct + { + + + + __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; + + + + + + } fd_set; + + + + + + +typedef __fd_mask fd_mask; +# 91 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +extern "C" { +# 102 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +extern int select (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + struct timeval *__restrict __timeout); +# 127 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +extern int pselect (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + const struct timespec *__restrict __timeout, + const __sigset_t *__restrict __sigmask); +# 153 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +} +# 180 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + + + + +typedef __blksize_t blksize_t; + + + + + + +typedef __blkcnt_t blkcnt_t; + + + +typedef __fsblkcnt_t fsblkcnt_t; + + + +typedef __fsfilcnt_t fsfilcnt_t; +# 219 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 +typedef __blkcnt64_t blkcnt64_t; +typedef __fsblkcnt64_t fsblkcnt64_t; +typedef __fsfilcnt64_t fsfilcnt64_t; + + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 1 3 4 +# 23 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 1 3 4 +# 44 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 1 3 4 +# 21 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 22 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 2 3 4 +# 45 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4 + +# 1 "/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h" 1 3 4 +# 25 "/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h" 3 4 +typedef union +{ + __extension__ unsigned long long int __value64; + struct + { + unsigned int __low; + unsigned int __high; + } __value32; +} __atomic_wide_counter; +# 47 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4 + + + + +typedef struct __pthread_internal_list +{ + struct __pthread_internal_list *__prev; + struct __pthread_internal_list *__next; +} __pthread_list_t; + +typedef struct __pthread_internal_slist +{ + struct __pthread_internal_slist *__next; +} __pthread_slist_t; +# 76 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 1 3 4 +# 22 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/bits/struct_mutex.h" 3 4 +}; +# 77 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4 +# 89 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 1 3 4 +# 23 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4 +struct __pthread_rwlock_arch_t +{ + unsigned int __readers; + unsigned int __writers; + unsigned int __wrphase_futex; + unsigned int __writers_futex; + unsigned int __pad3; + unsigned int __pad4; + + int __cur_writer; + int __shared; + signed char __rwelision; + + + + + unsigned char __pad1[7]; + + + unsigned long int __pad2; + + + unsigned int __flags; +# 55 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4 +}; +# 90 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4 + + + + +struct __pthread_cond_s +{ + __atomic_wide_counter __wseq; + __atomic_wide_counter __g1_start; + unsigned int __g_refs[2] ; + unsigned int __g_size[2]; + unsigned int __g1_orig_size; + unsigned int __wrefs; + unsigned int __g_signals[2]; +}; + +typedef unsigned int __tss_t; +typedef unsigned long int __thrd_t; + +typedef struct +{ + int __data ; +} __once_flag; +# 24 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 2 3 4 + + + +typedef unsigned long int pthread_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_mutexattr_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_condattr_t; + + + +typedef unsigned int pthread_key_t; + + + +typedef int pthread_once_t; + + +union pthread_attr_t +{ + char __size[56]; + long int __align; +}; + +typedef union pthread_attr_t pthread_attr_t; + + + + +typedef union +{ + struct __pthread_mutex_s __data; + char __size[40]; + long int __align; +} pthread_mutex_t; + + +typedef union +{ + struct __pthread_cond_s __data; + char __size[48]; + __extension__ long long int __align; +} pthread_cond_t; + + + + + +typedef union +{ + struct __pthread_rwlock_arch_t __data; + char __size[56]; + long int __align; +} pthread_rwlock_t; + +typedef union +{ + char __size[8]; + long int __align; +} pthread_rwlockattr_t; + + + + + +typedef volatile int pthread_spinlock_t; + + + + +typedef union +{ + char __size[32]; + long int __align; +} pthread_barrier_t; + +typedef union +{ + char __size[4]; + int __align; +} pthread_barrierattr_t; +# 228 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + +} +# 396 "/usr/include/stdlib.h" 2 3 4 + + + + + + +extern long int random (void) noexcept (true); + + +extern void srandom (unsigned int __seed) noexcept (true); + + + + + +extern char *initstate (unsigned int __seed, char *__statebuf, + size_t __statelen) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern char *setstate (char *__statebuf) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + + +struct random_data + { + int32_t *fptr; + int32_t *rptr; + int32_t *state; + int rand_type; + int rand_deg; + int rand_sep; + int32_t *end_ptr; + }; + +extern int random_r (struct random_data *__restrict __buf, + int32_t *__restrict __result) noexcept (true) __attribute__ ((__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 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-linux-gnu/11/include/stddef.h" 1 3 4 +# 25 "/usr/include/alloca.h" 2 3 4 + +extern "C" { + + + + + +extern void *alloca (size_t __size) noexcept (true); + + + + + +} +# 575 "/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__)); + + + +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))); +# 617 "/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); +# 682 "/usr/include/stdlib.h" 3 4 +extern char *mktemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))); +# 695 "/usr/include/stdlib.h" 3 4 +extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 705 "/usr/include/stdlib.h" 3 4 +extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 717 "/usr/include/stdlib.h" 3 4 +extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; +# 727 "/usr/include/stdlib.h" 3 4 +extern int mkstemps64 (char *__template, int __suffixlen) + __attribute__ ((__nonnull__ (1))) ; +# 738 "/usr/include/stdlib.h" 3 4 +extern char *mkdtemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))) ; +# 749 "/usr/include/stdlib.h" 3 4 +extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 759 "/usr/include/stdlib.h" 3 4 +extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 769 "/usr/include/stdlib.h" 3 4 +extern int mkostemps (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 781 "/usr/include/stdlib.h" 3 4 +extern int mkostemps64 (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 791 "/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))) ; +# 808 "/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__)) ; +# 880 "/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))) ; +# 967 "/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))); +# 1023 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/stdlib-float.h" 1 3 4 +# 1024 "/usr/include/stdlib.h" 2 3 4 +# 1035 "/usr/include/stdlib.h" 3 4 +} +# 76 "/usr/include/c++/11/cstdlib" 2 3 + +# 1 "/usr/include/c++/11/bits/std_abs.h" 1 3 +# 33 "/usr/include/c++/11/bits/std_abs.h" 3 + +# 34 "/usr/include/c++/11/bits/std_abs.h" 3 +# 46 "/usr/include/c++/11/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/include/c++/11/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); } + + + + inline constexpr __int128 + abs(__int128 __x) { return __x >= 0 ? __x : -__x; } +# 107 "/usr/include/c++/11/bits/std_abs.h" 3 + +} +} +# 78 "/usr/include/c++/11/cstdlib" 2 3 +# 121 "/usr/include/c++/11/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) { return ldiv(__i, __j); } + + + + +} +# 195 "/usr/include/c++/11/cstdlib" 3 +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + using ::lldiv_t; + + + + + + using ::_Exit; + + + + using ::llabs; + + inline lldiv_t + div(long long __n, long long __d) + { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; } + + using ::lldiv; +# 227 "/usr/include/c++/11/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; +} + + + +} +# 37 "/usr/include/c++/11/stdlib.h" 2 3 + +using std::abort; +using std::atexit; +using std::exit; + + + using std::at_quick_exit; + + + using std::quick_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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" 2 +# 169 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 170 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" 2 +# 180 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" + +# 180 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +extern "C" +{ + + + + + +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaDeviceSynchronizeDeprecationAvoidance(void); +# 236 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 301 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +} +# 336 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 364 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetEnabled(cudaGraphDeviceNode_t node, bool enable); +# 391 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetGridDim(cudaGraphDeviceNode_t node, dim3 gridDim); +# 420 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeUpdatesApply(const cudaGraphKernelNodeUpdate *updates, size_t updateCount); +# 438 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +static inline __attribute__((device)) __attribute__((cudart_builtin)) void cudaTriggerProgrammaticLaunchCompletion(void) +{ + asm volatile("griddepcontrol.launch_dependents;":::); +} +# 454 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +static inline __attribute__((device)) __attribute__((cudart_builtin)) void cudaGridDependencySynchronize(void) +{ + asm volatile("griddepcontrol.wait;":::"memory"); +} +# 466 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 695 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 781 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); + } +# 843 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 876 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" 2 +# 283 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern "C" { +# 323 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceReset(void); +# 345 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceSynchronize(void); +# 431 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetLimit(enum cudaLimit limit, size_t value); +# 467 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetLimit(size_t *pValue, enum cudaLimit limit); +# 490 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t *maxWidthInElements, const struct cudaChannelFormatDesc *fmtDesc, int device); +# 524 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetCacheConfig(enum cudaFuncCache *pCacheConfig); +# 561 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority); +# 605 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetCacheConfig(enum cudaFuncCache cacheConfig); +# 632 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetByPCIBusId(int *device, const char *pciBusId); +# 662 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetPCIBusId(char *pciBusId, int len, int device); +# 712 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t *handle, cudaEvent_t event); +# 755 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcOpenEventHandle(cudaEvent_t *event, cudaIpcEventHandle_t handle); +# 799 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t *handle, void *devPtr); +# 865 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcOpenMemHandle(void **devPtr, cudaIpcMemHandle_t handle, unsigned int flags); +# 903 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcCloseMemHandle(void *devPtr); +# 935 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(enum cudaFlushGPUDirectRDMAWritesTarget target, enum cudaFlushGPUDirectRDMAWritesScope scope); +# 973 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback); +# 996 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback); +# 1043 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetSharedMemConfig(enum cudaSharedMemConfig *pConfig); +# 1089 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaDeviceSetSharedMemConfig(enum cudaSharedMemConfig config); +# 1130 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadExit(void); +# 1156 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSynchronize(void); +# 1205 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSetLimit(enum cudaLimit limit, size_t value); +# 1238 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadGetLimit(size_t *pValue, enum cudaLimit limit); +# 1274 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadGetCacheConfig(enum cudaFuncCache *pCacheConfig); +# 1321 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSetCacheConfig(enum cudaFuncCache cacheConfig); +# 1386 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetLastError(void); +# 1437 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaPeekAtLastError(void); +# 1453 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) const char* cudaGetErrorName(cudaError_t error); +# 1469 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) const char* cudaGetErrorString(cudaError_t error); +# 1498 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceCount(int *count); +# 1803 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceProperties_v2(struct cudaDeviceProp *prop, int device); +# 2005 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device); +# 2023 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t *memPool, int device); +# 2047 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool); +# 2067 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetMemPool(cudaMemPool_t *memPool, int device); +# 2129 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetNvSciSyncAttributes(void *nvSciSyncAttrList, int device, int flags); +# 2169 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetP2PAttribute(int *value, enum cudaDeviceP2PAttr attr, int srcDevice, int dstDevice); +# 2191 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaChooseDevice(int *device, const struct cudaDeviceProp *prop); +# 2220 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags); +# 2266 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetDevice(int device); +# 2288 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDevice(int *device); +# 2319 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetValidDevices(int *device_arr, int len); +# 2389 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetDeviceFlags( unsigned int flags ); +# 2434 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetDeviceFlags( unsigned int *flags ); +# 2474 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamCreate(cudaStream_t *pStream); +# 2506 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithFlags(cudaStream_t *pStream, unsigned int flags); +# 2554 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithPriority(cudaStream_t *pStream, unsigned int flags, int priority); +# 2581 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int *priority); +# 2606 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int *flags); +# 2643 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetId(cudaStream_t hStream, unsigned long long *streamId); +# 2658 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaCtxResetPersistingL2Cache(void); +# 2678 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src); +# 2699 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetAttribute( + cudaStream_t hStream, cudaLaunchAttributeID attr, + cudaLaunchAttributeValue *value_out); +# 2723 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamSetAttribute( + cudaStream_t hStream, cudaLaunchAttributeID attr, + const cudaLaunchAttributeValue *value); +# 2757 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamDestroy(cudaStream_t stream); +# 2788 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 2863 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamAddCallback(cudaStream_t stream, + cudaStreamCallback_t callback, void *userData, unsigned int flags); +# 2887 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamSynchronize(cudaStream_t stream); +# 2912 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamQuery(cudaStream_t stream); +# 2996 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3035 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamBeginCapture(cudaStream_t stream, enum cudaStreamCaptureMode mode); +# 3076 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3127 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaThreadExchangeStreamCaptureMode(enum cudaStreamCaptureMode *mode); +# 3156 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t *pGraph); +# 3194 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamIsCapturing(cudaStream_t stream, enum cudaStreamCaptureStatus *pCaptureStatus); +# 3243 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3302 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3342 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t *dependencies, size_t numDependencies, unsigned int flags = 0); +# 3377 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3414 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventCreate(cudaEvent_t *event); +# 3451 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventCreateWithFlags(cudaEvent_t *event, unsigned int flags); +# 3492 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream = 0); +# 3540 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3573 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventQuery(cudaEvent_t event); +# 3604 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventSynchronize(cudaEvent_t event); +# 3634 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventDestroy(cudaEvent_t event); +# 3679 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventElapsedTime(float *ms, cudaEvent_t start, cudaEvent_t end); +# 3860 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaImportExternalMemory(cudaExternalMemory_t *extMem_out, const struct cudaExternalMemoryHandleDesc *memHandleDesc); +# 3915 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaExternalMemoryGetMappedBuffer(void **devPtr, cudaExternalMemory_t extMem, const struct cudaExternalMemoryBufferDesc *bufferDesc); +# 3975 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t *mipmap, cudaExternalMemory_t extMem, const struct cudaExternalMemoryMipmappedArrayDesc *mipmapDesc); +# 3999 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem); +# 4153 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t *extSem_out, const struct cudaExternalSemaphoreHandleDesc *semHandleDesc); +# 4236 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 4312 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 4335 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem); +# 4402 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 4464 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchKernelExC(const cudaLaunchConfig_t *config, const void *func, void **args); +# 4521 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 4622 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaLaunchCooperativeKernelMultiDevice(struct cudaLaunchParams *launchParamsList, unsigned int numDevices, unsigned int flags = 0); +# 4667 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFuncSetCacheConfig(const void *func, enum cudaFuncCache cacheConfig); +# 4700 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetAttributes(struct cudaFuncAttributes *attr, const void *func); +# 4737 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncSetAttribute(const void *func, enum cudaFuncAttribute attr, int value); +# 4761 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetName(const char **name, const void *func); +# 4783 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 4807 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaSetDoubleForDevice(double *d); +# 4831 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaSetDoubleForHost(double *d); +# 4897 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void *userData); +# 4971 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaFuncSetSharedMemConfig(const void *func, enum cudaSharedMemConfig config); +# 5027 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func, int blockSize, size_t dynamicSMemSize); +# 5056 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t *dynamicSmemSize, const void *func, int numBlocks, int blockSize); +# 5101 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 5136 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxPotentialClusterSize(int *clusterSize, const void *func, const cudaLaunchConfig_t *launchConfig); +# 5175 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveClusters(int *numClusters, const void *func, const cudaLaunchConfig_t *launchConfig); +# 5295 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMallocManaged(void **devPtr, size_t size, unsigned int flags = 0x01); +# 5328 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMalloc(void **devPtr, size_t size); +# 5365 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocHost(void **ptr, size_t size); +# 5408 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocPitch(void **devPtr, size_t *pitch, size_t width, size_t height); +# 5460 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 5498 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFree(void *devPtr); +# 5521 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeHost(void *ptr); +# 5544 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeArray(cudaArray_t array); +# 5567 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray); +# 5633 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostAlloc(void **pHost, size_t size, unsigned int flags); +# 5730 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostRegister(void *ptr, size_t size, unsigned int flags); +# 5753 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostUnregister(void *ptr); +# 5798 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostGetDevicePointer(void **pDevice, void *pHost, unsigned int flags); +# 5820 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostGetFlags(unsigned int *pFlags, void *pHost); +# 5859 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMalloc3D(struct cudaPitchedPtr* pitchedDevPtr, struct cudaExtent extent); +# 6004 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 6149 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 6182 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t *levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level); +# 6287 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3D(const struct cudaMemcpy3DParms *p); +# 6319 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3DPeer(const struct cudaMemcpy3DPeerParms *p); +# 6437 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy3DAsync(const struct cudaMemcpy3DParms *p, cudaStream_t stream = 0); +# 6464 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3DPeerAsync(const struct cudaMemcpy3DPeerParms *p, cudaStream_t stream = 0); +# 6498 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemGetInfo(size_t *free, size_t *total); +# 6524 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetInfo(struct cudaChannelFormatDesc *desc, struct cudaExtent *extent, unsigned int *flags, cudaArray_t array); +# 6553 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetPlane(cudaArray_t *pPlaneArray, cudaArray_t hArray, unsigned int planeIdx); +# 6576 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetMemoryRequirements(struct cudaArrayMemoryRequirements *memoryRequirements, cudaArray_t array, int device); +# 6600 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMipmappedArrayGetMemoryRequirements(struct cudaArrayMemoryRequirements *memoryRequirements, cudaMipmappedArray_t mipmap, int device); +# 6628 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaArrayGetSparseProperties(struct cudaArraySparseProperties *sparseProperties, cudaArray_t array); +# 6658 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaMipmappedArrayGetSparseProperties(struct cudaArraySparseProperties *sparseProperties, cudaMipmappedArray_t mipmap); +# 6703 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind); +# 6738 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyPeer(void *dst, int dstDevice, const void *src, int srcDevice, size_t count); +# 6787 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 6837 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 6887 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 6934 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 6977 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7021 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7078 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7113 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7176 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7234 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7291 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7342 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7393 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7422 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset(void *devPtr, int value, size_t count); +# 7456 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset2D(void *devPtr, size_t pitch, int value, size_t width, size_t height); +# 7502 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset3D(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent); +# 7538 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7579 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7632 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7660 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSymbolAddress(void **devPtr, const void *symbol); +# 7687 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSymbolSize(size_t *size, const void *symbol); +# 7757 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPrefetchAsync(const void *devPtr, size_t count, int dstDevice, cudaStream_t stream = 0); + +extern __attribute__((host)) cudaError_t cudaMemPrefetchAsync_v2(const void *devPtr, size_t count, struct cudaMemLocation location, unsigned int flags, cudaStream_t stream = 0); +# 7873 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemAdvise(const void *devPtr, size_t count, enum cudaMemoryAdvise advice, int device); +# 7996 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemAdvise_v2(const void *devPtr, size_t count, enum cudaMemoryAdvise advice, struct cudaMemLocation location); +# 8078 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 8121 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 8181 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 8223 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 8266 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 8317 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 8367 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 8436 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocAsync(void **devPtr, size_t size, cudaStream_t hStream); +# 8462 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeAsync(void *devPtr, cudaStream_t hStream); +# 8487 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep); +# 8531 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, enum cudaMemPoolAttr attr, void *value ); +# 8579 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, enum cudaMemPoolAttr attr, void *value ); +# 8594 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const struct cudaMemAccessDesc *descList, size_t count); +# 8607 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolGetAccess(enum cudaMemAccessFlags *flags, cudaMemPool_t memPool, struct cudaMemLocation *location); +# 8645 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolCreate(cudaMemPool_t *memPool, const struct cudaMemPoolProps *poolProps); +# 8667 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool); +# 8703 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocFromPoolAsync(void **ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream); +# 8728 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolExportToShareableHandle( + void *shareableHandle, + cudaMemPool_t memPool, + enum cudaMemAllocationHandleType handleType, + unsigned int flags); +# 8755 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolImportFromShareableHandle( + cudaMemPool_t *memPool, + void *shareableHandle, + enum cudaMemAllocationHandleType handleType, + unsigned int flags); +# 8778 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolExportPointer(struct cudaMemPoolPtrExportData *exportData, void *ptr); +# 8807 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolImportPointer(void **ptr, cudaMemPool_t memPool, struct cudaMemPoolPtrExportData *exportData); +# 8960 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaPointerGetAttributes(struct cudaPointerAttributes *attributes, const void *ptr); +# 9001 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceCanAccessPeer(int *canAccessPeer, int device, int peerDevice); +# 9043 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags); +# 9065 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceDisablePeerAccess(int peerDevice); +# 9129 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource); +# 9164 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags); +# 9203 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t *resources, cudaStream_t stream = 0); +# 9238 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t *resources, cudaStream_t stream = 0); +# 9270 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceGetMappedPointer(void **devPtr, size_t *size, cudaGraphicsResource_t resource); +# 9308 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t *array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel); +# 9337 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t *mipmappedArray, cudaGraphicsResource_t resource); +# 9372 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetChannelDesc(struct cudaChannelFormatDesc *desc, cudaArray_const_t array); +# 9402 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) struct cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, enum cudaChannelFormatKind f); +# 9626 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 9646 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject); +# 9666 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectResourceDesc(struct cudaResourceDesc *pResDesc, cudaTextureObject_t texObject); +# 9686 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectTextureDesc(struct cudaTextureDesc *pTexDesc, cudaTextureObject_t texObject); +# 9707 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectResourceViewDesc(struct cudaResourceViewDesc *pResViewDesc, cudaTextureObject_t texObject); +# 9752 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t *pSurfObject, const struct cudaResourceDesc *pResDesc); +# 9772 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject); +# 9791 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSurfaceObjectResourceDesc(struct cudaResourceDesc *pResDesc, cudaSurfaceObject_t surfObject); +# 9825 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDriverGetVersion(int *driverVersion); +# 9854 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaRuntimeGetVersion(int *runtimeVersion); +# 9901 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphCreate(cudaGraph_t *pGraph, unsigned int flags); +# 9999 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10032 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, struct cudaKernelNodeParams *pNodeParams); +# 10058 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const struct cudaKernelNodeParams *pNodeParams); +# 10078 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeCopyAttributes( + cudaGraphNode_t hSrc, + cudaGraphNode_t hDst); +# 10101 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeGetAttribute( + cudaGraphNode_t hNode, + cudaLaunchAttributeID attr, + cudaLaunchAttributeValue *value_out); +# 10125 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeSetAttribute( + cudaGraphNode_t hNode, + cudaLaunchAttributeID attr, + const cudaLaunchAttributeValue *value); +# 10176 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10235 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10304 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10372 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10404 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, struct cudaMemcpy3DParms *pNodeParams); +# 10431 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const struct cudaMemcpy3DParms *pNodeParams); +# 10470 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10516 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10562 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10610 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10633 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, struct cudaMemsetParams *pNodeParams); +# 10657 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const struct cudaMemsetParams *pNodeParams); +# 10699 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10722 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, struct cudaHostNodeParams *pNodeParams); +# 10746 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const struct cudaHostNodeParams *pNodeParams); +# 10787 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10814 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t *pGraph); +# 10852 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies); +# 10896 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10923 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t *event_out); +# 10951 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event); +# 10998 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11025 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t *event_out); +# 11053 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event); +# 11103 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11136 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, struct cudaExternalSemaphoreSignalNodeParams *params_out); +# 11164 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const struct cudaExternalSemaphoreSignalNodeParams *nodeParams); +# 11214 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11247 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, struct cudaExternalSemaphoreWaitNodeParams *params_out); +# 11275 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const struct cudaExternalSemaphoreWaitNodeParams *nodeParams); +# 11353 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11380 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, struct cudaMemAllocNodeParams *params_out); +# 11441 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11465 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void *dptr_out); +# 11493 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGraphMemTrim(int device); +# 11530 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetGraphMemAttribute(int device, enum cudaGraphMemAttributeType attr, void* value); +# 11564 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetGraphMemAttribute(int device, enum cudaGraphMemAttributeType attr, void* value); +# 11592 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphClone(cudaGraph_t *pGraphClone, cudaGraph_t originalGraph); +# 11620 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t *pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph); +# 11651 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, enum cudaGraphNodeType *pType); +# 11682 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t *nodes, size_t *numNodes); +# 11713 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t *pRootNodes, size_t *pNumRootNodes); +# 11747 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t *from, cudaGraphNode_t *to, size_t *numEdges); +# 11787 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11818 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t *pDependencies, size_t *pNumDependencies); +# 11855 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependencies_v2(cudaGraphNode_t node, cudaGraphNode_t *pDependencies, cudaGraphEdgeData *edgeData, size_t *pNumDependencies); +# 11887 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t *pDependentNodes, size_t *pNumDependentNodes); +# 11925 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependentNodes_v2(cudaGraphNode_t node, cudaGraphNode_t *pDependentNodes, cudaGraphEdgeData *edgeData, size_t *pNumDependentNodes); +# 11956 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11988 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 12019 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 12054 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 12084 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node); +# 12155 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiate(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, unsigned long long flags = 0); +# 12228 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, unsigned long long flags = 0); +# 12335 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiateWithParams(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams *instantiateParams); +# 12360 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long *flags); +# 12419 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaKernelNodeParams *pNodeParams); +# 12470 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaMemcpy3DParms *pNodeParams); +# 12525 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 12588 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 12649 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 12704 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaMemsetParams *pNodeParams); +# 12744 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaHostNodeParams *pNodeParams); +# 12791 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph); +# 12836 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event); +# 12881 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event); +# 12929 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const struct cudaExternalSemaphoreSignalNodeParams *nodeParams); +# 12977 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const struct cudaExternalSemaphoreWaitNodeParams *nodeParams); +# 13017 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled); +# 13051 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int *isEnabled); +# 13143 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo *resultInfo); +# 13168 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream); +# 13199 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream); +# 13222 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec); +# 13243 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDestroy(cudaGraph_t graph); +# 13262 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char *path, unsigned int flags); +# 13298 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 13322 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned int count = 1); +# 13350 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned int count = 1); +# 13378 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 13403 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count = 1); +# 13445 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 13489 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 13518 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeSetParams(cudaGraphNode_t node, struct cudaGraphNodeParams *nodeParams); +# 13567 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, struct cudaGraphNodeParams *nodeParams); +# 13593 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 13671 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetDriverEntryPoint(const char *symbol, void **funcPtr, unsigned long long flags, enum cudaDriverEntryPointQueryResult *driverStatus = +# 13671 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" 3 4 + __null +# 13671 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" + ); + + + + + + + +extern __attribute__((host)) cudaError_t cudaGetExportTable(const void **ppExportTable, const cudaUUID_t *pExportTableId); +# 13858 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetFuncBySymbol(cudaFunction_t* functionPtr, const void* symbolPtr); +# 13874 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetKernel(cudaKernel_t *kernelPtr, const void *entryFuncAddr); +# 14044 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +} +# 62 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/channel_descriptor.h" 2 +# 117 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 389 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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(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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_functions.h" 1 +# 53 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 54 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 55 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_functions.h" 2 +# 79 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 + + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 100 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 + + + + + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_functions.h" 1 +# 77 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_functions.hpp" 1 +# 73 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_functions.h" 2 +# 106 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 +# 117 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 1 +# 71 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 72 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 73 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 2 +# 85 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" +# 1 "/usr/include/string.h" 1 3 4 +# 26 "/usr/include/string.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/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-linux-gnu/11/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-linux-gnu/11/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 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))); +# 539 "/usr/include/string.h" 3 4 +} +# 86 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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-linux-gnu/11/include/stddef.h" 1 3 4 +# 30 "/usr/include/time.h" 2 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/time.h" 1 3 4 +# 73 "/usr/include/x86_64-linux-gnu/bits/time.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/timex.h" 1 3 4 +# 26 "/usr/include/x86_64-linux-gnu/bits/timex.h" 3 4 +struct timex +{ +# 58 "/usr/include/x86_64-linux-gnu/bits/timex.h" 3 4 + unsigned int modes; + __syscall_slong_t offset; + __syscall_slong_t freq; + __syscall_slong_t maxerror; + __syscall_slong_t esterror; + int status; + __syscall_slong_t constant; + __syscall_slong_t precision; + __syscall_slong_t tolerance; + struct timeval time; + __syscall_slong_t tick; + __syscall_slong_t ppsfreq; + __syscall_slong_t jitter; + int shift; + __syscall_slong_t stabil; + __syscall_slong_t jitcnt; + __syscall_slong_t calcnt; + __syscall_slong_t errcnt; + __syscall_slong_t stbcnt; + + int tai; + + + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; + +}; +# 74 "/usr/include/x86_64-linux-gnu/bits/time.h" 2 3 4 + +extern "C" { + + +extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) noexcept (true); +# 90 "/usr/include/x86_64-linux-gnu/bits/time.h" 3 4 +} +# 34 "/usr/include/time.h" 2 3 4 + + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_tm.h" 1 3 4 + + + + + + +struct tm +{ + int tm_sec; + int tm_min; + int tm_hour; + int tm_mday; + int tm_mon; + int tm_year; + int tm_wday; + int tm_yday; + int tm_isdst; + + + long int tm_gmtoff; + const char *tm_zone; + + + + +}; +# 40 "/usr/include/time.h" 2 3 4 +# 48 "/usr/include/time.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h" 1 3 4 + + + + + + + +struct itimerspec + { + struct timespec it_interval; + struct timespec it_value; + }; +# 49 "/usr/include/time.h" 2 3 4 +struct sigevent; +# 68 "/usr/include/time.h" 3 4 +extern "C" { + + + +extern clock_t clock (void) noexcept (true); + + + +extern time_t time (time_t *__timer) noexcept (true); + + +extern double difftime (time_t __time1, time_t __time0) + noexcept (true) __attribute__ ((__const__)); + + +extern time_t mktime (struct tm *__tp) noexcept (true); +# 100 "/usr/include/time.h" 3 4 +extern size_t strftime (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp) noexcept (true); + + + + +extern char *strptime (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp) + noexcept (true); + + + + + + +extern size_t strftime_l (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp, + locale_t __loc) noexcept (true); + + + +extern char *strptime_l (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp, + locale_t __loc) noexcept (true); + + + + + + +extern struct tm *gmtime (const time_t *__timer) noexcept (true); + + + +extern struct tm *localtime (const time_t *__timer) noexcept (true); +# 154 "/usr/include/time.h" 3 4 +extern struct tm *gmtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) noexcept (true); + + + +extern struct tm *localtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) noexcept (true); +# 179 "/usr/include/time.h" 3 4 +extern char *asctime (const struct tm *__tp) noexcept (true); + + + +extern char *ctime (const time_t *__timer) noexcept (true); +# 197 "/usr/include/time.h" 3 4 +extern char *asctime_r (const struct tm *__restrict __tp, + char *__restrict __buf) noexcept (true); + + + +extern char *ctime_r (const time_t *__restrict __timer, + char *__restrict __buf) noexcept (true); +# 217 "/usr/include/time.h" 3 4 +extern char *__tzname[2]; +extern int __daylight; +extern long int __timezone; + + + + +extern char *tzname[2]; + + + +extern void tzset (void) noexcept (true); + + + +extern int daylight; +extern long int timezone; +# 249 "/usr/include/time.h" 3 4 +extern time_t timegm (struct tm *__tp) noexcept (true); + +extern time_t timelocal (struct tm *__tp) noexcept (true); +# 262 "/usr/include/time.h" 3 4 +extern int dysize (int __year) noexcept (true) __attribute__ ((__const__)); +# 272 "/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); + + +extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp) + noexcept (true); +# 311 "/usr/include/time.h" 3 4 +extern int clock_nanosleep (clockid_t __clock_id, int __flags, + const struct timespec *__req, + struct timespec *__rem); +# 326 "/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); +# 364 "/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))); +# 387 "/usr/include/time.h" 3 4 +extern int timespec_getres (struct timespec *__ts, int __base) + noexcept (true); +# 413 "/usr/include/time.h" 3 4 +extern int getdate_err; +# 422 "/usr/include/time.h" 3 4 +extern struct tm *getdate (const char *__string); +# 436 "/usr/include/time.h" 3 4 +extern int getdate_r (const char *__restrict __string, + struct tm *__restrict __resbufp); + + +} +# 87 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 2 + + +# 88 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" +extern "C" +{ + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) clock_t clock(void) + + + + +# 95 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 3 4 +noexcept (true) +# 95 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void* memset(void*, int, size_t) +# 96 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 3 4 + noexcept (true) +# 96 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void* memcpy(void*, const void*, size_t) +# 97 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 3 4 + noexcept (true) +# 97 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" + ; + +} +# 303 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 1 +# 112 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 113 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 114 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 2 +# 124 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern "C" +{ +# 222 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) int abs(int a) +# 222 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 222 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; + + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) long int labs(long int a) +# 230 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 230 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; + + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) long long int llabs(long long int a) +# 238 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 238 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 288 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fabs(double x) +# 288 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 288 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 331 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fabsf(float x) +# 331 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 331 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 341 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 383 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fminf(float x, float y) +# 383 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 383 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 403 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmin(double x, double y) +# 403 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 403 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 416 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 459 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmaxf(float x, float y) +# 459 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 459 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 479 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmax(double, double) +# 479 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 479 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 523 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sin(double x) +# 523 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 523 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 556 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cos(double x) +# 556 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 556 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 575 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincos(double x, double *sptr, double *cptr) +# 575 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 575 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 591 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincosf(float x, float *sptr, float *cptr) +# 591 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 591 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 636 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tan(double x) +# 636 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 636 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 705 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sqrt(double x) +# 705 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 705 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 777 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rsqrt(double x); +# 847 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rsqrtf(float x); +# 903 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log2(double x) +# 903 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 903 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 968 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp2(double x) +# 968 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 968 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1033 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float exp2f(float x) +# 1033 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1033 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1100 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp10(double x) +# 1100 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1100 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1163 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float exp10f(float x) +# 1163 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1163 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1256 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double expm1(double x) +# 1256 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1256 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1348 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float expm1f(float x) +# 1348 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1348 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1404 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log2f(float x) +# 1404 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1404 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1458 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log10(double x) +# 1458 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1458 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1528 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log(double x) +# 1528 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1528 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1624 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log1p(double x) +# 1624 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1624 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1723 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log1pf(float x) +# 1723 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1723 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1787 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double floor(double x) +# 1787 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1787 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1866 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp(double x) +# 1866 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1866 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1907 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cosh(double x) +# 1907 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1907 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 1957 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sinh(double x) +# 1957 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 1957 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2007 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tanh(double x) +# 2007 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2007 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2062 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double acosh(double x) +# 2062 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2062 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2120 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float acoshf(float x) +# 2120 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2120 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2173 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double asinh(double x) +# 2173 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2173 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2226 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float asinhf(float x) +# 2226 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2226 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2280 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atanh(double x) +# 2280 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2280 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2334 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atanhf(float x) +# 2334 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2334 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2383 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double ldexp(double x, int exp) +# 2383 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2383 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2429 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ldexpf(float x, int exp) +# 2429 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2429 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2481 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double logb(double x) +# 2481 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2481 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2536 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float logbf(float x) +# 2536 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2536 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2576 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int ilogb(double x) +# 2576 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2576 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2616 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int ilogbf(float x) +# 2616 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2616 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2692 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double scalbn(double x, int n) +# 2692 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2692 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2768 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float scalbnf(float x, int n) +# 2768 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2768 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2844 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double scalbln(double x, long int n) +# 2844 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2844 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2920 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float scalblnf(float x, long int n) +# 2920 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2920 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 2997 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double frexp(double x, int *nptr) +# 2997 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 2997 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3071 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float frexpf(float x, int *nptr) +# 3071 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3071 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3123 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double round(double x) +# 3123 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3123 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3178 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float roundf(float x) +# 3178 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3178 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3196 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lround(double x) +# 3196 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3196 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3214 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lroundf(float x) +# 3214 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3214 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3232 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llround(double x) +# 3232 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3232 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3250 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llroundf(float x) +# 3250 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3250 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3378 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rintf(float x) +# 3378 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3378 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3395 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lrint(double x) +# 3395 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3395 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3412 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lrintf(float x) +# 3412 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3412 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3429 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llrint(double x) +# 3429 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3429 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3446 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llrintf(float x) +# 3446 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3446 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3499 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nearbyint(double x) +# 3499 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3499 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3552 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nearbyintf(float x) +# 3552 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3552 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3614 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double ceil(double x) +# 3614 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3614 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3664 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double trunc(double x) +# 3664 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3664 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3717 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float truncf(float x) +# 3717 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3717 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3743 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fdim(double x, double y) +# 3743 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3743 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 3769 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fdimf(float x, float y) +# 3769 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 3769 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4069 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atan2(double y, double x) +# 4069 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4069 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4140 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atan(double x) +# 4140 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4140 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4163 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double acos(double x) +# 4163 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4163 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4214 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double asin(double x) +# 4214 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4214 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4282 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double hypot(double x, double y) +# 4282 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4282 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4337 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rhypot(double x, double y) +# 4337 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4337 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4405 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float hypotf(float x, float y) +# 4405 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4405 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4460 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rhypotf(float x, float y) +# 4460 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4460 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4504 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double norm3d(double a, double b, double c) +# 4504 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4504 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4555 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm3d(double a, double b, double c) +# 4555 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4555 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4604 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double norm4d(double a, double b, double c, double d) +# 4604 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4604 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4660 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm4d(double a, double b, double c, double d) +# 4660 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4660 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4717 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + __attribute__((device)) __attribute__((device_builtin)) double norm(int dim, double const * p) +# 4717 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4717 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4781 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm(int dim, double const * p) +# 4781 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4781 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4846 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnormf(int dim, float const * p) +# 4846 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4846 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4903 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + __attribute__((device)) __attribute__((device_builtin)) float normf(int dim, float const * p) +# 4903 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4903 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4948 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float norm3df(float a, float b, float c) +# 4948 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4948 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 4999 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnorm3df(float a, float b, float c) +# 4999 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 4999 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 5048 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float norm4df(float a, float b, float c, float d) +# 5048 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 5048 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 5104 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnorm4df(float a, float b, float c, float d) +# 5104 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 5104 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 5191 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cbrt(double x) +# 5191 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 5191 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 5277 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cbrtf(float x) +# 5277 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 5277 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 5332 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rcbrt(double x); +# 5382 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rcbrtf(float x); +# 5442 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sinpi(double x); +# 5502 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinpif(float x); +# 5554 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cospi(double x); +# 5606 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cospif(float x); +# 5636 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincospi(double x, double *sptr, double *cptr); +# 5666 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincospif(float x, float *sptr, float *cptr); +# 5999 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double pow(double x, double y) +# 5999 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 5999 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6055 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double modf(double x, double *iptr) +# 6055 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6055 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6114 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmod(double x, double y) +# 6114 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6114 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6210 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double remainder(double x, double y) +# 6210 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6210 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6309 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float remainderf(float x, float y) +# 6309 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6309 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6381 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double remquo(double x, double y, int *quo) +# 6381 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6381 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6453 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float remquof(float x, float y, int *quo) +# 6453 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6453 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6494 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double j0(double x) +# 6494 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6494 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6536 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float j0f(float x) +# 6536 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6536 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6605 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double j1(double x) +# 6605 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6605 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6674 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float j1f(float x) +# 6674 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6674 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6717 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double jn(int n, double x) +# 6717 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6717 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6760 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float jnf(int n, float x) +# 6760 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6760 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6821 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double y0(double x) +# 6821 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6821 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6882 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float y0f(float x) +# 6882 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6882 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 6943 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double y1(double x) +# 6943 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 6943 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7004 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float y1f(float x) +# 7004 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7004 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7067 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double yn(int n, double x) +# 7067 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7067 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7130 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ynf(int n, float x) +# 7130 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7130 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7157 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double cyl_bessel_i0(double x) +# 7157 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7157 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7183 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float cyl_bessel_i0f(float x) +# 7183 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7183 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7210 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double cyl_bessel_i1(double x) +# 7210 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7210 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7236 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float cyl_bessel_i1f(float x) +# 7236 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7236 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7319 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erf(double x) +# 7319 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7319 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7401 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erff(float x) +# 7401 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7401 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7473 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfinv(double x); +# 7538 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfinvf(float x); +# 7577 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfc(double x) +# 7577 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7577 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7615 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcf(float x) +# 7615 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7615 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7732 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double lgamma(double x) +# 7732 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 7732 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 7794 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfcinv(double x); +# 7849 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcinvf(float x); +# 7917 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double normcdfinv(double x); +# 7985 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normcdfinvf(float x); +# 8028 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double normcdf(double x); +# 8071 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normcdff(float x); +# 8135 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfcx(double x); +# 8199 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcxf(float x); +# 8318 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float lgammaf(float x) +# 8318 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8318 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8416 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tgamma(double x) +# 8416 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8416 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8514 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tgammaf(float x) +# 8514 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8514 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8527 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double copysign(double x, double y) +# 8527 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8527 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8540 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float copysignf(float x, float y) +# 8540 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8540 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8559 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nextafter(double x, double y) +# 8559 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8559 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8578 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nextafterf(float x, float y) +# 8578 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8578 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8594 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nan(const char *tagp) +# 8594 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8594 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8610 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nanf(const char *tagp) +# 8610 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8610 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinff(float) +# 8617 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8617 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnanf(float) +# 8618 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8618 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8628 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finite(double) +# 8628 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8628 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finitef(float) +# 8629 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8629 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbit(double) +# 8630 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8630 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnan(double) +# 8631 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8631 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinf(double) +# 8632 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8632 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitf(float) +# 8635 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8635 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8794 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fma(double x, double y, double z) +# 8794 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8794 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8952 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmaf(float x, float y, float z) +# 8952 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8952 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 8963 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitl(long double) +# 8963 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8963 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finitel(long double) +# 8969 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8969 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinfl(long double) +# 8970 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8970 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnanl(long double) +# 8971 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 8971 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9021 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float acosf(float x) +# 9021 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9021 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9080 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float asinf(float x) +# 9080 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9080 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9160 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atanf(float x) +# 9160 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9160 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9457 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atan2f(float y, float x) +# 9457 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9457 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9491 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cosf(float x) +# 9491 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9491 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9533 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinf(float x) +# 9533 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9533 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9575 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tanf(float x) +# 9575 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9575 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9616 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float coshf(float x) +# 9616 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9616 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9666 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinhf(float x) +# 9666 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9666 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9716 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tanhf(float x) +# 9716 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9716 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9768 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float logf(float x) +# 9768 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9768 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9848 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float expf(float x) +# 9848 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9848 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9900 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log10f(float x) +# 9900 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9900 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 9955 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float modff(float x, float *iptr) +# 9955 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 9955 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 10285 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float powf(float x, float y) +# 10285 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 10285 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 10354 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sqrtf(float x) +# 10354 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 10354 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 10413 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ceilf(float x) +# 10413 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 10413 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 10474 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float floorf(float x) +# 10474 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 10474 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 10532 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmodf(float x, float y) +# 10532 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 3 4 + noexcept (true) +# 10532 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + ; +# 10547 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +} + + +# 1 "/usr/include/c++/11/math.h" 1 3 +# 36 "/usr/include/c++/11/math.h" 3 +# 1 "/usr/include/c++/11/cmath" 1 3 +# 39 "/usr/include/c++/11/cmath" 3 + +# 40 "/usr/include/c++/11/cmath" 3 + + +# 1 "/usr/include/c++/11/bits/cpp_type_traits.h" 1 3 +# 35 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 + +# 36 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 +# 67 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 + +# 67 "/usr/include/c++/11/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; + }; +# 184 "/usr/include/c++/11/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; + }; +# 270 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 +template<> struct __is_integer<__int128> { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; +# 287 "/usr/include/c++/11/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; + }; + + + + + 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; + }; +# 423 "/usr/include/c++/11/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; + }; +# 532 "/usr/include/c++/11/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; } + + +} +} +# 43 "/usr/include/c++/11/cmath" 2 3 +# 1 "/usr/include/c++/11/ext/type_traits.h" 1 3 +# 32 "/usr/include/c++/11/ext/type_traits.h" 3 + +# 33 "/usr/include/c++/11/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 + inline bool + __is_null_pointer(_Type* __ptr) + { return __ptr == 0; } + + template + inline bool + __is_null_pointer(_Type) + { return false; } + + + inline 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; }; + + + template + using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); + + + template::__type, + typename _Up2 = typename __promote<_Up>::__type> + struct __promote_2 + { + typedef __typeof__(_Tp2() + _Up2()) __type; + }; + + template::__type, + typename _Up2 = typename __promote<_Up>::__type, + typename _Vp2 = typename __promote<_Vp>::__type> + struct __promote_3 + { + typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type; + }; + + template::__type, + typename _Up2 = typename __promote<_Up>::__type, + typename _Vp2 = typename __promote<_Vp>::__type, + typename _Wp2 = typename __promote<_Wp>::__type> + struct __promote_4 + { + typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type; + }; + + +} +} +# 44 "/usr/include/c++/11/cmath" 2 3 + +# 1 "/usr/include/math.h" 1 3 4 +# 27 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4 +# 28 "/usr/include/math.h" 2 3 4 + + + + + + +extern "C" { + + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 1 3 4 +# 25 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h" 1 3 4 +# 26 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 2 3 4 +# 41 "/usr/include/math.h" 2 3 4 +# 152 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h" 1 3 4 +# 153 "/usr/include/math.h" 2 3 4 +# 163 "/usr/include/math.h" 3 4 +typedef float float_t; +typedef double double_t; +# 204 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/fp-logb.h" 1 3 4 +# 205 "/usr/include/math.h" 2 3 4 +# 247 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/fp-fast.h" 1 3 4 +# 248 "/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, + }; +# 312 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassify (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbit (double __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinf (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finite (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnan (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsig (double __x, double __y) noexcept (true); + + +extern int __issignaling (double __value) noexcept (true) + __attribute__ ((__const__)); +# 313 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/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 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 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 __ceil (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double fabs (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 __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); +# 183 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern int finite (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern double drem (double __x, double __y) noexcept (true); extern double __drem (double __x, double __y) noexcept (true); + + + +extern double significand (double __x) noexcept (true); extern double __significand (double __x) noexcept (true); + + + + + + +extern double copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__)); 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); +# 220 "/usr/include/x86_64-linux-gnu/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 __round (double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern double trunc (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 __fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + +extern double fma (double __x, double __y, double __z) noexcept (true); extern double __fma (double __x, double __y, double __z) noexcept (true); + + + + +extern double roundeven (double __x) noexcept (true) __attribute__ ((__const__)); 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 __fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern double fmaximum (double __x, double __y) noexcept (true) __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 __fminimum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_num (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 __fminimum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_mag (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 __fminimum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum_mag_num (double __x, 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); +# 314 "/usr/include/math.h" 2 3 4 +# 329 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyf (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitf (float __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinff (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitef (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanf (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigf (float __x, float __y) noexcept (true); + + +extern int __issignalingf (float __value) noexcept (true) + __attribute__ ((__const__)); +# 330 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/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 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 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 __ceilf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float fabsf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __fabsf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float floorf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __floorf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float fmodf (float __x, float __y) noexcept (true); extern float __fmodf (float __x, float __y) noexcept (true); +# 177 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern int isinff (float __value) noexcept (true) + __attribute__ ((__const__)); + + + + +extern int finitef (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern float dremf (float __x, float __y) noexcept (true); extern float __dremf (float __x, float __y) noexcept (true); + + + +extern float significandf (float __x) noexcept (true); extern float __significandf (float __x) noexcept (true); + + + + + + +extern float copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern float nanf (const char *__tagb) noexcept (true); extern float __nanf (const char *__tagb) noexcept (true); +# 213 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern int isnanf (float __value) noexcept (true) + __attribute__ ((__const__)); + + + + + +extern float j0f (float) noexcept (true); extern float __j0f (float) 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 __roundf (float __x) noexcept (true) __attribute__ ((__const__)); + + + +extern float truncf (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 __fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + +extern float fmaf (float __x, float __y, float __z) noexcept (true); extern float __fmaf (float __x, float __y, float __z) noexcept (true); + + + + +extern float roundevenf (float __x) noexcept (true) __attribute__ ((__const__)); 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 __fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminmagf (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 __fmaximumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_numf (float __x, float __y) noexcept (true) __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 __fminimum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_magf (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 __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 __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 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); +# 331 "/usr/include/math.h" 2 3 4 +# 398 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinfl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitel (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigl (long double __x, long double __y) noexcept (true); + + +extern int __issignalingl (long double __value) noexcept (true) + __attribute__ ((__const__)); +# 399 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/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 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 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 __ceill (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double floorl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __floorl (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmodl (long double __x, long double __y) noexcept (true); extern long double __fmodl (long double __x, long double __y) noexcept (true); +# 177 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern int isinfl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + + +extern int finitel (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern long double dreml (long double __x, long double __y) noexcept (true); extern long double __dreml (long double __x, long double __y) noexcept (true); + + + +extern long double significandl (long double __x) noexcept (true); extern long double __significandl (long double __x) noexcept (true); + + + + + + +extern long double copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __copysignl (long 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); +# 213 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern int isnanl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + + + +extern long double j0l (long double) noexcept (true); extern long double __j0l (long double) noexcept (true); +extern long double j1l (long double) noexcept (true); extern long double __j1l (long double) noexcept (true); +extern long double jnl (int, long double) noexcept (true); extern long 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 __roundl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern long double truncl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __truncl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double remquol (long double __x, long double __y, int *__quo) noexcept (true); extern long double __remquol (long double __x, long double __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintl (long double __x) noexcept (true); extern long int __lrintl (long double __x) noexcept (true); +__extension__ +extern long long int llrintl (long double __x) noexcept (true); extern 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 __fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + +extern long double fmal (long double __x, long double __y, long double __z) noexcept (true); extern long double __fmal (long double __x, long double __y, long double __z) noexcept (true); + + + + +extern long double roundevenl (long double __x) noexcept (true) __attribute__ ((__const__)); 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 __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 __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 __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 __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 __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 __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 __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 __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 __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 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); +# 400 "/usr/include/math.h" 2 3 4 +# 450 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 + extern _Float32 acosf32 (_Float32 __x) noexcept (true); extern _Float32 __acosf32 (_Float32 __x) noexcept (true); + + extern _Float32 asinf32 (_Float32 __x) noexcept (true); extern _Float32 __asinf32 (_Float32 __x) noexcept (true); + + extern _Float32 atanf32 (_Float32 __x) noexcept (true); extern _Float32 __atanf32 (_Float32 __x) noexcept (true); + + extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); 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 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 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 __ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fabsf32 (_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 __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); +# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); 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); +# 220 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32 j0f32 (_Float32) noexcept (true); extern _Float32 __j0f32 (_Float32) noexcept (true); +extern _Float32 j1f32 (_Float32) noexcept (true); extern _Float32 __j1f32 (_Float32) noexcept (true); +extern _Float32 jnf32 (int, _Float32) noexcept (true); extern _Float32 __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); +# 252 "/usr/include/x86_64-linux-gnu/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 __roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32 truncf32 (_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 __fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminf32 (_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 _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 __fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminmagf32 (_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 __fmaximumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimumf32 (_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 __fmaximum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_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 __fmaximum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_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 __fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) 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); +# 451 "/usr/include/math.h" 2 3 4 +# 467 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 + extern _Float64 acosf64 (_Float64 __x) noexcept (true); extern _Float64 __acosf64 (_Float64 __x) noexcept (true); + + extern _Float64 asinf64 (_Float64 __x) noexcept (true); extern _Float64 __asinf64 (_Float64 __x) noexcept (true); + + extern _Float64 atanf64 (_Float64 __x) noexcept (true); extern _Float64 __atanf64 (_Float64 __x) noexcept (true); + + extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); 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 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 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 __ceilf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fabsf64 (_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 __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); +# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); 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); +# 220 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64 j0f64 (_Float64) noexcept (true); extern _Float64 __j0f64 (_Float64) noexcept (true); +extern _Float64 j1f64 (_Float64) noexcept (true); extern _Float64 __j1f64 (_Float64) noexcept (true); +extern _Float64 jnf64 (int, _Float64) noexcept (true); extern _Float64 __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); +# 252 "/usr/include/x86_64-linux-gnu/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 __roundf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64 truncf64 (_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 __fmaxf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminf64 (_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 _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 __fmaxmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminmagf64 (_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 __fmaximumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimumf64 (_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 __fmaximum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_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 __fmaximum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_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 __fmaximum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminimum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf64 (const _Float64 *__x, const _Float64 *__y) 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); +# 468 "/usr/include/math.h" 2 3 4 +# 481 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/x86_64-linux-gnu/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__)); +# 482 "/usr/include/math.h" 2 3 4 + + +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/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 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 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 __ceilf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fabsf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fabsf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 floorf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); extern _Float128 __floorf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmodf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __fmodf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float128 copysignf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); 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); +# 220 "/usr/include/x86_64-linux-gnu/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); +# 252 "/usr/include/x86_64-linux-gnu/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 __roundf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float128 truncf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); extern _Float128 __truncf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 remquof128 (_Float128 __x, _Float128 __y, int *__quo) 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 __fmaxf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminf128 (_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 _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 __fmaxmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fminmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 fmaximumf128 (_Float128 __x, _Float128 __y) noexcept (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 __fminimumf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmaximum_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fmaximum_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_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 __fmaximum_magf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_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 __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 _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); +# 485 "/usr/include/math.h" 2 3 4 +# 501 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/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 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 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 __ceilf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x floorf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __floorf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); +# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); 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); +# 220 "/usr/include/x86_64-linux-gnu/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); +# 252 "/usr/include/x86_64-linux-gnu/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 __roundf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32x truncf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __truncf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) 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 __fmaxf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminf32x (_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 _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 __fmaxmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x fmaximumf32x (_Float32x __x, _Float32x __y) noexcept (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 __fminimumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaximum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_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 __fmaximum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_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 __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 _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); +# 502 "/usr/include/math.h" 2 3 4 +# 518 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/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 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 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 __ceilf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x floorf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __floorf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); 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); +# 220 "/usr/include/x86_64-linux-gnu/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); +# 252 "/usr/include/x86_64-linux-gnu/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 __roundf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64x truncf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __truncf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) 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 __fmaxf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminf64x (_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 _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 __fmaxmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x fmaximumf64x (_Float64x __x, _Float64x __y) noexcept (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 __fminimumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaximum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_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 __fmaximum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_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 __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 _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); +# 519 "/usr/include/math.h" 2 3 4 +# 566 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern float fadd (double __x, double __y) noexcept (true); + + +extern float fdiv (double __x, double __y) noexcept (true); + + +extern float ffma (double __x, double __y, double __z) noexcept (true); + + +extern float fmul (double __x, double __y) noexcept (true); + + +extern float fsqrt (double __x) noexcept (true); + + +extern float fsub (double __x, double __y) noexcept (true); +# 567 "/usr/include/math.h" 2 3 4 +# 587 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern float faddl (long double __x, long double __y) noexcept (true); + + +extern float fdivl (long double __x, long double __y) noexcept (true); + + +extern float ffmal (long double __x, long double __y, long double __z) 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); +# 588 "/usr/include/math.h" 2 3 4 +# 616 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern double daddl (long double __x, long double __y) noexcept (true); + + +extern double ddivl (long double __x, long double __y) noexcept (true); + + +extern double dfmal (long double __x, long double __y, long double __z) 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); +# 617 "/usr/include/math.h" 2 3 4 +# 697 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32divf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) 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); +# 698 "/usr/include/math.h" 2 3 4 +# 707 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32divf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) 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); +# 708 "/usr/include/math.h" 2 3 4 +# 717 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32divf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) 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); +# 718 "/usr/include/math.h" 2 3 4 +# 727 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32divf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) 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); +# 728 "/usr/include/math.h" 2 3 4 +# 747 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xdivf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xfmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) 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); +# 748 "/usr/include/math.h" 2 3 4 +# 757 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xdivf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xfmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + +extern _Float32x f32xmulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xsqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float32x f32xsubf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 758 "/usr/include/math.h" 2 3 4 +# 767 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xdivf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xfmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float32x f32xmulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xsqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float32x f32xsubf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 768 "/usr/include/math.h" 2 3 4 +# 787 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float64 f64addf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64divf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) 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); +# 788 "/usr/include/math.h" 2 3 4 +# 797 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float64 f64addf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64divf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) 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); +# 798 "/usr/include/math.h" 2 3 4 +# 817 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float64x f64xaddf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xdivf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xfmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float64x f64xmulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xsqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float64x f64xsubf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 818 "/usr/include/math.h" 2 3 4 +# 854 "/usr/include/math.h" 3 4 +extern int signgam; +# 934 "/usr/include/math.h" 3 4 +enum + { + FP_NAN = + + 0, + FP_INFINITE = + + 1, + FP_ZERO = + + 2, + FP_SUBNORMAL = + + 3, + FP_NORMAL = + + 4 + }; +# 1054 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/iscanonical.h" 1 3 4 +# 23 "/usr/include/x86_64-linux-gnu/bits/iscanonical.h" 3 4 +extern int __iscanonicall (long double __x) + noexcept (true) __attribute__ ((__const__)); +# 46 "/usr/include/x86_64-linux-gnu/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); } + +} +# 1055 "/usr/include/math.h" 2 3 4 +# 1066 "/usr/include/math.h" 3 4 +extern "C++" { +inline int issignaling (float __val) { return __issignalingf (__val); } +inline int issignaling (double __val) { return __issignaling (__val); } +inline int +issignaling (long double __val) +{ + + + + return __issignalingl (__val); + +} + + + +inline int issignaling (_Float128 __val) { return __issignalingf128 (__val); } + +} +# 1097 "/usr/include/math.h" 3 4 +extern "C++" { +# 1128 "/usr/include/math.h" 3 4 +template inline bool +iszero (__T __val) +{ + return __val == 0; +} + +} +# 1363 "/usr/include/math.h" 3 4 +extern "C++" { +template struct __iseqsig_type; + +template<> struct __iseqsig_type +{ + static int __call (float __x, float __y) throw () + { + return __iseqsigf (__x, __y); + } +}; + +template<> struct __iseqsig_type +{ + static int __call (double __x, double __y) throw () + { + return __iseqsig (__x, __y); + } +}; + +template<> struct __iseqsig_type +{ + static int __call (long double __x, long double __y) throw () + { + + return __iseqsigl (__x, __y); + + + + } +}; + + + + +template<> struct __iseqsig_type<_Float128> +{ + static int __call (_Float128 __x, _Float128 __y) throw () + { + return __iseqsigf128 (__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); +} + +} + + + + +} +# 46 "/usr/include/c++/11/cmath" 2 3 +# 77 "/usr/include/c++/11/cmath" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::acos; + + + inline constexpr float + acos(float __x) + { return __builtin_acosf(__x); } + + inline constexpr long double + acos(long double __x) + { return __builtin_acosl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acos(_Tp __x) + { return __builtin_acos(__x); } + + using ::asin; + + + inline constexpr float + asin(float __x) + { return __builtin_asinf(__x); } + + inline constexpr long double + asin(long double __x) + { return __builtin_asinl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asin(_Tp __x) + { return __builtin_asin(__x); } + + using ::atan; + + + inline constexpr float + atan(float __x) + { return __builtin_atanf(__x); } + + inline constexpr long double + atan(long double __x) + { return __builtin_atanl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atan(_Tp __x) + { return __builtin_atan(__x); } + + using ::atan2; + + + inline constexpr float + atan2(float __y, float __x) + { return __builtin_atan2f(__y, __x); } + + inline constexpr long double + atan2(long double __y, long double __x) + { return __builtin_atan2l(__y, __x); } + + + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + atan2(_Tp __y, _Up __x) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return atan2(__type(__y), __type(__x)); + } + + using ::ceil; + + + inline constexpr float + ceil(float __x) + { return __builtin_ceilf(__x); } + + inline constexpr long double + ceil(long double __x) + { return __builtin_ceill(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ceil(_Tp __x) + { return __builtin_ceil(__x); } + + using ::cos; + + + inline constexpr float + cos(float __x) + { return __builtin_cosf(__x); } + + inline constexpr long double + cos(long double __x) + { return __builtin_cosl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cos(_Tp __x) + { return __builtin_cos(__x); } + + using ::cosh; + + + inline constexpr float + cosh(float __x) + { return __builtin_coshf(__x); } + + inline constexpr long double + cosh(long double __x) + { return __builtin_coshl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cosh(_Tp __x) + { return __builtin_cosh(__x); } + + using ::exp; + + + inline constexpr float + exp(float __x) + { return __builtin_expf(__x); } + + inline constexpr long double + exp(long double __x) + { return __builtin_expl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp(_Tp __x) + { return __builtin_exp(__x); } + + using ::fabs; + + + inline constexpr float + fabs(float __x) + { return __builtin_fabsf(__x); } + + inline constexpr long double + fabs(long double __x) + { return __builtin_fabsl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + fabs(_Tp __x) + { return __builtin_fabs(__x); } + + using ::floor; + + + inline constexpr float + floor(float __x) + { return __builtin_floorf(__x); } + + inline constexpr long double + floor(long double __x) + { return __builtin_floorl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + floor(_Tp __x) + { return __builtin_floor(__x); } + + using ::fmod; + + + inline constexpr float + fmod(float __x, float __y) + { return __builtin_fmodf(__x, __y); } + + inline constexpr long double + fmod(long double __x, long double __y) + { return __builtin_fmodl(__x, __y); } + + + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmod(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmod(__type(__x), __type(__y)); + } + + using ::frexp; + + + inline float + frexp(float __x, int* __exp) + { return __builtin_frexpf(__x, __exp); } + + inline long double + frexp(long double __x, int* __exp) + { return __builtin_frexpl(__x, __exp); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + frexp(_Tp __x, int* __exp) + { return __builtin_frexp(__x, __exp); } + + using ::ldexp; + + + inline constexpr float + ldexp(float __x, int __exp) + { return __builtin_ldexpf(__x, __exp); } + + inline constexpr long double + ldexp(long double __x, int __exp) + { return __builtin_ldexpl(__x, __exp); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ldexp(_Tp __x, int __exp) + { return __builtin_ldexp(__x, __exp); } + + using ::log; + + + inline constexpr float + log(float __x) + { return __builtin_logf(__x); } + + inline constexpr long double + log(long double __x) + { return __builtin_logl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log(_Tp __x) + { return __builtin_log(__x); } + + using ::log10; + + + inline constexpr float + log10(float __x) + { return __builtin_log10f(__x); } + + inline constexpr long double + log10(long double __x) + { return __builtin_log10l(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log10(_Tp __x) + { return __builtin_log10(__x); } + + using ::modf; + + + inline float + modf(float __x, float* __iptr) + { return __builtin_modff(__x, __iptr); } + + inline long double + modf(long double __x, long double* __iptr) + { return __builtin_modfl(__x, __iptr); } + + + using ::pow; + + + inline constexpr float + pow(float __x, float __y) + { return __builtin_powf(__x, __y); } + + inline constexpr long double + pow(long double __x, long double __y) + { return __builtin_powl(__x, __y); } +# 412 "/usr/include/c++/11/cmath" 3 + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + pow(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return pow(__type(__x), __type(__y)); + } + + using ::sin; + + + inline constexpr float + sin(float __x) + { return __builtin_sinf(__x); } + + inline constexpr long double + sin(long double __x) + { return __builtin_sinl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sin(_Tp __x) + { return __builtin_sin(__x); } + + using ::sinh; + + + inline constexpr float + sinh(float __x) + { return __builtin_sinhf(__x); } + + inline constexpr long double + sinh(long double __x) + { return __builtin_sinhl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sinh(_Tp __x) + { return __builtin_sinh(__x); } + + using ::sqrt; + + + inline constexpr float + sqrt(float __x) + { return __builtin_sqrtf(__x); } + + inline constexpr long double + sqrt(long double __x) + { return __builtin_sqrtl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sqrt(_Tp __x) + { return __builtin_sqrt(__x); } + + using ::tan; + + + inline constexpr float + tan(float __x) + { return __builtin_tanf(__x); } + + inline constexpr long double + tan(long double __x) + { return __builtin_tanl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tan(_Tp __x) + { return __builtin_tan(__x); } + + using ::tanh; + + + inline constexpr float + tanh(float __x) + { return __builtin_tanhf(__x); } + + inline constexpr long double + tanh(long double __x) + { return __builtin_tanhl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tanh(_Tp __x) + { return __builtin_tanh(__x); } +# 536 "/usr/include/c++/11/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 __x) + { return true; } + + + + constexpr bool + isinf(float __x) + { return __builtin_isinf(__x); } + + + + + + constexpr bool + isinf(double __x) + { return __builtin_isinf(__x); } + + + constexpr bool + isinf(long double __x) + { return __builtin_isinf(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isinf(_Tp __x) + { return false; } + + + + constexpr bool + isnan(float __x) + { return __builtin_isnan(__x); } + + + + + + constexpr bool + isnan(double __x) + { return __builtin_isnan(__x); } + + + constexpr bool + isnan(long double __x) + { return __builtin_isnan(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isnan(_Tp __x) + { return false; } + + + + constexpr bool + isnormal(float __x) + { return __builtin_isnormal(__x); } + + constexpr bool + isnormal(double __x) + { return __builtin_isnormal(__x); } + + constexpr bool + isnormal(long double __x) + { return __builtin_isnormal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isnormal(_Tp __x) + { return __x != 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)); + } +# 1065 "/usr/include/c++/11/cmath" 3 + using ::double_t; + using ::float_t; + + + using ::acosh; + using ::acoshf; + using ::acoshl; + + using ::asinh; + using ::asinhf; + using ::asinhl; + + using ::atanh; + using ::atanhf; + using ::atanhl; + + using ::cbrt; + using ::cbrtf; + using ::cbrtl; + + using ::copysign; + using ::copysignf; + using ::copysignl; + + using ::erf; + using ::erff; + using ::erfl; + + using ::erfc; + using ::erfcf; + using ::erfcl; + + using ::exp2; + using ::exp2f; + using ::exp2l; + + using ::expm1; + using ::expm1f; + using ::expm1l; + + using ::fdim; + using ::fdimf; + using ::fdiml; + + using ::fma; + using ::fmaf; + using ::fmal; + + using ::fmax; + using ::fmaxf; + using ::fmaxl; + + using ::fmin; + using ::fminf; + using ::fminl; + + using ::hypot; + using ::hypotf; + using ::hypotl; + + using ::ilogb; + using ::ilogbf; + using ::ilogbl; + + using ::lgamma; + using ::lgammaf; + using ::lgammal; + + + using ::llrint; + using ::llrintf; + using ::llrintl; + + using ::llround; + using ::llroundf; + using ::llroundl; + + + using ::log1p; + using ::log1pf; + using ::log1pl; + + using ::log2; + using ::log2f; + using ::log2l; + + using ::logb; + using ::logbf; + using ::logbl; + + using ::lrint; + using ::lrintf; + using ::lrintl; + + using ::lround; + using ::lroundf; + using ::lroundl; + + using ::nan; + using ::nanf; + using ::nanl; + + using ::nearbyint; + using ::nearbyintf; + using ::nearbyintl; + + using ::nextafter; + using ::nextafterf; + using ::nextafterl; + + using ::nexttoward; + using ::nexttowardf; + using ::nexttowardl; + + using ::remainder; + using ::remainderf; + using ::remainderl; + + using ::remquo; + using ::remquof; + using ::remquol; + + using ::rint; + using ::rintf; + using ::rintl; + + using ::round; + using ::roundf; + using ::roundl; + + using ::scalbln; + using ::scalblnf; + using ::scalblnl; + + using ::scalbn; + using ::scalbnf; + using ::scalbnl; + + using ::tgamma; + using ::tgammaf; + using ::tgammal; + + using ::trunc; + using ::truncf; + using ::truncl; + + + + constexpr float + acosh(float __x) + { return __builtin_acoshf(__x); } + + constexpr long double + acosh(long double __x) + { return __builtin_acoshl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acosh(_Tp __x) + { return __builtin_acosh(__x); } + + + + constexpr float + asinh(float __x) + { return __builtin_asinhf(__x); } + + constexpr long double + asinh(long double __x) + { return __builtin_asinhl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asinh(_Tp __x) + { return __builtin_asinh(__x); } + + + + constexpr float + atanh(float __x) + { return __builtin_atanhf(__x); } + + constexpr long double + atanh(long double __x) + { return __builtin_atanhl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atanh(_Tp __x) + { return __builtin_atanh(__x); } + + + + constexpr float + cbrt(float __x) + { return __builtin_cbrtf(__x); } + + constexpr long double + cbrt(long double __x) + { return __builtin_cbrtl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cbrt(_Tp __x) + { return __builtin_cbrt(__x); } + + + + constexpr float + copysign(float __x, float __y) + { return __builtin_copysignf(__x, __y); } + + constexpr long double + copysign(long double __x, long double __y) + { return __builtin_copysignl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + copysign(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return copysign(__type(__x), __type(__y)); + } + + + + constexpr float + erf(float __x) + { return __builtin_erff(__x); } + + constexpr long double + erf(long double __x) + { return __builtin_erfl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erf(_Tp __x) + { return __builtin_erf(__x); } + + + + constexpr float + erfc(float __x) + { return __builtin_erfcf(__x); } + + constexpr long double + erfc(long double __x) + { return __builtin_erfcl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erfc(_Tp __x) + { return __builtin_erfc(__x); } + + + + constexpr float + exp2(float __x) + { return __builtin_exp2f(__x); } + + constexpr long double + exp2(long double __x) + { return __builtin_exp2l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp2(_Tp __x) + { return __builtin_exp2(__x); } + + + + constexpr float + expm1(float __x) + { return __builtin_expm1f(__x); } + + constexpr long double + expm1(long double __x) + { return __builtin_expm1l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + expm1(_Tp __x) + { return __builtin_expm1(__x); } + + + + constexpr float + fdim(float __x, float __y) + { return __builtin_fdimf(__x, __y); } + + constexpr long double + fdim(long double __x, long double __y) + { return __builtin_fdiml(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fdim(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fdim(__type(__x), __type(__y)); + } + + + + constexpr float + fma(float __x, float __y, float __z) + { return __builtin_fmaf(__x, __y, __z); } + + constexpr long double + fma(long double __x, long double __y, long double __z) + { return __builtin_fmal(__x, __y, __z); } + + + + template + constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type + fma(_Tp __x, _Up __y, _Vp __z) + { + typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; + return fma(__type(__x), __type(__y), __type(__z)); + } + + + + constexpr float + fmax(float __x, float __y) + { return __builtin_fmaxf(__x, __y); } + + constexpr long double + fmax(long double __x, long double __y) + { return __builtin_fmaxl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmax(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmax(__type(__x), __type(__y)); + } + + + + constexpr float + fmin(float __x, float __y) + { return __builtin_fminf(__x, __y); } + + constexpr long double + fmin(long double __x, long double __y) + { return __builtin_fminl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmin(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmin(__type(__x), __type(__y)); + } + + + + constexpr float + hypot(float __x, float __y) + { return __builtin_hypotf(__x, __y); } + + constexpr long double + hypot(long double __x, long double __y) + { return __builtin_hypotl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + hypot(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return hypot(__type(__x), __type(__y)); + } + + + + constexpr int + ilogb(float __x) + { return __builtin_ilogbf(__x); } + + constexpr int + ilogb(long double __x) + { return __builtin_ilogbl(__x); } + + + + template + constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + int>::__type + ilogb(_Tp __x) + { return __builtin_ilogb(__x); } + + + + constexpr float + lgamma(float __x) + { return __builtin_lgammaf(__x); } + + constexpr long double + lgamma(long double __x) + { return __builtin_lgammal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + lgamma(_Tp __x) + { return __builtin_lgamma(__x); } + + + + constexpr long long + llrint(float __x) + { return __builtin_llrintf(__x); } + + constexpr long long + llrint(long double __x) + { return __builtin_llrintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llrint(_Tp __x) + { return __builtin_llrint(__x); } + + + + constexpr long long + llround(float __x) + { return __builtin_llroundf(__x); } + + constexpr long long + llround(long double __x) + { return __builtin_llroundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llround(_Tp __x) + { return __builtin_llround(__x); } + + + + constexpr float + log1p(float __x) + { return __builtin_log1pf(__x); } + + constexpr long double + log1p(long double __x) + { return __builtin_log1pl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log1p(_Tp __x) + { return __builtin_log1p(__x); } + + + + + constexpr float + log2(float __x) + { return __builtin_log2f(__x); } + + constexpr long double + log2(long double __x) + { return __builtin_log2l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log2(_Tp __x) + { return __builtin_log2(__x); } + + + + constexpr float + logb(float __x) + { return __builtin_logbf(__x); } + + constexpr long double + logb(long double __x) + { return __builtin_logbl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + logb(_Tp __x) + { return __builtin_logb(__x); } + + + + constexpr long + lrint(float __x) + { return __builtin_lrintf(__x); } + + constexpr long + lrint(long double __x) + { return __builtin_lrintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lrint(_Tp __x) + { return __builtin_lrint(__x); } + + + + constexpr long + lround(float __x) + { return __builtin_lroundf(__x); } + + constexpr long + lround(long double __x) + { return __builtin_lroundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lround(_Tp __x) + { return __builtin_lround(__x); } + + + + constexpr float + nearbyint(float __x) + { return __builtin_nearbyintf(__x); } + + constexpr long double + nearbyint(long double __x) + { return __builtin_nearbyintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nearbyint(_Tp __x) + { return __builtin_nearbyint(__x); } + + + + constexpr float + nextafter(float __x, float __y) + { return __builtin_nextafterf(__x, __y); } + + constexpr long double + nextafter(long double __x, long double __y) + { return __builtin_nextafterl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + nextafter(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return nextafter(__type(__x), __type(__y)); + } + + + + constexpr float + nexttoward(float __x, long double __y) + { return __builtin_nexttowardf(__x, __y); } + + constexpr long double + nexttoward(long double __x, long double __y) + { return __builtin_nexttowardl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nexttoward(_Tp __x, long double __y) + { return __builtin_nexttoward(__x, __y); } + + + + constexpr float + remainder(float __x, float __y) + { return __builtin_remainderf(__x, __y); } + + constexpr long double + remainder(long double __x, long double __y) + { return __builtin_remainderl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remainder(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remainder(__type(__x), __type(__y)); + } + + + + inline float + remquo(float __x, float __y, int* __pquo) + { return __builtin_remquof(__x, __y, __pquo); } + + inline long double + remquo(long double __x, long double __y, int* __pquo) + { return __builtin_remquol(__x, __y, __pquo); } + + + + template + inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remquo(_Tp __x, _Up __y, int* __pquo) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remquo(__type(__x), __type(__y), __pquo); + } + + + + constexpr float + rint(float __x) + { return __builtin_rintf(__x); } + + constexpr long double + rint(long double __x) + { return __builtin_rintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + rint(_Tp __x) + { return __builtin_rint(__x); } + + + + constexpr float + round(float __x) + { return __builtin_roundf(__x); } + + constexpr long double + round(long double __x) + { return __builtin_roundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + round(_Tp __x) + { return __builtin_round(__x); } + + + + constexpr float + scalbln(float __x, long __ex) + { return __builtin_scalblnf(__x, __ex); } + + constexpr long double + scalbln(long double __x, long __ex) + { return __builtin_scalblnl(__x, __ex); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbln(_Tp __x, long __ex) + { return __builtin_scalbln(__x, __ex); } + + + + constexpr float + scalbn(float __x, int __ex) + { return __builtin_scalbnf(__x, __ex); } + + constexpr long double + scalbn(long double __x, int __ex) + { return __builtin_scalbnl(__x, __ex); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbn(_Tp __x, int __ex) + { return __builtin_scalbn(__x, __ex); } + + + + constexpr float + tgamma(float __x) + { return __builtin_tgammaf(__x); } + + constexpr long double + tgamma(long double __x) + { return __builtin_tgammal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tgamma(_Tp __x) + { return __builtin_tgamma(__x); } + + + + constexpr float + trunc(float __x) + { return __builtin_truncf(__x); } + + constexpr long double + trunc(long double __x) + { return __builtin_truncl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + trunc(_Tp __x) + { return __builtin_trunc(__x); } +# 1852 "/usr/include/c++/11/cmath" 3 + 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); + } +# 1931 "/usr/include/c++/11/cmath" 3 + +} + + +# 1 "/usr/include/c++/11/bits/specfun.h" 1 3 +# 33 "/usr/include/c++/11/bits/specfun.h" 3 +#pragma GCC visibility push(default) +# 45 "/usr/include/c++/11/bits/specfun.h" 3 +# 1 "/usr/include/c++/11/bits/stl_algobase.h" 1 3 +# 60 "/usr/include/c++/11/bits/stl_algobase.h" 3 +# 1 "/usr/include/c++/11/bits/functexcept.h" 1 3 +# 40 "/usr/include/c++/11/bits/functexcept.h" 3 +# 1 "/usr/include/c++/11/bits/exception_defines.h" 1 3 +# 41 "/usr/include/c++/11/bits/functexcept.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + void + __throw_bad_exception(void) __attribute__((__noreturn__)); + + + void + __throw_bad_alloc(void) __attribute__((__noreturn__)); + + void + __throw_bad_array_new_length(void) __attribute__((__noreturn__)); + + + void + __throw_bad_cast(void) __attribute__((__noreturn__)); + + void + __throw_bad_typeid(void) __attribute__((__noreturn__)); + + + void + __throw_logic_error(const char*) __attribute__((__noreturn__)); + + void + __throw_domain_error(const char*) __attribute__((__noreturn__)); + + void + __throw_invalid_argument(const char*) __attribute__((__noreturn__)); + + void + __throw_length_error(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__)) + __attribute__((__format__(__gnu_printf__, 1, 2))); + + void + __throw_runtime_error(const char*) __attribute__((__noreturn__)); + + void + __throw_range_error(const char*) __attribute__((__noreturn__)); + + void + __throw_overflow_error(const char*) __attribute__((__noreturn__)); + + void + __throw_underflow_error(const char*) __attribute__((__noreturn__)); + + + void + __throw_ios_failure(const char*) __attribute__((__noreturn__)); + + void + __throw_ios_failure(const char*, int) __attribute__((__noreturn__)); + + + void + __throw_system_error(int) __attribute__((__noreturn__)); + + + void + __throw_future_error(int) __attribute__((__noreturn__)); + + + void + __throw_bad_function_call() __attribute__((__noreturn__)); + + +} +# 61 "/usr/include/c++/11/bits/stl_algobase.h" 2 3 + + +# 1 "/usr/include/c++/11/ext/numeric_traits.h" 1 3 +# 32 "/usr/include/c++/11/ext/numeric_traits.h" 3 + +# 33 "/usr/include/c++/11/ext/numeric_traits.h" 3 + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 50 "/usr/include/c++/11/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; +# 135 "/usr/include/c++/11/ext/numeric_traits.h" 3 + template + using __int_traits = __numeric_traits_integer<_Tp>; +# 155 "/usr/include/c++/11/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 + { }; +# 236 "/usr/include/c++/11/ext/numeric_traits.h" 3 + +} +# 64 "/usr/include/c++/11/bits/stl_algobase.h" 2 3 +# 1 "/usr/include/c++/11/bits/stl_pair.h" 1 3 +# 59 "/usr/include/c++/11/bits/stl_pair.h" 3 +# 1 "/usr/include/c++/11/bits/move.h" 1 3 +# 38 "/usr/include/c++/11/bits/move.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + inline constexpr _Tp* + __addressof(_Tp& __r) noexcept + { return __builtin_addressof(__r); } + + + + +} + +# 1 "/usr/include/c++/11/type_traits" 1 3 +# 32 "/usr/include/c++/11/type_traits" 3 + +# 33 "/usr/include/c++/11/type_traits" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + class tuple; + + template + class reference_wrapper; +# 64 "/usr/include/c++/11/type_traits" 3 + template + struct integral_constant + { + static constexpr _Tp value = __v; + typedef _Tp value_type; + typedef integral_constant<_Tp, __v> type; + constexpr operator value_type() const noexcept { return value; } + + + + + constexpr value_type operator()() const noexcept { return value; } + + }; + + template + constexpr _Tp integral_constant<_Tp, __v>::value; + + + using true_type = integral_constant; + + + using false_type = integral_constant; + + + + template + using __bool_constant = integral_constant; + + + + + + + template + using bool_constant = integral_constant; + + + + + template + struct conditional; + + + template + struct __type_identity + { using type = _Type; }; + + template + using __type_identity_t = typename __type_identity<_Tp>::type; + + template + struct __or_; + + template<> + struct __or_<> + : public false_type + { }; + + template + struct __or_<_B1> + : public _B1 + { }; + + template + struct __or_<_B1, _B2> + : public conditional<_B1::value, _B1, _B2>::type + { }; + + template + struct __or_<_B1, _B2, _B3, _Bn...> + : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type + { }; + + template + struct __and_; + + template<> + struct __and_<> + : public true_type + { }; + + template + struct __and_<_B1> + : public _B1 + { }; + + template + struct __and_<_B1, _B2> + : public conditional<_B1::value, _B2, _B1>::type + { }; + + template + struct __and_<_B1, _B2, _B3, _Bn...> + : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type + { }; + + template + struct __not_ + : public __bool_constant + { }; + + + + + + template + inline constexpr bool __or_v = __or_<_Bn...>::value; + template + inline constexpr bool __and_v = __and_<_Bn...>::value; + + + + + template + struct conjunction + : __and_<_Bn...> + { }; + + template + struct disjunction + : __or_<_Bn...> + { }; + + template + struct negation + : __not_<_Pp> + { }; + + + + + 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 + struct __success_type + { typedef _Tp type; }; + + struct __failure_type + { }; + + + template + using __remove_cv_t = typename remove_cv<_Tp>::type; + + + + template + struct __is_void_helper + : public false_type { }; + + template<> + struct __is_void_helper + : public true_type { }; + + + + template + struct is_void + : public __is_void_helper<__remove_cv_t<_Tp>>::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 { }; +# 310 "/usr/include/c++/11/type_traits" 3 + 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<__int128> + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; +# 391 "/usr/include/c++/11/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 { }; +# 421 "/usr/include/c++/11/type_traits" 3 + template + struct is_floating_point + : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_array + : public false_type { }; + + template + struct is_array<_Tp[_Size]> + : public true_type { }; + + template + struct is_array<_Tp[]> + : public true_type { }; + + template + struct __is_pointer_helper + : public false_type { }; + + template + struct __is_pointer_helper<_Tp*> + : public true_type { }; + + + template + struct is_pointer + : public __is_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_lvalue_reference + : public false_type { }; + + template + struct is_lvalue_reference<_Tp&> + : public true_type { }; + + + template + struct is_rvalue_reference + : public false_type { }; + + template + struct is_rvalue_reference<_Tp&&> + : public true_type { }; + + template + struct __is_member_object_pointer_helper + : public false_type { }; + + template + struct __is_member_object_pointer_helper<_Tp _Cp::*> + : public __not_>::type { }; + + + template + struct is_member_object_pointer + : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + template + struct __is_member_function_pointer_helper + : public false_type { }; + + template + struct __is_member_function_pointer_helper<_Tp _Cp::*> + : public is_function<_Tp>::type { }; + + + template + struct is_member_function_pointer + : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_enum + : public integral_constant + { }; + + + template + struct is_union + : public integral_constant + { }; + + + template + struct is_class + : public integral_constant + { }; + + + template + struct is_function + : public __bool_constant::value> { }; + + template + struct is_function<_Tp&> + : public false_type { }; + + template + struct is_function<_Tp&&> + : public false_type { }; + + + + template + struct __is_null_pointer_helper + : public false_type { }; + + template<> + struct __is_null_pointer_helper + : public true_type { }; + + + template + struct is_null_pointer + : public __is_null_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + + template + struct __is_nullptr_t + : public is_null_pointer<_Tp> + { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead"))); + + + + + template + struct is_reference + : public __or_, + is_rvalue_reference<_Tp>>::type + { }; + + + template + struct is_arithmetic + : public __or_, is_floating_point<_Tp>>::type + { }; + + + template + struct is_fundamental + : public __or_, is_void<_Tp>, + is_null_pointer<_Tp>>::type + { }; + + + template + struct is_object + : public __not_<__or_, is_reference<_Tp>, + is_void<_Tp>>>::type + { }; + + template + struct is_member_pointer; + + + template + struct is_scalar + : public __or_, is_enum<_Tp>, is_pointer<_Tp>, + is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type + { }; + + + template + struct is_compound + : public __not_>::type { }; + + + template + struct __is_member_pointer_helper + : public false_type { }; + + template + struct __is_member_pointer_helper<_Tp _Cp::*> + : public true_type { }; + + + + template + struct is_member_pointer + : public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + template + struct is_same; + + + template + using __is_one_of = __or_...>; + + + 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 +# 637 "/usr/include/c++/11/type_traits" 3 + >; + + + 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 +# 656 "/usr/include/c++/11/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_referenceable + : public false_type + { }; + + template + struct __is_referenceable<_Tp, __void_t<_Tp&>> + : public true_type + { }; + + + + + + template + struct is_const + : public false_type { }; + + template + struct is_const<_Tp const> + : public true_type { }; + + + template + struct is_volatile + : public false_type { }; + + template + struct is_volatile<_Tp volatile> + : public true_type { }; + + + template + struct is_trivial + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copyable + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_standard_layout + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct + + is_pod + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + template + struct + [[__deprecated__]] + is_literal_type + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_empty + : public integral_constant + { }; + + + template + struct is_polymorphic + : public integral_constant + { }; + + + + + + template + struct is_final + : public integral_constant + { }; + + + + template + struct is_abstract + : public integral_constant + { }; + + + template::value> + struct __is_signed_helper + : public false_type { }; + + template + struct __is_signed_helper<_Tp, true> + : public integral_constant + { }; + + + + template + struct is_signed + : public __is_signed_helper<_Tp>::type + { }; + + + template + struct is_unsigned + : public __and_, __not_>> + { }; + + + template + _Up + __declval(int); + + template + _Tp + __declval(long); + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)); + + template + struct extent; + + template + struct remove_all_extents; + + + template + struct __is_array_known_bounds + : public integral_constant::value > 0)> + { }; + + template + struct __is_array_unknown_bounds + : public __and_, __not_>> + { }; +# 842 "/usr/include/c++/11/type_traits" 3 + struct __do_is_destructible_impl + { + template().~_Tp())> + static true_type __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_destructible_impl + : public __do_is_destructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_destructible_safe; + + template + struct __is_destructible_safe<_Tp, false, false> + : public __is_destructible_impl::type>::type + { }; + + template + struct __is_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_destructible + : public __is_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + + struct __do_is_nt_destructible_impl + { + template + static __bool_constant().~_Tp())> + __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_nt_destructible_impl + : public __do_is_nt_destructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __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 + struct __is_constructible_impl + : public __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>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template::value> + struct __is_copy_constructible_impl; + + template + struct __is_copy_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_copy_constructible_impl<_Tp, true> + : public __is_constructible_impl<_Tp, const _Tp&> + { }; + + + + template + struct is_copy_constructible + : public __is_copy_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::value> + struct __is_move_constructible_impl; + + template + struct __is_move_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_move_constructible_impl<_Tp, true> + : public __is_constructible_impl<_Tp, _Tp&&> + { }; + + + + template + struct is_move_constructible + : public __is_move_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_constructible_impl + = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>; + + + + template + struct is_nothrow_constructible + : public __is_nothrow_constructible_impl<_Tp, _Args...>::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_default_constructible + : public __bool_constant<__is_nothrow_constructible(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template::value> + struct __is_nothrow_copy_constructible_impl; + + template + struct __is_nothrow_copy_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_nothrow_copy_constructible_impl<_Tp, true> + : public __is_nothrow_constructible_impl<_Tp, const _Tp&> + { }; + + + + template + struct is_nothrow_copy_constructible + : public __is_nothrow_copy_constructible_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::value> + struct __is_nothrow_move_constructible_impl; + + template + struct __is_nothrow_move_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_nothrow_move_constructible_impl<_Tp, true> + : public __is_nothrow_constructible_impl<_Tp, _Tp&&> + { }; + + + + template + struct is_nothrow_move_constructible + : public __is_nothrow_move_constructible_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_assignable + : public __bool_constant<__is_assignable(_Tp, _Up)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + template::value> + struct __is_copy_assignable_impl; + + template + struct __is_copy_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_copy_assignable_impl<_Tp, true> + : public __bool_constant<__is_assignable(_Tp&, const _Tp&)> + { }; + + + template + struct is_copy_assignable + : public __is_copy_assignable_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::value> + struct __is_move_assignable_impl; + + template + struct __is_move_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_move_assignable_impl<_Tp, true> + : public __bool_constant<__is_assignable(_Tp&, _Tp&&)> + { }; + + + template + struct is_move_assignable + : public __is_move_assignable_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 + 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::value> + struct __is_nt_copy_assignable_impl; + + template + struct __is_nt_copy_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_nt_copy_assignable_impl<_Tp, true> + : public __is_nothrow_assignable_impl<_Tp&, const _Tp&> + { }; + + + template + struct is_nothrow_copy_assignable + : public __is_nt_copy_assignable_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + template::value> + struct __is_nt_move_assignable_impl; + + template + struct __is_nt_move_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_nt_move_assignable_impl<_Tp, true> + : public __is_nothrow_assignable_impl<_Tp&, _Tp&&> + { }; + + + template + struct is_nothrow_move_assignable + : public __is_nt_move_assignable_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_trivially_constructible + : public __bool_constant<__is_trivially_constructible(_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 __bool_constant<__is_trivially_constructible(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + struct __do_is_implicitly_default_constructible_impl + { + template + static void __helper(const _Tp&); + + template + static true_type __test(const _Tp&, + decltype(__helper({}))* = 0); + + static false_type __test(...); + }; + + template + struct __is_implicitly_default_constructible_impl + : public __do_is_implicitly_default_constructible_impl + { + typedef decltype(__test(declval<_Tp>())) type; + }; + + template + struct __is_implicitly_default_constructible_safe + : public __is_implicitly_default_constructible_impl<_Tp>::type + { }; + + template + struct __is_implicitly_default_constructible + : public __and_<__is_constructible_impl<_Tp>, + __is_implicitly_default_constructible_safe<_Tp>> + { }; + + template::value> + struct __is_trivially_copy_constructible_impl; + + template + struct __is_trivially_copy_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_trivially_copy_constructible_impl<_Tp, true> + : public __and_<__is_copy_constructible_impl<_Tp>, + integral_constant> + { }; + + + template + struct is_trivially_copy_constructible + : public __is_trivially_copy_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::value> + struct __is_trivially_move_constructible_impl; + + template + struct __is_trivially_move_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_trivially_move_constructible_impl<_Tp, true> + : public __and_<__is_move_constructible_impl<_Tp>, + integral_constant> + { }; + + + template + struct is_trivially_move_constructible + : public __is_trivially_move_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_trivially_assignable + : public __bool_constant<__is_trivially_assignable(_Tp, _Up)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + template::value> + struct __is_trivially_copy_assignable_impl; + + template + struct __is_trivially_copy_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_trivially_copy_assignable_impl<_Tp, true> + : public __bool_constant<__is_trivially_assignable(_Tp&, const _Tp&)> + { }; + + + template + struct is_trivially_copy_assignable + : public __is_trivially_copy_assignable_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + template::value> + struct __is_trivially_move_assignable_impl; + + template + struct __is_trivially_move_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_trivially_move_assignable_impl<_Tp, true> + : public __bool_constant<__is_trivially_assignable(_Tp&, _Tp&&)> + { }; + + + template + struct is_trivially_move_assignable + : public __is_trivially_move_assignable_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_trivially_destructible + : public __and_<__is_destructible_safe<_Tp>, + __bool_constant<__has_trivial_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 has_virtual_destructor + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct alignment_of + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct rank + : public integral_constant { }; + + template + struct rank<_Tp[_Size]> + : public integral_constant::value> { }; + + template + struct rank<_Tp[]> + : public integral_constant::value> { }; + + + template + struct extent + : public integral_constant { }; + + template + struct extent<_Tp[_Size], _Uint> + : public integral_constant::value> + { }; + + template + struct extent<_Tp[], _Uint> + : public integral_constant::value> + { }; + + + + + + template + struct is_same + + : public integral_constant + + + + { }; +# 1420 "/usr/include/c++/11/type_traits" 3 + template + struct is_base_of + : public integral_constant + { }; + + template, is_function<_To>, + is_array<_To>>::value> + struct __is_convertible_helper + { + typedef typename is_void<_To>::type type; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + template + class __is_convertible_helper<_From, _To, false> + { + template + static void __test_aux(_To1) noexcept; + + template(std::declval<_From1>()))> + static true_type + __test(int); + + template + static false_type + __test(...); + + public: + typedef decltype(__test<_From, _To>(0)) type; + }; +#pragma GCC diagnostic pop + + + template + struct is_convertible + : public __is_convertible_helper<_From, _To>::type + { }; + + + template + using __is_array_convertible + = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; + + template, is_function<_To>, + is_array<_To>>::value> + struct __is_nt_convertible_helper + : is_void<_To> + { }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + template + class __is_nt_convertible_helper<_From, _To, false> + { + template + static void __test_aux(_To1) noexcept; + + template + static + __bool_constant(std::declval<_From1>()))> + __test(int); + + template + static false_type + __test(...); + + public: + using type = decltype(__test<_From, _To>(0)); + }; +#pragma GCC diagnostic pop +# 1512 "/usr/include/c++/11/type_traits" 3 + template + struct remove_const + { typedef _Tp type; }; + + template + struct remove_const<_Tp const> + { typedef _Tp type; }; + + + template + struct remove_volatile + { typedef _Tp type; }; + + template + struct remove_volatile<_Tp volatile> + { typedef _Tp type; }; + + + template + struct remove_cv + { using type = _Tp; }; + + template + struct remove_cv + { using type = _Tp; }; + + template + struct remove_cv + { using type = _Tp; }; + + template + struct remove_cv + { using type = _Tp; }; + + + template + struct add_const + { typedef _Tp const type; }; + + + template + struct add_volatile + { typedef _Tp volatile type; }; + + + template + struct add_cv + { + typedef typename + add_const::type>::type type; + }; + + + + + + + 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 + { typedef _Tp type; }; + + template + struct remove_reference<_Tp&> + { typedef _Tp type; }; + + template + struct remove_reference<_Tp&&> + { typedef _Tp type; }; + + template::value> + struct __add_lvalue_reference_helper + { typedef _Tp type; }; + + template + struct __add_lvalue_reference_helper<_Tp, true> + { typedef _Tp& type; }; + + + template + struct add_lvalue_reference + : public __add_lvalue_reference_helper<_Tp> + { }; + + template::value> + struct __add_rvalue_reference_helper + { typedef _Tp type; }; + + template + struct __add_rvalue_reference_helper<_Tp, true> + { typedef _Tp&& type; }; + + + template + struct add_rvalue_reference + : public __add_rvalue_reference_helper<_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> + { typedef _Unqualified __type; }; + + template + struct __cv_selector<_Unqualified, false, true> + { typedef volatile _Unqualified __type; }; + + template + struct __cv_selector<_Unqualified, true, false> + { typedef const _Unqualified __type; }; + + template + struct __cv_selector<_Unqualified, true, true> + { typedef const volatile _Unqualified __type; }; + + template::value, + bool _IsVol = is_volatile<_Qualified>::value> + class __match_cv_qualifiers + { + typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match; + + public: + typedef typename __match::__type __type; + }; + + + template + struct __make_unsigned + { typedef _Tp __type; }; + + template<> + struct __make_unsigned + { typedef unsigned char __type; }; + + template<> + struct __make_unsigned + { typedef unsigned char __type; }; + + template<> + struct __make_unsigned + { typedef unsigned short __type; }; + + template<> + struct __make_unsigned + { typedef unsigned int __type; }; + + template<> + struct __make_unsigned + { typedef unsigned long __type; }; + + template<> + struct __make_unsigned + { typedef unsigned long long __type; }; + + + template<> + struct __make_unsigned<__int128> + { typedef unsigned __int128 __type; }; +# 1736 "/usr/include/c++/11/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + 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; + }; +# 1812 "/usr/include/c++/11/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 + { typedef typename __make_unsigned_selector<_Tp>::__type type; }; + + + template<> + struct make_unsigned; + + + + + template + struct __make_signed + { typedef _Tp __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed short __type; }; + + template<> + struct __make_signed + { typedef signed int __type; }; + + template<> + struct __make_signed + { typedef signed long __type; }; + + template<> + struct __make_signed + { typedef signed long long __type; }; + + + template<> + struct __make_signed + { typedef __int128 __type; }; +# 1892 "/usr/include/c++/11/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + 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> + { + typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type; + + public: + typedef typename __make_signed_selector<__unsigned_type>::__type __type; + }; + + + + + + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; +# 1940 "/usr/include/c++/11/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 + { typedef typename __make_signed_selector<_Tp>::__type type; }; + + + 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 + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[_Size]> + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[]> + { typedef _Tp type; }; + + + template + struct remove_all_extents + { typedef _Tp type; }; + + template + struct remove_all_extents<_Tp[_Size]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + template + struct remove_all_extents<_Tp[]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + + + template + using remove_extent_t = typename remove_extent<_Tp>::type; + + + template + using remove_all_extents_t = typename remove_all_extents<_Tp>::type; + + + + + template + struct __remove_pointer_helper + { typedef _Tp type; }; + + template + struct __remove_pointer_helper<_Tp, _Up*> + { typedef _Up type; }; + + + template + struct remove_pointer + : public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>> + { }; + + template, + is_void<_Tp>>::value> + struct __add_pointer_helper + { typedef _Tp type; }; + + template + struct __add_pointer_helper<_Tp, true> + { typedef typename remove_reference<_Tp>::type* type; }; + + + template + struct add_pointer + : public __add_pointer_helper<_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; + }; + }; +# 2076 "/usr/include/c++/11/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; + }; +# 2115 "/usr/include/c++/11/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; + + typedef typename aligned_storage<_S_len, alignment_value>::type type; + }; + + template + const size_t aligned_union<_Len, _Types...>::alignment_value; + + + + + + template::value, + bool _IsFunction = is_function<_Up>::value> + struct __decay_selector; + + + template + struct __decay_selector<_Up, false, false> + { typedef __remove_cv_t<_Up> __type; }; + + template + struct __decay_selector<_Up, true, false> + { typedef typename remove_extent<_Up>::type* __type; }; + + template + struct __decay_selector<_Up, false, true> + { typedef typename add_pointer<_Up>::type __type; }; + + + + template + class decay + { + typedef typename remove_reference<_Tp>::type __remove_type; + + public: + typedef typename __decay_selector<__remove_type>::__type type; + }; + + + + + template + struct __strip_reference_wrapper + { + typedef _Tp __type; + }; + + template + struct __strip_reference_wrapper > + { + typedef _Tp& __type; + }; + + + template + using __decay_t = typename decay<_Tp>::type; + + template + using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; + + + + + template + struct enable_if + { }; + + + template + struct enable_if + { typedef _Tp type; }; + + + + + template + using __enable_if_t = typename enable_if<_Cond, _Tp>::type; + + + template + using _Require = __enable_if_t<__and_<_Cond...>::value>; + + + template + using __remove_cvref_t + = typename remove_cv::type>::type; + + + + + template + struct conditional + { typedef _Iftrue type; }; + + + template + struct conditional + { typedef _Iffalse type; }; + + + template + struct common_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); +# 2255 "/usr/include/c++/11/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::value> + 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 + { + typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; + }; + + + struct __result_of_memfun_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_deref + : private __result_of_memfun_deref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; + }; + + + struct __result_of_memobj_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>() + ), __invoke_memobj_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_ref + : private __result_of_memobj_ref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + + struct __result_of_memobj_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>() + ), __invoke_memobj_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_deref + : private __result_of_memobj_deref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + template + struct __result_of_memobj; + + template + struct __result_of_memobj<_Res _Class::*, _Arg> + { + typedef __remove_cvref_t<_Arg> _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename conditional<__or_, + is_base_of<_Class, _Argval>>::value, + __result_of_memobj_ref<_MemPtr, _Arg>, + __result_of_memobj_deref<_MemPtr, _Arg> + >::type::type type; + }; + + template + struct __result_of_memfun; + + template + struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> + { + typedef typename remove_reference<_Arg>::type _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename conditional::value, + __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, + __result_of_memfun_deref<_MemPtr, _Arg, _Args...> + >::type::type type; + }; + + + + + + + template> + struct __inv_unwrap + { + using type = _Tp; + }; + + template + struct __inv_unwrap<_Tp, reference_wrapper<_Up>> + { + using type = _Up&; + }; + + template + struct __result_of_impl + { + typedef __failure_type type; + }; + + template + struct __result_of_impl + : public __result_of_memobj<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type> + { }; + + template + struct __result_of_impl + : public __result_of_memfun<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type, _Args...> + { }; + + + struct __result_of_other_impl + { + template + static __result_of_success()(std::declval<_Args>()...) + ), __invoke_other> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_impl + : private __result_of_other_impl + { + typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; + }; + + + template + struct __invoke_result + : public __result_of_impl< + is_member_object_pointer< + typename remove_reference<_Functor>::type + >::value, + is_member_function_pointer< + typename remove_reference<_Functor>::type + >::value, + _Functor, _ArgTypes... + >::type + { }; + + + template + struct result_of<_Functor(_ArgTypes...)> + : public __invoke_result<_Functor, _ArgTypes...> + { }; + + + + template::__type)> + using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; + + template + using aligned_union_t = typename aligned_union<_Len, _Types...>::type; + + + 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; + + + + + + template class _Op, typename... _Args> + struct __detector + { + using value_t = false_type; + using type = _Default; + }; + + + template class _Op, + typename... _Args> + struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> + { + using value_t = true_type; + using type = _Op<_Args...>; + }; + + + 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; +# 2649 "/usr/include/c++/11/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_impl> : true_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 + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_nothrow_swappable_impl + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_swappable + : public __is_swappable_impl<_Tp>::type + { }; + + template + struct __is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { }; + + + + + + + + template + struct is_swappable + : public __is_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_v = + 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 + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct __is_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + template + struct __is_nothrow_swappable_with_impl + : public __swappable_with_details::__do_is_nothrow_swappable_with_impl + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + + + template + struct is_swappable_with + : public __is_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable_with + : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_with_v = + is_swappable_with<_Tp, _Up>::value; + + + template + inline constexpr bool is_nothrow_swappable_with_v = + is_nothrow_swappable_with<_Tp, _Up>::value; +# 2876 "/usr/include/c++/11/type_traits" 3 + template::value, typename = void> + struct __is_invocable_impl + : false_type + { + using __nothrow_type = false_type; + }; + + + template + struct __is_invocable_impl<_Result, _Ret, + true, + __void_t> + : true_type + { + using __nothrow_type = true_type; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + + template + struct __is_invocable_impl<_Result, _Ret, + false, + __void_t> + { + private: + + + + static typename _Result::type _S_get() noexcept; + + template + static void _S_conv(_Tp) noexcept; + + + template(_S_get())), + bool _Noex = noexcept(_S_conv<_Tp>(_S_get()))> + static __bool_constant<_Check_Noex ? _Noex : true> + _S_test(int); + + template + static false_type + _S_test(...); + + public: + + using type = decltype(_S_test<_Ret>(1)); + + + using __nothrow_type = decltype(_S_test<_Ret, true>(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_type; + + + + 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"); + }; +# 3094 "/usr/include/c++/11/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>::value; +template + inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; +template + inline constexpr bool is_lvalue_reference_v = + is_lvalue_reference<_Tp>::value; +template + inline constexpr bool is_rvalue_reference_v = + is_rvalue_reference<_Tp>::value; +template + inline constexpr bool is_member_object_pointer_v = + is_member_object_pointer<_Tp>::value; +template + inline constexpr bool is_member_function_pointer_v = + is_member_function_pointer<_Tp>::value; +template + inline constexpr bool is_enum_v = is_enum<_Tp>::value; +template + inline constexpr bool is_union_v = is_union<_Tp>::value; +template + inline constexpr bool is_class_v = is_class<_Tp>::value; +template + inline constexpr bool is_function_v = is_function<_Tp>::value; +template + inline constexpr bool is_reference_v = is_reference<_Tp>::value; +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>::value; +template + inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; +template + inline constexpr bool is_compound_v = is_compound<_Tp>::value; +template + inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; +template + inline constexpr bool is_const_v = is_const<_Tp>::value; +template + inline constexpr bool is_volatile_v = is_volatile<_Tp>::value; +template + inline constexpr bool is_trivial_v = is_trivial<_Tp>::value; +template + inline constexpr bool is_trivially_copyable_v = + is_trivially_copyable<_Tp>::value; +template + inline constexpr bool is_standard_layout_v = is_standard_layout<_Tp>::value; +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +template + + inline constexpr bool is_pod_v = is_pod<_Tp>::value; +template + [[__deprecated__]] + inline constexpr bool is_literal_type_v = is_literal_type<_Tp>::value; +#pragma GCC diagnostic pop + template + inline constexpr bool is_empty_v = is_empty<_Tp>::value; +template + inline constexpr bool is_polymorphic_v = is_polymorphic<_Tp>::value; +template + inline constexpr bool is_abstract_v = is_abstract<_Tp>::value; +template + inline constexpr bool is_final_v = is_final<_Tp>::value; +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...>::value; +template + inline constexpr bool is_default_constructible_v = + is_default_constructible<_Tp>::value; +template + inline constexpr bool is_copy_constructible_v = + is_copy_constructible<_Tp>::value; +template + inline constexpr bool is_move_constructible_v = + is_move_constructible<_Tp>::value; +template + inline constexpr bool is_assignable_v = is_assignable<_Tp, _Up>::value; +template + inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value; +template + inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value; +template + inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; +template + inline constexpr bool is_trivially_constructible_v = + is_trivially_constructible<_Tp, _Args...>::value; +template + inline constexpr bool is_trivially_default_constructible_v = + is_trivially_default_constructible<_Tp>::value; +template + inline constexpr bool is_trivially_copy_constructible_v = + is_trivially_copy_constructible<_Tp>::value; +template + inline constexpr bool is_trivially_move_constructible_v = + is_trivially_move_constructible<_Tp>::value; +template + inline constexpr bool is_trivially_assignable_v = + is_trivially_assignable<_Tp, _Up>::value; +template + inline constexpr bool is_trivially_copy_assignable_v = + is_trivially_copy_assignable<_Tp>::value; +template + inline constexpr bool is_trivially_move_assignable_v = + is_trivially_move_assignable<_Tp>::value; +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...>::value; +template + inline constexpr bool is_nothrow_default_constructible_v = + is_nothrow_default_constructible<_Tp>::value; +template + inline constexpr bool is_nothrow_copy_constructible_v = + is_nothrow_copy_constructible<_Tp>::value; +template + inline constexpr bool is_nothrow_move_constructible_v = + is_nothrow_move_constructible<_Tp>::value; +template + inline constexpr bool is_nothrow_assignable_v = + is_nothrow_assignable<_Tp, _Up>::value; +template + inline constexpr bool is_nothrow_copy_assignable_v = + is_nothrow_copy_assignable<_Tp>::value; +template + inline constexpr bool is_nothrow_move_assignable_v = + is_nothrow_move_assignable<_Tp>::value; +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>::value; +template + inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; +template + inline constexpr size_t rank_v = rank<_Tp>::value; +template + inline constexpr size_t extent_v = extent<_Tp, _Idx>::value; + +template + inline constexpr bool is_same_v = __is_same(_Tp, _Up); + + + + +template + inline constexpr bool is_base_of_v = is_base_of<_Base, _Derived>::value; +template + inline constexpr bool is_convertible_v = is_convertible<_From, _To>::value; +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<_Tp>::value; +# 3598 "/usr/include/c++/11/type_traits" 3 + +} +# 58 "/usr/include/c++/11/bits/move.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 74 "/usr/include/c++/11/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Tp&&>(__t); } + + + + + + + + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type&& __t) noexcept + { + static_assert(!std::is_lvalue_reference<_Tp>::value, + "std::forward must not be used to convert an rvalue to an lvalue"); + return static_cast<_Tp&&>(__t); + } + + + + + + + template + [[__nodiscard__]] + constexpr typename std::remove_reference<_Tp>::type&& + move(_Tp&& __t) noexcept + { return static_cast::type&&>(__t); } + + + template + struct __move_if_noexcept_cond + : public __and_<__not_>, + is_copy_constructible<_Tp>>::type { }; +# 121 "/usr/include/c++/11/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr typename + conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type + move_if_noexcept(_Tp& __x) noexcept + { return std::move(__x); } +# 142 "/usr/include/c++/11/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; + } +# 186 "/usr/include/c++/11/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]); + } + + + +} +# 60 "/usr/include/c++/11/bits/stl_pair.h" 2 3 +# 69 "/usr/include/c++/11/bits/stl_pair.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 80 "/usr/include/c++/11/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 + class tuple; + + template + struct _Index_tuple; + + + + + + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return __and_, + is_constructible<_T2, const _U2&>>::value; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return __and_, + is_convertible>::value; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return __and_, + is_constructible<_T2, _U2&&>>::value; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return __and_, + is_convertible<_U2&&, _T2>>::value; + } + + template + static constexpr bool _CopyMovePair() + { + using __do_converts = __and_, + is_convertible<_U2&&, _T2>>; + using __converts = typename conditional<__implicit, + __do_converts, + __not_<__do_converts>>::type; + return __and_, + is_constructible<_T2, _U2&&>, + __converts + >::value; + } + + template + static constexpr bool _MoveCopyPair() + { + using __do_converts = __and_, + is_convertible>; + using __converts = typename conditional<__implicit, + __do_converts, + __not_<__do_converts>>::type; + return __and_, + is_constructible<_T2, const _U2&&>, + __converts + >::value; + } + }; + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return false; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return false; + } + }; + + + template class __pair_base + { + + template friend struct pair; + __pair_base() = default; + ~__pair_base() = default; + __pair_base(const __pair_base&) = default; + __pair_base& operator=(const __pair_base&) = delete; + + }; +# 210 "/usr/include/c++/11/bits/stl_pair.h" 3 + template + struct pair + : private __pair_base<_T1, _T2> + { + typedef _T1 first_type; + typedef _T2 second_type; + + _T1 first; + _T2 second; + + + + + + + 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() { } +# 256 "/usr/include/c++/11/bits/stl_pair.h" 3 + 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) { } +# 288 "/usr/include/c++/11/bits/stl_pair.h" 3 + 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) { } + + + + constexpr pair(const pair&) = default; + constexpr pair(pair&&) = default; + + + template(), + bool>::type=true> + constexpr pair(_U1&& __x, const _T2& __y) + : first(std::forward<_U1>(__x)), second(__y) { } + + template(), + bool>::type=false> + explicit constexpr pair(_U1&& __x, const _T2& __y) + : first(std::forward<_U1>(__x)), second(__y) { } + + template(), + bool>::type=true> + constexpr pair(const _T1& __x, _U2&& __y) + : first(__x), second(std::forward<_U2>(__y)) { } + + template(), + bool>::type=false> + explicit pair(const _T1& __x, _U2&& __y) + : first(__x), 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)) { } + + template + + pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); + + pair& + operator=(typename conditional< + __and_, + is_copy_assignable<_T2>>::value, + const pair&, const __nonesuch&>::type __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + pair& + operator=(typename conditional< + __and_, + is_move_assignable<_T2>>::value, + pair&&, __nonesuch&&>::type __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; + } + + + 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); + } + + private: + template + + pair(tuple<_Args1...>&, tuple<_Args2...>&, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); + + }; + + + + + template pair(_T1, _T2) -> pair<_T1, _T2>; + + + + template + inline constexpr bool + operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first == __y.first && __x.second == __y.second; } +# 487 "/usr/include/c++/11/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); } +# 524 "/usr/include/c++/11/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); } + + + template + typename enable_if, + __is_swappable<_T2>>::value>::type + swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete; +# 564 "/usr/include/c++/11/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)); + } +# 583 "/usr/include/c++/11/bits/stl_pair.h" 3 + +} +# 65 "/usr/include/c++/11/bits/stl_algobase.h" 2 3 +# 1 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 1 3 +# 62 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 3 + +# 63 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 3 +# 74 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 93 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 3 + struct input_iterator_tag { }; + + + struct output_iterator_tag { }; + + + struct forward_iterator_tag : public input_iterator_tag { }; + + + + struct bidirectional_iterator_tag : public forward_iterator_tag { }; + + + + struct random_access_iterator_tag : public bidirectional_iterator_tag { }; +# 125 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 3 + template + struct iterator + { + + typedef _Category iterator_category; + + typedef _Tp value_type; + + typedef _Distance difference_type; + + typedef _Pointer pointer; + + typedef _Reference reference; + }; +# 149 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits; + + + + + template> + struct __iterator_traits { }; + + + + template + struct __iterator_traits<_Iterator, + __void_t> + { + typedef typename _Iterator::iterator_category iterator_category; + typedef typename _Iterator::value_type value_type; + typedef typename _Iterator::difference_type difference_type; + typedef typename _Iterator::pointer pointer; + typedef typename _Iterator::reference reference; + }; + + + template + struct iterator_traits + : public __iterator_traits<_Iterator> { }; +# 209 "/usr/include/c++/11/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 + inline constexpr + typename iterator_traits<_Iter>::iterator_category + __iterator_category(const _Iter&) + { return typename iterator_traits<_Iter>::iterator_category(); } + + + + + template + using __iterator_category_t + = typename iterator_traits<_Iter>::iterator_category; + + template + using _RequireInputIter = + __enable_if_t, + input_iterator_tag>::value>; + + template> + struct __is_random_access_iter + : is_base_of + { + typedef is_base_of _Base; + enum { __value = _Base::value }; + }; + + + + + + + + +} +# 66 "/usr/include/c++/11/bits/stl_algobase.h" 2 3 +# 1 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 1 3 +# 62 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 3 + +# 63 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 3 + +# 1 "/usr/include/c++/11/bits/concept_check.h" 1 3 +# 33 "/usr/include/c++/11/bits/concept_check.h" 3 + +# 34 "/usr/include/c++/11/bits/concept_check.h" 3 +# 65 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 2 3 +# 1 "/usr/include/c++/11/debug/assertions.h" 1 3 +# 66 "/usr/include/c++/11/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 + 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); +# 135 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 3 + template + 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 (__builtin_is_constant_evaluated() && !bool(__n >= 0)) __builtin_unreachable(); } 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; + } +# 200 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 3 + template + 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 + inline constexpr _InputIterator + next(_InputIterator __x, typename + iterator_traits<_InputIterator>::difference_type __n = 1) + { + + + std::advance(__x, __n); + return __x; + } + + template + inline constexpr _BidirectionalIterator + prev(_BidirectionalIterator __x, typename + iterator_traits<_BidirectionalIterator>::difference_type __n = 1) + { + + + + std::advance(__x, -__n); + return __x; + } + + + + +} +# 67 "/usr/include/c++/11/bits/stl_algobase.h" 2 3 +# 1 "/usr/include/c++/11/bits/stl_iterator.h" 1 3 +# 67 "/usr/include/c++/11/bits/stl_iterator.h" 3 +# 1 "/usr/include/c++/11/bits/ptr_traits.h" 1 3 +# 42 "/usr/include/c++/11/bits/ptr_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + class __undefined; + + + template + struct __replace_first_arg + { }; + + template class _Template, typename _Up, + typename _Tp, typename... _Types> + struct __replace_first_arg<_Template<_Tp, _Types...>, _Up> + { using type = _Template<_Up, _Types...>; }; + + template + using __replace_first_arg_t = typename __replace_first_arg<_Tp, _Up>::type; + + template + using __make_not_void + = typename conditional::value, __undefined, _Tp>::type; + + template + struct __ptr_traits_elem_1 + { }; + + template class _SomePointer, typename _Tp, + typename... _Args> + struct __ptr_traits_elem_1<_SomePointer<_Tp, _Args...>> + { + using element_type = _Tp; + using pointer = _SomePointer<_Tp, _Args...>; + + static pointer + pointer_to(__make_not_void& __e) + { return pointer::pointer_to(__e); } + }; + + template + struct __ptr_traits_elem : __ptr_traits_elem_1<_Ptr> + { }; + + template + struct __ptr_traits_elem<_Ptr, __void_t> + { + using element_type = typename _Ptr::element_type; + + static _Ptr + pointer_to(__make_not_void& __e) + { return _Ptr::pointer_to(__e); } + }; + + + + + + template + struct pointer_traits : __ptr_traits_elem<_Ptr> + { + private: + template + using __difference_type = typename _Tp::difference_type; + + template + struct __rebind : __replace_first_arg<_Tp, _Up> { }; + + template + struct __rebind<_Tp, _Up, __void_t>> + { using type = typename _Tp::template rebind<_Up>; }; + + public: + + using pointer = _Ptr; + + + using difference_type + = __detected_or_t; + + + template + using rebind = typename __rebind<_Ptr, _Up>::type; + }; + + + + + + template + struct pointer_traits<_Tp*> + { + + typedef _Tp* pointer; + + typedef _Tp element_type; + + typedef ptrdiff_t difference_type; + + template + using rebind = _Up*; + + + + + + + static pointer + pointer_to(__make_not_void& __r) noexcept + { return std::addressof(__r); } + }; + + + 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->()); } +# 214 "/usr/include/c++/11/bits/ptr_traits.h" 3 + +} +# 68 "/usr/include/c++/11/bits/stl_iterator.h" 2 3 +# 88 "/usr/include/c++/11/bits/stl_iterator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 127 "/usr/include/c++/11/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; +# 146 "/usr/include/c++/11/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; +# 177 "/usr/include/c++/11/bits/stl_iterator.h" 3 + constexpr + reverse_iterator() : current() { } + + + + + explicit constexpr + reverse_iterator(iterator_type __x) : current(__x) { } + + + + + constexpr + reverse_iterator(const reverse_iterator& __x) + : current(__x.current) { } + + + reverse_iterator& operator=(const reverse_iterator&) = default; + + + + + + + template + + + + constexpr + reverse_iterator(const reverse_iterator<_Iter>& __x) + : current(__x.current) { } + + + template + + + + + constexpr + reverse_iterator& + operator=(const reverse_iterator<_Iter>& __x) + { + current = __x.current; + return *this; + } + + + + + + constexpr iterator_type + base() const + { return current; } +# 241 "/usr/include/c++/11/bits/stl_iterator.h" 3 + constexpr reference + operator*() const + { + _Iterator __tmp = current; + return *--__tmp; + } + + + + + + + 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; + } + + + + + + + constexpr reverse_iterator + operator+(difference_type __n) const + { return reverse_iterator(current - __n); } + + + + + + + + constexpr reverse_iterator& + operator+=(difference_type __n) + { + current -= __n; + return *this; + } + + + + + + + constexpr reverse_iterator + operator-(difference_type __n) const + { return reverse_iterator(current + __n); } + + + + + + + + constexpr reverse_iterator& + operator-=(difference_type __n) + { + current += __n; + return *this; + } + + + + + + + constexpr reference + operator[](difference_type __n) const + { return *(*this + __n); } +# 395 "/usr/include/c++/11/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->(); } + }; +# 418 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + inline constexpr bool + operator==(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } + + template + inline constexpr bool + operator<(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y.base() < __x.base(); } + + template + inline constexpr bool + operator!=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + inline constexpr bool + operator>(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y < __x; } + + template + inline constexpr bool + operator<=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + inline constexpr bool + operator>=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + + template + 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 + 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 + 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(); } +# 575 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + 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 + 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 + inline constexpr reverse_iterator<_Iterator> + make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } +# 616 "/usr/include/c++/11/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())); } +# 647 "/usr/include/c++/11/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)) { } +# 687 "/usr/include/c++/11/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; + } + + + + + back_insert_iterator& + operator*() + { return *this; } + + + + back_insert_iterator& + operator++() + { return *this; } + + + + back_insert_iterator + operator++(int) + { return *this; } + }; +# 734 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + + inline back_insert_iterator<_Container> + back_inserter(_Container& __x) + { return back_insert_iterator<_Container>(__x); } +# 750 "/usr/include/c++/11/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)) { } +# 790 "/usr/include/c++/11/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; + } + + + + + front_insert_iterator& + operator*() + { return *this; } + + + + front_insert_iterator& + operator++() + { return *this; } + + + + front_insert_iterator + operator++(int) + { return *this; } + }; +# 837 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + + inline front_insert_iterator<_Container> + front_inserter(_Container& __x) + { return front_insert_iterator<_Container>(__x); } +# 857 "/usr/include/c++/11/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; +# 889 "/usr/include/c++/11/bits/stl_iterator.h" 3 + + insert_iterator(_Container& __x, _Iter __i) + : container(std::__addressof(__x)), iter(__i) {} +# 925 "/usr/include/c++/11/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; + } + + + + + insert_iterator& + operator*() + { return *this; } + + + + insert_iterator& + operator++() + { return *this; } + + + + insert_iterator& + operator++(int) + { return *this; } + }; +# 981 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + inline insert_iterator<_Container> + inserter(_Container& __x, typename _Container::iterator __i) + { return insert_iterator<_Container>(__x, __i); } + + + + + +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 1003 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + class __normal_iterator + { + protected: + _Iterator _M_current; + + typedef std::iterator_traits<_Iterator> __traits_type; + + 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, + typename __enable_if< + (std::__are_same<_Iter, typename _Container::pointer>::__value), + _Container>::__type>& __i) noexcept + : _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; } + }; +# 1152 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + + inline bool + operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + + inline bool + operator==(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + + inline bool + operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + template + + inline bool + operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + + template + inline bool + operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + + inline bool + operator<(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + inline bool + operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + + inline bool + operator>(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + inline bool + operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + + inline bool + operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + inline bool + operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + template + + inline bool + operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + + + + + + template + + + + 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 + + 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 + + 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(); } +# 1342 "/usr/include/c++/11/bits/stl_iterator.h" 3 + namespace __detail + { +# 1358 "/usr/include/c++/11/bits/stl_iterator.h" 3 + } +# 1369 "/usr/include/c++/11/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; +# 1408 "/usr/include/c++/11/bits/stl_iterator.h" 3 + public: + using iterator_type = _Iterator; +# 1422 "/usr/include/c++/11/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; + + + typedef typename conditional::value, + typename remove_reference<__base_ref>::type&&, + __base_ref>::type reference; + + + 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; + } + + + constexpr iterator_type + base() const + { return _M_current; } +# 1476 "/usr/include/c++/11/bits/stl_iterator.h" 3 + constexpr reference + operator*() const + + + + { return static_cast(*_M_current); } + + + 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; + } + + 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; + } + + 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; + } + + constexpr reference + operator[](difference_type __n) const + + + + { return std::move(_M_current[__n]); } +# 1581 "/usr/include/c++/11/bits/stl_iterator.h" 3 + }; + + template + inline constexpr bool + operator==(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() == __y.base(); } +# 1600 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + inline constexpr bool + operator!=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return !(__x == __y); } + + + template + inline constexpr bool + operator<(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() < __y.base(); } + + template + inline constexpr bool + operator<=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__y < __x); } + + template + inline constexpr bool + operator>(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __y < __x; } + + template + inline constexpr bool + operator>=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__x < __y); } + + + + + template + inline constexpr bool + operator==(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } +# 1659 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + inline constexpr bool + operator!=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + inline constexpr bool + operator<(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() < __y.base(); } + + template + inline constexpr bool + operator<=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + inline constexpr bool + operator>(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __y < __x; } + + template + inline constexpr bool + operator>=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + template + 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 + inline constexpr move_iterator<_Iterator> + operator+(typename move_iterator<_Iterator>::difference_type __n, + const move_iterator<_Iterator>& __x) + { return __x + __n; } + + template + 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>>::type> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Iterator __i) + { return _ReturnType(__i); } + + + + template::value, + const _Tp*, move_iterator<_Tp*>>::type> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Tp* __i) + { return _ReturnType(__i); } +# 2447 "/usr/include/c++/11/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()); } +# 2479 "/usr/include/c++/11/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/include/c++/11/bits/stl_algobase.h" 2 3 + +# 1 "/usr/include/c++/11/debug/debug.h" 1 3 +# 48 "/usr/include/c++/11/debug/debug.h" 3 +namespace std +{ + namespace __debug { } +} + + + + +namespace __gnu_debug +{ + using namespace std::__debug; + + template + struct _Safe_iterator; +} +# 70 "/usr/include/c++/11/bits/stl_algobase.h" 2 3 + +# 1 "/usr/include/c++/11/bits/predefined_ops.h" 1 3 +# 35 "/usr/include/c++/11/bits/predefined_ops.h" 3 +namespace __gnu_cxx +{ +namespace __ops +{ + struct _Iter_less_iter + { + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 < *__it2; } + }; + + constexpr + inline _Iter_less_iter + __iter_less_iter() + { return _Iter_less_iter(); } + + struct _Iter_less_val + { + + constexpr _Iter_less_val() = default; + + + + + + explicit + _Iter_less_val(_Iter_less_iter) { } + + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it < __val; } + }; + + + inline _Iter_less_val + __iter_less_val() + { return _Iter_less_val(); } + + + inline _Iter_less_val + __iter_comp_val(_Iter_less_iter) + { return _Iter_less_val(); } + + struct _Val_less_iter + { + + constexpr _Val_less_iter() = default; + + + + + + explicit + _Val_less_iter(_Iter_less_iter) { } + + template + + bool + operator()(_Value& __val, _Iterator __it) const + { return __val < *__it; } + }; + + + inline _Val_less_iter + __val_less_iter() + { return _Val_less_iter(); } + + + inline _Val_less_iter + __val_comp_iter(_Iter_less_iter) + { return _Val_less_iter(); } + + struct _Iter_equal_to_iter + { + template + + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 == *__it2; } + }; + + + inline _Iter_equal_to_iter + __iter_equal_to_iter() + { return _Iter_equal_to_iter(); } + + struct _Iter_equal_to_val + { + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it == __val; } + }; + + + inline _Iter_equal_to_val + __iter_equal_to_val() + { return _Iter_equal_to_val(); } + + + inline _Iter_equal_to_val + __iter_comp_val(_Iter_equal_to_iter) + { return _Iter_equal_to_val(); } + + template + struct _Iter_comp_iter + { + _Compare _M_comp; + + explicit constexpr + _Iter_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) + { return bool(_M_comp(*__it1, *__it2)); } + }; + + template + constexpr + inline _Iter_comp_iter<_Compare> + __iter_comp_iter(_Compare __comp) + { return _Iter_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_comp_val + { + _Compare _M_comp; + + + explicit + _Iter_comp_val(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Iterator __it, _Value& __val) + { return bool(_M_comp(*__it, __val)); } + }; + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Compare __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Iter_comp_iter<_Compare> __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + struct _Val_comp_iter + { + _Compare _M_comp; + + + explicit + _Val_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Value& __val, _Iterator __it) + { return bool(_M_comp(__val, *__it)); } + }; + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Compare __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Iter_comp_iter<_Compare> __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_equals_val + { + _Value& _M_value; + + + explicit + _Iter_equals_val(_Value& __value) + : _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return *__it == _M_value; } + }; + + template + + inline _Iter_equals_val<_Value> + __iter_equals_val(_Value& __val) + { return _Iter_equals_val<_Value>(__val); } + + template + struct _Iter_equals_iter + { + _Iterator1 _M_it1; + + + explicit + _Iter_equals_iter(_Iterator1 __it1) + : _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return *__it2 == *_M_it1; } + }; + + template + + inline _Iter_equals_iter<_Iterator> + __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) + { return _Iter_equals_iter<_Iterator>(__it); } + + template + struct _Iter_pred + { + _Predicate _M_pred; + + + explicit + _Iter_pred(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_pred<_Predicate> + __pred_iter(_Predicate __pred) + { return _Iter_pred<_Predicate>(std::move(__pred)); } + + template + struct _Iter_comp_to_val + { + _Compare _M_comp; + _Value& _M_value; + + + _Iter_comp_to_val(_Compare __comp, _Value& __value) + : _M_comp(std::move(__comp)), _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_comp(*__it, _M_value)); } + }; + + template + _Iter_comp_to_val<_Compare, _Value> + + __iter_comp_val(_Compare __comp, _Value &__val) + { + return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val); + } + + template + struct _Iter_comp_to_iter + { + _Compare _M_comp; + _Iterator1 _M_it1; + + + _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) + : _M_comp(std::move(__comp)), _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return bool(_M_comp(*__it2, *_M_it1)); } + }; + + template + + inline _Iter_comp_to_iter<_Compare, _Iterator> + __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) + { + return _Iter_comp_to_iter<_Compare, _Iterator>( + std::move(__comp._M_comp), __it); + } + + template + struct _Iter_negate + { + _Predicate _M_pred; + + + explicit + _Iter_negate(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return !bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_negate<_Predicate> + __negate(_Iter_pred<_Predicate> __pred) + { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } + +} +} +# 72 "/usr/include/c++/11/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"); +# 105 "/usr/include/c++/11/bits/stl_algobase.h" 3 + return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); + } +# 149 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline void + iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) + { + + + + +# 182 "/usr/include/c++/11/bits/stl_algobase.h" 3 + swap(*__a, *__b); + + } +# 198 "/usr/include/c++/11/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; + } +# 227 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b) + { + + + + if (__b < __a) + return __b; + return __a; + } +# 251 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b) + { + + + + if (__a < __b) + return __b; + return __a; + } +# 275 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__b, __a)) + return __b; + return __a; + } +# 297 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__a, __b)) + return __b; + return __a; + } + + + + template + + inline _Iterator + __niter_base(_Iterator __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it; } + + template + _Ite + __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, + std::random_access_iterator_tag>&); + + + + + template + + inline _From + __niter_wrap(_From __from, _To __res) + { return __from + (__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<> + 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 + struct __copy_move<_IsMove, true, random_access_iterator_tag> + { + template + + static _Tp* + __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result) + { + + using __assignable = conditional<_IsMove, + is_move_assignable<_Tp>, + is_copy_assignable<_Tp>>; + + static_assert( __assignable::type::value, "type is not assignable" ); + + const ptrdiff_t _Num = __last - __first; + if (_Num) + __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); + 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); +# 608 "/usr/include/c++/11/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); + } +# 641 "/usr/include/c++/11/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 _Tp* + __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result) + { + + using __assignable = conditional<_IsMove, + is_move_assignable<_Tp>, + is_copy_assignable<_Tp>>; + + static_assert( __assignable::type::value, "type is not assignable" ); + + const ptrdiff_t _Num = __last - __first; + if (_Num) + __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); + 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>&); +# 845 "/usr/include/c++/11/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); + } +# 881 "/usr/include/c++/11/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; +# 943 "/usr/include/c++/11/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&); +# 989 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline void + fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) + { + + + + ; + + std::__fill_a(__first, __last, __value); + } + + + inline constexpr int + __size_to_integer(int __n) { return __n; } + inline constexpr unsigned + __size_to_integer(unsigned __n) { return __n; } + inline constexpr long + __size_to_integer(long __n) { return __n; } + inline constexpr unsigned long + __size_to_integer(unsigned long __n) { return __n; } + inline constexpr long long + __size_to_integer(long long __n) { return __n; } + inline constexpr unsigned long long + __size_to_integer(unsigned long long __n) { return __n; } + + + inline constexpr __int128 + __size_to_integer(__int128 __n) { return __n; } + inline constexpr unsigned __int128 + __size_to_integer(unsigned __int128 __n) { return __n; } +# 1041 "/usr/include/c++/11/bits/stl_algobase.h" 3 + inline constexpr long long + __size_to_integer(float __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(double __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(long double __n) { return (long long)__n; } + + + + + + template + + 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; + } +# 1141 "/usr/include/c++/11/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; + } +# 1487 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline _ForwardIterator + lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + + + + + ; + + return std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val()); + } + + + + inline constexpr int + __lg(int __n) + { return (int)sizeof(int) * 8 - 1 - __builtin_clz(__n); } + + inline constexpr unsigned + __lg(unsigned __n) + { return (int)sizeof(int) * 8 - 1 - __builtin_clz(__n); } + + inline constexpr long + __lg(long __n) + { return (int)sizeof(long) * 8 - 1 - __builtin_clzl(__n); } + + inline constexpr unsigned long + __lg(unsigned long __n) + { return (int)sizeof(long) * 8 - 1 - __builtin_clzl(__n); } + + inline constexpr long long + __lg(long long __n) + { return (int)sizeof(long long) * 8 - 1 - __builtin_clzll(__n); } + + inline constexpr unsigned long long + __lg(unsigned long long __n) + { return (int)sizeof(long long) * 8 - 1 - __builtin_clzll(__n); } + + +# 1543 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + + + + + + + ; + + return std::__equal_aux(__first1, __last1, __first2); + } +# 1574 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + 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; + } + + + + 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 (_RAIters()) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + return std::equal(__first1, __last1, __first2); + } + + 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 (_RAIters()) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + return std::equal(__first1, __last1, __first2, + __binary_pred); + } + + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return __first1 == __last1 && __first2 == __last2; + } +# 1664 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + + + + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2); + } +# 1697 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2, + __binary_pred); + } +# 1729 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + + + + + + + + + + ; + ; + + return std::__lexicographical_compare_aux(__first1, __last1, + __first2, __last2); + } +# 1764 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + 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)); + } +# 1877 "/usr/include/c++/11/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); + } +# 1905 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2) + { + + + + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 1939 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + 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); + } +# 1988 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + 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()); + } +# 2024 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + 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 + + 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; + } +# 2181 "/usr/include/c++/11/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()); + } + + + +} +# 46 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/limits" 1 3 +# 40 "/usr/include/c++/11/limits" 3 + +# 41 "/usr/include/c++/11/limits" 3 +# 158 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/limits" 3 + template + struct numeric_limits : public __numeric_limits_base + { + + + static constexpr _Tp + min() noexcept { return _Tp(); } + + + static constexpr _Tp + max() noexcept { return _Tp(); } + + + + + static constexpr _Tp + lowest() noexcept { return _Tp(); } + + + + + static constexpr _Tp + epsilon() noexcept { return _Tp(); } + + + static constexpr _Tp + round_error() noexcept { return _Tp(); } + + + static constexpr _Tp + infinity() noexcept { return _Tp(); } + + + + static constexpr _Tp + quiet_NaN() noexcept { return _Tp(); } + + + + static constexpr _Tp + signaling_NaN() noexcept { return _Tp(); } + + + + + static constexpr _Tp + denorm_min() noexcept { return _Tp(); } + }; + + + + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; +# 383 "/usr/include/c++/11/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/include/c++/11/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; + }; +# 1635 "/usr/include/c++/11/limits" 3 + 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; }; 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; }; +# 1667 "/usr/include/c++/11/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; + }; + + + + + + +} +# 47 "/usr/include/c++/11/bits/specfun.h" 2 3 + + +# 1 "/usr/include/c++/11/tr1/gamma.tcc" 1 3 +# 49 "/usr/include/c++/11/tr1/gamma.tcc" 3 +# 1 "/usr/include/c++/11/tr1/special_function_util.h" 1 3 +# 39 "/usr/include/c++/11/tr1/special_function_util.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 50 "/usr/include/c++/11/tr1/special_function_util.h" 3 + namespace __detail + { + + + + template + struct __floating_point_constant + { + static const _Tp __value; + }; + + + + template + struct __numeric_constants + { + + static _Tp __pi() throw() + { return static_cast<_Tp>(3.1415926535897932384626433832795029L); } + + static _Tp __pi_2() throw() + { return static_cast<_Tp>(1.5707963267948966192313216916397514L); } + + static _Tp __pi_3() throw() + { return static_cast<_Tp>(1.0471975511965977461542144610931676L); } + + static _Tp __pi_4() throw() + { return static_cast<_Tp>(0.7853981633974483096156608458198757L); } + + static _Tp __1_pi() throw() + { return static_cast<_Tp>(0.3183098861837906715377675267450287L); } + + static _Tp __2_sqrtpi() throw() + { return static_cast<_Tp>(1.1283791670955125738961589031215452L); } + + static _Tp __sqrt2() throw() + { return static_cast<_Tp>(1.4142135623730950488016887242096981L); } + + static _Tp __sqrt3() throw() + { return static_cast<_Tp>(1.7320508075688772935274463415058723L); } + + static _Tp __sqrtpio2() throw() + { return static_cast<_Tp>(1.2533141373155002512078826424055226L); } + + static _Tp __sqrt1_2() throw() + { return static_cast<_Tp>(0.7071067811865475244008443621048490L); } + + static _Tp __lnpi() throw() + { return static_cast<_Tp>(1.1447298858494001741434273513530587L); } + + static _Tp __gamma_e() throw() + { return static_cast<_Tp>(0.5772156649015328606065120900824024L); } + + static _Tp __euler() throw() + { return static_cast<_Tp>(2.7182818284590452353602874713526625L); } + }; +# 114 "/usr/include/c++/11/tr1/special_function_util.h" 3 + template + inline bool __isnan(_Tp __x) + { return std::isnan(__x); } +# 133 "/usr/include/c++/11/tr1/special_function_util.h" 3 + } + + + + + +} +# 50 "/usr/include/c++/11/tr1/gamma.tcc" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/include/c++/11/tr1/gamma.tcc" 3 + namespace __detail + { +# 76 "/usr/include/c++/11/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/include/c++/11/tr1/gamma.tcc" 3 + template + inline _Tp + __bernoulli(int __n) + { return __bernoulli_series<_Tp>(__n); } +# 153 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/gamma.tcc" 3 + template + inline _Tp + __gamma(_Tp __x) + { return std::exp(__log_gamma(__x)); } +# 356 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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; + } + } + } + + + + + + +} +# 50 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/bessel_function.tcc" 1 3 +# 55 "/usr/include/c++/11/tr1/bessel_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 71 "/usr/include/c++/11/tr1/bessel_function.tcc" 3 + namespace __detail + { +# 98 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_bessel_j(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_j.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x * __x < _Tp(10) * (__nu + _Tp(1))) + return __cyl_bessel_ij_series(__nu, __x, -_Tp(1), 200); + else if (__x > _Tp(1000)) + { + _Tp __J_nu, __N_nu; + __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); + return __J_nu; + } + else + { + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + return __J_nu; + } + } +# 532 "/usr/include/c++/11/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_neumann_n(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_neumann_n.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x > _Tp(1000)) + { + _Tp __J_nu, __N_nu; + __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); + return __N_nu; + } + else + { + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + return __N_nu; + } + } +# 569 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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; + } + } + } + + + + + + +} +# 51 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/beta_function.tcc" 1 3 +# 49 "/usr/include/c++/11/tr1/beta_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/include/c++/11/tr1/beta_function.tcc" 3 + namespace __detail + { +# 79 "/usr/include/c++/11/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/include/c++/11/tr1/beta_function.tcc" 3 + return __bet; + } +# 127 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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); + } + } + + + + + + +} +# 52 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/ell_integral.tcc" 1 3 +# 45 "/usr/include/c++/11/tr1/ell_integral.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 59 "/usr/include/c++/11/tr1/ell_integral.tcc" 3 + namespace __detail + { +# 76 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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); + } + } + } + + + + + +} +# 53 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/exp_integral.tcc" 1 3 +# 50 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 64 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 + namespace __detail + { + template _Tp __expint_E1(_Tp); +# 81 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_Ei(_Tp __x) + { + if (__x < _Tp(0)) + return -__expint_E1(-__x); + else if (__x < -std::log(std::numeric_limits<_Tp>::epsilon())) + return __expint_Ei_series(__x); + else + return __expint_Ei_asymp(__x); + } +# 378 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_E1(_Tp __x) + { + if (__x < _Tp(0)) + return -__expint_Ei(-__x); + else if (__x < _Tp(1)) + return __expint_E1_series(__x); + else if (__x < _Tp(100)) + return __expint_En_cont_frac(1, __x); + else + return __expint_E1_asymp(__x); + } +# 408 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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); + } + } + + + + + +} +# 54 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/hypergeometric.tcc" 1 3 +# 44 "/usr/include/c++/11/tr1/hypergeometric.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 60 "/usr/include/c++/11/tr1/hypergeometric.tcc" 3 + namespace __detail + { +# 83 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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); + } + } + + + + + + +} +# 55 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/legendre_function.tcc" 1 3 +# 49 "/usr/include/c++/11/tr1/legendre_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/include/c++/11/tr1/legendre_function.tcc" 3 + namespace __detail + { +# 80 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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; + } + } + } + } + + + + + + +} +# 56 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/modified_bessel_func.tcc" 1 3 +# 51 "/usr/include/c++/11/tr1/modified_bessel_func.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/include/c++/11/tr1/modified_bessel_func.tcc" 3 + namespace __detail + { +# 83 "/usr/include/c++/11/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/include/c++/11/tr1/modified_bessel_func.tcc" 3 + template + _Tp + __cyl_bessel_i(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_i.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x * __x < _Tp(10) * (__nu + _Tp(1))) + return __cyl_bessel_ij_series(__nu, __x, +_Tp(1), 200); + else + { + _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + return __I_nu; + } + } +# 303 "/usr/include/c++/11/tr1/modified_bessel_func.tcc" 3 + template + _Tp + __cyl_bessel_k(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_k.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + { + _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + return __K_nu; + } + } +# 337 "/usr/include/c++/11/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/include/c++/11/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; + } + } + + + + + +} +# 57 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/poly_hermite.tcc" 1 3 +# 42 "/usr/include/c++/11/tr1/poly_hermite.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 56 "/usr/include/c++/11/tr1/poly_hermite.tcc" 3 + namespace __detail + { +# 72 "/usr/include/c++/11/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/include/c++/11/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); + } + } + + + + + +} +# 58 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/poly_laguerre.tcc" 1 3 +# 44 "/usr/include/c++/11/tr1/poly_laguerre.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 60 "/usr/include/c++/11/tr1/poly_laguerre.tcc" 3 + namespace __detail + { +# 75 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/poly_laguerre.tcc" 3 + template + inline _Tp + __assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x) + { return __poly_laguerre(__n, __m, __x); } +# 316 "/usr/include/c++/11/tr1/poly_laguerre.tcc" 3 + template + inline _Tp + __laguerre(unsigned int __n, _Tp __x) + { return __poly_laguerre(__n, 0, __x); } + } + + + + + + +} +# 59 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/riemann_zeta.tcc" 1 3 +# 47 "/usr/include/c++/11/tr1/riemann_zeta.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 63 "/usr/include/c++/11/tr1/riemann_zeta.tcc" 3 + namespace __detail + { +# 78 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/riemann_zeta.tcc" 3 + template + inline _Tp + __hurwitz_zeta(_Tp __a, _Tp __s) + { return __hurwitz_zeta_glob(__a, __s); } + } + + + + + + +} +# 60 "/usr/include/c++/11/bits/specfun.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 205 "/usr/include/c++/11/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); } +# 250 "/usr/include/c++/11/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); + } +# 266 "/usr/include/c++/11/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); } +# 296 "/usr/include/c++/11/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); + } +# 311 "/usr/include/c++/11/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); } +# 341 "/usr/include/c++/11/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); + } +# 357 "/usr/include/c++/11/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); } +# 389 "/usr/include/c++/11/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); + } +# 405 "/usr/include/c++/11/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); } +# 436 "/usr/include/c++/11/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); + } +# 452 "/usr/include/c++/11/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); } +# 487 "/usr/include/c++/11/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); + } +# 503 "/usr/include/c++/11/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); } +# 533 "/usr/include/c++/11/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); + } +# 549 "/usr/include/c++/11/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); } +# 579 "/usr/include/c++/11/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); + } +# 595 "/usr/include/c++/11/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); } +# 631 "/usr/include/c++/11/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); + } +# 647 "/usr/include/c++/11/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); } +# 679 "/usr/include/c++/11/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); + } +# 695 "/usr/include/c++/11/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); } +# 727 "/usr/include/c++/11/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); + } +# 743 "/usr/include/c++/11/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); } +# 775 "/usr/include/c++/11/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); + } +# 791 "/usr/include/c++/11/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); } +# 828 "/usr/include/c++/11/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); + } +# 843 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + expintf(float __x) + { return __detail::__expint(__x); } + + + + + + + + inline long double + expintl(long double __x) + { return __detail::__expint(__x); } +# 868 "/usr/include/c++/11/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); + } +# 884 "/usr/include/c++/11/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); } +# 916 "/usr/include/c++/11/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); + } +# 932 "/usr/include/c++/11/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); } +# 960 "/usr/include/c++/11/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); + } +# 976 "/usr/include/c++/11/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); } +# 1005 "/usr/include/c++/11/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); + } +# 1021 "/usr/include/c++/11/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); } +# 1056 "/usr/include/c++/11/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); + } +# 1072 "/usr/include/c++/11/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); } +# 1100 "/usr/include/c++/11/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); + } +# 1116 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + sph_legendref(unsigned int __l, unsigned int __m, float __theta) + { return __detail::__sph_legendre(__l, __m, __theta); } +# 1127 "/usr/include/c++/11/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); } +# 1147 "/usr/include/c++/11/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); + } +# 1163 "/usr/include/c++/11/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); } +# 1191 "/usr/include/c++/11/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"))) +{ + +# 1218 "/usr/include/c++/11/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; + } +# 1294 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + conf_hypergf(float __a, float __c, float __x) + { return std::__detail::__conf_hyperg(__a, __c, __x); } +# 1305 "/usr/include/c++/11/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); } +# 1325 "/usr/include/c++/11/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); + } +# 1342 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + hypergf(float __a, float __b, float __c, float __x) + { return std::__detail::__hyperg(__a, __b, __c, __x); } +# 1353 "/usr/include/c++/11/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); } +# 1374 "/usr/include/c++/11/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); + } + + + +} + + +#pragma GCC visibility pop +# 1936 "/usr/include/c++/11/cmath" 2 3 + + +} +# 37 "/usr/include/c++/11/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; +# 10551 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 2 +# 1 "/usr/include/c++/11/stdlib.h" 1 3 +# 10552 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 2 + + +# 1 "/usr/include/c++/11/cmath" 1 3 +# 39 "/usr/include/c++/11/cmath" 3 + +# 40 "/usr/include/c++/11/cmath" 3 +# 10555 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 2 +# 1 "/usr/include/c++/11/cstdlib" 1 3 +# 39 "/usr/include/c++/11/cstdlib" 3 + +# 40 "/usr/include/c++/11/cstdlib" 3 +# 10556 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 2 +# 10626 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" + +# 10626 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 10805 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 11206 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +namespace std { +# 11215 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int abs(long long int); +# 11225 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int abs(long int); +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); +# 11350 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +} +# 11456 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 11595 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11736 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float min(const float a, const float b); +# 11747 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(const double a, const double b); +# 11757 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(const float a, const double b); +# 11767 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11866 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float max(const float a, const float b); +# 11877 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const double a, const double b); +# 11887 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const float a, const double b); +# 11897 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const double a, const float b); +# 11909 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +} +# 12199 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.hpp" 1 +# 77 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.hpp" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 78 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.hpp" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 79 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.hpp" 2 +# 758 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +} +# 12200 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" 2 +# 304 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" 2 +# 118 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 1 +# 81 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 82 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_types.h" 1 +# 83 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 84 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 95 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +extern "C" +{ +# 106 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __mulhi(int x, int y); +# 116 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __umulhi(unsigned int x, unsigned int y); +# 126 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int_as_float(int x); +# 154 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float_as_int(float x); +# 163 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint_as_float(unsigned int x); +# 172 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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(); +# 207 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __saturatef(float x); +# 276 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __sad(int x, int y, unsigned int z); +# 344 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 354 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __mul24(int x, int y); +# 364 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __umul24(unsigned int x, unsigned int y); +# 377 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float fdividef(float x, float y); +# 450 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 463 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __sinf(float x) +# 463 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 3 4 + noexcept (true) +# 463 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" + ; +# 474 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __cosf(float x) +# 474 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 3 4 + noexcept (true) +# 474 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" + ; +# 487 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __tanf(float x) +# 487 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 3 4 + noexcept (true) +# 487 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" + ; +# 502 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void __sincosf(float x, float *sptr, float *cptr) +# 502 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 3 4 + noexcept (true) +# 502 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" + ; +# 551 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __expf(float x) +# 551 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 3 4 + noexcept (true) +# 551 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" + ; +# 582 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __exp10f(float x) +# 582 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 3 4 + noexcept (true) +# 582 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" + ; +# 607 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __log2f(float x) +# 607 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 3 4 + noexcept (true) +# 607 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" + ; +# 634 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __log10f(float x) +# 634 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 3 4 + noexcept (true) +# 634 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" + ; +# 677 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __logf(float x) +# 677 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 3 4 + noexcept (true) +# 677 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" + ; +# 719 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __powf(float x, float y) +# 719 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 3 4 + noexcept (true) +# 719 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" + ; +# 728 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rn(float x); +# 737 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rz(float x); +# 746 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_ru(float); +# 755 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rd(float x); +# 764 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rn(float x); +# 773 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rz(float x); +# 782 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_ru(float x); +# 791 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rd(float x); +# 800 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rn(int x); +# 809 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rz(int x); +# 818 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_ru(int x); +# 827 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rd(int x); +# 836 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rn(unsigned int x); +# 845 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rz(unsigned int x); +# 854 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_ru(unsigned int x); +# 863 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rd(unsigned int x); +# 872 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rn(float x); +# 881 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rz(float x); +# 890 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_ru(float x); +# 899 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rd(float x); +# 908 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rn(float x); +# 917 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rz(float x); +# 926 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_ru(float x); +# 935 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rd(float x); +# 944 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rn(long long int x); +# 953 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rz(long long int x); +# 962 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_ru(long long int x); +# 971 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rd(long long int x); +# 980 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rn(unsigned long long int x); +# 989 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rz(unsigned long long int x); +# 998 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_ru(unsigned long long int x); +# 1007 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rd(unsigned long long int x); +# 1019 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rn(float x, float y); +# 1031 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rz(float x, float y); +# 1043 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_ru(float x, float y); +# 1055 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rd(float x, float y); +# 1067 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rn(float x, float y); +# 1079 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rz(float x, float y); +# 1091 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_ru(float x, float y); +# 1103 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rd(float x, float y); +# 1115 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rn(float x, float y); +# 1127 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rz(float x, float y); +# 1139 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_ru(float x, float y); +# 1151 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rd(float x, float y); +# 1304 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rn(float x, float y, float z); +# 1457 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rz(float x, float y, float z); +# 1610 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_ru(float x, float y, float z); +# 1763 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rd(float x, float y, float z); +# 1796 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rn(float x); +# 1829 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rz(float x); +# 1862 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_ru(float x); +# 1895 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rd(float x); +# 1926 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rn(float x); +# 1957 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rz(float x); +# 1988 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_ru(float x); +# 2019 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rd(float x); +# 2058 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frsqrt_rn(float x); +# 2069 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rn(float x, float y); +# 2080 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rz(float x, float y); +# 2091 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_ru(float x, float y); +# 2102 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rd(float x, float y); +# 2111 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __clz(int x); +# 2122 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __ffs(int x); +# 2131 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __popc(unsigned int x); +# 2140 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __brev(unsigned int x); +# 2149 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __clzll(long long int x); +# 2160 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __ffsll(long long int x); +# 2171 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __popcll(unsigned long long int x); +# 2180 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __brevll(unsigned long long int x); +# 2203 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 2215 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __hadd(int x, int y); +# 2228 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __rhadd(int x, int y); +# 2240 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __uhadd(unsigned int x, unsigned int y); +# 2253 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __urhadd(unsigned int x, unsigned int y); +# 2263 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __double2int_rz(double x); +# 2272 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __double2uint_rz(double x); +# 2281 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __double2ll_rz(double x); +# 2290 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 2320 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabs2(unsigned int a); +# 2331 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsss2(unsigned int a); +# 2342 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vadd2(unsigned int a, unsigned int b); +# 2353 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddss2 (unsigned int a, unsigned int b); +# 2363 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddus2 (unsigned int a, unsigned int b); +# 2374 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgs2(unsigned int a, unsigned int b); +# 2385 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgu2(unsigned int a, unsigned int b); +# 2396 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vhaddu2(unsigned int a, unsigned int b); +# 2407 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpeq2(unsigned int a, unsigned int b); +# 2418 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpges2(unsigned int a, unsigned int b); +# 2429 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgeu2(unsigned int a, unsigned int b); +# 2440 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgts2(unsigned int a, unsigned int b); +# 2451 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgtu2(unsigned int a, unsigned int b); +# 2462 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmples2(unsigned int a, unsigned int b); +# 2474 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpleu2(unsigned int a, unsigned int b); +# 2485 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmplts2(unsigned int a, unsigned int b); +# 2496 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpltu2(unsigned int a, unsigned int b); +# 2507 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpne2(unsigned int a, unsigned int b); +# 2518 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffu2(unsigned int a, unsigned int b); +# 2529 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxs2(unsigned int a, unsigned int b); +# 2540 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxu2(unsigned int a, unsigned int b); +# 2551 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmins2(unsigned int a, unsigned int b); +# 2562 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vminu2(unsigned int a, unsigned int b); +# 2573 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vseteq2(unsigned int a, unsigned int b); +# 2584 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetges2(unsigned int a, unsigned int b); +# 2595 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgeu2(unsigned int a, unsigned int b); +# 2606 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgts2(unsigned int a, unsigned int b); +# 2617 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgtu2(unsigned int a, unsigned int b); +# 2628 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetles2(unsigned int a, unsigned int b); +# 2639 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetleu2(unsigned int a, unsigned int b); +# 2650 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetlts2(unsigned int a, unsigned int b); +# 2661 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetltu2(unsigned int a, unsigned int b); +# 2672 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetne2(unsigned int a, unsigned int b); +# 2683 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsadu2(unsigned int a, unsigned int b); +# 2694 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsub2(unsigned int a, unsigned int b); +# 2705 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubss2 (unsigned int a, unsigned int b); +# 2716 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubus2 (unsigned int a, unsigned int b); +# 2726 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vneg2(unsigned int a); +# 2736 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vnegss2(unsigned int a); +# 2747 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffs2(unsigned int a, unsigned int b); +# 2758 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsads2(unsigned int a, unsigned int b); +# 2768 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabs4(unsigned int a); +# 2779 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsss4(unsigned int a); +# 2790 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vadd4(unsigned int a, unsigned int b); +# 2801 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddss4 (unsigned int a, unsigned int b); +# 2811 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddus4 (unsigned int a, unsigned int b); +# 2822 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgs4(unsigned int a, unsigned int b); +# 2833 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgu4(unsigned int a, unsigned int b); +# 2844 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vhaddu4(unsigned int a, unsigned int b); +# 2855 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpeq4(unsigned int a, unsigned int b); +# 2866 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpges4(unsigned int a, unsigned int b); +# 2877 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgeu4(unsigned int a, unsigned int b); +# 2888 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgts4(unsigned int a, unsigned int b); +# 2899 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgtu4(unsigned int a, unsigned int b); +# 2910 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmples4(unsigned int a, unsigned int b); +# 2921 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpleu4(unsigned int a, unsigned int b); +# 2932 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmplts4(unsigned int a, unsigned int b); +# 2943 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpltu4(unsigned int a, unsigned int b); +# 2954 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpne4(unsigned int a, unsigned int b); +# 2965 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffu4(unsigned int a, unsigned int b); +# 2976 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxs4(unsigned int a, unsigned int b); +# 2987 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxu4(unsigned int a, unsigned int b); +# 2998 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmins4(unsigned int a, unsigned int b); +# 3009 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vminu4(unsigned int a, unsigned int b); +# 3020 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vseteq4(unsigned int a, unsigned int b); +# 3031 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetles4(unsigned int a, unsigned int b); +# 3042 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetleu4(unsigned int a, unsigned int b); +# 3053 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetlts4(unsigned int a, unsigned int b); +# 3064 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetltu4(unsigned int a, unsigned int b); +# 3075 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetges4(unsigned int a, unsigned int b); +# 3086 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgeu4(unsigned int a, unsigned int b); +# 3097 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgts4(unsigned int a, unsigned int b); +# 3108 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgtu4(unsigned int a, unsigned int b); +# 3119 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetne4(unsigned int a, unsigned int b); +# 3130 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsadu4(unsigned int a, unsigned int b); +# 3141 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsub4(unsigned int a, unsigned int b); +# 3152 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubss4(unsigned int a, unsigned int b); +# 3163 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubus4(unsigned int a, unsigned int b); +# 3173 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vneg4(unsigned int a); +# 3183 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vnegss4(unsigned int a); +# 3194 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffs4(unsigned int a, unsigned int b); +# 3205 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsads4(unsigned int a, unsigned int b); +# 3215 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax_s32_relu(const int a, const int b); +# 3227 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3236 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin_s32_relu(const int a, const int b); +# 3248 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3257 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3269 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3278 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3290 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3299 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3311 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3320 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3332 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3341 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3353 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3362 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3374 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3383 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3395 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3404 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3416 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3425 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3437 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3446 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3458 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3468 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3480 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3490 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3502 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3511 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3520 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3529 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3538 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3552 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3566 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3580 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3594 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); + + + + + + +} +# 3617 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" 1 +# 81 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 82 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" 2 + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 84 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" 2 +# 108 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +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 = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + + short ansS_lo = (short)max(aS_lo, bS_lo); + short ansS_hi = (short)max(aS_hi, bS_hi); + + + if(ansS_lo < 0){ ansS_lo = 0; } + if(ansS_hi < 0){ ansS_hi = 0; } + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + res = ((unsigned int) ansU_lo) | (((unsigned int) 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 = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + + short ansS_lo = (short)min(aS_lo, bS_lo); + short ansS_hi = (short)min(aS_hi, bS_hi); + + + if(ansS_lo < 0){ ansS_lo = 0; } + if(ansS_hi < 0){ ansS_hi = 0; } + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_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(const int a, const int b, const int c){ +# 226 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 243 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + short cS_lo = *(short*)& cU_lo; + short cS_hi = *(short*)& cU_hi; + + + short ansS_lo = (short)max(max(aS_lo, bS_lo), cS_lo); + short ansS_hi = (short)max(max(aS_hi, bS_hi), cS_hi); + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + res = ((unsigned int) ansU_lo) | (((unsigned int) 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){ +# 286 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 302 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 332 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 348 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + short cS_lo = *(short*)& cU_lo; + short cS_hi = *(short*)& cU_hi; + + + short ansS_lo = (short)min(min(aS_lo, bS_lo), cS_lo); + short ansS_hi = (short)min(min(aS_hi, bS_hi), cS_hi); + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + res = ((unsigned int) ansU_lo) | (((unsigned int) 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){ +# 392 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 408 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 438 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 456 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + short cS_lo = *(short*)& cU_lo; + short cS_hi = *(short*)& cU_hi; + + + short ansS_lo = (short)max(max(aS_lo, bS_lo), cS_lo); + short ansS_hi = (short)max(max(aS_hi, bS_hi), cS_hi); + + + if(ansS_lo < 0){ansS_lo = 0;} + if(ansS_hi < 0){ansS_hi = 0;} + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_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_relu(const int a, const int b, const int c){ +# 504 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 522 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + short cS_lo = *(short*)& cU_lo; + short cS_hi = *(short*)& cU_hi; + + + short ansS_lo = (short)min(min(aS_lo, bS_lo), cS_lo); + short ansS_hi = (short)min(min(aS_hi, bS_hi), cS_hi); + + + if(ansS_lo < 0){ansS_lo = 0;} + if(ansS_hi < 0){ansS_hi = 0;} + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_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(const int a, const int b, const int c){ +# 570 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 586 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + short cS_lo = *(short*)& cU_lo; + short cS_hi = *(short*)& cU_hi; + + + short ansS_lo = (short)max((short)(aS_lo + bS_lo), cS_lo); + short ansS_hi = (short)max((short)(aS_hi + bS_hi), cS_hi); + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + res = ((unsigned int) ansU_lo) | (((unsigned int) 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){ +# 630 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 646 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 676 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 692 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + short cS_lo = *(short*)& cU_lo; + short cS_hi = *(short*)& cU_hi; + + + short ansS_lo = (short)min((short)(aS_lo + bS_lo), cS_lo); + short ansS_hi = (short)min((short)(aS_hi + bS_hi), cS_hi); + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + res = ((unsigned int) ansU_lo) | (((unsigned int) 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){ +# 736 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 752 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 782 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 800 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + short cS_lo = *(short*)& cU_lo; + short cS_hi = *(short*)& cU_hi; + + + short ansS_lo = (short)max((short)(aS_lo + bS_lo), cS_lo); + short ansS_hi = (short)max((short)(aS_hi + bS_hi), cS_hi); + + if(ansS_lo < 0){ansS_lo = 0;} + if(ansS_hi < 0){ansS_hi = 0;} + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_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_relu(const int a, const int b, const int c){ +# 847 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +# 865 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + short cS_lo = *(short*)& cU_lo; + short cS_hi = *(short*)& cU_hi; + + + short ansS_lo = (short)min((short)(aS_lo + bS_lo), cS_lo); + short ansS_hi = (short)min((short)(aS_hi + bS_hi), cS_hi); + + if(ansS_lo < 0){ansS_lo = 0;} + if(ansS_hi < 0){ansS_hi = 0;} + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + res = ((unsigned int) ansU_lo) | (((unsigned int) 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){ +# 918 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 939 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 961 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 983 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 1012 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + + short ansS_lo = (short)max(aS_lo, bS_lo); + short ansS_hi = (short)max(aS_hi, bS_hi); + + *pred_hi = (aS_hi >= bS_hi); + *pred_lo = (aS_lo >= bS_lo); + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + 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 __vibmax_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 1065 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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){ +# 1107 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + + short ansS_lo = (short)min(aS_lo, bS_lo); + short ansS_hi = (short)min(aS_hi, bS_hi); + + *pred_hi = (aS_hi <= bS_hi); + *pred_lo = (aS_lo <= bS_lo); + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + 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_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 1160 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; + +} +# 3618 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 + + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_atomic_functions.h" 1 +# 89 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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) { } +# 3621 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" 1 +# 83 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 84 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" 2 + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 86 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" 2 + + + + +extern "C" +{ +# 100 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double_as_longlong(double x); +# 109 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __longlong_as_double(long long int x); +# 266 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rn(double x, double y, double z); +# 423 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rz(double x, double y, double z); +# 580 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_ru(double x, double y, double z); +# 737 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rd(double x, double y, double z); +# 749 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rn(double x, double y); +# 761 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rz(double x, double y); +# 773 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_ru(double x, double y); +# 785 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rd(double x, double y); +# 797 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rn(double x, double y); +# 809 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rz(double x, double y); +# 821 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_ru(double x, double y); +# 833 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rd(double x, double y); +# 845 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rn(double x, double y); +# 857 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rz(double x, double y); +# 869 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_ru(double x, double y); +# 881 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rd(double x, double y); +# 890 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rn(double x); +# 899 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rz(double x); +# 908 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_ru(double x); +# 917 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rd(double x); +# 926 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rn(double x); +# 935 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_ru(double x); +# 944 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rd(double x); +# 953 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rn(double x); +# 962 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_ru(double x); +# 971 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rd(double x); +# 980 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rn(double x); +# 989 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_ru(double x); +# 998 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rd(double x); +# 1007 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rn(double x); +# 1016 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_ru(double x); +# 1025 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rn(long long int x); +# 1059 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rz(long long int x); +# 1068 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_ru(long long int x); +# 1077 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rd(long long int x); +# 1086 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rn(unsigned long long int x); +# 1095 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rz(unsigned long long int x); +# 1104 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_ru(unsigned long long int x); +# 1113 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rd(unsigned long long int x); +# 1122 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2hiint(double x); +# 1131 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2loint(double x); +# 1141 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.hpp" 1 +# 83 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.hpp" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 84 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.hpp" 2 + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 86 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" 2 +# 3622 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_atomic_functions.h" 1 +# 88 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_atomic_functions.h" +static __inline__ __attribute__((device)) float atomicAdd(float *address, float val) { } +# 3623 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_atomic_functions.h" 1 +# 89 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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) { } +# 3624 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_35_atomic_functions.h" 1 +# 56 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_35_atomic_functions.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_atomic_functions.h" 1 +# 57 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_35_atomic_functions.h" 2 +# 3625 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_60_atomic_functions.h" 1 +# 93 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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) { } +# 3626 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" 1 +# 95 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) void __threadfence_system(void); +# 109 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rn(double x, double y); +# 121 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rz(double x, double y); +# 133 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_ru(double x, double y); +# 145 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rd(double x, double y); +# 179 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rn(double x); +# 213 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rz(double x); +# 247 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_ru(double x); +# 281 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rd(double x); +# 313 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rn(double x); +# 345 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rz(double x); +# 377 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_ru(double x); +# 409 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 424 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rn(float x, float y, float z); +# 433 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rd(float x, float y, float z); +# 442 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_ru(float x, float y, float z); +# 451 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rz(float x, float y, float z); +# 464 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double_as_longlong(double x); +# 473 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __longlong_as_double(long long int x); +# 630 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rn(double x, double y, double z); +# 787 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rz(double x, double y, double z); +# 944 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_ru(double x, double y, double z); +# 1101 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rd(double x, double y, double z); +# 1113 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rn(double x, double y); +# 1125 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rz(double x, double y); +# 1137 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_ru(double x, double y); +# 1149 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rd(double x, double y); +# 1161 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rn(double x, double y); +# 1173 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rz(double x, double y); +# 1185 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_ru(double x, double y); +# 1197 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rd(double x, double y); +# 1209 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rn(double x, double y); +# 1221 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rz(double x, double y); +# 1233 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_ru(double x, double y); +# 1245 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rd(double x, double y); +# 1254 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rn(double x); +# 1263 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rz(double x); +# 1272 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_ru(double x); +# 1281 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rd(double x); +# 1290 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rn(double x); +# 1299 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_ru(double x); +# 1308 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rd(double x); +# 1317 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rn(double x); +# 1326 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_ru(double x); +# 1335 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rd(double x); +# 1344 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rn(double x); +# 1353 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_ru(double x); +# 1362 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rd(double x); +# 1371 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rn(double x); +# 1380 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_ru(double x); +# 1389 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 1414 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rn(long long int x); +# 1423 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rz(long long int x); +# 1432 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_ru(long long int x); +# 1441 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rd(long long int x); +# 1450 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rn(unsigned long long int x); +# 1459 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rz(unsigned long long int x); +# 1468 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_ru(unsigned long long int x); +# 1477 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rd(unsigned long long int x); +# 1486 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2hiint(double x); +# 1495 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2loint(double x); +# 1505 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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) { } +# 3627 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_30_intrinsics.h" 1 +# 123 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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) { } +# 3628 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_intrinsics.h" 1 +# 91 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_l(unsigned int lo, unsigned int hi, unsigned int shift) { } +# 477 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_lc(unsigned int lo, unsigned int hi, unsigned int shift) { } +# 490 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_r(unsigned int lo, unsigned int hi, unsigned int shift) { } +# 502 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_rc(unsigned int lo, unsigned int hi, unsigned int shift) { } +# 3629 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_35_intrinsics.h" 1 +# 3630 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_61_intrinsics.h" 1 +# 102 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp2a_lo(int srcA, int srcB, int c) { } +# 113 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp2a_lo(unsigned int srcA, unsigned int srcB, unsigned int c) { } +# 125 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp2a_lo(short2 srcA, char4 srcB, int c) { } +# 136 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp2a_lo(ushort2 srcA, uchar4 srcB, unsigned int c) { } +# 148 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp2a_hi(int srcA, int srcB, int c) { } +# 159 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp2a_hi(unsigned int srcA, unsigned int srcB, unsigned int c) { } +# 171 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp2a_hi(short2 srcA, char4 srcB, int c) { } +# 182 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp2a_hi(ushort2 srcA, uchar4 srcB, unsigned int c) { } +# 197 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp4a(int srcA, int srcB, int c) { } +# 206 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp4a(unsigned int srcA, unsigned int srcB, unsigned int c) { } +# 216 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp4a(char4 srcA, char4 srcB, int c) { } +# 225 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp4a(uchar4 srcA, uchar4 srcB, unsigned int c) { } +# 3631 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_70_rt.h" 1 +# 84 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_70_rt.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 85 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_70_rt.h" 2 + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 87 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_70_rt.h" 2 +# 98 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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) { } +# 3632 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_80_rt.h" 1 +# 81 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_80_rt.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 82 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_80_rt.h" 2 + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 84 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_80_rt.h" 2 +# 97 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} + +} +# 3633 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_90_rt.h" 1 +# 79 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_90_rt.h" +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/builtin_types.h" 1 +# 80 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_90_rt.h" 2 + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/host_defines.h" 1 +# 82 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_90_rt.h" 2 +# 92 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_90_rt.h" +template +struct __nv_atomic_triv_cp_helper { + + + + + + + static const bool __val = __is_trivially_copyable(_T); + + + + +}; +# 201 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +} +# 3634 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/texture_indirect_functions.h" 1 +# 65 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +} +# 3636 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/surface_indirect_functions.h" 1 +# 58 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 3637 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" 2 + +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/cudacc_ext.h" 1 +# 3639 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 119 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 +# 1 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_launch_parameters.h" 1 +# 68 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 +# 148 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +# 1 "/usr/include/c++/11/utility" 1 3 +# 58 "/usr/include/c++/11/utility" 3 + +# 59 "/usr/include/c++/11/utility" 3 +# 69 "/usr/include/c++/11/utility" 3 +# 1 "/usr/include/c++/11/bits/stl_relops.h" 1 3 +# 67 "/usr/include/c++/11/bits/stl_relops.h" 3 + +# 67 "/usr/include/c++/11/bits/stl_relops.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + namespace rel_ops + { +# 85 "/usr/include/c++/11/bits/stl_relops.h" 3 + template + inline bool + operator!=(const _Tp& __x, const _Tp& __y) + { return !(__x == __y); } +# 98 "/usr/include/c++/11/bits/stl_relops.h" 3 + template + inline bool + operator>(const _Tp& __x, const _Tp& __y) + { return __y < __x; } +# 111 "/usr/include/c++/11/bits/stl_relops.h" 3 + template + inline bool + operator<=(const _Tp& __x, const _Tp& __y) + { return !(__y < __x); } +# 124 "/usr/include/c++/11/bits/stl_relops.h" 3 + template + inline bool + operator>=(const _Tp& __x, const _Tp& __y) + { return !(__x < __y); } + } + + +} +# 70 "/usr/include/c++/11/utility" 2 3 + + + + + + +# 1 "/usr/include/c++/11/initializer_list" 1 3 +# 33 "/usr/include/c++/11/initializer_list" 3 + +# 34 "/usr/include/c++/11/initializer_list" 3 + + + + + +#pragma GCC visibility push(default) + + + +namespace std +{ + + 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(); } +} + +#pragma GCC visibility pop +# 77 "/usr/include/c++/11/utility" 2 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 + struct tuple_element; + + + template + using __tuple_element_t = typename tuple_element<__i, _Tp>::type; + + template + struct tuple_element<__i, const _Tp> + { + typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type; + }; + + template + struct tuple_element<__i, volatile _Tp> + { + typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type; + }; + + template + struct tuple_element<__i, const volatile _Tp> + { + typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type; + }; + + + + + + + + template + using tuple_element_t = typename tuple_element<__i, _Tp>::type; + + + + + + 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 __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); } + + + + + template + + inline _Tp + exchange(_Tp& __obj, _Up&& __new_val) + { return std::__exchange(__obj, std::forward<_Up>(__new_val)); } + + + + + + template struct _Index_tuple { }; + + + template + struct _Build_index_tuple + { +# 312 "/usr/include/c++/11/utility" 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 + [[nodiscard]] + constexpr add_const_t<_Tp>& + as_const(_Tp& __t) noexcept + { return __t; } + + template + void as_const(const _Tp&&) = delete; +# 476 "/usr/include/c++/11/utility" 3 + +} +# 149 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" 2 +# 206 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" + +# 206 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchKernel( + const 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); +} +# 277 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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)...); +} +# 340 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchCooperativeKernel( + const 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); +} +# 384 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaEventCreate( + cudaEvent_t *event, + unsigned int flags +) +{ + return ::cudaEventCreateWithFlags(event, flags); +} +# 428 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 499 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 628 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 646 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 749 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 799 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 878 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 932 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 980 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 1034 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 1103 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 1174 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 1225 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 1273 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 1331 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 1390 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +} +# 1443 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 1493 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetSymbolAddress( + void **devPtr, + const T &symbol +) +{ + return ::cudaGetSymbolAddress(devPtr, (const void*)&symbol); +} +# 1525 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetSymbolSize( + size_t *size, + const T &symbol +) +{ + return ::cudaGetSymbolSize(size, (const void*)&symbol); +} +# 1577 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 + +} +# 1636 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 1688 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; + } +}; +# 1758 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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; +} +# 1954 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 2000 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 2038 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 2097 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 2141 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 2184 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +} +# 2224 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncGetAttributes( + struct cudaFuncAttributes *attr, + T *entry +) +{ + return ::cudaFuncGetAttributes(attr, (const void*)entry); +} +# 2286 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncSetAttribute( + T *entry, + enum cudaFuncAttribute attr, + int value +) +{ + return ::cudaFuncSetAttribute((const void*)entry, attr, value); +} +# 2318 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncGetName( + const char **name, + const T *func +) +{ + return ::cudaFuncGetName(name, (const void *)func); +} +# 2341 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetKernel( + cudaKernel_t *kernelPtr, + const T *entryFuncAddr +) +{ + return ::cudaGetKernel(kernelPtr, (const void *)entryFuncAddr); +} +# 2359 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +#pragma GCC diagnostic pop +# 0 "" 2 +# 1 "CMakeCUDACompilerId.cu" +# 492 "CMakeCUDACompilerId.cu" +char const* info_compiler = "INFO" ":" "compiler[" "NVIDIA" "]"; + +char const* info_simulate = "INFO" ":" "simulate[" "GNU" "]"; +# 819 "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' + (((4) / 10000000)%10)), ('0' + (((4) / 1000000)%10)), ('0' + (((4) / 100000)%10)), ('0' + (((4) / 10000)%10)), ('0' + (((4) / 1000)%10)), ('0' + (((4) / 100)%10)), ('0' + (((4) / 10)%10)), ('0' + ((4) % 10)), + + '.', ('0' + (((131) / 10000000)%10)), ('0' + (((131) / 1000000)%10)), ('0' + (((131) / 100000)%10)), ('0' + (((131) / 10000)%10)), ('0' + (((131) / 1000)%10)), ('0' + (((131) / 100)%10)), ('0' + (((131) / 10)%10)), ('0' + ((131) % 10)), + + + + + + ']','\0'}; +# 848 "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' + (((11) / 10000000)%10)), ('0' + (((11) / 1000000)%10)), ('0' + (((11) / 100000)%10)), ('0' + (((11) / 10000)%10)), ('0' + (((11) / 1000)%10)), ('0' + (((11) / 100)%10)), ('0' + (((11) / 10)%10)), ('0' + ((11) % 10)), + + '.', ('0' + (((4) / 10000000)%10)), ('0' + (((4) / 1000000)%10)), ('0' + (((4) / 100000)%10)), ('0' + (((4) / 10000)%10)), ('0' + (((4) / 1000)%10)), ('0' + (((4) / 100)%10)), ('0' + (((4) / 10)%10)), ('0' + ((4) % 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' + (((11) / 10000000)%10)), ('0' + (((11) / 1000000)%10)), ('0' + (((11) / 100000)%10)), ('0' + (((11) / 10000)%10)), ('0' + (((11) / 1000)%10)), ('0' + (((11) / 100)%10)), ('0' + (((11) / 10)%10)), ('0' + ((11) % 10)), + + '.', ('0' + (((4) / 10000000)%10)), ('0' + (((4) / 1000000)%10)), ('0' + (((4) / 100000)%10)), ('0' + (((4) / 10000)%10)), ('0' + (((4) / 1000)%10)), ('0' + (((4) / 100)%10)), ('0' + (((4) / 10)%10)), ('0' + ((4) % 10)), + + '.', ('0' + (((0) / 10000000)%10)), ('0' + (((0) / 1000000)%10)), ('0' + (((0) / 100000)%10)), ('0' + (((0) / 10000)%10)), ('0' + (((0) / 1000)%10)), ('0' + (((0) / 100)%10)), ('0' + (((0) / 10)%10)), ('0' + ((0) % 10)), + + + + + + ']','\0'}; +# 911 "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/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.c b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.c new file mode 100644 index 0000000..0a7e876 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.c @@ -0,0 +1,51 @@ +# 1 "CMakeCUDACompilerId.cu" +# 492 "CMakeCUDACompilerId.cu" +extern const char *info_compiler; + +extern const char *info_simulate; +# 819 "CMakeCUDACompilerId.cu" +static const char info_version[50]; +# 848 "CMakeCUDACompilerId.cu" +static const char info_simulate_version[41]; +# 868 "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]; +# 911 "CMakeCUDACompilerId.cu" +extern const char *info_language_standard_default; +# 929 "CMakeCUDACompilerId.cu" +extern const char *info_language_extensions_default; +# 492 "CMakeCUDACompilerId.cu" +const char *info_compiler = ((const char *)"INFO:compiler[NVIDIA]"); + +const char *info_simulate = ((const char *)"INFO:simulate[GNU]"); +# 819 "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)52),((char)46),((char)48),((char)48),((char)48),((char)48),((char)48),((char)49),((char)51),((char)49),((char)93),((char)0)}; +# 848 "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)49),((char)46),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)52),((char)93),((char)0)}; +# 868 "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)49),((char)46),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)52),((char)46),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)93),((char)0)}; +# 911 "CMakeCUDACompilerId.cu" +const char *info_language_standard_default = ((const char *)"INFO:standard_default[17]"); +# 929 "CMakeCUDACompilerId.cu" +const char *info_language_extensions_default = ((const char *)"INFO:extensions_default[ON]"); diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.cpp b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.cpp new file mode 100644 index 0000000..f115d8c --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.cpp @@ -0,0 +1,34730 @@ +# 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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +#pragma GCC diagnostic push +# 64 +#pragma GCC diagnostic ignored "-Wunused-function" +# 31 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/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/x86_64-linux-gnu/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/x86_64-linux-gnu/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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_types.h" +#if 0 +# 68 +enum cudaRoundMode { +# 70 +cudaRoundNearest, +# 71 +cudaRoundZero, +# 72 +cudaRoundPosInf, +# 73 +cudaRoundMinInf +# 74 +}; +#endif +# 104 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 104 +struct char1 { +# 106 +signed char x; +# 107 +}; +#endif +# 109 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 109 +struct uchar1 { +# 111 +unsigned char x; +# 112 +}; +#endif +# 115 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 115 +struct __attribute((aligned(2))) char2 { +# 117 +signed char x, y; +# 118 +}; +#endif +# 120 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 120 +struct __attribute((aligned(2))) uchar2 { +# 122 +unsigned char x, y; +# 123 +}; +#endif +# 125 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 125 +struct char3 { +# 127 +signed char x, y, z; +# 128 +}; +#endif +# 130 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 130 +struct uchar3 { +# 132 +unsigned char x, y, z; +# 133 +}; +#endif +# 135 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 135 +struct __attribute((aligned(4))) char4 { +# 137 +signed char x, y, z, w; +# 138 +}; +#endif +# 140 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 140 +struct __attribute((aligned(4))) uchar4 { +# 142 +unsigned char x, y, z, w; +# 143 +}; +#endif +# 145 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 145 +struct short1 { +# 147 +short x; +# 148 +}; +#endif +# 150 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 150 +struct ushort1 { +# 152 +unsigned short x; +# 153 +}; +#endif +# 155 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 155 +struct __attribute((aligned(4))) short2 { +# 157 +short x, y; +# 158 +}; +#endif +# 160 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 160 +struct __attribute((aligned(4))) ushort2 { +# 162 +unsigned short x, y; +# 163 +}; +#endif +# 165 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 165 +struct short3 { +# 167 +short x, y, z; +# 168 +}; +#endif +# 170 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 170 +struct ushort3 { +# 172 +unsigned short x, y, z; +# 173 +}; +#endif +# 175 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 175 +struct __attribute((aligned(8))) short4 { short x; short y; short z; short w; }; +#endif +# 176 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 178 +struct int1 { +# 180 +int x; +# 181 +}; +#endif +# 183 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 183 +struct uint1 { +# 185 +unsigned x; +# 186 +}; +#endif +# 188 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 188 +struct __attribute((aligned(8))) int2 { int x; int y; }; +#endif +# 189 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 189 +struct __attribute((aligned(8))) uint2 { unsigned x; unsigned y; }; +#endif +# 191 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 191 +struct int3 { +# 193 +int x, y, z; +# 194 +}; +#endif +# 196 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 196 +struct uint3 { +# 198 +unsigned x, y, z; +# 199 +}; +#endif +# 201 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 201 +struct __attribute((aligned(16))) int4 { +# 203 +int x, y, z, w; +# 204 +}; +#endif +# 206 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 206 +struct __attribute((aligned(16))) uint4 { +# 208 +unsigned x, y, z, w; +# 209 +}; +#endif +# 211 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 211 +struct long1 { +# 213 +long x; +# 214 +}; +#endif +# 216 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 216 +struct ulong1 { +# 218 +unsigned long x; +# 219 +}; +#endif +# 226 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 226 +struct __attribute((aligned((2) * sizeof(long)))) long2 { +# 228 +long x, y; +# 229 +}; +#endif +# 231 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 231 +struct __attribute((aligned((2) * sizeof(unsigned long)))) ulong2 { +# 233 +unsigned long x, y; +# 234 +}; +#endif +# 238 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 238 +struct long3 { +# 240 +long x, y, z; +# 241 +}; +#endif +# 243 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 243 +struct ulong3 { +# 245 +unsigned long x, y, z; +# 246 +}; +#endif +# 248 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 248 +struct __attribute((aligned(16))) long4 { +# 250 +long x, y, z, w; +# 251 +}; +#endif +# 253 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 253 +struct __attribute((aligned(16))) ulong4 { +# 255 +unsigned long x, y, z, w; +# 256 +}; +#endif +# 258 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 258 +struct float1 { +# 260 +float x; +# 261 +}; +#endif +# 280 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 280 +struct __attribute((aligned(8))) float2 { float x; float y; }; +#endif +# 285 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 285 +struct float3 { +# 287 +float x, y, z; +# 288 +}; +#endif +# 290 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 290 +struct __attribute((aligned(16))) float4 { +# 292 +float x, y, z, w; +# 293 +}; +#endif +# 295 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 295 +struct longlong1 { +# 297 +long long x; +# 298 +}; +#endif +# 300 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 300 +struct ulonglong1 { +# 302 +unsigned long long x; +# 303 +}; +#endif +# 305 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 305 +struct __attribute((aligned(16))) longlong2 { +# 307 +long long x, y; +# 308 +}; +#endif +# 310 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 310 +struct __attribute((aligned(16))) ulonglong2 { +# 312 +unsigned long long x, y; +# 313 +}; +#endif +# 315 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 315 +struct longlong3 { +# 317 +long long x, y, z; +# 318 +}; +#endif +# 320 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 320 +struct ulonglong3 { +# 322 +unsigned long long x, y, z; +# 323 +}; +#endif +# 325 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 325 +struct __attribute((aligned(16))) longlong4 { +# 327 +long long x, y, z, w; +# 328 +}; +#endif +# 330 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 330 +struct __attribute((aligned(16))) ulonglong4 { +# 332 +unsigned long long x, y, z, w; +# 333 +}; +#endif +# 335 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 335 +struct double1 { +# 337 +double x; +# 338 +}; +#endif +# 340 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 340 +struct __attribute((aligned(16))) double2 { +# 342 +double x, y; +# 343 +}; +#endif +# 345 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 345 +struct double3 { +# 347 +double x, y, z; +# 348 +}; +#endif +# 350 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 350 +struct __attribute((aligned(16))) double4 { +# 352 +double x, y, z, w; +# 353 +}; +#endif +# 367 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef char1 +# 367 +char1; +#endif +# 368 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef uchar1 +# 368 +uchar1; +#endif +# 369 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef char2 +# 369 +char2; +#endif +# 370 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef uchar2 +# 370 +uchar2; +#endif +# 371 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef char3 +# 371 +char3; +#endif +# 372 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef uchar3 +# 372 +uchar3; +#endif +# 373 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef char4 +# 373 +char4; +#endif +# 374 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef uchar4 +# 374 +uchar4; +#endif +# 375 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef short1 +# 375 +short1; +#endif +# 376 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef ushort1 +# 376 +ushort1; +#endif +# 377 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef short2 +# 377 +short2; +#endif +# 378 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef ushort2 +# 378 +ushort2; +#endif +# 379 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef short3 +# 379 +short3; +#endif +# 380 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef ushort3 +# 380 +ushort3; +#endif +# 381 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef short4 +# 381 +short4; +#endif +# 382 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef ushort4 +# 382 +ushort4; +#endif +# 383 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef int1 +# 383 +int1; +#endif +# 384 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef uint1 +# 384 +uint1; +#endif +# 385 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef int2 +# 385 +int2; +#endif +# 386 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef uint2 +# 386 +uint2; +#endif +# 387 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef int3 +# 387 +int3; +#endif +# 388 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef uint3 +# 388 +uint3; +#endif +# 389 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef int4 +# 389 +int4; +#endif +# 390 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef uint4 +# 390 +uint4; +#endif +# 391 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef long1 +# 391 +long1; +#endif +# 392 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef ulong1 +# 392 +ulong1; +#endif +# 393 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef long2 +# 393 +long2; +#endif +# 394 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef ulong2 +# 394 +ulong2; +#endif +# 395 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef long3 +# 395 +long3; +#endif +# 396 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef ulong3 +# 396 +ulong3; +#endif +# 397 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef long4 +# 397 +long4; +#endif +# 398 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef ulong4 +# 398 +ulong4; +#endif +# 399 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef float1 +# 399 +float1; +#endif +# 400 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef float2 +# 400 +float2; +#endif +# 401 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef float3 +# 401 +float3; +#endif +# 402 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef float4 +# 402 +float4; +#endif +# 403 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef longlong1 +# 403 +longlong1; +#endif +# 404 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef ulonglong1 +# 404 +ulonglong1; +#endif +# 405 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef longlong2 +# 405 +longlong2; +#endif +# 406 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef ulonglong2 +# 406 +ulonglong2; +#endif +# 407 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef longlong3 +# 407 +longlong3; +#endif +# 408 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef ulonglong3 +# 408 +ulonglong3; +#endif +# 409 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef longlong4 +# 409 +longlong4; +#endif +# 410 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef ulonglong4 +# 410 +ulonglong4; +#endif +# 411 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef double1 +# 411 +double1; +#endif +# 412 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef double2 +# 412 +double2; +#endif +# 413 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef double3 +# 413 +double3; +#endif +# 414 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef double4 +# 414 +double4; +#endif +# 426 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +# 426 +struct dim3 { +# 428 +unsigned x, y, z; +# 440 +}; +#endif +# 442 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/vector_types.h" +#if 0 +typedef dim3 +# 442 +dim3; +#endif +# 23 "/usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h" 3 +extern "C" { +# 24 +extern long __sysconf(int __name) noexcept(true); +# 25 +} +# 143 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 3 +typedef long ptrdiff_t; +# 209 "/usr/lib/gcc/x86_64-linux-gnu/11/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" +# 426 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 3 +typedef +# 415 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 3 +struct { +# 416 +long long __max_align_ll __attribute((__aligned__(__alignof__(long long)))); +# 417 +long double __max_align_ld __attribute((__aligned__(__alignof__(long double)))); +# 426 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 3 +} max_align_t; +# 433 +typedef __decltype((nullptr)) nullptr_t; +# 205 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorAddressOfConstant, +# 345 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorTextureFetchFailed, +# 354 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorTextureNotBound, +# 363 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorSynchronizationError, +# 368 +cudaErrorInvalidFilterSetting, +# 374 +cudaErrorInvalidNormSetting, +# 382 +cudaErrorMixedDeviceExecution, +# 390 +cudaErrorNotYetImplemented = 31, +# 399 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorMemoryValueTooLarge, +# 405 +cudaErrorStubLibrary = 34, +# 412 +cudaErrorInsufficientDriver, +# 419 +cudaErrorCallRequiresNewerDriver, +# 425 +cudaErrorInvalidSurface, +# 431 +cudaErrorDuplicateVariableName = 43, +# 437 +cudaErrorDuplicateTextureName, +# 443 +cudaErrorDuplicateSurfaceName, +# 453 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorDevicesUnavailable, +# 466 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorIncompatibleDriverContext = 49, +# 472 +cudaErrorMissingConfiguration = 52, +# 481 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorPriorLaunchFailure, +# 487 +cudaErrorLaunchMaxDepthExceeded = 65, +# 495 +cudaErrorLaunchFileScopedTex, +# 503 +cudaErrorLaunchFileScopedSurf, +# 519 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorSyncDepthExceeded, +# 531 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorLaunchPendingCountExceeded, +# 537 +cudaErrorInvalidDeviceFunction = 98, +# 543 +cudaErrorNoDevice = 100, +# 550 +cudaErrorInvalidDevice, +# 555 +cudaErrorDeviceNotLicensed, +# 564 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorSoftwareValidityNotEstablished, +# 569 +cudaErrorStartupFailure = 127, +# 574 +cudaErrorInvalidKernelImage = 200, +# 584 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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, +# 713 +cudaErrorInvalidSource = 300, +# 718 +cudaErrorFileNotFound, +# 723 +cudaErrorSharedObjectSymbolNotFound, +# 728 +cudaErrorSharedObjectInitFailed, +# 733 +cudaErrorOperatingSystem, +# 740 +cudaErrorInvalidResourceHandle = 400, +# 746 +cudaErrorIllegalState, +# 754 +cudaErrorLossyQuery, +# 761 +cudaErrorSymbolNotFound = 500, +# 769 +cudaErrorNotReady = 600, +# 777 +cudaErrorIllegalAddress = 700, +# 786 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorLaunchOutOfResources, +# 797 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorLaunchTimeout, +# 803 +cudaErrorLaunchIncompatibleTexturing, +# 810 +cudaErrorPeerAccessAlreadyEnabled, +# 817 +cudaErrorPeerAccessNotEnabled, +# 830 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorSetOnActiveProcess = 708, +# 837 +cudaErrorContextIsDestroyed, +# 844 +cudaErrorAssert, +# 851 +cudaErrorTooManyPeers, +# 857 +cudaErrorHostMemoryAlreadyRegistered, +# 863 +cudaErrorHostMemoryNotRegistered, +# 872 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorHardwareStackError, +# 880 +cudaErrorIllegalInstruction, +# 889 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorMisalignedAddress, +# 900 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorInvalidAddressSpace, +# 908 +cudaErrorInvalidPc, +# 919 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorLaunchFailure, +# 928 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorCooperativeLaunchTooLarge, +# 933 +cudaErrorNotPermitted = 800, +# 939 +cudaErrorNotSupported, +# 948 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorSystemNotReady, +# 955 +cudaErrorSystemDriverMismatch, +# 964 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorCompatNotSupportedOnDevice, +# 969 +cudaErrorMpsConnectionFailed, +# 974 +cudaErrorMpsRpcFailure, +# 980 +cudaErrorMpsServerNotReady, +# 985 +cudaErrorMpsMaxClientsReached, +# 990 +cudaErrorMpsMaxConnectionsReached, +# 995 +cudaErrorMpsClientTerminated, +# 1000 +cudaErrorCdpNotSupported, +# 1005 +cudaErrorCdpVersionMismatch, +# 1010 +cudaErrorStreamCaptureUnsupported = 900, +# 1016 +cudaErrorStreamCaptureInvalidated, +# 1022 +cudaErrorStreamCaptureMerge, +# 1027 +cudaErrorStreamCaptureUnmatched, +# 1033 +cudaErrorStreamCaptureUnjoined, +# 1040 +cudaErrorStreamCaptureIsolation, +# 1046 +cudaErrorStreamCaptureImplicit, +# 1052 +cudaErrorCapturedEvent, +# 1059 +cudaErrorStreamCaptureWrongThread, +# 1064 +cudaErrorTimeout, +# 1070 +cudaErrorGraphExecUpdateFailure, +# 1080 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaErrorExternalDevice, +# 1086 +cudaErrorInvalidClusterSize, +# 1091 +cudaErrorUnknown = 999, +# 1099 +cudaErrorApiFailureBase = 10000 +# 1100 +}; +#endif +# 1105 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1105 +enum cudaChannelFormatKind { +# 1107 +cudaChannelFormatKindSigned, +# 1108 +cudaChannelFormatKindUnsigned, +# 1109 +cudaChannelFormatKindFloat, +# 1110 +cudaChannelFormatKindNone, +# 1111 +cudaChannelFormatKindNV12, +# 1112 +cudaChannelFormatKindUnsignedNormalized8X1, +# 1113 +cudaChannelFormatKindUnsignedNormalized8X2, +# 1114 +cudaChannelFormatKindUnsignedNormalized8X4, +# 1115 +cudaChannelFormatKindUnsignedNormalized16X1, +# 1116 +cudaChannelFormatKindUnsignedNormalized16X2, +# 1117 +cudaChannelFormatKindUnsignedNormalized16X4, +# 1118 +cudaChannelFormatKindSignedNormalized8X1, +# 1119 +cudaChannelFormatKindSignedNormalized8X2, +# 1120 +cudaChannelFormatKindSignedNormalized8X4, +# 1121 +cudaChannelFormatKindSignedNormalized16X1, +# 1122 +cudaChannelFormatKindSignedNormalized16X2, +# 1123 +cudaChannelFormatKindSignedNormalized16X4, +# 1124 +cudaChannelFormatKindUnsignedBlockCompressed1, +# 1125 +cudaChannelFormatKindUnsignedBlockCompressed1SRGB, +# 1126 +cudaChannelFormatKindUnsignedBlockCompressed2, +# 1127 +cudaChannelFormatKindUnsignedBlockCompressed2SRGB, +# 1128 +cudaChannelFormatKindUnsignedBlockCompressed3, +# 1129 +cudaChannelFormatKindUnsignedBlockCompressed3SRGB, +# 1130 +cudaChannelFormatKindUnsignedBlockCompressed4, +# 1131 +cudaChannelFormatKindSignedBlockCompressed4, +# 1132 +cudaChannelFormatKindUnsignedBlockCompressed5, +# 1133 +cudaChannelFormatKindSignedBlockCompressed5, +# 1134 +cudaChannelFormatKindUnsignedBlockCompressed6H, +# 1135 +cudaChannelFormatKindSignedBlockCompressed6H, +# 1136 +cudaChannelFormatKindUnsignedBlockCompressed7, +# 1137 +cudaChannelFormatKindUnsignedBlockCompressed7SRGB +# 1138 +}; +#endif +# 1143 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1143 +struct cudaChannelFormatDesc { +# 1145 +int x; +# 1146 +int y; +# 1147 +int z; +# 1148 +int w; +# 1149 +cudaChannelFormatKind f; +# 1150 +}; +#endif +# 1155 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +typedef struct cudaArray *cudaArray_t; +# 1160 +typedef const cudaArray *cudaArray_const_t; +# 1162 +struct cudaArray; +# 1167 +typedef struct cudaMipmappedArray *cudaMipmappedArray_t; +# 1172 +typedef const cudaMipmappedArray *cudaMipmappedArray_const_t; +# 1174 +struct cudaMipmappedArray; +# 1184 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1184 +struct cudaArraySparseProperties { +# 1185 +struct { +# 1186 +unsigned width; +# 1187 +unsigned height; +# 1188 +unsigned depth; +# 1189 +} tileExtent; +# 1190 +unsigned miptailFirstLevel; +# 1191 +unsigned long long miptailSize; +# 1192 +unsigned flags; +# 1193 +unsigned reserved[4]; +# 1194 +}; +#endif +# 1199 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1199 +struct cudaArrayMemoryRequirements { +# 1200 +size_t size; +# 1201 +size_t alignment; +# 1202 +unsigned reserved[4]; +# 1203 +}; +#endif +# 1208 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1208 +enum cudaMemoryType { +# 1210 +cudaMemoryTypeUnregistered, +# 1211 +cudaMemoryTypeHost, +# 1212 +cudaMemoryTypeDevice, +# 1213 +cudaMemoryTypeManaged +# 1214 +}; +#endif +# 1219 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1219 +enum cudaMemcpyKind { +# 1221 +cudaMemcpyHostToHost, +# 1222 +cudaMemcpyHostToDevice, +# 1223 +cudaMemcpyDeviceToHost, +# 1224 +cudaMemcpyDeviceToDevice, +# 1225 +cudaMemcpyDefault +# 1226 +}; +#endif +# 1233 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1233 +struct cudaPitchedPtr { +# 1235 +void *ptr; +# 1236 +size_t pitch; +# 1237 +size_t xsize; +# 1238 +size_t ysize; +# 1239 +}; +#endif +# 1246 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1246 +struct cudaExtent { +# 1248 +size_t width; +# 1249 +size_t height; +# 1250 +size_t depth; +# 1251 +}; +#endif +# 1258 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1258 +struct cudaPos { +# 1260 +size_t x; +# 1261 +size_t y; +# 1262 +size_t z; +# 1263 +}; +#endif +# 1268 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1268 +struct cudaMemcpy3DParms { +# 1270 +cudaArray_t srcArray; +# 1271 +cudaPos srcPos; +# 1272 +cudaPitchedPtr srcPtr; +# 1274 +cudaArray_t dstArray; +# 1275 +cudaPos dstPos; +# 1276 +cudaPitchedPtr dstPtr; +# 1278 +cudaExtent extent; +# 1279 +cudaMemcpyKind kind; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 1280 +}; +#endif +# 1285 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1285 +struct cudaMemcpyNodeParams { +# 1286 +int flags; +# 1287 +int reserved[3]; +# 1288 +cudaMemcpy3DParms copyParams; +# 1289 +}; +#endif +# 1294 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1294 +struct cudaMemcpy3DPeerParms { +# 1296 +cudaArray_t srcArray; +# 1297 +cudaPos srcPos; +# 1298 +cudaPitchedPtr srcPtr; +# 1299 +int srcDevice; +# 1301 +cudaArray_t dstArray; +# 1302 +cudaPos dstPos; +# 1303 +cudaPitchedPtr dstPtr; +# 1304 +int dstDevice; +# 1306 +cudaExtent extent; +# 1307 +}; +#endif +# 1312 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1312 +struct cudaMemsetParams { +# 1313 +void *dst; +# 1314 +size_t pitch; +# 1315 +unsigned value; +# 1316 +unsigned elementSize; +# 1317 +size_t width; +# 1318 +size_t height; +# 1319 +}; +#endif +# 1324 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1324 +struct cudaMemsetParamsV2 { +# 1325 +void *dst; +# 1326 +size_t pitch; +# 1327 +unsigned value; +# 1328 +unsigned elementSize; +# 1329 +size_t width; +# 1330 +size_t height; +# 1331 +}; +#endif +# 1336 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1336 +enum cudaAccessProperty { +# 1337 +cudaAccessPropertyNormal, +# 1338 +cudaAccessPropertyStreaming, +# 1339 +cudaAccessPropertyPersisting +# 1340 +}; +#endif +# 1353 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1353 +struct cudaAccessPolicyWindow { +# 1354 +void *base_ptr; +# 1355 +size_t num_bytes; +# 1356 +float hitRatio; +# 1357 +cudaAccessProperty hitProp; +# 1358 +cudaAccessProperty missProp; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 1359 +}; +#endif +# 1371 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +typedef void (*cudaHostFn_t)(void * userData); +# 1376 +#if 0 +# 1376 +struct cudaHostNodeParams { +# 1377 +cudaHostFn_t fn; +# 1378 +void *userData; +# 1379 +}; +#endif +# 1384 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1384 +struct cudaHostNodeParamsV2 { +# 1385 +cudaHostFn_t fn; +# 1386 +void *userData; +# 1387 +}; +#endif +# 1392 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1392 +enum cudaStreamCaptureStatus { +# 1393 +cudaStreamCaptureStatusNone, +# 1394 +cudaStreamCaptureStatusActive, +# 1395 +cudaStreamCaptureStatusInvalidated +# 1397 +}; +#endif +# 1403 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1403 +enum cudaStreamCaptureMode { +# 1404 +cudaStreamCaptureModeGlobal, +# 1405 +cudaStreamCaptureModeThreadLocal, +# 1406 +cudaStreamCaptureModeRelaxed +# 1407 +}; +#endif +# 1409 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1409 +enum cudaSynchronizationPolicy { +# 1410 +cudaSyncPolicyAuto = 1, +# 1411 +cudaSyncPolicySpin, +# 1412 +cudaSyncPolicyYield, +# 1413 +cudaSyncPolicyBlockingSync +# 1414 +}; +#endif +# 1419 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1419 +enum cudaClusterSchedulingPolicy { +# 1420 +cudaClusterSchedulingPolicyDefault, +# 1421 +cudaClusterSchedulingPolicySpread, +# 1422 +cudaClusterSchedulingPolicyLoadBalancing +# 1423 +}; +#endif +# 1428 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1428 +enum cudaStreamUpdateCaptureDependenciesFlags { +# 1429 +cudaStreamAddCaptureDependencies, +# 1430 +cudaStreamSetCaptureDependencies +# 1431 +}; +#endif +# 1436 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1436 +enum cudaUserObjectFlags { +# 1437 +cudaUserObjectNoDestructorSync = 1 +# 1438 +}; +#endif +# 1443 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1443 +enum cudaUserObjectRetainFlags { +# 1444 +cudaGraphUserObjectMove = 1 +# 1445 +}; +#endif +# 1450 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +struct cudaGraphicsResource; +# 1455 +#if 0 +# 1455 +enum cudaGraphicsRegisterFlags { +# 1457 +cudaGraphicsRegisterFlagsNone, +# 1458 +cudaGraphicsRegisterFlagsReadOnly, +# 1459 +cudaGraphicsRegisterFlagsWriteDiscard, +# 1460 +cudaGraphicsRegisterFlagsSurfaceLoadStore = 4, +# 1461 +cudaGraphicsRegisterFlagsTextureGather = 8 +# 1462 +}; +#endif +# 1467 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1467 +enum cudaGraphicsMapFlags { +# 1469 +cudaGraphicsMapFlagsNone, +# 1470 +cudaGraphicsMapFlagsReadOnly, +# 1471 +cudaGraphicsMapFlagsWriteDiscard +# 1472 +}; +#endif +# 1477 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1477 +enum cudaGraphicsCubeFace { +# 1479 +cudaGraphicsCubeFacePositiveX, +# 1480 +cudaGraphicsCubeFaceNegativeX, +# 1481 +cudaGraphicsCubeFacePositiveY, +# 1482 +cudaGraphicsCubeFaceNegativeY, +# 1483 +cudaGraphicsCubeFacePositiveZ, +# 1484 +cudaGraphicsCubeFaceNegativeZ +# 1485 +}; +#endif +# 1490 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1490 +enum cudaResourceType { +# 1492 +cudaResourceTypeArray, +# 1493 +cudaResourceTypeMipmappedArray, +# 1494 +cudaResourceTypeLinear, +# 1495 +cudaResourceTypePitch2D +# 1496 +}; +#endif +# 1501 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1501 +enum cudaResourceViewFormat { +# 1503 +cudaResViewFormatNone, +# 1504 +cudaResViewFormatUnsignedChar1, +# 1505 +cudaResViewFormatUnsignedChar2, +# 1506 +cudaResViewFormatUnsignedChar4, +# 1507 +cudaResViewFormatSignedChar1, +# 1508 +cudaResViewFormatSignedChar2, +# 1509 +cudaResViewFormatSignedChar4, +# 1510 +cudaResViewFormatUnsignedShort1, +# 1511 +cudaResViewFormatUnsignedShort2, +# 1512 +cudaResViewFormatUnsignedShort4, +# 1513 +cudaResViewFormatSignedShort1, +# 1514 +cudaResViewFormatSignedShort2, +# 1515 +cudaResViewFormatSignedShort4, +# 1516 +cudaResViewFormatUnsignedInt1, +# 1517 +cudaResViewFormatUnsignedInt2, +# 1518 +cudaResViewFormatUnsignedInt4, +# 1519 +cudaResViewFormatSignedInt1, +# 1520 +cudaResViewFormatSignedInt2, +# 1521 +cudaResViewFormatSignedInt4, +# 1522 +cudaResViewFormatHalf1, +# 1523 +cudaResViewFormatHalf2, +# 1524 +cudaResViewFormatHalf4, +# 1525 +cudaResViewFormatFloat1, +# 1526 +cudaResViewFormatFloat2, +# 1527 +cudaResViewFormatFloat4, +# 1528 +cudaResViewFormatUnsignedBlockCompressed1, +# 1529 +cudaResViewFormatUnsignedBlockCompressed2, +# 1530 +cudaResViewFormatUnsignedBlockCompressed3, +# 1531 +cudaResViewFormatUnsignedBlockCompressed4, +# 1532 +cudaResViewFormatSignedBlockCompressed4, +# 1533 +cudaResViewFormatUnsignedBlockCompressed5, +# 1534 +cudaResViewFormatSignedBlockCompressed5, +# 1535 +cudaResViewFormatUnsignedBlockCompressed6H, +# 1536 +cudaResViewFormatSignedBlockCompressed6H, +# 1537 +cudaResViewFormatUnsignedBlockCompressed7 +# 1538 +}; +#endif +# 1543 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1543 +struct cudaResourceDesc { +# 1544 +cudaResourceType resType; +# 1546 +union { +# 1547 +struct { +# 1548 +cudaArray_t array; +# 1549 +} array; +# 1550 +struct { +# 1551 +cudaMipmappedArray_t mipmap; +# 1552 +} mipmap; +# 1553 +struct { +# 1554 +void *devPtr; +# 1555 +cudaChannelFormatDesc desc; +# 1556 +size_t sizeInBytes; +# 1557 +} linear; +# 1558 +struct { +# 1559 +void *devPtr; +# 1560 +cudaChannelFormatDesc desc; +# 1561 +size_t width; +# 1562 +size_t height; +# 1563 +size_t pitchInBytes; +# 1564 +} pitch2D; +# 1565 +} res; +# 1566 +}; +#endif +# 1571 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1571 +struct cudaResourceViewDesc { +# 1573 +cudaResourceViewFormat format; +# 1574 +size_t width; +# 1575 +size_t height; +# 1576 +size_t depth; +# 1577 +unsigned firstMipmapLevel; +# 1578 +unsigned lastMipmapLevel; +# 1579 +unsigned firstLayer; +# 1580 +unsigned lastLayer; +# 1581 +}; +#endif +# 1586 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1586 +struct cudaPointerAttributes { +# 1592 +cudaMemoryType type; +# 1603 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +int device; +# 1609 +void *devicePointer; +# 1618 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +void *hostPointer; +# 1619 +}; +#endif +# 1624 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1624 +struct cudaFuncAttributes { +# 1631 +size_t sharedSizeBytes; +# 1637 +size_t constSizeBytes; +# 1642 +size_t localSizeBytes; +# 1649 +int maxThreadsPerBlock; +# 1654 +int numRegs; +# 1661 +int ptxVersion; +# 1668 +int binaryVersion; +# 1674 +int cacheModeCA; +# 1681 +int maxDynamicSharedSizeBytes; +# 1690 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +int preferredShmemCarveout; +# 1696 +int clusterDimMustBeSet; +# 1707 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +int requiredClusterWidth; +# 1708 +int requiredClusterHeight; +# 1709 +int requiredClusterDepth; +# 1715 +int clusterSchedulingPolicyPreference; +# 1737 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +int nonPortableClusterSizeAllowed; +# 1742 +int reserved[16]; +# 1743 +}; +#endif +# 1748 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1748 +enum cudaFuncAttribute { +# 1750 +cudaFuncAttributeMaxDynamicSharedMemorySize = 8, +# 1751 +cudaFuncAttributePreferredSharedMemoryCarveout, +# 1752 +cudaFuncAttributeClusterDimMustBeSet, +# 1753 +cudaFuncAttributeRequiredClusterWidth, +# 1754 +cudaFuncAttributeRequiredClusterHeight, +# 1755 +cudaFuncAttributeRequiredClusterDepth, +# 1756 +cudaFuncAttributeNonPortableClusterSizeAllowed, +# 1757 +cudaFuncAttributeClusterSchedulingPolicyPreference, +# 1758 +cudaFuncAttributeMax +# 1759 +}; +#endif +# 1764 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1764 +enum cudaFuncCache { +# 1766 +cudaFuncCachePreferNone, +# 1767 +cudaFuncCachePreferShared, +# 1768 +cudaFuncCachePreferL1, +# 1769 +cudaFuncCachePreferEqual +# 1770 +}; +#endif +# 1776 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1776 +enum cudaSharedMemConfig { +# 1778 +cudaSharedMemBankSizeDefault, +# 1779 +cudaSharedMemBankSizeFourByte, +# 1780 +cudaSharedMemBankSizeEightByte +# 1781 +}; +#endif +# 1786 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1786 +enum cudaSharedCarveout { +# 1787 +cudaSharedmemCarveoutDefault = (-1), +# 1788 +cudaSharedmemCarveoutMaxShared = 100, +# 1789 +cudaSharedmemCarveoutMaxL1 = 0 +# 1790 +}; +#endif +# 1795 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1795 +enum cudaComputeMode { +# 1797 +cudaComputeModeDefault, +# 1798 +cudaComputeModeExclusive, +# 1799 +cudaComputeModeProhibited, +# 1800 +cudaComputeModeExclusiveProcess +# 1801 +}; +#endif +# 1806 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1806 +enum cudaLimit { +# 1808 +cudaLimitStackSize, +# 1809 +cudaLimitPrintfFifoSize, +# 1810 +cudaLimitMallocHeapSize, +# 1811 +cudaLimitDevRuntimeSyncDepth, +# 1812 +cudaLimitDevRuntimePendingLaunchCount, +# 1813 +cudaLimitMaxL2FetchGranularity, +# 1814 +cudaLimitPersistingL2CacheSize +# 1815 +}; +#endif +# 1820 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1820 +enum cudaMemoryAdvise { +# 1822 +cudaMemAdviseSetReadMostly = 1, +# 1823 +cudaMemAdviseUnsetReadMostly, +# 1824 +cudaMemAdviseSetPreferredLocation, +# 1825 +cudaMemAdviseUnsetPreferredLocation, +# 1826 +cudaMemAdviseSetAccessedBy, +# 1827 +cudaMemAdviseUnsetAccessedBy +# 1828 +}; +#endif +# 1833 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1833 +enum cudaMemRangeAttribute { +# 1835 +cudaMemRangeAttributeReadMostly = 1, +# 1836 +cudaMemRangeAttributePreferredLocation, +# 1837 +cudaMemRangeAttributeAccessedBy, +# 1838 +cudaMemRangeAttributeLastPrefetchLocation, +# 1839 +cudaMemRangeAttributePreferredLocationType, +# 1840 +cudaMemRangeAttributePreferredLocationId, +# 1841 +cudaMemRangeAttributeLastPrefetchLocationType, +# 1842 +cudaMemRangeAttributeLastPrefetchLocationId +# 1843 +}; +#endif +# 1848 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1848 +enum cudaFlushGPUDirectRDMAWritesOptions { +# 1849 +cudaFlushGPUDirectRDMAWritesOptionHost = (1 << 0), +# 1850 +cudaFlushGPUDirectRDMAWritesOptionMemOps +# 1851 +}; +#endif +# 1856 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1856 +enum cudaGPUDirectRDMAWritesOrdering { +# 1857 +cudaGPUDirectRDMAWritesOrderingNone, +# 1858 +cudaGPUDirectRDMAWritesOrderingOwner = 100, +# 1859 +cudaGPUDirectRDMAWritesOrderingAllDevices = 200 +# 1860 +}; +#endif +# 1865 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1865 +enum cudaFlushGPUDirectRDMAWritesScope { +# 1866 +cudaFlushGPUDirectRDMAWritesToOwner = 100, +# 1867 +cudaFlushGPUDirectRDMAWritesToAllDevices = 200 +# 1868 +}; +#endif +# 1873 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1873 +enum cudaFlushGPUDirectRDMAWritesTarget { +# 1874 +cudaFlushGPUDirectRDMAWritesTargetCurrentDevice +# 1875 +}; +#endif +# 1881 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 1881 +enum cudaDeviceAttr { +# 1883 +cudaDevAttrMaxThreadsPerBlock = 1, +# 1884 +cudaDevAttrMaxBlockDimX, +# 1885 +cudaDevAttrMaxBlockDimY, +# 1886 +cudaDevAttrMaxBlockDimZ, +# 1887 +cudaDevAttrMaxGridDimX, +# 1888 +cudaDevAttrMaxGridDimY, +# 1889 +cudaDevAttrMaxGridDimZ, +# 1890 +cudaDevAttrMaxSharedMemoryPerBlock, +# 1891 +cudaDevAttrTotalConstantMemory, +# 1892 +cudaDevAttrWarpSize, +# 1893 +cudaDevAttrMaxPitch, +# 1894 +cudaDevAttrMaxRegistersPerBlock, +# 1895 +cudaDevAttrClockRate, +# 1896 +cudaDevAttrTextureAlignment, +# 1897 +cudaDevAttrGpuOverlap, +# 1898 +cudaDevAttrMultiProcessorCount, +# 1899 +cudaDevAttrKernelExecTimeout, +# 1900 +cudaDevAttrIntegrated, +# 1901 +cudaDevAttrCanMapHostMemory, +# 1902 +cudaDevAttrComputeMode, +# 1903 +cudaDevAttrMaxTexture1DWidth, +# 1904 +cudaDevAttrMaxTexture2DWidth, +# 1905 +cudaDevAttrMaxTexture2DHeight, +# 1906 +cudaDevAttrMaxTexture3DWidth, +# 1907 +cudaDevAttrMaxTexture3DHeight, +# 1908 +cudaDevAttrMaxTexture3DDepth, +# 1909 +cudaDevAttrMaxTexture2DLayeredWidth, +# 1910 +cudaDevAttrMaxTexture2DLayeredHeight, +# 1911 +cudaDevAttrMaxTexture2DLayeredLayers, +# 1912 +cudaDevAttrSurfaceAlignment, +# 1913 +cudaDevAttrConcurrentKernels, +# 1914 +cudaDevAttrEccEnabled, +# 1915 +cudaDevAttrPciBusId, +# 1916 +cudaDevAttrPciDeviceId, +# 1917 +cudaDevAttrTccDriver, +# 1918 +cudaDevAttrMemoryClockRate, +# 1919 +cudaDevAttrGlobalMemoryBusWidth, +# 1920 +cudaDevAttrL2CacheSize, +# 1921 +cudaDevAttrMaxThreadsPerMultiProcessor, +# 1922 +cudaDevAttrAsyncEngineCount, +# 1923 +cudaDevAttrUnifiedAddressing, +# 1924 +cudaDevAttrMaxTexture1DLayeredWidth, +# 1925 +cudaDevAttrMaxTexture1DLayeredLayers, +# 1926 +cudaDevAttrMaxTexture2DGatherWidth = 45, +# 1927 +cudaDevAttrMaxTexture2DGatherHeight, +# 1928 +cudaDevAttrMaxTexture3DWidthAlt, +# 1929 +cudaDevAttrMaxTexture3DHeightAlt, +# 1930 +cudaDevAttrMaxTexture3DDepthAlt, +# 1931 +cudaDevAttrPciDomainId, +# 1932 +cudaDevAttrTexturePitchAlignment, +# 1933 +cudaDevAttrMaxTextureCubemapWidth, +# 1934 +cudaDevAttrMaxTextureCubemapLayeredWidth, +# 1935 +cudaDevAttrMaxTextureCubemapLayeredLayers, +# 1936 +cudaDevAttrMaxSurface1DWidth, +# 1937 +cudaDevAttrMaxSurface2DWidth, +# 1938 +cudaDevAttrMaxSurface2DHeight, +# 1939 +cudaDevAttrMaxSurface3DWidth, +# 1940 +cudaDevAttrMaxSurface3DHeight, +# 1941 +cudaDevAttrMaxSurface3DDepth, +# 1942 +cudaDevAttrMaxSurface1DLayeredWidth, +# 1943 +cudaDevAttrMaxSurface1DLayeredLayers, +# 1944 +cudaDevAttrMaxSurface2DLayeredWidth, +# 1945 +cudaDevAttrMaxSurface2DLayeredHeight, +# 1946 +cudaDevAttrMaxSurface2DLayeredLayers, +# 1947 +cudaDevAttrMaxSurfaceCubemapWidth, +# 1948 +cudaDevAttrMaxSurfaceCubemapLayeredWidth, +# 1949 +cudaDevAttrMaxSurfaceCubemapLayeredLayers, +# 1950 +cudaDevAttrMaxTexture1DLinearWidth, +# 1951 +cudaDevAttrMaxTexture2DLinearWidth, +# 1952 +cudaDevAttrMaxTexture2DLinearHeight, +# 1953 +cudaDevAttrMaxTexture2DLinearPitch, +# 1954 +cudaDevAttrMaxTexture2DMipmappedWidth, +# 1955 +cudaDevAttrMaxTexture2DMipmappedHeight, +# 1956 +cudaDevAttrComputeCapabilityMajor, +# 1957 +cudaDevAttrComputeCapabilityMinor, +# 1958 +cudaDevAttrMaxTexture1DMipmappedWidth, +# 1959 +cudaDevAttrStreamPrioritiesSupported, +# 1960 +cudaDevAttrGlobalL1CacheSupported, +# 1961 +cudaDevAttrLocalL1CacheSupported, +# 1962 +cudaDevAttrMaxSharedMemoryPerMultiprocessor, +# 1963 +cudaDevAttrMaxRegistersPerMultiprocessor, +# 1964 +cudaDevAttrManagedMemory, +# 1965 +cudaDevAttrIsMultiGpuBoard, +# 1966 +cudaDevAttrMultiGpuBoardGroupID, +# 1967 +cudaDevAttrHostNativeAtomicSupported, +# 1968 +cudaDevAttrSingleToDoublePrecisionPerfRatio, +# 1969 +cudaDevAttrPageableMemoryAccess, +# 1970 +cudaDevAttrConcurrentManagedAccess, +# 1971 +cudaDevAttrComputePreemptionSupported, +# 1972 +cudaDevAttrCanUseHostPointerForRegisteredMem, +# 1973 +cudaDevAttrReserved92, +# 1974 +cudaDevAttrReserved93, +# 1975 +cudaDevAttrReserved94, +# 1976 +cudaDevAttrCooperativeLaunch, +# 1977 +cudaDevAttrCooperativeMultiDeviceLaunch, +# 1978 +cudaDevAttrMaxSharedMemoryPerBlockOptin, +# 1979 +cudaDevAttrCanFlushRemoteWrites, +# 1980 +cudaDevAttrHostRegisterSupported, +# 1981 +cudaDevAttrPageableMemoryAccessUsesHostPageTables, +# 1982 +cudaDevAttrDirectManagedMemAccessFromHost, +# 1983 +cudaDevAttrMaxBlocksPerMultiprocessor = 106, +# 1984 +cudaDevAttrMaxPersistingL2CacheSize = 108, +# 1985 +cudaDevAttrMaxAccessPolicyWindowSize, +# 1986 +cudaDevAttrReservedSharedMemoryPerBlock = 111, +# 1987 +cudaDevAttrSparseCudaArraySupported, +# 1988 +cudaDevAttrHostRegisterReadOnlySupported, +# 1989 +cudaDevAttrTimelineSemaphoreInteropSupported, +# 1990 +cudaDevAttrMaxTimelineSemaphoreInteropSupported = 114, +# 1991 +cudaDevAttrMemoryPoolsSupported, +# 1992 +cudaDevAttrGPUDirectRDMASupported, +# 1993 +cudaDevAttrGPUDirectRDMAFlushWritesOptions, +# 1994 +cudaDevAttrGPUDirectRDMAWritesOrdering, +# 1995 +cudaDevAttrMemoryPoolSupportedHandleTypes, +# 1996 +cudaDevAttrClusterLaunch, +# 1997 +cudaDevAttrDeferredMappingCudaArraySupported, +# 1998 +cudaDevAttrReserved122, +# 1999 +cudaDevAttrReserved123, +# 2000 +cudaDevAttrReserved124, +# 2001 +cudaDevAttrIpcEventSupport, +# 2002 +cudaDevAttrMemSyncDomainCount, +# 2003 +cudaDevAttrReserved127, +# 2004 +cudaDevAttrReserved128, +# 2005 +cudaDevAttrReserved129, +# 2006 +cudaDevAttrNumaConfig, +# 2007 +cudaDevAttrNumaId, +# 2008 +cudaDevAttrReserved132, +# 2009 +cudaDevAttrMpsEnabled, +# 2010 +cudaDevAttrHostNumaId, +# 2011 +cudaDevAttrMax +# 2012 +}; +#endif +# 2017 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2017 +enum cudaMemPoolAttr { +# 2027 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaMemPoolReuseFollowEventDependencies = 1, +# 2034 +cudaMemPoolReuseAllowOpportunistic, +# 2042 +cudaMemPoolReuseAllowInternalDependencies, +# 2053 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaMemPoolAttrReleaseThreshold, +# 2059 +cudaMemPoolAttrReservedMemCurrent, +# 2066 +cudaMemPoolAttrReservedMemHigh, +# 2072 +cudaMemPoolAttrUsedMemCurrent, +# 2079 +cudaMemPoolAttrUsedMemHigh +# 2080 +}; +#endif +# 2085 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2085 +enum cudaMemLocationType { +# 2086 +cudaMemLocationTypeInvalid, +# 2087 +cudaMemLocationTypeDevice, +# 2088 +cudaMemLocationTypeHost, +# 2089 +cudaMemLocationTypeHostNuma, +# 2090 +cudaMemLocationTypeHostNumaCurrent +# 2091 +}; +#endif +# 2099 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2099 +struct cudaMemLocation { +# 2100 +cudaMemLocationType type; +# 2101 +int id; +# 2102 +}; +#endif +# 2107 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2107 +enum cudaMemAccessFlags { +# 2108 +cudaMemAccessFlagsProtNone, +# 2109 +cudaMemAccessFlagsProtRead, +# 2110 +cudaMemAccessFlagsProtReadWrite = 3 +# 2111 +}; +#endif +# 2116 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2116 +struct cudaMemAccessDesc { +# 2117 +cudaMemLocation location; +# 2118 +cudaMemAccessFlags flags; +# 2119 +}; +#endif +# 2124 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2124 +enum cudaMemAllocationType { +# 2125 +cudaMemAllocationTypeInvalid, +# 2129 +cudaMemAllocationTypePinned, +# 2130 +cudaMemAllocationTypeMax = 2147483647 +# 2131 +}; +#endif +# 2136 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2136 +enum cudaMemAllocationHandleType { +# 2137 +cudaMemHandleTypeNone, +# 2138 +cudaMemHandleTypePosixFileDescriptor, +# 2139 +cudaMemHandleTypeWin32, +# 2140 +cudaMemHandleTypeWin32Kmt = 4, +# 2141 +cudaMemHandleTypeFabric = 8 +# 2142 +}; +#endif +# 2147 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2147 +struct cudaMemPoolProps { +# 2148 +cudaMemAllocationType allocType; +# 2149 +cudaMemAllocationHandleType handleTypes; +# 2150 +cudaMemLocation location; +# 2157 +void *win32SecurityAttributes; +# 2158 +size_t maxSize; +# 2159 +unsigned char reserved[56]; +# 2160 +}; +#endif +# 2165 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2165 +struct cudaMemPoolPtrExportData { +# 2166 +unsigned char reserved[64]; +# 2167 +}; +#endif +# 2172 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2172 +struct cudaMemAllocNodeParams { +# 2177 +cudaMemPoolProps poolProps; +# 2178 +const cudaMemAccessDesc *accessDescs; +# 2179 +size_t accessDescCount; +# 2180 +size_t bytesize; +# 2181 +void *dptr; +# 2182 +}; +#endif +# 2187 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2187 +struct cudaMemAllocNodeParamsV2 { +# 2192 +cudaMemPoolProps poolProps; +# 2193 +const cudaMemAccessDesc *accessDescs; +# 2194 +size_t accessDescCount; +# 2195 +size_t bytesize; +# 2196 +void *dptr; +# 2197 +}; +#endif +# 2202 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2202 +struct cudaMemFreeNodeParams { +# 2203 +void *dptr; +# 2204 +}; +#endif +# 2209 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2209 +enum cudaGraphMemAttributeType { +# 2214 +cudaGraphMemAttrUsedMemCurrent, +# 2221 +cudaGraphMemAttrUsedMemHigh, +# 2228 +cudaGraphMemAttrReservedMemCurrent, +# 2235 +cudaGraphMemAttrReservedMemHigh +# 2236 +}; +#endif +# 2242 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2242 +enum cudaDeviceP2PAttr { +# 2243 +cudaDevP2PAttrPerformanceRank = 1, +# 2244 +cudaDevP2PAttrAccessSupported, +# 2245 +cudaDevP2PAttrNativeAtomicSupported, +# 2246 +cudaDevP2PAttrCudaArrayAccessSupported +# 2247 +}; +#endif +# 2254 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2254 +struct CUuuid_st { +# 2255 +char bytes[16]; +# 2256 +}; +#endif +# 2257 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef CUuuid_st +# 2257 +CUuuid; +#endif +# 2259 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef CUuuid_st +# 2259 +cudaUUID_t; +#endif +# 2264 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2264 +struct cudaDeviceProp { +# 2266 +char name[256]; +# 2267 +cudaUUID_t uuid; +# 2268 +char luid[8]; +# 2269 +unsigned luidDeviceNodeMask; +# 2270 +size_t totalGlobalMem; +# 2271 +size_t sharedMemPerBlock; +# 2272 +int regsPerBlock; +# 2273 +int warpSize; +# 2274 +size_t memPitch; +# 2275 +int maxThreadsPerBlock; +# 2276 +int maxThreadsDim[3]; +# 2277 +int maxGridSize[3]; +# 2278 +int clockRate; +# 2279 +size_t totalConstMem; +# 2280 +int major; +# 2281 +int minor; +# 2282 +size_t textureAlignment; +# 2283 +size_t texturePitchAlignment; +# 2284 +int deviceOverlap; +# 2285 +int multiProcessorCount; +# 2286 +int kernelExecTimeoutEnabled; +# 2287 +int integrated; +# 2288 +int canMapHostMemory; +# 2289 +int computeMode; +# 2290 +int maxTexture1D; +# 2291 +int maxTexture1DMipmap; +# 2292 +int maxTexture1DLinear; +# 2293 +int maxTexture2D[2]; +# 2294 +int maxTexture2DMipmap[2]; +# 2295 +int maxTexture2DLinear[3]; +# 2296 +int maxTexture2DGather[2]; +# 2297 +int maxTexture3D[3]; +# 2298 +int maxTexture3DAlt[3]; +# 2299 +int maxTextureCubemap; +# 2300 +int maxTexture1DLayered[2]; +# 2301 +int maxTexture2DLayered[3]; +# 2302 +int maxTextureCubemapLayered[2]; +# 2303 +int maxSurface1D; +# 2304 +int maxSurface2D[2]; +# 2305 +int maxSurface3D[3]; +# 2306 +int maxSurface1DLayered[2]; +# 2307 +int maxSurface2DLayered[3]; +# 2308 +int maxSurfaceCubemap; +# 2309 +int maxSurfaceCubemapLayered[2]; +# 2310 +size_t surfaceAlignment; +# 2311 +int concurrentKernels; +# 2312 +int ECCEnabled; +# 2313 +int pciBusID; +# 2314 +int pciDeviceID; +# 2315 +int pciDomainID; +# 2316 +int tccDriver; +# 2317 +int asyncEngineCount; +# 2318 +int unifiedAddressing; +# 2319 +int memoryClockRate; +# 2320 +int memoryBusWidth; +# 2321 +int l2CacheSize; +# 2322 +int persistingL2CacheMaxSize; +# 2323 +int maxThreadsPerMultiProcessor; +# 2324 +int streamPrioritiesSupported; +# 2325 +int globalL1CacheSupported; +# 2326 +int localL1CacheSupported; +# 2327 +size_t sharedMemPerMultiprocessor; +# 2328 +int regsPerMultiprocessor; +# 2329 +int managedMemory; +# 2330 +int isMultiGpuBoard; +# 2331 +int multiGpuBoardGroupID; +# 2332 +int hostNativeAtomicSupported; +# 2333 +int singleToDoublePrecisionPerfRatio; +# 2334 +int pageableMemoryAccess; +# 2335 +int concurrentManagedAccess; +# 2336 +int computePreemptionSupported; +# 2337 +int canUseHostPointerForRegisteredMem; +# 2338 +int cooperativeLaunch; +# 2339 +int cooperativeMultiDeviceLaunch; +# 2340 +size_t sharedMemPerBlockOptin; +# 2341 +int pageableMemoryAccessUsesHostPageTables; +# 2342 +int directManagedMemAccessFromHost; +# 2343 +int maxBlocksPerMultiProcessor; +# 2344 +int accessPolicyMaxWindowSize; +# 2345 +size_t reservedSharedMemPerBlock; +# 2346 +int hostRegisterSupported; +# 2347 +int sparseCudaArraySupported; +# 2348 +int hostRegisterReadOnlySupported; +# 2349 +int timelineSemaphoreInteropSupported; +# 2350 +int memoryPoolsSupported; +# 2351 +int gpuDirectRDMASupported; +# 2352 +unsigned gpuDirectRDMAFlushWritesOptions; +# 2353 +int gpuDirectRDMAWritesOrdering; +# 2354 +unsigned memoryPoolSupportedHandleTypes; +# 2355 +int deferredMappingCudaArraySupported; +# 2356 +int ipcEventSupported; +# 2357 +int clusterLaunch; +# 2358 +int unifiedFunctionPointers; +# 2359 +int reserved2[2]; +# 2360 +int reserved1[1]; +# 2361 +int reserved[60]; +# 2362 +}; +#endif +# 2375 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef +# 2372 +struct cudaIpcEventHandle_st { +# 2374 +char reserved[64]; +# 2375 +} cudaIpcEventHandle_t; +#endif +# 2383 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef +# 2380 +struct cudaIpcMemHandle_st { +# 2382 +char reserved[64]; +# 2383 +} cudaIpcMemHandle_t; +#endif +# 2391 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef +# 2388 +struct cudaMemFabricHandle_st { +# 2390 +char reserved[64]; +# 2391 +} cudaMemFabricHandle_t; +#endif +# 2396 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2396 +enum cudaExternalMemoryHandleType { +# 2400 +cudaExternalMemoryHandleTypeOpaqueFd = 1, +# 2404 +cudaExternalMemoryHandleTypeOpaqueWin32, +# 2408 +cudaExternalMemoryHandleTypeOpaqueWin32Kmt, +# 2412 +cudaExternalMemoryHandleTypeD3D12Heap, +# 2416 +cudaExternalMemoryHandleTypeD3D12Resource, +# 2420 +cudaExternalMemoryHandleTypeD3D11Resource, +# 2424 +cudaExternalMemoryHandleTypeD3D11ResourceKmt, +# 2428 +cudaExternalMemoryHandleTypeNvSciBuf +# 2429 +}; +#endif +# 2471 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2471 +struct cudaExternalMemoryHandleDesc { +# 2475 +cudaExternalMemoryHandleType type; +# 2476 +union { +# 2482 +int fd; +# 2498 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +struct { +# 2502 +void *handle; +# 2507 +const void *name; +# 2508 +} win32; +# 2513 +const void *nvSciBufObject; +# 2514 +} handle; +# 2518 +unsigned long long size; +# 2522 +unsigned flags; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 2523 +}; +#endif +# 2528 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2528 +struct cudaExternalMemoryBufferDesc { +# 2532 +unsigned long long offset; +# 2536 +unsigned long long size; +# 2540 +unsigned flags; +# 2541 +}; +#endif +# 2546 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2546 +struct cudaExternalMemoryMipmappedArrayDesc { +# 2551 +unsigned long long offset; +# 2555 +cudaChannelFormatDesc formatDesc; +# 2559 +cudaExtent extent; +# 2564 +unsigned flags; +# 2568 +unsigned numLevels; +# 2569 +}; +#endif +# 2574 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2574 +enum cudaExternalSemaphoreHandleType { +# 2578 +cudaExternalSemaphoreHandleTypeOpaqueFd = 1, +# 2582 +cudaExternalSemaphoreHandleTypeOpaqueWin32, +# 2586 +cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt, +# 2590 +cudaExternalSemaphoreHandleTypeD3D12Fence, +# 2594 +cudaExternalSemaphoreHandleTypeD3D11Fence, +# 2598 +cudaExternalSemaphoreHandleTypeNvSciSync, +# 2602 +cudaExternalSemaphoreHandleTypeKeyedMutex, +# 2606 +cudaExternalSemaphoreHandleTypeKeyedMutexKmt, +# 2610 +cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd, +# 2614 +cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32 +# 2615 +}; +#endif +# 2620 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2620 +struct cudaExternalSemaphoreHandleDesc { +# 2624 +cudaExternalSemaphoreHandleType type; +# 2625 +union { +# 2632 +int fd; +# 2648 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +struct { +# 2652 +void *handle; +# 2657 +const void *name; +# 2658 +} win32; +# 2662 +const void *nvSciSyncObj; +# 2663 +} handle; +# 2667 +unsigned flags; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 2668 +}; +#endif +# 2673 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2673 +struct cudaExternalSemaphoreSignalParams_v1 { +# 2674 +struct { +# 2678 +struct { +# 2682 +unsigned long long value; +# 2683 +} fence; +# 2684 +union { +# 2689 +void *fence; +# 2690 +unsigned long long reserved; +# 2691 +} nvSciSync; +# 2695 +struct { +# 2699 +unsigned long long key; +# 2700 +} keyedMutex; +# 2701 +} params; +# 2712 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +unsigned flags; +# 2713 +}; +#endif +# 2718 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2718 +struct cudaExternalSemaphoreWaitParams_v1 { +# 2719 +struct { +# 2723 +struct { +# 2727 +unsigned long long value; +# 2728 +} fence; +# 2729 +union { +# 2734 +void *fence; +# 2735 +unsigned long long reserved; +# 2736 +} nvSciSync; +# 2740 +struct { +# 2744 +unsigned long long key; +# 2748 +unsigned timeoutMs; +# 2749 +} keyedMutex; +# 2750 +} params; +# 2761 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +unsigned flags; +# 2762 +}; +#endif +# 2767 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2767 +struct cudaExternalSemaphoreSignalParams { +# 2768 +struct { +# 2772 +struct { +# 2776 +unsigned long long value; +# 2777 +} fence; +# 2778 +union { +# 2783 +void *fence; +# 2784 +unsigned long long reserved; +# 2785 +} nvSciSync; +# 2789 +struct { +# 2793 +unsigned long long key; +# 2794 +} keyedMutex; +# 2795 +unsigned reserved[12]; +# 2796 +} params; +# 2807 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +unsigned flags; +# 2808 +unsigned reserved[16]; +# 2809 +}; +#endif +# 2814 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2814 +struct cudaExternalSemaphoreWaitParams { +# 2815 +struct { +# 2819 +struct { +# 2823 +unsigned long long value; +# 2824 +} fence; +# 2825 +union { +# 2830 +void *fence; +# 2831 +unsigned long long reserved; +# 2832 +} nvSciSync; +# 2836 +struct { +# 2840 +unsigned long long key; +# 2844 +unsigned timeoutMs; +# 2845 +} keyedMutex; +# 2846 +unsigned reserved[10]; +# 2847 +} params; +# 2858 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +unsigned flags; +# 2859 +unsigned reserved[16]; +# 2860 +}; +#endif +# 2871 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef cudaError +# 2871 +cudaError_t; +#endif +# 2876 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef struct CUstream_st * +# 2876 +cudaStream_t; +#endif +# 2881 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef struct CUevent_st * +# 2881 +cudaEvent_t; +#endif +# 2886 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef cudaGraphicsResource * +# 2886 +cudaGraphicsResource_t; +#endif +# 2891 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef struct CUexternalMemory_st * +# 2891 +cudaExternalMemory_t; +#endif +# 2896 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef struct CUexternalSemaphore_st * +# 2896 +cudaExternalSemaphore_t; +#endif +# 2901 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef struct CUgraph_st * +# 2901 +cudaGraph_t; +#endif +# 2906 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef struct CUgraphNode_st * +# 2906 +cudaGraphNode_t; +#endif +# 2911 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef struct CUuserObject_st * +# 2911 +cudaUserObject_t; +#endif +# 2916 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef unsigned long long +# 2916 +cudaGraphConditionalHandle; +#endif +# 2921 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef struct CUfunc_st * +# 2921 +cudaFunction_t; +#endif +# 2926 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef struct CUkern_st * +# 2926 +cudaKernel_t; +#endif +# 2931 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef struct CUmemPoolHandle_st * +# 2931 +cudaMemPool_t; +#endif +# 2936 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2936 +enum cudaCGScope { +# 2937 +cudaCGScopeInvalid, +# 2938 +cudaCGScopeGrid, +# 2939 +cudaCGScopeMultiGrid +# 2940 +}; +#endif +# 2945 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2945 +struct cudaLaunchParams { +# 2947 +void *func; +# 2948 +dim3 gridDim; +# 2949 +dim3 blockDim; +# 2950 +void **args; +# 2951 +size_t sharedMem; +# 2952 +cudaStream_t stream; +# 2953 +}; +#endif +# 2958 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2958 +struct cudaKernelNodeParams { +# 2959 +void *func; +# 2960 +dim3 gridDim; +# 2961 +dim3 blockDim; +# 2962 +unsigned sharedMemBytes; +# 2963 +void **kernelParams; +# 2964 +void **extra; +# 2965 +}; +#endif +# 2970 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2970 +struct cudaKernelNodeParamsV2 { +# 2971 +void *func; +# 2973 +dim3 gridDim; +# 2974 +dim3 blockDim; +# 2980 +unsigned sharedMemBytes; +# 2981 +void **kernelParams; +# 2982 +void **extra; +# 2983 +}; +#endif +# 2988 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2988 +struct cudaExternalSemaphoreSignalNodeParams { +# 2989 +cudaExternalSemaphore_t *extSemArray; +# 2990 +const cudaExternalSemaphoreSignalParams *paramsArray; +# 2991 +unsigned numExtSems; +# 2992 +}; +#endif +# 2997 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 2997 +struct cudaExternalSemaphoreSignalNodeParamsV2 { +# 2998 +cudaExternalSemaphore_t *extSemArray; +# 2999 +const cudaExternalSemaphoreSignalParams *paramsArray; +# 3000 +unsigned numExtSems; +# 3001 +}; +#endif +# 3006 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 3006 +struct cudaExternalSemaphoreWaitNodeParams { +# 3007 +cudaExternalSemaphore_t *extSemArray; +# 3008 +const cudaExternalSemaphoreWaitParams *paramsArray; +# 3009 +unsigned numExtSems; +# 3010 +}; +#endif +# 3015 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 3015 +struct cudaExternalSemaphoreWaitNodeParamsV2 { +# 3016 +cudaExternalSemaphore_t *extSemArray; +# 3017 +const cudaExternalSemaphoreWaitParams *paramsArray; +# 3018 +unsigned numExtSems; +# 3019 +}; +#endif +# 3021 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 3021 +enum cudaGraphConditionalHandleFlags { +# 3022 +cudaGraphCondAssignDefault = 1 +# 3023 +}; +#endif +# 3028 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 3028 +enum cudaGraphConditionalNodeType { +# 3029 +cudaGraphCondTypeIf, +# 3030 +cudaGraphCondTypeWhile +# 3031 +}; +#endif +# 3036 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 3036 +struct cudaConditionalNodeParams { +# 3037 +cudaGraphConditionalHandle handle; +# 3040 +cudaGraphConditionalNodeType type; +# 3041 +unsigned size; +# 3042 +cudaGraph_t *phGraph_out; +# 3052 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +}; +#endif +# 3057 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 3057 +enum cudaGraphNodeType { +# 3058 +cudaGraphNodeTypeKernel, +# 3059 +cudaGraphNodeTypeMemcpy, +# 3060 +cudaGraphNodeTypeMemset, +# 3061 +cudaGraphNodeTypeHost, +# 3062 +cudaGraphNodeTypeGraph, +# 3063 +cudaGraphNodeTypeEmpty, +# 3064 +cudaGraphNodeTypeWaitEvent, +# 3065 +cudaGraphNodeTypeEventRecord, +# 3066 +cudaGraphNodeTypeExtSemaphoreSignal, +# 3067 +cudaGraphNodeTypeExtSemaphoreWait, +# 3068 +cudaGraphNodeTypeMemAlloc, +# 3069 +cudaGraphNodeTypeMemFree, +# 3070 +cudaGraphNodeTypeConditional = 13, +# 3087 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaGraphNodeTypeCount +# 3088 +}; +#endif +# 3093 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 3093 +struct cudaChildGraphNodeParams { +# 3094 +cudaGraph_t graph; +# 3096 +}; +#endif +# 3101 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 3101 +struct cudaEventRecordNodeParams { +# 3102 +cudaEvent_t event; +# 3103 +}; +#endif +# 3108 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 3108 +struct cudaEventWaitNodeParams { +# 3109 +cudaEvent_t event; +# 3110 +}; +#endif +# 3115 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 3115 +struct cudaGraphNodeParams { +# 3116 +cudaGraphNodeType type; +# 3117 +int reserved0[3]; +# 3119 +union { +# 3120 +long long reserved1[29]; +# 3121 +cudaKernelNodeParamsV2 kernel; +# 3122 +cudaMemcpyNodeParams memcpy; +# 3123 +cudaMemsetParamsV2 memset; +# 3124 +cudaHostNodeParamsV2 host; +# 3125 +cudaChildGraphNodeParams graph; +# 3126 +cudaEventWaitNodeParams eventWait; +# 3127 +cudaEventRecordNodeParams eventRecord; +# 3128 +cudaExternalSemaphoreSignalNodeParamsV2 extSemSignal; +# 3129 +cudaExternalSemaphoreWaitNodeParamsV2 extSemWait; +# 3130 +cudaMemAllocNodeParamsV2 alloc; +# 3131 +cudaMemFreeNodeParams free; +# 3132 +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;) +# 3133 +}; +# 3135 +long long reserved2; +# 3136 +}; +#endif +# 3148 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef +# 3141 +enum cudaGraphDependencyType_enum { +# 3142 +cudaGraphDependencyTypeDefault, +# 3143 +cudaGraphDependencyTypeProgrammatic +# 3148 +} cudaGraphDependencyType; +#endif +# 3178 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef +# 3155 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +struct cudaGraphEdgeData_st { +# 3156 +unsigned char from_port; +# 3166 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +unsigned char to_port; +# 3173 +unsigned char type; +# 3176 +unsigned char reserved[5]; +# 3178 +} cudaGraphEdgeData; +#endif +# 3199 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +typedef struct CUgraphExec_st *cudaGraphExec_t; +# 3204 +#if 0 +# 3204 +enum cudaGraphExecUpdateResult { +# 3205 +cudaGraphExecUpdateSuccess, +# 3206 +cudaGraphExecUpdateError, +# 3207 +cudaGraphExecUpdateErrorTopologyChanged, +# 3208 +cudaGraphExecUpdateErrorNodeTypeChanged, +# 3209 +cudaGraphExecUpdateErrorFunctionChanged, +# 3210 +cudaGraphExecUpdateErrorParametersChanged, +# 3211 +cudaGraphExecUpdateErrorNotSupported, +# 3212 +cudaGraphExecUpdateErrorUnsupportedFunctionChange, +# 3213 +cudaGraphExecUpdateErrorAttributesChanged +# 3214 +}; +#endif +# 3225 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef +# 3219 +enum cudaGraphInstantiateResult { +# 3220 +cudaGraphInstantiateSuccess, +# 3221 +cudaGraphInstantiateError, +# 3222 +cudaGraphInstantiateInvalidStructure, +# 3223 +cudaGraphInstantiateNodeOperationNotSupported, +# 3224 +cudaGraphInstantiateMultipleDevicesNotSupported +# 3225 +} cudaGraphInstantiateResult; +#endif +# 3236 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef +# 3230 +struct cudaGraphInstantiateParams_st { +# 3232 +unsigned long long flags; +# 3233 +cudaStream_t uploadStream; +# 3234 +cudaGraphNode_t errNode_out; +# 3235 +cudaGraphInstantiateResult result_out; +# 3236 +} cudaGraphInstantiateParams; +#endif +# 3258 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef +# 3241 +struct cudaGraphExecUpdateResultInfo_st { +# 3245 +cudaGraphExecUpdateResult result; +# 3252 +cudaGraphNode_t errorNode; +# 3257 +cudaGraphNode_t errorFromNode; +# 3258 +} cudaGraphExecUpdateResultInfo; +#endif +# 3263 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +typedef struct CUgraphDeviceUpdatableNode_st *cudaGraphDeviceNode_t; +# 3268 +#if 0 +# 3268 +enum cudaGraphKernelNodeField { +# 3270 +cudaGraphKernelNodeFieldInvalid, +# 3271 +cudaGraphKernelNodeFieldGridDim, +# 3272 +cudaGraphKernelNodeFieldParam, +# 3273 +cudaGraphKernelNodeFieldEnabled +# 3274 +}; +#endif +# 3279 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 3279 +struct cudaGraphKernelNodeUpdate { +# 3280 +cudaGraphDeviceNode_t node; +# 3281 +cudaGraphKernelNodeField field; +# 3282 +union { +# 3284 +dim3 gridDim; +# 3289 +struct { +# 3290 +const void *pValue; +# 3291 +size_t offset; +# 3292 +size_t size; +# 3293 +} param; +# 3294 +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;) +# 3295 +} updateData; +# 3296 +}; +#endif +# 3302 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 3302 +enum cudaGetDriverEntryPointFlags { +# 3303 +cudaEnableDefault, +# 3304 +cudaEnableLegacyStream, +# 3305 +cudaEnablePerThreadDefaultStream +# 3306 +}; +#endif +# 3311 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 3311 +enum cudaDriverEntryPointQueryResult { +# 3312 +cudaDriverEntryPointSuccess, +# 3313 +cudaDriverEntryPointSymbolNotFound, +# 3314 +cudaDriverEntryPointVersionNotSufficent +# 3315 +}; +#endif +# 3320 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 3320 +enum cudaGraphDebugDotFlags { +# 3321 +cudaGraphDebugDotFlagsVerbose = (1 << 0), +# 3322 +cudaGraphDebugDotFlagsKernelNodeParams = (1 << 2), +# 3323 +cudaGraphDebugDotFlagsMemcpyNodeParams = (1 << 3), +# 3324 +cudaGraphDebugDotFlagsMemsetNodeParams = (1 << 4), +# 3325 +cudaGraphDebugDotFlagsHostNodeParams = (1 << 5), +# 3326 +cudaGraphDebugDotFlagsEventNodeParams = (1 << 6), +# 3327 +cudaGraphDebugDotFlagsExtSemasSignalNodeParams = (1 << 7), +# 3328 +cudaGraphDebugDotFlagsExtSemasWaitNodeParams = (1 << 8), +# 3329 +cudaGraphDebugDotFlagsKernelNodeAttributes = (1 << 9), +# 3330 +cudaGraphDebugDotFlagsHandles = (1 << 10), +# 3331 +cudaGraphDebugDotFlagsConditionalNodeParams = (1 << 15) +# 3332 +}; +#endif +# 3337 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 3337 +enum cudaGraphInstantiateFlags { +# 3338 +cudaGraphInstantiateFlagAutoFreeOnLaunch = 1, +# 3339 +cudaGraphInstantiateFlagUpload, +# 3342 +cudaGraphInstantiateFlagDeviceLaunch = 4, +# 3345 +cudaGraphInstantiateFlagUseNodePriority = 8 +# 3347 +}; +#endif +# 3368 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef +# 3365 +enum cudaLaunchMemSyncDomain { +# 3366 +cudaLaunchMemSyncDomainDefault, +# 3367 +cudaLaunchMemSyncDomainRemote +# 3368 +} cudaLaunchMemSyncDomain; +#endif +# 3384 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef +# 3381 +struct cudaLaunchMemSyncDomainMap_st { +# 3382 +unsigned char default_; +# 3383 +unsigned char remote; +# 3384 +} cudaLaunchMemSyncDomainMap; +#endif +# 3493 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef +# 3389 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +enum cudaLaunchAttributeID { +# 3390 +cudaLaunchAttributeIgnore, +# 3391 +cudaLaunchAttributeAccessPolicyWindow, +# 3393 +cudaLaunchAttributeCooperative, +# 3395 +cudaLaunchAttributeSynchronizationPolicy, +# 3396 +cudaLaunchAttributeClusterDimension, +# 3398 +cudaLaunchAttributeClusterSchedulingPolicyPreference, +# 3400 +cudaLaunchAttributeProgrammaticStreamSerialization, +# 3411 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaLaunchAttributeProgrammaticEvent, +# 3437 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaLaunchAttributePriority, +# 3439 +cudaLaunchAttributeMemSyncDomainMap, +# 3441 +cudaLaunchAttributeMemSyncDomain, +# 3443 +cudaLaunchAttributeLaunchCompletionEvent = 12, +# 3465 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +cudaLaunchAttributeDeviceUpdatableKernelNode +# 3493 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +} cudaLaunchAttributeID; +#endif +# 3549 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef +# 3498 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +union cudaLaunchAttributeValue { +# 3499 +char pad[64]; +# 3500 +cudaAccessPolicyWindow accessPolicyWindow; +# 3501 +int cooperative; +# 3503 +cudaSynchronizationPolicy syncPolicy; +# 3517 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +struct { +# 3518 +unsigned x; +# 3519 +unsigned y; +# 3520 +unsigned z; +# 3521 +} clusterDim; +# 3522 +cudaClusterSchedulingPolicy clusterSchedulingPolicyPreference; +# 3525 +int programmaticStreamSerializationAllowed; +# 3527 +struct { +# 3528 +cudaEvent_t event; +# 3529 +int flags; +# 3531 +int triggerAtBlockStart; +# 3532 +} programmaticEvent; +# 3533 +int priority; +# 3534 +cudaLaunchMemSyncDomainMap memSyncDomainMap; +# 3537 +cudaLaunchMemSyncDomain memSyncDomain; +# 3539 +struct { +# 3540 +cudaEvent_t event; +# 3541 +int flags; +# 3543 +} launchCompletionEvent; +# 3545 +struct { +# 3546 +int deviceUpdatable; +# 3547 +cudaGraphDeviceNode_t devNode; +# 3548 +} deviceUpdatableKernelNode; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 3549 +} cudaLaunchAttributeValue; +#endif +# 3558 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef +# 3554 +struct cudaLaunchAttribute_st { +# 3555 +cudaLaunchAttributeID id; +# 3556 +char pad[(8) - sizeof(cudaLaunchAttributeID)]; +# 3557 +cudaLaunchAttributeValue val; +# 3558 +} cudaLaunchAttribute; +#endif +# 3570 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef +# 3563 +struct cudaLaunchConfig_st { +# 3564 +dim3 gridDim; +# 3565 +dim3 blockDim; +# 3566 +size_t dynamicSmemBytes; +# 3567 +cudaStream_t stream; +# 3568 +cudaLaunchAttribute *attrs; +# 3569 +unsigned numAttrs; __pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;)__pad__(volatile char:8;) +# 3570 +} cudaLaunchConfig_t; +#endif +# 3593 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +# 3593 +enum cudaDeviceNumaConfig { +# 3594 +cudaDeviceNumaConfigNone, +# 3595 +cudaDeviceNumaConfigNumaNode +# 3596 +}; +#endif +# 3601 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +typedef struct cudaAsyncCallbackEntry *cudaAsyncCallbackHandle_t; +# 3603 +struct cudaAsyncCallbackEntry; +# 3610 +#if 0 +typedef +# 3608 +enum cudaAsyncNotificationType_enum { +# 3609 +cudaAsyncNotificationTypeOverBudget = 1 +# 3610 +} cudaAsyncNotificationType; +#endif +# 3623 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +#if 0 +typedef +# 3615 +struct cudaAsyncNotificationInfo { +# 3617 +cudaAsyncNotificationType type; +# 3618 +union { +# 3619 +struct { +# 3620 +unsigned long long bytesOverBudget; +# 3621 +} overBudget; +# 3622 +} info; +# 3623 +} cudaAsyncNotificationInfo_t; +#endif +# 3625 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/driver_types.h" +typedef void (*cudaAsyncCallback)(cudaAsyncNotificationInfo_t *, void *, cudaAsyncCallbackHandle_t); +# 86 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/surface_types.h" +#if 0 +# 86 +enum cudaSurfaceBoundaryMode { +# 88 +cudaBoundaryModeZero, +# 89 +cudaBoundaryModeClamp, +# 90 +cudaBoundaryModeTrap +# 91 +}; +#endif +# 96 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/surface_types.h" +#if 0 +# 96 +enum cudaSurfaceFormatMode { +# 98 +cudaFormatModeForced, +# 99 +cudaFormatModeAuto +# 100 +}; +#endif +# 105 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/surface_types.h" +#if 0 +typedef unsigned long long +# 105 +cudaSurfaceObject_t; +#endif +# 86 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/texture_types.h" +#if 0 +# 86 +enum cudaTextureAddressMode { +# 88 +cudaAddressModeWrap, +# 89 +cudaAddressModeClamp, +# 90 +cudaAddressModeMirror, +# 91 +cudaAddressModeBorder +# 92 +}; +#endif +# 97 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/texture_types.h" +#if 0 +# 97 +enum cudaTextureFilterMode { +# 99 +cudaFilterModePoint, +# 100 +cudaFilterModeLinear +# 101 +}; +#endif +# 106 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/texture_types.h" +#if 0 +# 106 +enum cudaTextureReadMode { +# 108 +cudaReadModeElementType, +# 109 +cudaReadModeNormalizedFloat +# 110 +}; +#endif +# 115 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/texture_types.h" +#if 0 +typedef unsigned long long +# 174 +cudaTextureObject_t; +#endif +# 89 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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_E5M2 +# 89 +} cudaDataType; +# 97 +typedef +# 92 +enum libraryPropertyType_t { +# 94 +MAJOR_VERSION, +# 95 +MINOR_VERSION, +# 96 +PATCH_LEVEL +# 97 +} libraryPropertyType; +# 278 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 3 +namespace std { +# 280 +typedef unsigned long size_t; +# 281 +typedef long ptrdiff_t; +# 284 +typedef __decltype((nullptr)) nullptr_t; +# 286 +} +# 300 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 3 +namespace std { +# 302 +inline namespace __cxx11 __attribute((__abi_tag__("cxx11"))) { } +# 303 +} +# 304 +namespace __gnu_cxx { +# 306 +inline namespace __cxx11 __attribute((__abi_tag__("cxx11"))) { } +# 307 +} +# 34 "/usr/include/stdlib.h" 3 +extern "C" { +# 74 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 +typedef float __complex__ __cfloat128 __attribute((__mode__(__TC__))); +# 86 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 +typedef __float128 _Float128; +# 214 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 +typedef float _Float32; +# 251 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 +typedef double _Float64; +# 268 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 +typedef double _Float32x; +# 285 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 +typedef long double _Float64x; +# 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) +# 179 + __attribute((__nonnull__(1))); +# 181 +extern unsigned long strtoul(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) +# 183 + __attribute((__nonnull__(1))); +# 188 +__extension__ extern long long strtoq(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) +# 190 + __attribute((__nonnull__(1))); +# 193 +__extension__ extern unsigned long long strtouq(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) +# 195 + __attribute((__nonnull__(1))); +# 201 +__extension__ extern long long strtoll(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) +# 203 + __attribute((__nonnull__(1))); +# 206 +__extension__ extern unsigned long long strtoull(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base) noexcept(true) +# 208 + __attribute((__nonnull__(1))); +# 213 +extern int strfromd(char * __dest, size_t __size, const char * __format, double __f) noexcept(true) +# 215 + __attribute((__nonnull__(3))); +# 217 +extern int strfromf(char * __dest, size_t __size, const char * __format, float __f) noexcept(true) +# 219 + __attribute((__nonnull__(3))); +# 221 +extern int strfroml(char * __dest, size_t __size, const char * __format, long double __f) noexcept(true) +# 223 + __attribute((__nonnull__(3))); +# 233 "/usr/include/stdlib.h" 3 +extern int strfromf32(char * __dest, size_t __size, const char * __format, _Float32 __f) noexcept(true) +# 235 + __attribute((__nonnull__(3))); +# 239 +extern int strfromf64(char * __dest, size_t __size, const char * __format, _Float64 __f) noexcept(true) +# 241 + __attribute((__nonnull__(3))); +# 245 +extern int strfromf128(char * __dest, size_t __size, const char * __format, _Float128 __f) noexcept(true) +# 247 + __attribute((__nonnull__(3))); +# 251 +extern int strfromf32x(char * __dest, size_t __size, const char * __format, _Float32x __f) noexcept(true) +# 253 + __attribute((__nonnull__(3))); +# 257 +extern int strfromf64x(char * __dest, size_t __size, const char * __format, _Float64x __f) noexcept(true) +# 259 + __attribute((__nonnull__(3))); +# 275 "/usr/include/stdlib.h" 3 +extern long strtol_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base, locale_t __loc) noexcept(true) +# 277 + __attribute((__nonnull__(1, 4))); +# 279 +extern unsigned long strtoul_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base, locale_t __loc) noexcept(true) +# 282 + __attribute((__nonnull__(1, 4))); +# 285 +__extension__ extern long long strtoll_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base, locale_t __loc) noexcept(true) +# 288 + __attribute((__nonnull__(1, 4))); +# 291 +__extension__ extern unsigned long long strtoull_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, int __base, locale_t __loc) noexcept(true) +# 294 + __attribute((__nonnull__(1, 4))); +# 296 +extern double strtod_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 298 + __attribute((__nonnull__(1, 3))); +# 300 +extern float strtof_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 302 + __attribute((__nonnull__(1, 3))); +# 304 +extern long double strtold_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 307 + __attribute((__nonnull__(1, 3))); +# 317 "/usr/include/stdlib.h" 3 +extern _Float32 strtof32_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 320 + __attribute((__nonnull__(1, 3))); +# 324 +extern _Float64 strtof64_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 327 + __attribute((__nonnull__(1, 3))); +# 331 +extern _Float128 strtof128_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 334 + __attribute((__nonnull__(1, 3))); +# 338 +extern _Float32x strtof32x_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 341 + __attribute((__nonnull__(1, 3))); +# 345 +extern _Float64x strtof64x_l(const char *__restrict__ __nptr, char **__restrict__ __endptr, locale_t __loc) noexcept(true) +# 348 + __attribute((__nonnull__(1, 3))); +# 386 "/usr/include/stdlib.h" 3 +extern char *l64a(long __n) noexcept(true); +# 389 +extern long a64l(const char * __s) noexcept(true) +# 390 + __attribute((__pure__)) __attribute((__nonnull__(1))); +# 27 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/bits/types/clock_t.h" 3 +typedef __clock_t clock_t; +# 7 "/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h" 3 +typedef __clockid_t clockid_t; +# 10 "/usr/include/x86_64-linux-gnu/bits/types/time_t.h" 3 +typedef __time_t time_t; +# 7 "/usr/include/x86_64-linux-gnu/bits/types/timer_t.h" 3 +typedef __timer_t timer_t; +# 134 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 +typedef __useconds_t useconds_t; +# 138 +typedef __suseconds_t suseconds_t; +# 148 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 +typedef unsigned long ulong; +# 149 +typedef unsigned short ushort; +# 150 +typedef unsigned uint; +# 24 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/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/x86_64-linux-gnu/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/x86_64-linux-gnu/bits/byteswap.h" 3 +__extension__ static inline __uint64_t __bswap_64(__uint64_t __bsx) +# 71 +{ +# 73 +return __builtin_bswap64(__bsx); +# 77 +} +# 33 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/bits/types/__sigset_t.h" 3 +typedef +# 6 +struct { +# 7 +unsigned long __val[(1024) / ((8) * sizeof(unsigned long))]; +# 8 +} __sigset_t; +# 7 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 3 +typedef __sigset_t sigset_t; +# 8 "/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h" 3 +struct timeval { +# 14 +__time_t tv_sec; +# 15 +__suseconds_t tv_usec; +# 17 +}; +# 11 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 +struct timespec { +# 16 +__time_t tv_sec; +# 21 +__syscall_slong_t tv_nsec; +# 31 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 +}; +# 49 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 +typedef long __fd_mask; +# 70 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/sys/select.h" 3 +extern "C" { +# 102 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/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/x86_64-linux-gnu/sys/select.h" 3 +} +# 185 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/sys/types.h" 3 +typedef __blkcnt64_t blkcnt64_t; +# 220 +typedef __fsblkcnt64_t fsblkcnt64_t; +# 221 +typedef __fsfilcnt64_t fsfilcnt64_t; +# 33 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/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/x86_64-linux-gnu/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/x86_64-linux-gnu/bits/struct_mutex.h" 3 +}; +# 23 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/bits/struct_rwlock.h" 3 +}; +# 94 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 +struct __pthread_cond_s { +# 96 +__atomic_wide_counter __wseq; +# 97 +__atomic_wide_counter __g1_start; +# 98 +unsigned __g_refs[2]; +# 99 +unsigned __g_size[2]; +# 100 +unsigned __g1_orig_size; +# 101 +unsigned __wrefs; +# 102 +unsigned __g_signals[2]; +# 103 +}; +# 105 +typedef unsigned __tss_t; +# 106 +typedef unsigned long __thrd_t; +# 111 +typedef +# 109 +struct { +# 110 +int __data; +# 111 +} __once_flag; +# 27 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/sys/types.h" 3 +} +# 402 "/usr/include/stdlib.h" 3 +extern long random() noexcept(true); +# 405 +extern void srandom(unsigned __seed) noexcept(true); +# 411 +extern char *initstate(unsigned __seed, char * __statebuf, size_t __statelen) noexcept(true) +# 412 + __attribute((__nonnull__(2))); +# 416 +extern char *setstate(char * __statebuf) noexcept(true) __attribute((__nonnull__(1))); +# 424 +struct random_data { +# 426 +int32_t *fptr; +# 427 +int32_t *rptr; +# 428 +int32_t *state; +# 429 +int rand_type; +# 430 +int rand_deg; +# 431 +int rand_sep; +# 432 +int32_t *end_ptr; +# 433 +}; +# 435 +extern int random_r(random_data *__restrict__ __buf, int32_t *__restrict__ __result) noexcept(true) +# 436 + __attribute((__nonnull__(1, 2))); +# 438 +extern int srandom_r(unsigned __seed, random_data * __buf) noexcept(true) +# 439 + __attribute((__nonnull__(2))); +# 441 +extern int initstate_r(unsigned __seed, char *__restrict__ __statebuf, size_t __statelen, random_data *__restrict__ __buf) noexcept(true) +# 444 + __attribute((__nonnull__(2, 4))); +# 446 +extern int setstate_r(char *__restrict__ __statebuf, random_data *__restrict__ __buf) noexcept(true) +# 448 + __attribute((__nonnull__(1, 2))); +# 454 +extern int rand() noexcept(true); +# 456 +extern void srand(unsigned __seed) noexcept(true); +# 460 +extern int rand_r(unsigned * __seed) noexcept(true); +# 468 +extern double drand48() noexcept(true); +# 469 +extern double erand48(unsigned short __xsubi[3]) noexcept(true) __attribute((__nonnull__(1))); +# 472 +extern long lrand48() noexcept(true); +# 473 +extern long nrand48(unsigned short __xsubi[3]) noexcept(true) +# 474 + __attribute((__nonnull__(1))); +# 477 +extern long mrand48() noexcept(true); +# 478 +extern long jrand48(unsigned short __xsubi[3]) noexcept(true) +# 479 + __attribute((__nonnull__(1))); +# 482 +extern void srand48(long __seedval) noexcept(true); +# 483 +extern unsigned short *seed48(unsigned short __seed16v[3]) noexcept(true) +# 484 + __attribute((__nonnull__(1))); +# 485 +extern void lcong48(unsigned short __param[7]) noexcept(true) __attribute((__nonnull__(1))); +# 491 +struct drand48_data { +# 493 +unsigned short __x[3]; +# 494 +unsigned short __old_x[3]; +# 495 +unsigned short __c; +# 496 +unsigned short __init; +# 497 +__extension__ unsigned long long __a; +# 499 +}; +# 502 +extern int drand48_r(drand48_data *__restrict__ __buffer, double *__restrict__ __result) noexcept(true) +# 503 + __attribute((__nonnull__(1, 2))); +# 504 +extern int erand48_r(unsigned short __xsubi[3], drand48_data *__restrict__ __buffer, double *__restrict__ __result) noexcept(true) +# 506 + __attribute((__nonnull__(1, 2))); +# 509 +extern int lrand48_r(drand48_data *__restrict__ __buffer, long *__restrict__ __result) noexcept(true) +# 511 + __attribute((__nonnull__(1, 2))); +# 512 +extern int nrand48_r(unsigned short __xsubi[3], drand48_data *__restrict__ __buffer, long *__restrict__ __result) noexcept(true) +# 515 + __attribute((__nonnull__(1, 2))); +# 518 +extern int mrand48_r(drand48_data *__restrict__ __buffer, long *__restrict__ __result) noexcept(true) +# 520 + __attribute((__nonnull__(1, 2))); +# 521 +extern int jrand48_r(unsigned short __xsubi[3], drand48_data *__restrict__ __buffer, long *__restrict__ __result) noexcept(true) +# 524 + __attribute((__nonnull__(1, 2))); +# 527 +extern int srand48_r(long __seedval, drand48_data * __buffer) noexcept(true) +# 528 + __attribute((__nonnull__(2))); +# 530 +extern int seed48_r(unsigned short __seed16v[3], drand48_data * __buffer) noexcept(true) +# 531 + __attribute((__nonnull__(1, 2))); +# 533 +extern int lcong48_r(unsigned short __param[7], drand48_data * __buffer) noexcept(true) +# 535 + __attribute((__nonnull__(1, 2))); +# 540 +extern void *malloc(size_t __size) noexcept(true) __attribute((__malloc__)) +# 541 + __attribute((__alloc_size__(1))); +# 543 +extern void *calloc(size_t __nmemb, size_t __size) noexcept(true) +# 544 + __attribute((__malloc__)) __attribute((__alloc_size__(1, 2))); +# 551 +extern void *realloc(void * __ptr, size_t __size) noexcept(true) +# 552 + __attribute((__warn_unused_result__)) __attribute((__alloc_size__(2))); +# 555 +extern void free(void * __ptr) noexcept(true); +# 563 +extern void *reallocarray(void * __ptr, size_t __nmemb, size_t __size) noexcept(true) +# 564 + __attribute((__warn_unused_result__)) +# 565 + __attribute((__alloc_size__(2, 3))) +# 566 + __attribute((__malloc__(__builtin_free, 1))); +# 569 +extern void *reallocarray(void * __ptr, size_t __nmemb, size_t __size) noexcept(true) +# 570 + __attribute((__malloc__(reallocarray, 1))); +# 26 "/usr/include/alloca.h" 3 +extern "C" { +# 32 +extern void *alloca(size_t __size) noexcept(true); +# 38 +} +# 580 "/usr/include/stdlib.h" 3 +extern void *valloc(size_t __size) noexcept(true) __attribute((__malloc__)) +# 581 + __attribute((__alloc_size__(1))); +# 586 +extern int posix_memalign(void ** __memptr, size_t __alignment, size_t __size) noexcept(true) +# 587 + __attribute((__nonnull__(1))); +# 592 +extern void *aligned_alloc(size_t __alignment, size_t __size) noexcept(true) +# 593 + __attribute((__malloc__)) __attribute((__alloc_align__(1 ))) +# 594 + __attribute((__alloc_size__(2))); +# 598 +extern void abort() noexcept(true) __attribute((__noreturn__)); +# 602 +extern int atexit(void (* __func)(void)) noexcept(true) __attribute((__nonnull__(1))); +# 607 +extern "C++" int at_quick_exit(void (* __func)(void)) noexcept(true) __asm__("at_quick_exit") +# 608 + __attribute((__nonnull__(1))); +# 617 "/usr/include/stdlib.h" 3 +extern int on_exit(void (* __func)(int __status, void * __arg), void * __arg) noexcept(true) +# 618 + __attribute((__nonnull__(1))); +# 624 +extern void exit(int __status) noexcept(true) __attribute((__noreturn__)); +# 630 +extern void quick_exit(int __status) noexcept(true) __attribute((__noreturn__)); +# 636 +extern void _Exit(int __status) noexcept(true) __attribute((__noreturn__)); +# 641 +extern char *getenv(const char * __name) noexcept(true) __attribute((__nonnull__(1))); +# 646 +extern char *secure_getenv(const char * __name) noexcept(true) +# 647 + __attribute((__nonnull__(1))); +# 654 +extern int putenv(char * __string) noexcept(true) __attribute((__nonnull__(1))); +# 660 +extern int setenv(const char * __name, const char * __value, int __replace) noexcept(true) +# 661 + __attribute((__nonnull__(2))); +# 664 +extern int unsetenv(const char * __name) noexcept(true) __attribute((__nonnull__(1))); +# 671 +extern int clearenv() noexcept(true); +# 682 "/usr/include/stdlib.h" 3 +extern char *mktemp(char * __template) noexcept(true) __attribute((__nonnull__(1))); +# 695 "/usr/include/stdlib.h" 3 +extern int mkstemp(char * __template) __attribute((__nonnull__(1))); +# 705 "/usr/include/stdlib.h" 3 +extern int mkstemp64(char * __template) __attribute((__nonnull__(1))); +# 717 "/usr/include/stdlib.h" 3 +extern int mkstemps(char * __template, int __suffixlen) __attribute((__nonnull__(1))); +# 727 "/usr/include/stdlib.h" 3 +extern int mkstemps64(char * __template, int __suffixlen) +# 728 + __attribute((__nonnull__(1))); +# 738 "/usr/include/stdlib.h" 3 +extern char *mkdtemp(char * __template) noexcept(true) __attribute((__nonnull__(1))); +# 749 "/usr/include/stdlib.h" 3 +extern int mkostemp(char * __template, int __flags) __attribute((__nonnull__(1))); +# 759 "/usr/include/stdlib.h" 3 +extern int mkostemp64(char * __template, int __flags) __attribute((__nonnull__(1))); +# 769 "/usr/include/stdlib.h" 3 +extern int mkostemps(char * __template, int __suffixlen, int __flags) +# 770 + __attribute((__nonnull__(1))); +# 781 "/usr/include/stdlib.h" 3 +extern int mkostemps64(char * __template, int __suffixlen, int __flags) +# 782 + __attribute((__nonnull__(1))); +# 791 "/usr/include/stdlib.h" 3 +extern int system(const char * __command); +# 797 +extern char *canonicalize_file_name(const char * __name) noexcept(true) +# 798 + __attribute((__nonnull__(1))) __attribute((__malloc__)) +# 799 + __attribute((__malloc__(__builtin_free, 1))); +# 808 "/usr/include/stdlib.h" 3 +extern char *realpath(const char *__restrict__ __name, char *__restrict__ __resolved) noexcept(true); +# 816 +typedef int (*__compar_fn_t)(const void *, const void *); +# 819 +typedef __compar_fn_t comparison_fn_t; +# 823 +typedef int (*__compar_d_fn_t)(const void *, const void *, void *); +# 828 +extern void *bsearch(const void * __key, const void * __base, size_t __nmemb, size_t __size, __compar_fn_t __compar) +# 830 + __attribute((__nonnull__(1, 2, 5))); +# 838 +extern void qsort(void * __base, size_t __nmemb, size_t __size, __compar_fn_t __compar) +# 839 + __attribute((__nonnull__(1, 4))); +# 841 +extern void qsort_r(void * __base, size_t __nmemb, size_t __size, __compar_d_fn_t __compar, void * __arg) +# 843 + __attribute((__nonnull__(1, 4))); +# 848 +extern int abs(int __x) noexcept(true) __attribute((const)); +# 849 +extern long labs(long __x) noexcept(true) __attribute((const)); +# 852 +__extension__ extern long long llabs(long long __x) noexcept(true) +# 853 + __attribute((const)); +# 860 +extern div_t div(int __numer, int __denom) noexcept(true) +# 861 + __attribute((const)); +# 862 +extern ldiv_t ldiv(long __numer, long __denom) noexcept(true) +# 863 + __attribute((const)); +# 866 +__extension__ extern lldiv_t lldiv(long long __numer, long long __denom) noexcept(true) +# 868 + __attribute((const)); +# 880 "/usr/include/stdlib.h" 3 +extern char *ecvt(double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign) noexcept(true) +# 881 + __attribute((__nonnull__(3, 4))); +# 886 +extern char *fcvt(double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign) noexcept(true) +# 887 + __attribute((__nonnull__(3, 4))); +# 892 +extern char *gcvt(double __value, int __ndigit, char * __buf) noexcept(true) +# 893 + __attribute((__nonnull__(3))); +# 898 +extern char *qecvt(long double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign) noexcept(true) +# 900 + __attribute((__nonnull__(3, 4))); +# 901 +extern char *qfcvt(long double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign) noexcept(true) +# 903 + __attribute((__nonnull__(3, 4))); +# 904 +extern char *qgcvt(long double __value, int __ndigit, char * __buf) noexcept(true) +# 905 + __attribute((__nonnull__(3))); +# 910 +extern int ecvt_r(double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign, char *__restrict__ __buf, size_t __len) noexcept(true) +# 912 + __attribute((__nonnull__(3, 4, 5))); +# 913 +extern int fcvt_r(double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign, char *__restrict__ __buf, size_t __len) noexcept(true) +# 915 + __attribute((__nonnull__(3, 4, 5))); +# 917 +extern int qecvt_r(long double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign, char *__restrict__ __buf, size_t __len) noexcept(true) +# 920 + __attribute((__nonnull__(3, 4, 5))); +# 921 +extern int qfcvt_r(long double __value, int __ndigit, int *__restrict__ __decpt, int *__restrict__ __sign, char *__restrict__ __buf, size_t __len) noexcept(true) +# 924 + __attribute((__nonnull__(3, 4, 5))); +# 930 +extern int mblen(const char * __s, size_t __n) noexcept(true); +# 933 +extern int mbtowc(wchar_t *__restrict__ __pwc, const char *__restrict__ __s, size_t __n) noexcept(true); +# 937 +extern int wctomb(char * __s, wchar_t __wchar) noexcept(true); +# 941 +extern size_t mbstowcs(wchar_t *__restrict__ __pwcs, const char *__restrict__ __s, size_t __n) noexcept(true) +# 943 + __attribute((__access__(__read_only__ , 2 ))); +# 945 +extern size_t wcstombs(char *__restrict__ __s, const wchar_t *__restrict__ __pwcs, size_t __n) noexcept(true) +# 948 + __attribute((__access__(__write_only__ , 1 , 3 ))) +# 949 + __attribute((__access__(__read_only__ , 2 ))); +# 956 +extern int rpmatch(const char * __response) noexcept(true) __attribute((__nonnull__(1))); +# 967 "/usr/include/stdlib.h" 3 +extern int getsubopt(char **__restrict__ __optionp, char *const *__restrict__ __tokens, char **__restrict__ __valuep) noexcept(true) +# 970 + __attribute((__nonnull__(1, 2, 3))); +# 978 +extern int posix_openpt(int __oflag); +# 986 +extern int grantpt(int __fd) noexcept(true); +# 990 +extern int unlockpt(int __fd) noexcept(true); +# 995 +extern char *ptsname(int __fd) noexcept(true); +# 1002 +extern int ptsname_r(int __fd, char * __buf, size_t __buflen) noexcept(true) +# 1003 + __attribute((__nonnull__(2))) __attribute((__access__(__write_only__ , 2 , 3 ))); +# 1006 +extern int getpt(); +# 1013 +extern int getloadavg(double __loadavg[], int __nelem) noexcept(true) +# 1014 + __attribute((__nonnull__(1))); +# 1035 "/usr/include/stdlib.h" 3 +} +# 46 "/usr/include/c++/11/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/include/c++/11/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 +constexpr __int128 abs(__int128 __x) { return (__x >= (0)) ? __x : (-__x); } +# 108 "/usr/include/c++/11/bits/std_abs.h" 3 +} +# 109 +} +# 121 "/usr/include/c++/11/cstdlib" 3 +extern "C++" { +# 123 +namespace std __attribute((__visibility__("default"))) { +# 127 +using ::div_t; +# 128 +using ::ldiv_t; +# 130 +using ::abort; +# 132 +using ::aligned_alloc; +# 134 +using ::atexit; +# 137 +using ::at_quick_exit; +# 140 +using ::atof; +# 141 +using ::atoi; +# 142 +using ::atol; +# 143 +using ::bsearch; +# 144 +using ::calloc; +# 145 +using ::div; +# 146 +using ::exit; +# 147 +using ::free; +# 148 +using ::getenv; +# 149 +using ::labs; +# 150 +using ::ldiv; +# 151 +using ::malloc; +# 153 +using ::mblen; +# 154 +using ::mbstowcs; +# 155 +using ::mbtowc; +# 157 +using ::qsort; +# 160 +using ::quick_exit; +# 163 +using ::rand; +# 164 +using ::realloc; +# 165 +using ::srand; +# 166 +using ::strtod; +# 167 +using ::strtol; +# 168 +using ::strtoul; +# 169 +using ::system; +# 171 +using ::wcstombs; +# 172 +using ::wctomb; +# 177 +inline ldiv_t div(long __i, long __j) { return ldiv(__i, __j); } +# 182 +} +# 195 "/usr/include/c++/11/cstdlib" 3 +namespace __gnu_cxx __attribute((__visibility__("default"))) { +# 200 +using ::lldiv_t; +# 206 +using ::_Exit; +# 210 +using ::llabs; +# 213 +inline lldiv_t div(long long __n, long long __d) +# 214 +{ lldiv_t __q; (__q.quot) = (__n / __d); (__q.rem) = (__n % __d); return __q; } +# 216 +using ::lldiv; +# 227 "/usr/include/c++/11/cstdlib" 3 +using ::atoll; +# 228 +using ::strtoll; +# 229 +using ::strtoull; +# 231 +using ::strtof; +# 232 +using ::strtold; +# 235 +} +# 237 +namespace std { +# 240 +using __gnu_cxx::lldiv_t; +# 242 +using __gnu_cxx::_Exit; +# 244 +using __gnu_cxx::llabs; +# 245 +using __gnu_cxx::div; +# 246 +using __gnu_cxx::lldiv; +# 248 +using __gnu_cxx::atoll; +# 249 +using __gnu_cxx::strtof; +# 250 +using __gnu_cxx::strtoll; +# 251 +using __gnu_cxx::strtoull; +# 252 +using __gnu_cxx::strtold; +# 253 +} +# 257 +} +# 38 "/usr/include/c++/11/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; +# 54 +using std::abs; +# 55 +using std::atof; +# 56 +using std::atoi; +# 57 +using std::atol; +# 58 +using std::bsearch; +# 59 +using std::calloc; +# 60 +using std::div; +# 61 +using std::free; +# 62 +using std::getenv; +# 63 +using std::labs; +# 64 +using std::ldiv; +# 65 +using std::malloc; +# 67 +using std::mblen; +# 68 +using std::mbstowcs; +# 69 +using std::mbtowc; +# 71 +using std::qsort; +# 72 +using std::rand; +# 73 +using std::realloc; +# 74 +using std::srand; +# 75 +using std::strtod; +# 76 +using std::strtol; +# 77 +using std::strtoul; +# 78 +using std::system; +# 80 +using std::wcstombs; +# 81 +using std::wctomb; +# 180 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +extern "C" { +# 187 +__attribute__((unused)) extern cudaError_t __cudaDeviceSynchronizeDeprecationAvoidance(); +# 236 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +__attribute__((unused)) extern cudaError_t __cudaCDP2DeviceGetAttribute(int * value, cudaDeviceAttr attr, int device); +# 237 +__attribute__((unused)) extern cudaError_t __cudaCDP2DeviceGetLimit(size_t * pValue, cudaLimit limit); +# 238 +__attribute__((unused)) extern cudaError_t __cudaCDP2DeviceGetCacheConfig(cudaFuncCache * pCacheConfig); +# 239 +__attribute__((unused)) extern cudaError_t __cudaCDP2DeviceGetSharedMemConfig(cudaSharedMemConfig * pConfig); +# 240 +__attribute__((unused)) extern cudaError_t __cudaCDP2GetLastError(); +# 241 +__attribute__((unused)) extern cudaError_t __cudaCDP2PeekAtLastError(); +# 242 +__attribute__((unused)) extern const char *__cudaCDP2GetErrorString(cudaError_t error); +# 243 +__attribute__((unused)) extern const char *__cudaCDP2GetErrorName(cudaError_t error); +# 244 +__attribute__((unused)) extern cudaError_t __cudaCDP2GetDeviceCount(int * count); +# 245 +__attribute__((unused)) extern cudaError_t __cudaCDP2GetDevice(int * device); +# 246 +__attribute__((unused)) extern cudaError_t __cudaCDP2StreamCreateWithFlags(cudaStream_t * pStream, unsigned flags); +# 247 +__attribute__((unused)) extern cudaError_t __cudaCDP2StreamDestroy(cudaStream_t stream); +# 248 +__attribute__((unused)) extern cudaError_t __cudaCDP2StreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned flags); +# 249 +__attribute__((unused)) extern cudaError_t __cudaCDP2StreamWaitEvent_ptsz(cudaStream_t stream, cudaEvent_t event, unsigned flags); +# 250 +__attribute__((unused)) extern cudaError_t __cudaCDP2EventCreateWithFlags(cudaEvent_t * event, unsigned flags); +# 251 +__attribute__((unused)) extern cudaError_t __cudaCDP2EventRecord(cudaEvent_t event, cudaStream_t stream); +# 252 +__attribute__((unused)) extern cudaError_t __cudaCDP2EventRecord_ptsz(cudaEvent_t event, cudaStream_t stream); +# 253 +__attribute__((unused)) extern cudaError_t __cudaCDP2EventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned flags); +# 254 +__attribute__((unused)) extern cudaError_t __cudaCDP2EventRecordWithFlags_ptsz(cudaEvent_t event, cudaStream_t stream, unsigned flags); +# 255 +__attribute__((unused)) extern cudaError_t __cudaCDP2EventDestroy(cudaEvent_t event); +# 256 +__attribute__((unused)) extern cudaError_t __cudaCDP2FuncGetAttributes(cudaFuncAttributes * attr, const void * func); +# 257 +__attribute__((unused)) extern cudaError_t __cudaCDP2Free(void * devPtr); +# 258 +__attribute__((unused)) extern cudaError_t __cudaCDP2Malloc(void ** devPtr, size_t size); +# 259 +__attribute__((unused)) extern cudaError_t __cudaCDP2MemcpyAsync(void * dst, const void * src, size_t count, cudaMemcpyKind kind, cudaStream_t stream); +# 260 +__attribute__((unused)) extern cudaError_t __cudaCDP2MemcpyAsync_ptsz(void * dst, const void * src, size_t count, cudaMemcpyKind kind, cudaStream_t stream); +# 261 +__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); +# 262 +__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); +# 263 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memcpy3DAsync(const cudaMemcpy3DParms * p, cudaStream_t stream); +# 264 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memcpy3DAsync_ptsz(const cudaMemcpy3DParms * p, cudaStream_t stream); +# 265 +__attribute__((unused)) extern cudaError_t __cudaCDP2MemsetAsync(void * devPtr, int value, size_t count, cudaStream_t stream); +# 266 +__attribute__((unused)) extern cudaError_t __cudaCDP2MemsetAsync_ptsz(void * devPtr, int value, size_t count, cudaStream_t stream); +# 267 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memset2DAsync(void * devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream); +# 268 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memset2DAsync_ptsz(void * devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream); +# 269 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream); +# 270 +__attribute__((unused)) extern cudaError_t __cudaCDP2Memset3DAsync_ptsz(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream); +# 271 +__attribute__((unused)) extern cudaError_t __cudaCDP2RuntimeGetVersion(int * runtimeVersion); +# 272 +__attribute__((unused)) extern void *__cudaCDP2GetParameterBuffer(size_t alignment, size_t size); +# 273 +__attribute__((unused)) extern void *__cudaCDP2GetParameterBufferV2(void * func, dim3 gridDimension, dim3 blockDimension, unsigned sharedMemSize); +# 274 +__attribute__((unused)) extern cudaError_t __cudaCDP2LaunchDevice_ptsz(void * func, void * parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned sharedMemSize, cudaStream_t stream); +# 275 +__attribute__((unused)) extern cudaError_t __cudaCDP2LaunchDeviceV2_ptsz(void * parameterBuffer, cudaStream_t stream); +# 276 +__attribute__((unused)) extern cudaError_t __cudaCDP2LaunchDevice(void * func, void * parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned sharedMemSize, cudaStream_t stream); +# 277 +__attribute__((unused)) extern cudaError_t __cudaCDP2LaunchDeviceV2(void * parameterBuffer, cudaStream_t stream); +# 278 +__attribute__((unused)) extern cudaError_t __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessor(int * numBlocks, const void * func, int blockSize, size_t dynamicSmemSize); +# 279 +__attribute__((unused)) extern cudaError_t __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int * numBlocks, const void * func, int blockSize, size_t dynamicSmemSize, unsigned flags); +# 282 +extern cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream); +# 301 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline cudaGraphExec_t cudaGetCurrentGraphExec() +# 302 +{int volatile ___ = 1; +# 306 +::exit(___);} +#if 0 +# 302 +{ +# 303 +unsigned long long current_graph_exec; +# 304 +__asm__("mov.u64 %0, %%current_graph_exec;" : "=l" (current_graph_exec) :); +# 305 +return (cudaGraphExec_t)current_graph_exec; +# 306 +} +#endif +# 336 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +__attribute__((unused)) extern cudaError_t cudaGraphKernelNodeSetParam(cudaGraphDeviceNode_t node, size_t offset, const void * value, size_t size); +# 364 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +__attribute__((unused)) extern cudaError_t cudaGraphKernelNodeSetEnabled(cudaGraphDeviceNode_t node, bool enable); +# 391 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +__attribute__((unused)) extern cudaError_t cudaGraphKernelNodeSetGridDim(cudaGraphDeviceNode_t node, dim3 gridDim); +# 420 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +__attribute__((unused)) extern cudaError_t cudaGraphKernelNodeUpdatesApply(const cudaGraphKernelNodeUpdate * updates, size_t updateCount); +# 438 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline void cudaTriggerProgrammaticLaunchCompletion() +# 439 +{int volatile ___ = 1; +# 441 +::exit(___);} +#if 0 +# 439 +{ +# 440 +__asm__ volatile("griddepcontrol.launch_dependents;" : :); +# 441 +} +#endif +# 454 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline void cudaGridDependencySynchronize() +# 455 +{int volatile ___ = 1; +# 457 +::exit(___);} +#if 0 +# 455 +{ +# 456 +__asm__ volatile("griddepcontrol.wait;" : : : "memory"); +# 457 +} +#endif +# 466 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +__attribute__((unused)) extern void cudaGraphSetConditional(cudaGraphConditionalHandle handle, unsigned value); +# 469 +__attribute__((unused)) extern unsigned long long cudaCGGetIntrinsicHandle(cudaCGScope scope); +# 470 +__attribute__((unused)) extern cudaError_t cudaCGSynchronize(unsigned long long handle, unsigned flags); +# 471 +__attribute__((unused)) extern cudaError_t cudaCGSynchronizeGrid(unsigned long long handle, unsigned flags); +# 472 +__attribute__((unused)) extern cudaError_t cudaCGGetSize(unsigned * numThreads, unsigned * numGrids, unsigned long long handle); +# 473 +__attribute__((unused)) extern cudaError_t cudaCGGetRank(unsigned * threadRank, unsigned * gridRank, unsigned long long handle); +# 695 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline void *cudaGetParameterBuffer(size_t alignment, size_t size) +# 696 +{int volatile ___ = 1;(void)alignment;(void)size; +# 698 +::exit(___);} +#if 0 +# 696 +{ +# 697 +return __cudaCDP2GetParameterBuffer(alignment, size); +# 698 +} +#endif +# 705 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline void *cudaGetParameterBufferV2(void *func, dim3 gridDimension, dim3 blockDimension, unsigned sharedMemSize) +# 706 +{int volatile ___ = 1;(void)func;(void)gridDimension;(void)blockDimension;(void)sharedMemSize; +# 708 +::exit(___);} +#if 0 +# 706 +{ +# 707 +return __cudaCDP2GetParameterBufferV2(func, gridDimension, blockDimension, sharedMemSize); +# 708 +} +#endif +# 715 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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) +# 716 +{int volatile ___ = 1;(void)func;(void)parameterBuffer;(void)gridDimension;(void)blockDimension;(void)sharedMemSize;(void)stream; +# 718 +::exit(___);} +#if 0 +# 716 +{ +# 717 +return __cudaCDP2LaunchDevice_ptsz(func, parameterBuffer, gridDimension, blockDimension, sharedMemSize, stream); +# 718 +} +#endif +# 720 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline cudaError_t cudaLaunchDeviceV2_ptsz(void *parameterBuffer, cudaStream_t stream) +# 721 +{int volatile ___ = 1;(void)parameterBuffer;(void)stream; +# 723 +::exit(___);} +#if 0 +# 721 +{ +# 722 +return __cudaCDP2LaunchDeviceV2_ptsz(parameterBuffer, stream); +# 723 +} +#endif +# 781 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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) +# 782 +{int volatile ___ = 1;(void)func;(void)parameterBuffer;(void)gridDimension;(void)blockDimension;(void)sharedMemSize;(void)stream; +# 784 +::exit(___);} +#if 0 +# 782 +{ +# 783 +return __cudaCDP2LaunchDevice(func, parameterBuffer, gridDimension, blockDimension, sharedMemSize, stream); +# 784 +} +#endif +# 786 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +__attribute__((unused)) static inline cudaError_t cudaLaunchDeviceV2(void *parameterBuffer, cudaStream_t stream) +# 787 +{int volatile ___ = 1;(void)parameterBuffer;(void)stream; +# 789 +::exit(___);} +#if 0 +# 787 +{ +# 788 +return __cudaCDP2LaunchDeviceV2(parameterBuffer, stream); +# 789 +} +#endif +# 843 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +} +# 845 +template< class T> static inline cudaError_t cudaMalloc(T ** devPtr, size_t size); +# 846 +template< class T> static inline cudaError_t cudaFuncGetAttributes(cudaFuncAttributes * attr, T * entry); +# 847 +template< class T> static inline cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int * numBlocks, T func, int blockSize, size_t dynamicSmemSize); +# 848 +template< class T> static inline cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int * numBlocks, T func, int blockSize, size_t dynamicSmemSize, unsigned flags); +# 876 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_device_runtime_api.h" +template< class T> __attribute__((unused)) static inline cudaError_t +# 877 +cudaGraphKernelNodeSetParam(cudaGraphDeviceNode_t node, size_t offset, const T &value) +# 878 +{int volatile ___ = 1;(void)node;(void)offset;(void)value; +# 880 +::exit(___);} +#if 0 +# 878 +{ +# 879 +return cudaGraphKernelNodeSetParam(node, offset, &value, sizeof(T)); +# 880 +} +#endif +# 283 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern "C" { +# 323 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceReset(); +# 345 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceSynchronize(); +# 431 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceSetLimit(cudaLimit limit, size_t value); +# 467 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetLimit(size_t * pValue, cudaLimit limit); +# 490 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t * maxWidthInElements, const cudaChannelFormatDesc * fmtDesc, int device); +# 524 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetCacheConfig(cudaFuncCache * pCacheConfig); +# 561 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetStreamPriorityRange(int * leastPriority, int * greatestPriority); +# 605 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig); +# 632 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetByPCIBusId(int * device, const char * pciBusId); +# 662 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetPCIBusId(char * pciBusId, int len, int device); +# 712 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t * handle, cudaEvent_t event); +# 755 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaIpcOpenEventHandle(cudaEvent_t * event, cudaIpcEventHandle_t handle); +# 799 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t * handle, void * devPtr); +# 865 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaIpcOpenMemHandle(void ** devPtr, cudaIpcMemHandle_t handle, unsigned flags); +# 903 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaIpcCloseMemHandle(void * devPtr); +# 935 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope); +# 973 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void * userData, cudaAsyncCallbackHandle_t * callback); +# 996 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback); +# 1043 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaDeviceGetSharedMemConfig(cudaSharedMemConfig * pConfig); +# 1089 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config); +# 1130 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaThreadExit(); +# 1156 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaThreadSynchronize(); +# 1205 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaThreadSetLimit(cudaLimit limit, size_t value); +# 1238 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaThreadGetLimit(size_t * pValue, cudaLimit limit); +# 1274 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaThreadGetCacheConfig(cudaFuncCache * pCacheConfig); +# 1321 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaThreadSetCacheConfig(cudaFuncCache cacheConfig); +# 1386 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGetLastError(); +# 1437 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaPeekAtLastError(); +# 1453 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern const char *cudaGetErrorName(cudaError_t error); +# 1469 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern const char *cudaGetErrorString(cudaError_t error); +# 1498 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGetDeviceCount(int * count); +# 1803 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGetDeviceProperties_v2(cudaDeviceProp * prop, int device); +# 2005 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetAttribute(int * value, cudaDeviceAttr attr, int device); +# 2023 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t * memPool, int device); +# 2047 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool); +# 2067 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetMemPool(cudaMemPool_t * memPool, int device); +# 2129 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetNvSciSyncAttributes(void * nvSciSyncAttrList, int device, int flags); +# 2169 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetP2PAttribute(int * value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice); +# 2191 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaChooseDevice(int * device, const cudaDeviceProp * prop); +# 2220 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaInitDevice(int device, unsigned deviceFlags, unsigned flags); +# 2266 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaSetDevice(int device); +# 2288 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGetDevice(int * device); +# 2319 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaSetValidDevices(int * device_arr, int len); +# 2389 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaSetDeviceFlags(unsigned flags); +# 2434 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGetDeviceFlags(unsigned * flags); +# 2474 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaStreamCreate(cudaStream_t * pStream); +# 2506 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaStreamCreateWithFlags(cudaStream_t * pStream, unsigned flags); +# 2554 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaStreamCreateWithPriority(cudaStream_t * pStream, unsigned flags, int priority); +# 2581 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int * priority); +# 2606 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned * flags); +# 2643 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaStreamGetId(cudaStream_t hStream, unsigned long long * streamId); +# 2658 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaCtxResetPersistingL2Cache(); +# 2678 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src); +# 2699 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaStreamGetAttribute(cudaStream_t hStream, cudaLaunchAttributeID attr, cudaLaunchAttributeValue * value_out); +# 2723 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaStreamSetAttribute(cudaStream_t hStream, cudaLaunchAttributeID attr, const cudaLaunchAttributeValue * value); +# 2757 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaStreamDestroy(cudaStream_t stream); +# 2788 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned flags = 0); +# 2796 +typedef void (*cudaStreamCallback_t)(cudaStream_t stream, cudaError_t status, void * userData); +# 2863 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void * userData, unsigned flags); +# 2887 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaStreamSynchronize(cudaStream_t stream); +# 2912 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaStreamQuery(cudaStream_t stream); +# 2996 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaStreamAttachMemAsync(cudaStream_t stream, void * devPtr, size_t length = 0, unsigned flags = 4); +# 3035 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode); +# 3076 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3127 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode * mode); +# 3156 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t * pGraph); +# 3194 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus * pCaptureStatus); +# 3243 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3302 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3342 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t * dependencies, size_t numDependencies, unsigned flags = 0); +# 3377 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 3414 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaEventCreate(cudaEvent_t * event); +# 3451 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaEventCreateWithFlags(cudaEvent_t * event, unsigned flags); +# 3492 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream = 0); +# 3540 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream = 0, unsigned flags = 0); +# 3573 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaEventQuery(cudaEvent_t event); +# 3604 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaEventSynchronize(cudaEvent_t event); +# 3634 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaEventDestroy(cudaEvent_t event); +# 3679 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaEventElapsedTime(float * ms, cudaEvent_t start, cudaEvent_t end); +# 3860 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaImportExternalMemory(cudaExternalMemory_t * extMem_out, const cudaExternalMemoryHandleDesc * memHandleDesc); +# 3915 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaExternalMemoryGetMappedBuffer(void ** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc * bufferDesc); +# 3975 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t * mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc * mipmapDesc); +# 3999 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem); +# 4153 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t * extSem_out, const cudaExternalSemaphoreHandleDesc * semHandleDesc); +# 4236 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaSignalExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t * extSemArray, const cudaExternalSemaphoreSignalParams * paramsArray, unsigned numExtSems, cudaStream_t stream = 0); +# 4312 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaWaitExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t * extSemArray, const cudaExternalSemaphoreWaitParams * paramsArray, unsigned numExtSems, cudaStream_t stream = 0); +# 4335 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem); +# 4402 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaLaunchKernel(const void * func, dim3 gridDim, dim3 blockDim, void ** args, size_t sharedMem, cudaStream_t stream); +# 4464 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaLaunchKernelExC(const cudaLaunchConfig_t * config, const void * func, void ** args); +# 4521 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaLaunchCooperativeKernel(const void * func, dim3 gridDim, dim3 blockDim, void ** args, size_t sharedMem, cudaStream_t stream); +# 4622 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaLaunchCooperativeKernelMultiDevice(cudaLaunchParams * launchParamsList, unsigned numDevices, unsigned flags = 0); +# 4667 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaFuncSetCacheConfig(const void * func, cudaFuncCache cacheConfig); +# 4700 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaFuncGetAttributes(cudaFuncAttributes * attr, const void * func); +# 4737 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaFuncSetAttribute(const void * func, cudaFuncAttribute attr, int value); +# 4761 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaFuncGetName(const char ** name, const void * func); +# 4783 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaFuncGetParamInfo(const void * func, size_t paramIndex, size_t * paramOffset, size_t * paramSize); +# 4807 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaSetDoubleForDevice(double * d); +# 4831 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaSetDoubleForHost(double * d); +# 4897 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void * userData); +# 4971 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +__attribute((deprecated)) extern cudaError_t cudaFuncSetSharedMemConfig(const void * func, cudaSharedMemConfig config); +# 5027 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int * numBlocks, const void * func, int blockSize, size_t dynamicSMemSize); +# 5056 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t * dynamicSmemSize, const void * func, int numBlocks, int blockSize); +# 5101 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int * numBlocks, const void * func, int blockSize, size_t dynamicSMemSize, unsigned flags); +# 5136 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaOccupancyMaxPotentialClusterSize(int * clusterSize, const void * func, const cudaLaunchConfig_t * launchConfig); +# 5175 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaOccupancyMaxActiveClusters(int * numClusters, const void * func, const cudaLaunchConfig_t * launchConfig); +# 5295 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMallocManaged(void ** devPtr, size_t size, unsigned flags = 1); +# 5328 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMalloc(void ** devPtr, size_t size); +# 5365 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMallocHost(void ** ptr, size_t size); +# 5408 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMallocPitch(void ** devPtr, size_t * pitch, size_t width, size_t height); +# 5460 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 5498 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaFree(void * devPtr); +# 5521 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaFreeHost(void * ptr); +# 5544 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaFreeArray(cudaArray_t array); +# 5567 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray); +# 5633 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaHostAlloc(void ** pHost, size_t size, unsigned flags); +# 5730 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaHostRegister(void * ptr, size_t size, unsigned flags); +# 5753 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaHostUnregister(void * ptr); +# 5798 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaHostGetDevicePointer(void ** pDevice, void * pHost, unsigned flags); +# 5820 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaHostGetFlags(unsigned * pFlags, void * pHost); +# 5859 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMalloc3D(cudaPitchedPtr * pitchedDevPtr, cudaExtent extent); +# 6004 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMalloc3DArray(cudaArray_t * array, const cudaChannelFormatDesc * desc, cudaExtent extent, unsigned flags = 0); +# 6149 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMallocMipmappedArray(cudaMipmappedArray_t * mipmappedArray, const cudaChannelFormatDesc * desc, cudaExtent extent, unsigned numLevels, unsigned flags = 0); +# 6182 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t * levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned level); +# 6287 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy3D(const cudaMemcpy3DParms * p); +# 6319 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms * p); +# 6437 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy3DAsync(const cudaMemcpy3DParms * p, cudaStream_t stream = 0); +# 6464 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms * p, cudaStream_t stream = 0); +# 6498 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemGetInfo(size_t * free, size_t * total); +# 6524 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaArrayGetInfo(cudaChannelFormatDesc * desc, cudaExtent * extent, unsigned * flags, cudaArray_t array); +# 6553 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaArrayGetPlane(cudaArray_t * pPlaneArray, cudaArray_t hArray, unsigned planeIdx); +# 6576 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements * memoryRequirements, cudaArray_t array, int device); +# 6600 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements * memoryRequirements, cudaMipmappedArray_t mipmap, int device); +# 6628 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaArrayGetSparseProperties(cudaArraySparseProperties * sparseProperties, cudaArray_t array); +# 6658 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties * sparseProperties, cudaMipmappedArray_t mipmap); +# 6703 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpy(void * dst, const void * src, size_t count, cudaMemcpyKind kind); +# 6738 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpyPeer(void * dst, int dstDevice, const void * src, int srcDevice, size_t count); +# 6787 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 6837 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 6887 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 6934 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 6977 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7021 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpyFromSymbol(void * dst, const void * symbol, size_t count, size_t offset = 0, cudaMemcpyKind kind = cudaMemcpyDeviceToHost); +# 7078 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemcpyAsync(void * dst, const void * src, size_t count, cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7113 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7176 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7234 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7291 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7342 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7393 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7422 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemset(void * devPtr, int value, size_t count); +# 7456 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemset2D(void * devPtr, size_t pitch, int value, size_t width, size_t height); +# 7502 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent); +# 7538 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemsetAsync(void * devPtr, int value, size_t count, cudaStream_t stream = 0); +# 7579 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 7632 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream = 0); +# 7660 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGetSymbolAddress(void ** devPtr, const void * symbol); +# 7687 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGetSymbolSize(size_t * size, const void * symbol); +# 7757 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemPrefetchAsync(const void * devPtr, size_t count, int dstDevice, cudaStream_t stream = 0); +# 7759 +extern cudaError_t cudaMemPrefetchAsync_v2(const void * devPtr, size_t count, cudaMemLocation location, unsigned flags, cudaStream_t stream = 0); +# 7873 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemAdvise(const void * devPtr, size_t count, cudaMemoryAdvise advice, int device); +# 7996 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemAdvise_v2(const void * devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location); +# 8078 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemRangeGetAttribute(void * data, size_t dataSize, cudaMemRangeAttribute attribute, const void * devPtr, size_t count); +# 8121 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 8181 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 8223 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 8266 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 8317 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 8367 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 8436 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMallocAsync(void ** devPtr, size_t size, cudaStream_t hStream); +# 8462 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaFreeAsync(void * devPtr, cudaStream_t hStream); +# 8487 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep); +# 8531 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void * value); +# 8579 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void * value); +# 8594 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc * descList, size_t count); +# 8607 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolGetAccess(cudaMemAccessFlags * flags, cudaMemPool_t memPool, cudaMemLocation * location); +# 8645 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolCreate(cudaMemPool_t * memPool, const cudaMemPoolProps * poolProps); +# 8667 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool); +# 8703 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMallocFromPoolAsync(void ** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream); +# 8728 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolExportToShareableHandle(void * shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned flags); +# 8755 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolImportFromShareableHandle(cudaMemPool_t * memPool, void * shareableHandle, cudaMemAllocationHandleType handleType, unsigned flags); +# 8778 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolExportPointer(cudaMemPoolPtrExportData * exportData, void * ptr); +# 8807 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaMemPoolImportPointer(void ** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData * exportData); +# 8960 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaPointerGetAttributes(cudaPointerAttributes * attributes, const void * ptr); +# 9001 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceCanAccessPeer(int * canAccessPeer, int device, int peerDevice); +# 9043 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned flags); +# 9065 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceDisablePeerAccess(int peerDevice); +# 9129 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource); +# 9164 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned flags); +# 9203 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t * resources, cudaStream_t stream = 0); +# 9238 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t * resources, cudaStream_t stream = 0); +# 9270 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsResourceGetMappedPointer(void ** devPtr, size_t * size, cudaGraphicsResource_t resource); +# 9308 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t * array, cudaGraphicsResource_t resource, unsigned arrayIndex, unsigned mipLevel); +# 9337 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t * mipmappedArray, cudaGraphicsResource_t resource); +# 9372 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGetChannelDesc(cudaChannelFormatDesc * desc, cudaArray_const_t array); +# 9402 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f); +# 9626 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaCreateTextureObject(cudaTextureObject_t * pTexObject, const cudaResourceDesc * pResDesc, const cudaTextureDesc * pTexDesc, const cudaResourceViewDesc * pResViewDesc); +# 9646 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject); +# 9666 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGetTextureObjectResourceDesc(cudaResourceDesc * pResDesc, cudaTextureObject_t texObject); +# 9686 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGetTextureObjectTextureDesc(cudaTextureDesc * pTexDesc, cudaTextureObject_t texObject); +# 9707 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc * pResViewDesc, cudaTextureObject_t texObject); +# 9752 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t * pSurfObject, const cudaResourceDesc * pResDesc); +# 9772 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject); +# 9791 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGetSurfaceObjectResourceDesc(cudaResourceDesc * pResDesc, cudaSurfaceObject_t surfObject); +# 9825 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDriverGetVersion(int * driverVersion); +# 9854 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaRuntimeGetVersion(int * runtimeVersion); +# 9901 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphCreate(cudaGraph_t * pGraph, unsigned flags); +# 9999 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10032 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams * pNodeParams); +# 10058 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams * pNodeParams); +# 10078 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hSrc, cudaGraphNode_t hDst); +# 10101 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaLaunchAttributeID attr, cudaLaunchAttributeValue * value_out); +# 10125 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaLaunchAttributeID attr, const cudaLaunchAttributeValue * value); +# 10176 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10235 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10304 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10372 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10404 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms * pNodeParams); +# 10431 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms * pNodeParams); +# 10470 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10516 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10562 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void * dst, const void * src, size_t count, cudaMemcpyKind kind); +# 10610 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10633 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams * pNodeParams); +# 10657 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams * pNodeParams); +# 10699 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10722 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams * pNodeParams); +# 10746 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams * pNodeParams); +# 10787 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10814 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t * pGraph); +# 10852 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies); +# 10896 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 10923 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t * event_out); +# 10951 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event); +# 10998 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11025 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t * event_out); +# 11053 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event); +# 11103 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11136 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams * params_out); +# 11164 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams * nodeParams); +# 11214 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 11247 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams * params_out); +# 11275 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams * nodeParams); +# 11353 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddMemAllocNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, cudaMemAllocNodeParams * nodeParams); +# 11380 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams * params_out); +# 11441 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddMemFreeNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, void * dptr); +# 11465 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void * dptr_out); +# 11493 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGraphMemTrim(int device); +# 11530 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void * value); +# 11564 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void * value); +# 11592 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphClone(cudaGraph_t * pGraphClone, cudaGraph_t originalGraph); +# 11620 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t * pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph); +# 11651 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType * pType); +# 11682 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t * nodes, size_t * numNodes); +# 11713 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t * pRootNodes, size_t * pNumRootNodes); +# 11747 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t * from, cudaGraphNode_t * to, size_t * numEdges); +# 11787 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphGetEdges_v2(cudaGraph_t graph, cudaGraphNode_t * from, cudaGraphNode_t * to, cudaGraphEdgeData * edgeData, size_t * numEdges); +# 11818 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t * pDependencies, size_t * pNumDependencies); +# 11855 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeGetDependencies_v2(cudaGraphNode_t node, cudaGraphNode_t * pDependencies, cudaGraphEdgeData * edgeData, size_t * pNumDependencies); +# 11887 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t * pDependentNodes, size_t * pNumDependentNodes); +# 11925 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeGetDependentNodes_v2(cudaGraphNode_t node, cudaGraphNode_t * pDependentNodes, cudaGraphEdgeData * edgeData, size_t * pNumDependentNodes); +# 11956 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t * from, const cudaGraphNode_t * to, size_t numDependencies); +# 11988 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 12019 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t * from, const cudaGraphNode_t * to, size_t numDependencies); +# 12054 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 12084 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node); +# 12155 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphInstantiate(cudaGraphExec_t * pGraphExec, cudaGraph_t graph, unsigned long long flags = 0); +# 12228 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t * pGraphExec, cudaGraph_t graph, unsigned long long flags = 0); +# 12335 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphInstantiateWithParams(cudaGraphExec_t * pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams * instantiateParams); +# 12360 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long * flags); +# 12419 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams * pNodeParams); +# 12470 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms * pNodeParams); +# 12525 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 12588 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 12649 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 12704 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams * pNodeParams); +# 12744 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams * pNodeParams); +# 12791 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph); +# 12836 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event); +# 12881 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event); +# 12929 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams * nodeParams); +# 12977 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams * nodeParams); +# 13017 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned isEnabled); +# 13051 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned * isEnabled); +# 13143 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo * resultInfo); +# 13168 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream); +# 13199 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream); +# 13222 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec); +# 13243 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphDestroy(cudaGraph_t graph); +# 13262 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char * path, unsigned flags); +# 13298 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaUserObjectCreate(cudaUserObject_t * object_out, void * ptr, cudaHostFn_t destroy, unsigned initialRefcount, unsigned flags); +# 13322 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned count = 1); +# 13350 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned count = 1); +# 13378 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned count = 1, unsigned flags = 0); +# 13403 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned count = 1); +# 13445 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphAddNode(cudaGraphNode_t * pGraphNode, cudaGraph_t graph, const cudaGraphNode_t * pDependencies, size_t numDependencies, cudaGraphNodeParams * nodeParams); +# 13489 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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); +# 13518 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams * nodeParams); +# 13567 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams * nodeParams); +# 13593 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle * pHandle_out, cudaGraph_t graph, unsigned defaultLaunchValue = 0, unsigned flags = 0); +# 13671 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGetDriverEntryPoint(const char * symbol, void ** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult * driverStatus = 0); +# 13679 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGetExportTable(const void ** ppExportTable, const cudaUUID_t * pExportTableId); +# 13858 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGetFuncBySymbol(cudaFunction_t * functionPtr, const void * symbolPtr); +# 13874 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +extern cudaError_t cudaGetKernel(cudaKernel_t * kernelPtr, const void * entryFuncAddr); +# 14044 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime_api.h" +} +# 117 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/channel_descriptor.h" +template< class T> inline cudaChannelFormatDesc cudaCreateChannelDesc() +# 118 +{ +# 119 +return cudaCreateChannelDesc(0, 0, 0, 0, cudaChannelFormatKindNone); +# 120 +} +# 122 +static inline cudaChannelFormatDesc cudaCreateChannelDescHalf() +# 123 +{ +# 124 +int e = (((int)sizeof(unsigned short)) * 8); +# 126 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +# 127 +} +# 129 +static inline cudaChannelFormatDesc cudaCreateChannelDescHalf1() +# 130 +{ +# 131 +int e = (((int)sizeof(unsigned short)) * 8); +# 133 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +# 134 +} +# 136 +static inline cudaChannelFormatDesc cudaCreateChannelDescHalf2() +# 137 +{ +# 138 +int e = (((int)sizeof(unsigned short)) * 8); +# 140 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindFloat); +# 141 +} +# 143 +static inline cudaChannelFormatDesc cudaCreateChannelDescHalf4() +# 144 +{ +# 145 +int e = (((int)sizeof(unsigned short)) * 8); +# 147 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindFloat); +# 148 +} +# 150 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< char> () +# 151 +{ +# 152 +int e = (((int)sizeof(char)) * 8); +# 157 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 159 +} +# 161 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< signed char> () +# 162 +{ +# 163 +int e = (((int)sizeof(signed char)) * 8); +# 165 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 166 +} +# 168 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< unsigned char> () +# 169 +{ +# 170 +int e = (((int)sizeof(unsigned char)) * 8); +# 172 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +# 173 +} +# 175 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< char1> () +# 176 +{ +# 177 +int e = (((int)sizeof(signed char)) * 8); +# 179 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 180 +} +# 182 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< uchar1> () +# 183 +{ +# 184 +int e = (((int)sizeof(unsigned char)) * 8); +# 186 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +# 187 +} +# 189 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< char2> () +# 190 +{ +# 191 +int e = (((int)sizeof(signed char)) * 8); +# 193 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +# 194 +} +# 196 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< uchar2> () +# 197 +{ +# 198 +int e = (((int)sizeof(unsigned char)) * 8); +# 200 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +# 201 +} +# 203 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< char4> () +# 204 +{ +# 205 +int e = (((int)sizeof(signed char)) * 8); +# 207 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +# 208 +} +# 210 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< uchar4> () +# 211 +{ +# 212 +int e = (((int)sizeof(unsigned char)) * 8); +# 214 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +# 215 +} +# 217 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< short> () +# 218 +{ +# 219 +int e = (((int)sizeof(short)) * 8); +# 221 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 222 +} +# 224 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< unsigned short> () +# 225 +{ +# 226 +int e = (((int)sizeof(unsigned short)) * 8); +# 228 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +# 229 +} +# 231 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< short1> () +# 232 +{ +# 233 +int e = (((int)sizeof(short)) * 8); +# 235 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 236 +} +# 238 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< ushort1> () +# 239 +{ +# 240 +int e = (((int)sizeof(unsigned short)) * 8); +# 242 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +# 243 +} +# 245 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< short2> () +# 246 +{ +# 247 +int e = (((int)sizeof(short)) * 8); +# 249 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +# 250 +} +# 252 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< ushort2> () +# 253 +{ +# 254 +int e = (((int)sizeof(unsigned short)) * 8); +# 256 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +# 257 +} +# 259 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< short4> () +# 260 +{ +# 261 +int e = (((int)sizeof(short)) * 8); +# 263 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +# 264 +} +# 266 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< ushort4> () +# 267 +{ +# 268 +int e = (((int)sizeof(unsigned short)) * 8); +# 270 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +# 271 +} +# 273 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< int> () +# 274 +{ +# 275 +int e = (((int)sizeof(int)) * 8); +# 277 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 278 +} +# 280 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< unsigned> () +# 281 +{ +# 282 +int e = (((int)sizeof(unsigned)) * 8); +# 284 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +# 285 +} +# 287 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< int1> () +# 288 +{ +# 289 +int e = (((int)sizeof(int)) * 8); +# 291 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +# 292 +} +# 294 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< uint1> () +# 295 +{ +# 296 +int e = (((int)sizeof(unsigned)) * 8); +# 298 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +# 299 +} +# 301 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< int2> () +# 302 +{ +# 303 +int e = (((int)sizeof(int)) * 8); +# 305 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +# 306 +} +# 308 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< uint2> () +# 309 +{ +# 310 +int e = (((int)sizeof(unsigned)) * 8); +# 312 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +# 313 +} +# 315 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< int4> () +# 316 +{ +# 317 +int e = (((int)sizeof(int)) * 8); +# 319 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +# 320 +} +# 322 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< uint4> () +# 323 +{ +# 324 +int e = (((int)sizeof(unsigned)) * 8); +# 326 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +# 327 +} +# 389 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/channel_descriptor.h" +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< float> () +# 390 +{ +# 391 +int e = (((int)sizeof(float)) * 8); +# 393 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +# 394 +} +# 396 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< float1> () +# 397 +{ +# 398 +int e = (((int)sizeof(float)) * 8); +# 400 +return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +# 401 +} +# 403 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< float2> () +# 404 +{ +# 405 +int e = (((int)sizeof(float)) * 8); +# 407 +return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindFloat); +# 408 +} +# 410 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< float4> () +# 411 +{ +# 412 +int e = (((int)sizeof(float)) * 8); +# 414 +return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindFloat); +# 415 +} +# 417 +static inline cudaChannelFormatDesc cudaCreateChannelDescNV12() +# 418 +{ +# 419 +int e = (((int)sizeof(char)) * 8); +# 421 +return cudaCreateChannelDesc(e, e, e, 0, cudaChannelFormatKindNV12); +# 422 +} +# 424 +template< cudaChannelFormatKind > inline cudaChannelFormatDesc cudaCreateChannelDesc() +# 425 +{ +# 426 +return cudaCreateChannelDesc(0, 0, 0, 0, cudaChannelFormatKindNone); +# 427 +} +# 430 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedNormalized8X1> () +# 431 +{ +# 432 +return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindSignedNormalized8X1); +# 433 +} +# 435 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedNormalized8X2> () +# 436 +{ +# 437 +return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindSignedNormalized8X2); +# 438 +} +# 440 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedNormalized8X4> () +# 441 +{ +# 442 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindSignedNormalized8X4); +# 443 +} +# 446 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedNormalized8X1> () +# 447 +{ +# 448 +return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindUnsignedNormalized8X1); +# 449 +} +# 451 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedNormalized8X2> () +# 452 +{ +# 453 +return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindUnsignedNormalized8X2); +# 454 +} +# 456 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedNormalized8X4> () +# 457 +{ +# 458 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedNormalized8X4); +# 459 +} +# 462 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedNormalized16X1> () +# 463 +{ +# 464 +return cudaCreateChannelDesc(16, 0, 0, 0, cudaChannelFormatKindSignedNormalized16X1); +# 465 +} +# 467 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedNormalized16X2> () +# 468 +{ +# 469 +return cudaCreateChannelDesc(16, 16, 0, 0, cudaChannelFormatKindSignedNormalized16X2); +# 470 +} +# 472 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedNormalized16X4> () +# 473 +{ +# 474 +return cudaCreateChannelDesc(16, 16, 16, 16, cudaChannelFormatKindSignedNormalized16X4); +# 475 +} +# 478 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedNormalized16X1> () +# 479 +{ +# 480 +return cudaCreateChannelDesc(16, 0, 0, 0, cudaChannelFormatKindUnsignedNormalized16X1); +# 481 +} +# 483 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedNormalized16X2> () +# 484 +{ +# 485 +return cudaCreateChannelDesc(16, 16, 0, 0, cudaChannelFormatKindUnsignedNormalized16X2); +# 486 +} +# 488 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedNormalized16X4> () +# 489 +{ +# 490 +return cudaCreateChannelDesc(16, 16, 16, 16, cudaChannelFormatKindUnsignedNormalized16X4); +# 491 +} +# 494 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindNV12> () +# 495 +{ +# 496 +return cudaCreateChannelDesc(8, 8, 8, 0, cudaChannelFormatKindNV12); +# 497 +} +# 500 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed1> () +# 501 +{ +# 502 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed1); +# 503 +} +# 506 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed1SRGB> () +# 507 +{ +# 508 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed1SRGB); +# 509 +} +# 512 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed2> () +# 513 +{ +# 514 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed2); +# 515 +} +# 518 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed2SRGB> () +# 519 +{ +# 520 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed2SRGB); +# 521 +} +# 524 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed3> () +# 525 +{ +# 526 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed3); +# 527 +} +# 530 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed3SRGB> () +# 531 +{ +# 532 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed3SRGB); +# 533 +} +# 536 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed4> () +# 537 +{ +# 538 +return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindUnsignedBlockCompressed4); +# 539 +} +# 542 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedBlockCompressed4> () +# 543 +{ +# 544 +return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindSignedBlockCompressed4); +# 545 +} +# 548 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed5> () +# 549 +{ +# 550 +return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindUnsignedBlockCompressed5); +# 551 +} +# 554 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedBlockCompressed5> () +# 555 +{ +# 556 +return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindSignedBlockCompressed5); +# 557 +} +# 560 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed6H> () +# 561 +{ +# 562 +return cudaCreateChannelDesc(16, 16, 16, 0, cudaChannelFormatKindUnsignedBlockCompressed6H); +# 563 +} +# 566 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindSignedBlockCompressed6H> () +# 567 +{ +# 568 +return cudaCreateChannelDesc(16, 16, 16, 0, cudaChannelFormatKindSignedBlockCompressed6H); +# 569 +} +# 572 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed7> () +# 573 +{ +# 574 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed7); +# 575 +} +# 578 +template<> inline cudaChannelFormatDesc cudaCreateChannelDesc< cudaChannelFormatKindUnsignedBlockCompressed7SRGB> () +# 579 +{ +# 580 +return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed7SRGB); +# 581 +} +# 79 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 int strverscmp(const char * __s1, const char * __s2) noexcept(true) +# 507 + __attribute((__pure__)) __attribute((__nonnull__(1, 2))); +# 510 +extern char *strfry(char * __string) noexcept(true) __attribute((__nonnull__(1))); +# 513 +extern void *memfrob(void * __s, size_t __n) noexcept(true) __attribute((__nonnull__(1))) +# 514 + __attribute((__access__(__read_write__ , 1 , 2 ))); +# 522 +extern "C++" char *basename(char * __filename) noexcept(true) __asm__("basename") +# 523 + __attribute((__nonnull__(1))); +# 524 +extern "C++" const char *basename(const char * __filename) noexcept(true) __asm__("basename") +# 525 + __attribute((__nonnull__(1))); +# 539 "/usr/include/string.h" 3 +} +# 26 "/usr/include/x86_64-linux-gnu/bits/timex.h" 3 +struct timex { +# 58 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/bits/time.h" 3 +extern "C" { +# 78 +extern int clock_adjtime(__clockid_t __clock_id, timex * __utx) noexcept(true); +# 90 "/usr/include/x86_64-linux-gnu/bits/time.h" 3 +} +# 7 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/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) noexcept(true) +# 80 + __attribute((const)); +# 83 +extern time_t mktime(tm * __tp) noexcept(true); +# 100 "/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); +# 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; +# 249 "/usr/include/time.h" 3 +extern time_t timegm(tm * __tp) noexcept(true); +# 251 +extern time_t timelocal(tm * __tp) noexcept(true); +# 262 "/usr/include/time.h" 3 +extern int dysize(int __year) noexcept(true) __attribute((const)); +# 272 "/usr/include/time.h" 3 +extern int nanosleep(const timespec * __requested_time, timespec * __remaining); +# 276 +extern int clock_getres(clockid_t __clock_id, timespec * __res) noexcept(true); +# 279 +extern int clock_gettime(clockid_t __clock_id, timespec * __tp) noexcept(true); +# 282 +extern int clock_settime(clockid_t __clock_id, const timespec * __tp) noexcept(true); +# 311 "/usr/include/time.h" 3 +extern int clock_nanosleep(clockid_t __clock_id, int __flags, const timespec * __req, timespec * __rem); +# 326 "/usr/include/time.h" 3 +extern int clock_getcpuclockid(pid_t __pid, clockid_t * __clock_id) noexcept(true); +# 331 +extern int timer_create(clockid_t __clock_id, sigevent *__restrict__ __evp, timer_t *__restrict__ __timerid) noexcept(true); +# 336 +extern int timer_delete(timer_t __timerid) noexcept(true); +# 340 +extern int timer_settime(timer_t __timerid, int __flags, const itimerspec *__restrict__ __value, itimerspec *__restrict__ __ovalue) noexcept(true); +# 345 +extern int timer_gettime(timer_t __timerid, itimerspec * __value) noexcept(true); +# 364 "/usr/include/time.h" 3 +extern int timer_getoverrun(timer_t __timerid) noexcept(true); +# 371 +extern int timespec_get(timespec * __ts, int __base) noexcept(true) +# 372 + __attribute((__nonnull__(1))); +# 387 "/usr/include/time.h" 3 +extern int timespec_getres(timespec * __ts, int __base) noexcept(true); +# 413 "/usr/include/time.h" 3 +extern int getdate_err; +# 422 "/usr/include/time.h" 3 +extern tm *getdate(const char * __string); +# 436 "/usr/include/time.h" 3 +extern int getdate_r(const char *__restrict__ __string, tm *__restrict__ __resbufp); +# 440 +} +# 88 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" +extern "C" { +# 91 +extern clock_t clock() noexcept(true); +# 96 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" +extern void *memset(void *, int, size_t) noexcept(true); +# 97 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" +extern void *memcpy(void *, const void *, size_t) noexcept(true); +# 99 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/common_functions.h" +} +# 124 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern "C" { +# 222 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern int abs(int a) noexcept(true); +# 230 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern long labs(long a) noexcept(true); +# 238 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern long long llabs(long long a) noexcept(true); +# 288 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double fabs(double x) noexcept(true); +# 331 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float fabsf(float x) noexcept(true); +# 341 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern inline int min(const int a, const int b); +# 348 +extern inline unsigned umin(const unsigned a, const unsigned b); +# 355 +extern inline long long llmin(const long long a, const long long b); +# 362 +extern inline unsigned long long ullmin(const unsigned long long a, const unsigned long long b); +# 383 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float fminf(float x, float y) noexcept(true); +# 403 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double fmin(double x, double y) noexcept(true); +# 416 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern inline int max(const int a, const int b); +# 424 +extern inline unsigned umax(const unsigned a, const unsigned b); +# 431 +extern inline long long llmax(const long long a, const long long b); +# 438 +extern inline unsigned long long ullmax(const unsigned long long a, const unsigned long long b); +# 459 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float fmaxf(float x, float y) noexcept(true); +# 479 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double fmax(double, double) noexcept(true); +# 523 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double sin(double x) noexcept(true); +# 556 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double cos(double x) noexcept(true); +# 575 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern void sincos(double x, double * sptr, double * cptr) noexcept(true); +# 591 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern void sincosf(float x, float * sptr, float * cptr) noexcept(true); +# 636 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double tan(double x) noexcept(true); +# 705 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double sqrt(double x) noexcept(true); +# 777 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double rsqrt(double x); +# 847 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float rsqrtf(float x); +# 903 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double log2(double x) noexcept(true); +# 968 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double exp2(double x) noexcept(true); +# 1033 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float exp2f(float x) noexcept(true); +# 1100 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double exp10(double x) noexcept(true); +# 1163 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float exp10f(float x) noexcept(true); +# 1256 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double expm1(double x) noexcept(true); +# 1348 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float expm1f(float x) noexcept(true); +# 1404 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float log2f(float x) noexcept(true); +# 1458 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double log10(double x) noexcept(true); +# 1528 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double log(double x) noexcept(true); +# 1624 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double log1p(double x) noexcept(true); +# 1723 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float log1pf(float x) noexcept(true); +# 1787 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double floor(double x) noexcept(true); +# 1866 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double exp(double x) noexcept(true); +# 1907 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double cosh(double x) noexcept(true); +# 1957 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double sinh(double x) noexcept(true); +# 2007 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double tanh(double x) noexcept(true); +# 2062 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double acosh(double x) noexcept(true); +# 2120 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float acoshf(float x) noexcept(true); +# 2173 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double asinh(double x) noexcept(true); +# 2226 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float asinhf(float x) noexcept(true); +# 2280 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double atanh(double x) noexcept(true); +# 2334 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float atanhf(float x) noexcept(true); +# 2383 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double ldexp(double x, int exp) noexcept(true); +# 2429 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float ldexpf(float x, int exp) noexcept(true); +# 2481 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double logb(double x) noexcept(true); +# 2536 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float logbf(float x) noexcept(true); +# 2576 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern int ilogb(double x) noexcept(true); +# 2616 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern int ilogbf(float x) noexcept(true); +# 2692 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double scalbn(double x, int n) noexcept(true); +# 2768 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float scalbnf(float x, int n) noexcept(true); +# 2844 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double scalbln(double x, long n) noexcept(true); +# 2920 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float scalblnf(float x, long n) noexcept(true); +# 2997 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double frexp(double x, int * nptr) noexcept(true); +# 3071 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float frexpf(float x, int * nptr) noexcept(true); +# 3123 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double round(double x) noexcept(true); +# 3178 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float roundf(float x) noexcept(true); +# 3196 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern long lround(double x) noexcept(true); +# 3214 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern long lroundf(float x) noexcept(true); +# 3232 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern long long llround(double x) noexcept(true); +# 3250 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern long long llroundf(float x) noexcept(true); +# 3378 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float rintf(float x) noexcept(true); +# 3395 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern long lrint(double x) noexcept(true); +# 3412 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern long lrintf(float x) noexcept(true); +# 3429 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern long long llrint(double x) noexcept(true); +# 3446 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern long long llrintf(float x) noexcept(true); +# 3499 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double nearbyint(double x) noexcept(true); +# 3552 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float nearbyintf(float x) noexcept(true); +# 3614 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double ceil(double x) noexcept(true); +# 3664 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double trunc(double x) noexcept(true); +# 3717 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float truncf(float x) noexcept(true); +# 3743 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double fdim(double x, double y) noexcept(true); +# 3769 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float fdimf(float x, float y) noexcept(true); +# 4069 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double atan2(double y, double x) noexcept(true); +# 4140 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double atan(double x) noexcept(true); +# 4163 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double acos(double x) noexcept(true); +# 4214 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double asin(double x) noexcept(true); +# 4282 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double hypot(double x, double y) noexcept(true); +# 4405 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float hypotf(float x, float y) noexcept(true); +# 5191 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double cbrt(double x) noexcept(true); +# 5277 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float cbrtf(float x) noexcept(true); +# 5332 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double rcbrt(double x); +# 5382 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float rcbrtf(float x); +# 5442 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double sinpi(double x); +# 5502 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float sinpif(float x); +# 5554 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double cospi(double x); +# 5606 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float cospif(float x); +# 5636 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern void sincospi(double x, double * sptr, double * cptr); +# 5666 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern void sincospif(float x, float * sptr, float * cptr); +# 5999 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double pow(double x, double y) noexcept(true); +# 6055 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double modf(double x, double * iptr) noexcept(true); +# 6114 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double fmod(double x, double y) noexcept(true); +# 6210 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double remainder(double x, double y) noexcept(true); +# 6309 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float remainderf(float x, float y) noexcept(true); +# 6381 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double remquo(double x, double y, int * quo) noexcept(true); +# 6453 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float remquof(float x, float y, int * quo) noexcept(true); +# 6494 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double j0(double x) noexcept(true); +# 6536 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float j0f(float x) noexcept(true); +# 6605 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double j1(double x) noexcept(true); +# 6674 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float j1f(float x) noexcept(true); +# 6717 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double jn(int n, double x) noexcept(true); +# 6760 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float jnf(int n, float x) noexcept(true); +# 6821 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double y0(double x) noexcept(true); +# 6882 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float y0f(float x) noexcept(true); +# 6943 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double y1(double x) noexcept(true); +# 7004 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float y1f(float x) noexcept(true); +# 7067 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double yn(int n, double x) noexcept(true); +# 7130 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float ynf(int n, float x) noexcept(true); +# 7319 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double erf(double x) noexcept(true); +# 7401 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float erff(float x) noexcept(true); +# 7473 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double erfinv(double x); +# 7538 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float erfinvf(float x); +# 7577 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double erfc(double x) noexcept(true); +# 7615 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float erfcf(float x) noexcept(true); +# 7732 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double lgamma(double x) noexcept(true); +# 7794 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double erfcinv(double x); +# 7849 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float erfcinvf(float x); +# 7917 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double normcdfinv(double x); +# 7985 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float normcdfinvf(float x); +# 8028 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double normcdf(double x); +# 8071 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float normcdff(float x); +# 8135 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double erfcx(double x); +# 8199 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float erfcxf(float x); +# 8318 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float lgammaf(float x) noexcept(true); +# 8416 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double tgamma(double x) noexcept(true); +# 8514 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float tgammaf(float x) noexcept(true); +# 8527 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double copysign(double x, double y) noexcept(true); +# 8540 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float copysignf(float x, float y) noexcept(true); +# 8559 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double nextafter(double x, double y) noexcept(true); +# 8578 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float nextafterf(float x, float y) noexcept(true); +# 8594 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double nan(const char * tagp) noexcept(true); +# 8610 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float nanf(const char * tagp) noexcept(true); +# 8617 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern int __isinff(float) noexcept(true); +# 8618 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern int __isnanf(float) noexcept(true); +# 8628 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern int __finite(double) noexcept(true); +# 8629 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern int __finitef(float) noexcept(true); +# 8630 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern int __signbit(double) noexcept(true); +# 8631 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern int __isnan(double) noexcept(true); +# 8632 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern int __isinf(double) noexcept(true); +# 8635 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern int __signbitf(float) noexcept(true); +# 8794 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern double fma(double x, double y, double z) noexcept(true); +# 8952 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float fmaf(float x, float y, float z) noexcept(true); +# 8963 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern int __signbitl(long double) noexcept(true); +# 8969 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern int __finitel(long double) noexcept(true); +# 8970 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern int __isinfl(long double) noexcept(true); +# 8971 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern int __isnanl(long double) noexcept(true); +# 9021 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float acosf(float x) noexcept(true); +# 9080 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float asinf(float x) noexcept(true); +# 9160 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float atanf(float x) noexcept(true); +# 9457 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float atan2f(float y, float x) noexcept(true); +# 9491 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float cosf(float x) noexcept(true); +# 9533 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float sinf(float x) noexcept(true); +# 9575 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float tanf(float x) noexcept(true); +# 9616 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float coshf(float x) noexcept(true); +# 9666 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float sinhf(float x) noexcept(true); +# 9716 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float tanhf(float x) noexcept(true); +# 9768 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float logf(float x) noexcept(true); +# 9848 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float expf(float x) noexcept(true); +# 9900 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float log10f(float x) noexcept(true); +# 9955 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float modff(float x, float * iptr) noexcept(true); +# 10285 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float powf(float x, float y) noexcept(true); +# 10354 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float sqrtf(float x) noexcept(true); +# 10413 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float ceilf(float x) noexcept(true); +# 10474 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float floorf(float x) noexcept(true); +# 10532 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern float fmodf(float x, float y) noexcept(true); +# 10547 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +} +# 67 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 +extern "C++" { +# 69 +namespace std __attribute((__visibility__("default"))) { +# 73 +struct __true_type { }; +# 74 +struct __false_type { }; +# 76 +template< bool > +# 77 +struct __truth_type { +# 78 +typedef __false_type __type; }; +# 81 +template<> struct __truth_type< true> { +# 82 +typedef __true_type __type; }; +# 86 +template< class _Sp, class _Tp> +# 87 +struct __traitor { +# 89 +enum { __value = ((bool)_Sp::__value) || ((bool)_Tp::__value)}; +# 90 +typedef typename __truth_type< __value> ::__type __type; +# 91 +}; +# 94 +template< class , class > +# 95 +struct __are_same { +# 97 +enum { __value}; +# 98 +typedef __false_type __type; +# 99 +}; +# 101 +template< class _Tp> +# 102 +struct __are_same< _Tp, _Tp> { +# 104 +enum { __value = 1}; +# 105 +typedef __true_type __type; +# 106 +}; +# 109 +template< class _Tp> +# 110 +struct __is_void { +# 112 +enum { __value}; +# 113 +typedef __false_type __type; +# 114 +}; +# 117 +template<> struct __is_void< void> { +# 119 +enum { __value = 1}; +# 120 +typedef __true_type __type; +# 121 +}; +# 126 +template< class _Tp> +# 127 +struct __is_integer { +# 129 +enum { __value}; +# 130 +typedef __false_type __type; +# 131 +}; +# 138 +template<> struct __is_integer< bool> { +# 140 +enum { __value = 1}; +# 141 +typedef __true_type __type; +# 142 +}; +# 145 +template<> struct __is_integer< char> { +# 147 +enum { __value = 1}; +# 148 +typedef __true_type __type; +# 149 +}; +# 152 +template<> struct __is_integer< signed char> { +# 154 +enum { __value = 1}; +# 155 +typedef __true_type __type; +# 156 +}; +# 159 +template<> struct __is_integer< unsigned char> { +# 161 +enum { __value = 1}; +# 162 +typedef __true_type __type; +# 163 +}; +# 167 +template<> struct __is_integer< wchar_t> { +# 169 +enum { __value = 1}; +# 170 +typedef __true_type __type; +# 171 +}; +# 185 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 +template<> struct __is_integer< char16_t> { +# 187 +enum { __value = 1}; +# 188 +typedef __true_type __type; +# 189 +}; +# 192 +template<> struct __is_integer< char32_t> { +# 194 +enum { __value = 1}; +# 195 +typedef __true_type __type; +# 196 +}; +# 200 +template<> struct __is_integer< short> { +# 202 +enum { __value = 1}; +# 203 +typedef __true_type __type; +# 204 +}; +# 207 +template<> struct __is_integer< unsigned short> { +# 209 +enum { __value = 1}; +# 210 +typedef __true_type __type; +# 211 +}; +# 214 +template<> struct __is_integer< int> { +# 216 +enum { __value = 1}; +# 217 +typedef __true_type __type; +# 218 +}; +# 221 +template<> struct __is_integer< unsigned> { +# 223 +enum { __value = 1}; +# 224 +typedef __true_type __type; +# 225 +}; +# 228 +template<> struct __is_integer< long> { +# 230 +enum { __value = 1}; +# 231 +typedef __true_type __type; +# 232 +}; +# 235 +template<> struct __is_integer< unsigned long> { +# 237 +enum { __value = 1}; +# 238 +typedef __true_type __type; +# 239 +}; +# 242 +template<> struct __is_integer< long long> { +# 244 +enum { __value = 1}; +# 245 +typedef __true_type __type; +# 246 +}; +# 249 +template<> struct __is_integer< unsigned long long> { +# 251 +enum { __value = 1}; +# 252 +typedef __true_type __type; +# 253 +}; +# 270 "/usr/include/c++/11/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; }; +# 287 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 +template< class _Tp> +# 288 +struct __is_floating { +# 290 +enum { __value}; +# 291 +typedef __false_type __type; +# 292 +}; +# 296 +template<> struct __is_floating< float> { +# 298 +enum { __value = 1}; +# 299 +typedef __true_type __type; +# 300 +}; +# 303 +template<> struct __is_floating< double> { +# 305 +enum { __value = 1}; +# 306 +typedef __true_type __type; +# 307 +}; +# 310 +template<> struct __is_floating< long double> { +# 312 +enum { __value = 1}; +# 313 +typedef __true_type __type; +# 314 +}; +# 319 +template< class _Tp> +# 320 +struct __is_pointer { +# 322 +enum { __value}; +# 323 +typedef __false_type __type; +# 324 +}; +# 326 +template< class _Tp> +# 327 +struct __is_pointer< _Tp *> { +# 329 +enum { __value = 1}; +# 330 +typedef __true_type __type; +# 331 +}; +# 336 +template< class _Tp> +# 337 +struct __is_arithmetic : public __traitor< __is_integer< _Tp> , __is_floating< _Tp> > { +# 339 +}; +# 344 +template< class _Tp> +# 345 +struct __is_scalar : public __traitor< __is_arithmetic< _Tp> , __is_pointer< _Tp> > { +# 347 +}; +# 352 +template< class _Tp> +# 353 +struct __is_char { +# 355 +enum { __value}; +# 356 +typedef __false_type __type; +# 357 +}; +# 360 +template<> struct __is_char< char> { +# 362 +enum { __value = 1}; +# 363 +typedef __true_type __type; +# 364 +}; +# 368 +template<> struct __is_char< wchar_t> { +# 370 +enum { __value = 1}; +# 371 +typedef __true_type __type; +# 372 +}; +# 375 +template< class _Tp> +# 376 +struct __is_byte { +# 378 +enum { __value}; +# 379 +typedef __false_type __type; +# 380 +}; +# 383 +template<> struct __is_byte< char> { +# 385 +enum { __value = 1}; +# 386 +typedef __true_type __type; +# 387 +}; +# 390 +template<> struct __is_byte< signed char> { +# 392 +enum { __value = 1}; +# 393 +typedef __true_type __type; +# 394 +}; +# 397 +template<> struct __is_byte< unsigned char> { +# 399 +enum { __value = 1}; +# 400 +typedef __true_type __type; +# 401 +}; +# 404 +enum class byte: unsigned char; +# 407 +template<> struct __is_byte< byte> { +# 409 +enum { __value = 1}; +# 410 +typedef __true_type __type; +# 411 +}; +# 423 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 +template< class > struct iterator_traits; +# 426 +template< class _Tp> +# 427 +struct __is_nonvolatile_trivially_copyable { +# 429 +enum { __value = __is_trivially_copyable(_Tp)}; +# 430 +}; +# 435 +template< class _Tp> +# 436 +struct __is_nonvolatile_trivially_copyable< volatile _Tp> { +# 438 +enum { __value}; +# 439 +}; +# 442 +template< class _OutputIter, class _InputIter> +# 443 +struct __memcpyable { +# 445 +enum { __value}; +# 446 +}; +# 448 +template< class _Tp> +# 449 +struct __memcpyable< _Tp *, _Tp *> : public __is_nonvolatile_trivially_copyable< _Tp> { +# 451 +}; +# 453 +template< class _Tp> +# 454 +struct __memcpyable< _Tp *, const _Tp *> : public __is_nonvolatile_trivially_copyable< _Tp> { +# 456 +}; +# 463 +template< class _Iter1, class _Iter2> +# 464 +struct __memcmpable { +# 466 +enum { __value}; +# 467 +}; +# 470 +template< class _Tp> +# 471 +struct __memcmpable< _Tp *, _Tp *> : public __is_nonvolatile_trivially_copyable< _Tp> { +# 473 +}; +# 475 +template< class _Tp> +# 476 +struct __memcmpable< const _Tp *, _Tp *> : public __is_nonvolatile_trivially_copyable< _Tp> { +# 478 +}; +# 480 +template< class _Tp> +# 481 +struct __memcmpable< _Tp *, const _Tp *> : public __is_nonvolatile_trivially_copyable< _Tp> { +# 483 +}; +# 491 +template< class _Tp, bool _TreatAsBytes = __is_byte< _Tp> ::__value> +# 498 +struct __is_memcmp_ordered { +# 500 +static const bool __value = (((_Tp)(-1)) > ((_Tp)1)); +# 501 +}; +# 503 +template< class _Tp> +# 504 +struct __is_memcmp_ordered< _Tp, false> { +# 506 +static const bool __value = false; +# 507 +}; +# 510 +template< class _Tp, class _Up, bool = sizeof(_Tp) == sizeof(_Up)> +# 511 +struct __is_memcmp_ordered_with { +# 513 +static const bool __value = (__is_memcmp_ordered< _Tp> ::__value && __is_memcmp_ordered< _Up> ::__value); +# 515 +}; +# 517 +template< class _Tp, class _Up> +# 518 +struct __is_memcmp_ordered_with< _Tp, _Up, false> { +# 520 +static const bool __value = false; +# 521 +}; +# 533 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 +template<> struct __is_memcmp_ordered_with< byte, byte, true> { +# 534 +static constexpr inline bool __value = true; }; +# 536 +template< class _Tp, bool _SameSize> +# 537 +struct __is_memcmp_ordered_with< _Tp, byte, _SameSize> { +# 538 +static constexpr inline bool __value = false; }; +# 540 +template< class _Up, bool _SameSize> +# 541 +struct __is_memcmp_ordered_with< byte, _Up, _SameSize> { +# 542 +static constexpr inline bool __value = false; }; +# 548 +template< class _Tp> +# 549 +struct __is_move_iterator { +# 551 +enum { __value}; +# 552 +typedef __false_type __type; +# 553 +}; +# 557 +template< class _Iterator> inline _Iterator +# 560 +__miter_base(_Iterator __it) +# 561 +{ return __it; } +# 564 +} +# 565 +} +# 37 "/usr/include/c++/11/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> inline bool +# 152 +__is_null_pointer(_Type *__ptr) +# 153 +{ return __ptr == 0; } +# 155 +template< class _Type> inline bool +# 157 +__is_null_pointer(_Type) +# 158 +{ return false; } +# 162 +inline bool __is_null_pointer(std::nullptr_t) +# 163 +{ return true; } +# 168 +template< class _Tp, bool = std::template __is_integer< _Tp> ::__value> +# 169 +struct __promote { +# 170 +typedef double __type; }; +# 175 +template< class _Tp> +# 176 +struct __promote< _Tp, false> { +# 177 +}; +# 180 +template<> struct __promote< long double> { +# 181 +typedef long double __type; }; +# 184 +template<> struct __promote< double> { +# 185 +typedef double __type; }; +# 188 +template<> struct __promote< float> { +# 189 +typedef float __type; }; +# 192 +template< class ..._Tp> using __promoted_t = __decltype(((((typename __promote< _Tp> ::__type)0) + ... ))); +# 196 +template< class _Tp, class _Up, class +# 197 +_Tp2 = typename __promote< _Tp> ::__type, class +# 198 +_Up2 = typename __promote< _Up> ::__type> +# 199 +struct __promote_2 { +# 201 +typedef __typeof__(_Tp2() + _Up2()) __type; +# 202 +}; +# 204 +template< class _Tp, class _Up, class _Vp, class +# 205 +_Tp2 = typename __promote< _Tp> ::__type, class +# 206 +_Up2 = typename __promote< _Up> ::__type, class +# 207 +_Vp2 = typename __promote< _Vp> ::__type> +# 208 +struct __promote_3 { +# 210 +typedef __typeof__((_Tp2() + _Up2()) + _Vp2()) __type; +# 211 +}; +# 213 +template< class _Tp, class _Up, class _Vp, class _Wp, class +# 214 +_Tp2 = typename __promote< _Tp> ::__type, class +# 215 +_Up2 = typename __promote< _Up> ::__type, class +# 216 +_Vp2 = typename __promote< _Vp> ::__type, class +# 217 +_Wp2 = typename __promote< _Wp> ::__type> +# 218 +struct __promote_4 { +# 220 +typedef __typeof__(((_Tp2() + _Up2()) + _Vp2()) + _Wp2()) __type; +# 221 +}; +# 224 +} +# 225 +} +# 34 "/usr/include/math.h" 3 +extern "C" { +# 163 "/usr/include/math.h" 3 +typedef float float_t; +# 164 +typedef double double_t; +# 252 "/usr/include/math.h" 3 +enum { +# 253 +FP_INT_UPWARD, +# 256 +FP_INT_DOWNWARD, +# 259 +FP_INT_TOWARDZERO, +# 262 +FP_INT_TONEARESTFROMZERO, +# 265 +FP_INT_TONEAREST +# 268 +}; +# 20 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/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); +# 71 +extern double cosh(double __x) noexcept(true); extern double __cosh(double __x) noexcept(true); +# 73 +extern double sinh(double __x) noexcept(true); extern double __sinh(double __x) noexcept(true); +# 75 +extern double tanh(double __x) noexcept(true); extern double __tanh(double __x) noexcept(true); +# 79 +extern void sincos(double __x, double * __sinx, double * __cosx) noexcept(true); extern void __sincos(double __x, double * __sinx, double * __cosx) noexcept(true); +# 85 +extern double acosh(double __x) noexcept(true); extern double __acosh(double __x) noexcept(true); +# 87 +extern double asinh(double __x) noexcept(true); extern double __asinh(double __x) noexcept(true); +# 89 +extern double atanh(double __x) noexcept(true); extern double __atanh(double __x) noexcept(true); +# 95 +extern double exp(double __x) noexcept(true); extern double __exp(double __x) noexcept(true); +# 98 +extern double frexp(double __x, int * __exponent) noexcept(true); extern double __frexp(double __x, int * __exponent) noexcept(true); +# 101 +extern double ldexp(double __x, int __exponent) noexcept(true); extern double __ldexp(double __x, int __exponent) noexcept(true); +# 104 +extern double log(double __x) noexcept(true); extern double __log(double __x) noexcept(true); +# 107 +extern double log10(double __x) noexcept(true); extern double __log10(double __x) noexcept(true); +# 110 +extern double modf(double __x, double * __iptr) noexcept(true); extern double __modf(double __x, double * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 114 +extern double exp10(double __x) noexcept(true); extern double __exp10(double __x) noexcept(true); +# 119 +extern double expm1(double __x) noexcept(true); extern double __expm1(double __x) noexcept(true); +# 122 +extern double log1p(double __x) noexcept(true); extern double __log1p(double __x) noexcept(true); +# 125 +extern double logb(double __x) noexcept(true); extern double __logb(double __x) noexcept(true); +# 130 +extern double exp2(double __x) noexcept(true); extern double __exp2(double __x) noexcept(true); +# 133 +extern double log2(double __x) noexcept(true); extern double __log2(double __x) noexcept(true); +# 140 +extern double pow(double __x, double __y) noexcept(true); extern double __pow(double __x, double __y) noexcept(true); +# 143 +extern double sqrt(double __x) noexcept(true); extern double __sqrt(double __x) noexcept(true); +# 147 +extern double hypot(double __x, double __y) noexcept(true); extern double __hypot(double __x, double __y) noexcept(true); +# 152 +extern double cbrt(double __x) noexcept(true); extern double __cbrt(double __x) noexcept(true); +# 159 +extern double ceil(double __x) noexcept(true) __attribute((const)); extern double __ceil(double __x) noexcept(true) __attribute((const)); +# 162 +extern double fabs(double __x) noexcept(true) __attribute((const)); extern double __fabs(double __x) noexcept(true) __attribute((const)); +# 165 +extern double floor(double __x) noexcept(true) __attribute((const)); extern double __floor(double __x) noexcept(true) __attribute((const)); +# 168 +extern double fmod(double __x, double __y) noexcept(true); extern double __fmod(double __x, double __y) noexcept(true); +# 183 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern int finite(double __value) noexcept(true) +# 184 + __attribute((const)); +# 187 +extern double drem(double __x, double __y) noexcept(true); extern double __drem(double __x, double __y) noexcept(true); +# 191 +extern double significand(double __x) noexcept(true); extern double __significand(double __x) noexcept(true); +# 198 +extern double copysign(double __x, double __y) noexcept(true) __attribute((const)); extern double __copysign(double __x, double __y) noexcept(true) __attribute((const)); +# 203 +extern double nan(const char * __tagb) noexcept(true); extern double __nan(const char * __tagb) noexcept(true); +# 220 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern double j0(double) noexcept(true); extern double __j0(double) noexcept(true); +# 221 +extern double j1(double) noexcept(true); extern double __j1(double) noexcept(true); +# 222 +extern double jn(int, double) noexcept(true); extern double __jn(int, double) noexcept(true); +# 223 +extern double y0(double) noexcept(true); extern double __y0(double) noexcept(true); +# 224 +extern double y1(double) noexcept(true); extern double __y1(double) noexcept(true); +# 225 +extern double yn(int, double) noexcept(true); extern double __yn(int, double) noexcept(true); +# 231 +extern double erf(double) noexcept(true); extern double __erf(double) noexcept(true); +# 232 +extern double erfc(double) noexcept(true); extern double __erfc(double) noexcept(true); +# 233 +extern double lgamma(double) noexcept(true); extern double __lgamma(double) noexcept(true); +# 238 +extern double tgamma(double) noexcept(true); extern double __tgamma(double) noexcept(true); +# 244 +extern double gamma(double) noexcept(true); extern double __gamma(double) noexcept(true); +# 252 +extern double lgamma_r(double, int * __signgamp) noexcept(true); extern double __lgamma_r(double, int * __signgamp) noexcept(true); +# 259 +extern double rint(double __x) noexcept(true); extern double __rint(double __x) noexcept(true); +# 262 +extern double nextafter(double __x, double __y) noexcept(true); extern double __nextafter(double __x, double __y) noexcept(true); +# 264 +extern double nexttoward(double __x, long double __y) noexcept(true); extern double __nexttoward(double __x, long double __y) noexcept(true); +# 269 +extern double nextdown(double __x) noexcept(true); extern double __nextdown(double __x) noexcept(true); +# 271 +extern double nextup(double __x) noexcept(true); extern double __nextup(double __x) noexcept(true); +# 275 +extern double remainder(double __x, double __y) noexcept(true); extern double __remainder(double __x, double __y) noexcept(true); +# 279 +extern double scalbn(double __x, int __n) noexcept(true); extern double __scalbn(double __x, int __n) noexcept(true); +# 283 +extern int ilogb(double __x) noexcept(true); extern int __ilogb(double __x) noexcept(true); +# 288 +extern long llogb(double __x) noexcept(true); extern long __llogb(double __x) noexcept(true); +# 293 +extern double scalbln(double __x, long __n) noexcept(true); extern double __scalbln(double __x, long __n) noexcept(true); +# 297 +extern double nearbyint(double __x) noexcept(true); extern double __nearbyint(double __x) noexcept(true); +# 301 +extern double round(double __x) noexcept(true) __attribute((const)); extern double __round(double __x) noexcept(true) __attribute((const)); +# 305 +extern double trunc(double __x) noexcept(true) __attribute((const)); extern double __trunc(double __x) noexcept(true) __attribute((const)); +# 310 +extern double remquo(double __x, double __y, int * __quo) noexcept(true); extern double __remquo(double __x, double __y, int * __quo) noexcept(true); +# 317 +extern long lrint(double __x) noexcept(true); extern long __lrint(double __x) noexcept(true); +# 319 +__extension__ extern long long llrint(double __x) noexcept(true); extern long long __llrint(double __x) noexcept(true); +# 323 +extern long lround(double __x) noexcept(true); extern long __lround(double __x) noexcept(true); +# 325 +__extension__ extern long long llround(double __x) noexcept(true); extern long long __llround(double __x) noexcept(true); +# 329 +extern double fdim(double __x, double __y) noexcept(true); extern double __fdim(double __x, double __y) noexcept(true); +# 333 +extern double fmax(double __x, double __y) noexcept(true) __attribute((const)); extern double __fmax(double __x, double __y) noexcept(true) __attribute((const)); +# 336 +extern double fmin(double __x, double __y) noexcept(true) __attribute((const)); extern double __fmin(double __x, double __y) noexcept(true) __attribute((const)); +# 340 +extern double fma(double __x, double __y, double __z) noexcept(true); extern double __fma(double __x, double __y, double __z) noexcept(true); +# 345 +extern double roundeven(double __x) noexcept(true) __attribute((const)); extern double __roundeven(double __x) noexcept(true) __attribute((const)); +# 349 +extern __intmax_t fromfp(double __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfp(double __x, int __round, unsigned __width) noexcept(true); +# 354 +extern __uintmax_t ufromfp(double __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfp(double __x, int __round, unsigned __width) noexcept(true); +# 360 +extern __intmax_t fromfpx(double __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpx(double __x, int __round, unsigned __width) noexcept(true); +# 366 +extern __uintmax_t ufromfpx(double __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpx(double __x, int __round, unsigned __width) noexcept(true); +# 370 +extern int canonicalize(double * __cx, const double * __x) noexcept(true); +# 377 +extern double fmaxmag(double __x, double __y) noexcept(true) __attribute((const)); extern double __fmaxmag(double __x, double __y) noexcept(true) __attribute((const)); +# 380 +extern double fminmag(double __x, double __y) noexcept(true) __attribute((const)); extern double __fminmag(double __x, double __y) noexcept(true) __attribute((const)); +# 385 +extern double fmaximum(double __x, double __y) noexcept(true) __attribute((const)); extern double __fmaximum(double __x, double __y) noexcept(true) __attribute((const)); +# 388 +extern double fminimum(double __x, double __y) noexcept(true) __attribute((const)); extern double __fminimum(double __x, double __y) noexcept(true) __attribute((const)); +# 391 +extern double fmaximum_num(double __x, double __y) noexcept(true) __attribute((const)); extern double __fmaximum_num(double __x, double __y) noexcept(true) __attribute((const)); +# 394 +extern double fminimum_num(double __x, double __y) noexcept(true) __attribute((const)); extern double __fminimum_num(double __x, double __y) noexcept(true) __attribute((const)); +# 397 +extern double fmaximum_mag(double __x, double __y) noexcept(true) __attribute((const)); extern double __fmaximum_mag(double __x, double __y) noexcept(true) __attribute((const)); +# 400 +extern double fminimum_mag(double __x, double __y) noexcept(true) __attribute((const)); extern double __fminimum_mag(double __x, double __y) noexcept(true) __attribute((const)); +# 403 +extern double fmaximum_mag_num(double __x, double __y) noexcept(true) __attribute((const)); extern double __fmaximum_mag_num(double __x, double __y) noexcept(true) __attribute((const)); +# 406 +extern double fminimum_mag_num(double __x, double __y) noexcept(true) __attribute((const)); extern double __fminimum_mag_num(double __x, double __y) noexcept(true) __attribute((const)); +# 411 +extern int totalorder(const double * __x, const double * __y) noexcept(true) +# 413 + __attribute((__pure__)); +# 416 +extern int totalordermag(const double * __x, const double * __y) noexcept(true) +# 418 + __attribute((__pure__)); +# 421 +extern double getpayload(const double * __x) noexcept(true); extern double __getpayload(const double * __x) noexcept(true); +# 424 +extern int setpayload(double * __x, double __payload) noexcept(true); +# 427 +extern int setpayloadsig(double * __x, double __payload) noexcept(true); +# 435 +extern double scalb(double __x, double __n) noexcept(true); extern double __scalb(double __x, double __n) noexcept(true); +# 20 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/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); +# 71 +extern float coshf(float __x) noexcept(true); extern float __coshf(float __x) noexcept(true); +# 73 +extern float sinhf(float __x) noexcept(true); extern float __sinhf(float __x) noexcept(true); +# 75 +extern float tanhf(float __x) noexcept(true); extern float __tanhf(float __x) noexcept(true); +# 79 +extern void sincosf(float __x, float * __sinx, float * __cosx) noexcept(true); +# 85 +extern float acoshf(float __x) noexcept(true); extern float __acoshf(float __x) noexcept(true); +# 87 +extern float asinhf(float __x) noexcept(true); extern float __asinhf(float __x) noexcept(true); +# 89 +extern float atanhf(float __x) noexcept(true); extern float __atanhf(float __x) noexcept(true); +# 95 +extern float expf(float __x) noexcept(true); +# 98 +extern float frexpf(float __x, int * __exponent) noexcept(true); extern float __frexpf(float __x, int * __exponent) noexcept(true); +# 101 +extern float ldexpf(float __x, int __exponent) noexcept(true); extern float __ldexpf(float __x, int __exponent) noexcept(true); +# 104 +extern float logf(float __x) noexcept(true); +# 107 +extern float log10f(float __x) noexcept(true); +# 110 +extern float modff(float __x, float * __iptr) noexcept(true); extern float __modff(float __x, float * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 114 +extern float exp10f(float __x) noexcept(true); +# 119 +extern float expm1f(float __x) noexcept(true); extern float __expm1f(float __x) noexcept(true); +# 122 +extern float log1pf(float __x) noexcept(true); extern float __log1pf(float __x) noexcept(true); +# 125 +extern float logbf(float __x) noexcept(true); extern float __logbf(float __x) noexcept(true); +# 130 +extern float exp2f(float __x) noexcept(true); extern float __exp2f(float __x) noexcept(true); +# 133 +extern float log2f(float __x) noexcept(true); +# 140 +extern float powf(float __x, float __y) noexcept(true); +# 143 +extern float sqrtf(float __x) noexcept(true); extern float __sqrtf(float __x) noexcept(true); +# 147 +extern float hypotf(float __x, float __y) noexcept(true); extern float __hypotf(float __x, float __y) noexcept(true); +# 152 +extern float cbrtf(float __x) noexcept(true); extern float __cbrtf(float __x) noexcept(true); +# 159 +extern float ceilf(float __x) noexcept(true) __attribute((const)); extern float __ceilf(float __x) noexcept(true) __attribute((const)); +# 162 +extern float fabsf(float __x) noexcept(true) __attribute((const)); extern float __fabsf(float __x) noexcept(true) __attribute((const)); +# 165 +extern float floorf(float __x) noexcept(true) __attribute((const)); extern float __floorf(float __x) noexcept(true) __attribute((const)); +# 168 +extern float fmodf(float __x, float __y) noexcept(true); extern float __fmodf(float __x, float __y) noexcept(true); +# 177 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern int isinff(float __value) noexcept(true) +# 178 + __attribute((const)); +# 183 +extern int finitef(float __value) noexcept(true) +# 184 + __attribute((const)); +# 187 +extern float dremf(float __x, float __y) noexcept(true); extern float __dremf(float __x, float __y) noexcept(true); +# 191 +extern float significandf(float __x) noexcept(true); extern float __significandf(float __x) noexcept(true); +# 198 +extern float copysignf(float __x, float __y) noexcept(true) __attribute((const)); extern float __copysignf(float __x, float __y) noexcept(true) __attribute((const)); +# 203 +extern float nanf(const char * __tagb) noexcept(true); extern float __nanf(const char * __tagb) noexcept(true); +# 213 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern int isnanf(float __value) noexcept(true) +# 214 + __attribute((const)); +# 220 +extern float j0f(float) noexcept(true); extern float __j0f(float) noexcept(true); +# 221 +extern float j1f(float) noexcept(true); extern float __j1f(float) noexcept(true); +# 222 +extern float jnf(int, float) noexcept(true); extern float __jnf(int, float) noexcept(true); +# 223 +extern float y0f(float) noexcept(true); extern float __y0f(float) noexcept(true); +# 224 +extern float y1f(float) noexcept(true); extern float __y1f(float) noexcept(true); +# 225 +extern float ynf(int, float) noexcept(true); extern float __ynf(int, float) noexcept(true); +# 231 +extern float erff(float) noexcept(true); extern float __erff(float) noexcept(true); +# 232 +extern float erfcf(float) noexcept(true); extern float __erfcf(float) noexcept(true); +# 233 +extern float lgammaf(float) noexcept(true); extern float __lgammaf(float) noexcept(true); +# 238 +extern float tgammaf(float) noexcept(true); extern float __tgammaf(float) noexcept(true); +# 244 +extern float gammaf(float) noexcept(true); extern float __gammaf(float) noexcept(true); +# 252 +extern float lgammaf_r(float, int * __signgamp) noexcept(true); extern float __lgammaf_r(float, int * __signgamp) noexcept(true); +# 259 +extern float rintf(float __x) noexcept(true); extern float __rintf(float __x) noexcept(true); +# 262 +extern float nextafterf(float __x, float __y) noexcept(true); extern float __nextafterf(float __x, float __y) noexcept(true); +# 264 +extern float nexttowardf(float __x, long double __y) noexcept(true); extern float __nexttowardf(float __x, long double __y) noexcept(true); +# 269 +extern float nextdownf(float __x) noexcept(true); extern float __nextdownf(float __x) noexcept(true); +# 271 +extern float nextupf(float __x) noexcept(true); extern float __nextupf(float __x) noexcept(true); +# 275 +extern float remainderf(float __x, float __y) noexcept(true); extern float __remainderf(float __x, float __y) noexcept(true); +# 279 +extern float scalbnf(float __x, int __n) noexcept(true); extern float __scalbnf(float __x, int __n) noexcept(true); +# 283 +extern int ilogbf(float __x) noexcept(true); extern int __ilogbf(float __x) noexcept(true); +# 288 +extern long llogbf(float __x) noexcept(true); extern long __llogbf(float __x) noexcept(true); +# 293 +extern float scalblnf(float __x, long __n) noexcept(true); extern float __scalblnf(float __x, long __n) noexcept(true); +# 297 +extern float nearbyintf(float __x) noexcept(true); extern float __nearbyintf(float __x) noexcept(true); +# 301 +extern float roundf(float __x) noexcept(true) __attribute((const)); extern float __roundf(float __x) noexcept(true) __attribute((const)); +# 305 +extern float truncf(float __x) noexcept(true) __attribute((const)); extern float __truncf(float __x) noexcept(true) __attribute((const)); +# 310 +extern float remquof(float __x, float __y, int * __quo) noexcept(true); extern float __remquof(float __x, float __y, int * __quo) noexcept(true); +# 317 +extern long lrintf(float __x) noexcept(true); extern long __lrintf(float __x) noexcept(true); +# 319 +__extension__ extern long long llrintf(float __x) noexcept(true); extern long long __llrintf(float __x) noexcept(true); +# 323 +extern long lroundf(float __x) noexcept(true); extern long __lroundf(float __x) noexcept(true); +# 325 +__extension__ extern long long llroundf(float __x) noexcept(true); extern long long __llroundf(float __x) noexcept(true); +# 329 +extern float fdimf(float __x, float __y) noexcept(true); extern float __fdimf(float __x, float __y) noexcept(true); +# 333 +extern float fmaxf(float __x, float __y) noexcept(true) __attribute((const)); extern float __fmaxf(float __x, float __y) noexcept(true) __attribute((const)); +# 336 +extern float fminf(float __x, float __y) noexcept(true) __attribute((const)); extern float __fminf(float __x, float __y) noexcept(true) __attribute((const)); +# 340 +extern float fmaf(float __x, float __y, float __z) noexcept(true); extern float __fmaf(float __x, float __y, float __z) noexcept(true); +# 345 +extern float roundevenf(float __x) noexcept(true) __attribute((const)); extern float __roundevenf(float __x) noexcept(true) __attribute((const)); +# 349 +extern __intmax_t fromfpf(float __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpf(float __x, int __round, unsigned __width) noexcept(true); +# 354 +extern __uintmax_t ufromfpf(float __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpf(float __x, int __round, unsigned __width) noexcept(true); +# 360 +extern __intmax_t fromfpxf(float __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpxf(float __x, int __round, unsigned __width) noexcept(true); +# 366 +extern __uintmax_t ufromfpxf(float __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpxf(float __x, int __round, unsigned __width) noexcept(true); +# 370 +extern int canonicalizef(float * __cx, const float * __x) noexcept(true); +# 377 +extern float fmaxmagf(float __x, float __y) noexcept(true) __attribute((const)); extern float __fmaxmagf(float __x, float __y) noexcept(true) __attribute((const)); +# 380 +extern float fminmagf(float __x, float __y) noexcept(true) __attribute((const)); extern float __fminmagf(float __x, float __y) noexcept(true) __attribute((const)); +# 385 +extern float fmaximumf(float __x, float __y) noexcept(true) __attribute((const)); extern float __fmaximumf(float __x, float __y) noexcept(true) __attribute((const)); +# 388 +extern float fminimumf(float __x, float __y) noexcept(true) __attribute((const)); extern float __fminimumf(float __x, float __y) noexcept(true) __attribute((const)); +# 391 +extern float fmaximum_numf(float __x, float __y) noexcept(true) __attribute((const)); extern float __fmaximum_numf(float __x, float __y) noexcept(true) __attribute((const)); +# 394 +extern float fminimum_numf(float __x, float __y) noexcept(true) __attribute((const)); extern float __fminimum_numf(float __x, float __y) noexcept(true) __attribute((const)); +# 397 +extern float fmaximum_magf(float __x, float __y) noexcept(true) __attribute((const)); extern float __fmaximum_magf(float __x, float __y) noexcept(true) __attribute((const)); +# 400 +extern float fminimum_magf(float __x, float __y) noexcept(true) __attribute((const)); extern float __fminimum_magf(float __x, float __y) noexcept(true) __attribute((const)); +# 403 +extern float fmaximum_mag_numf(float __x, float __y) noexcept(true) __attribute((const)); extern float __fmaximum_mag_numf(float __x, float __y) noexcept(true) __attribute((const)); +# 406 +extern float fminimum_mag_numf(float __x, float __y) noexcept(true) __attribute((const)); extern float __fminimum_mag_numf(float __x, float __y) noexcept(true) __attribute((const)); +# 411 +extern int totalorderf(const float * __x, const float * __y) noexcept(true) +# 413 + __attribute((__pure__)); +# 416 +extern int totalordermagf(const float * __x, const float * __y) noexcept(true) +# 418 + __attribute((__pure__)); +# 421 +extern float getpayloadf(const float * __x) noexcept(true); extern float __getpayloadf(const float * __x) noexcept(true); +# 424 +extern int setpayloadf(float * __x, float __payload) noexcept(true); +# 427 +extern int setpayloadsigf(float * __x, float __payload) noexcept(true); +# 435 +extern float scalbf(float __x, float __n) noexcept(true); extern float __scalbf(float __x, float __n) noexcept(true); +# 20 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/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); +# 71 +extern long double coshl(long double __x) noexcept(true); extern long double __coshl(long double __x) noexcept(true); +# 73 +extern long double sinhl(long double __x) noexcept(true); extern long double __sinhl(long double __x) noexcept(true); +# 75 +extern long double tanhl(long double __x) noexcept(true); extern long double __tanhl(long double __x) noexcept(true); +# 79 +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); +# 85 +extern long double acoshl(long double __x) noexcept(true); extern long double __acoshl(long double __x) noexcept(true); +# 87 +extern long double asinhl(long double __x) noexcept(true); extern long double __asinhl(long double __x) noexcept(true); +# 89 +extern long double atanhl(long double __x) noexcept(true); extern long double __atanhl(long double __x) noexcept(true); +# 95 +extern long double expl(long double __x) noexcept(true); extern long double __expl(long double __x) noexcept(true); +# 98 +extern long double frexpl(long double __x, int * __exponent) noexcept(true); extern long double __frexpl(long double __x, int * __exponent) noexcept(true); +# 101 +extern long double ldexpl(long double __x, int __exponent) noexcept(true); extern long double __ldexpl(long double __x, int __exponent) noexcept(true); +# 104 +extern long double logl(long double __x) noexcept(true); extern long double __logl(long double __x) noexcept(true); +# 107 +extern long double log10l(long double __x) noexcept(true); extern long double __log10l(long double __x) noexcept(true); +# 110 +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))); +# 114 +extern long double exp10l(long double __x) noexcept(true); extern long double __exp10l(long double __x) noexcept(true); +# 119 +extern long double expm1l(long double __x) noexcept(true); extern long double __expm1l(long double __x) noexcept(true); +# 122 +extern long double log1pl(long double __x) noexcept(true); extern long double __log1pl(long double __x) noexcept(true); +# 125 +extern long double logbl(long double __x) noexcept(true); extern long double __logbl(long double __x) noexcept(true); +# 130 +extern long double exp2l(long double __x) noexcept(true); extern long double __exp2l(long double __x) noexcept(true); +# 133 +extern long double log2l(long double __x) noexcept(true); extern long double __log2l(long double __x) noexcept(true); +# 140 +extern long double powl(long double __x, long double __y) noexcept(true); extern long double __powl(long double __x, long double __y) noexcept(true); +# 143 +extern long double sqrtl(long double __x) noexcept(true); extern long double __sqrtl(long double __x) noexcept(true); +# 147 +extern long double hypotl(long double __x, long double __y) noexcept(true); extern long double __hypotl(long double __x, long double __y) noexcept(true); +# 152 +extern long double cbrtl(long double __x) noexcept(true); extern long double __cbrtl(long double __x) noexcept(true); +# 159 +extern long double ceill(long double __x) noexcept(true) __attribute((const)); extern long double __ceill(long double __x) noexcept(true) __attribute((const)); +# 162 +extern long double fabsl(long double __x) noexcept(true) __attribute((const)); extern long double __fabsl(long double __x) noexcept(true) __attribute((const)); +# 165 +extern long double floorl(long double __x) noexcept(true) __attribute((const)); extern long double __floorl(long double __x) noexcept(true) __attribute((const)); +# 168 +extern long double fmodl(long double __x, long double __y) noexcept(true); extern long double __fmodl(long double __x, long double __y) noexcept(true); +# 177 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern int isinfl(long double __value) noexcept(true) +# 178 + __attribute((const)); +# 183 +extern int finitel(long double __value) noexcept(true) +# 184 + __attribute((const)); +# 187 +extern long double dreml(long double __x, long double __y) noexcept(true); extern long double __dreml(long double __x, long double __y) noexcept(true); +# 191 +extern long double significandl(long double __x) noexcept(true); extern long double __significandl(long double __x) noexcept(true); +# 198 +extern long double copysignl(long double __x, long double __y) noexcept(true) __attribute((const)); extern long double __copysignl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 203 +extern long double nanl(const char * __tagb) noexcept(true); extern long double __nanl(const char * __tagb) noexcept(true); +# 213 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern int isnanl(long double __value) noexcept(true) +# 214 + __attribute((const)); +# 220 +extern long double j0l(long double) noexcept(true); extern long double __j0l(long double) noexcept(true); +# 221 +extern long double j1l(long double) noexcept(true); extern long double __j1l(long double) noexcept(true); +# 222 +extern long double jnl(int, long double) noexcept(true); extern long double __jnl(int, long double) noexcept(true); +# 223 +extern long double y0l(long double) noexcept(true); extern long double __y0l(long double) noexcept(true); +# 224 +extern long double y1l(long double) noexcept(true); extern long double __y1l(long double) noexcept(true); +# 225 +extern long double ynl(int, long double) noexcept(true); extern long double __ynl(int, long double) noexcept(true); +# 231 +extern long double erfl(long double) noexcept(true); extern long double __erfl(long double) noexcept(true); +# 232 +extern long double erfcl(long double) noexcept(true); extern long double __erfcl(long double) noexcept(true); +# 233 +extern long double lgammal(long double) noexcept(true); extern long double __lgammal(long double) noexcept(true); +# 238 +extern long double tgammal(long double) noexcept(true); extern long double __tgammal(long double) noexcept(true); +# 244 +extern long double gammal(long double) noexcept(true); extern long double __gammal(long double) noexcept(true); +# 252 +extern long double lgammal_r(long double, int * __signgamp) noexcept(true); extern long double __lgammal_r(long double, int * __signgamp) noexcept(true); +# 259 +extern long double rintl(long double __x) noexcept(true); extern long double __rintl(long double __x) noexcept(true); +# 262 +extern long double nextafterl(long double __x, long double __y) noexcept(true); extern long double __nextafterl(long double __x, long double __y) noexcept(true); +# 264 +extern long double nexttowardl(long double __x, long double __y) noexcept(true); extern long double __nexttowardl(long double __x, long double __y) noexcept(true); +# 269 +extern long double nextdownl(long double __x) noexcept(true); extern long double __nextdownl(long double __x) noexcept(true); +# 271 +extern long double nextupl(long double __x) noexcept(true); extern long double __nextupl(long double __x) noexcept(true); +# 275 +extern long double remainderl(long double __x, long double __y) noexcept(true); extern long double __remainderl(long double __x, long double __y) noexcept(true); +# 279 +extern long double scalbnl(long double __x, int __n) noexcept(true); extern long double __scalbnl(long double __x, int __n) noexcept(true); +# 283 +extern int ilogbl(long double __x) noexcept(true); extern int __ilogbl(long double __x) noexcept(true); +# 288 +extern long llogbl(long double __x) noexcept(true); extern long __llogbl(long double __x) noexcept(true); +# 293 +extern long double scalblnl(long double __x, long __n) noexcept(true); extern long double __scalblnl(long double __x, long __n) noexcept(true); +# 297 +extern long double nearbyintl(long double __x) noexcept(true); extern long double __nearbyintl(long double __x) noexcept(true); +# 301 +extern long double roundl(long double __x) noexcept(true) __attribute((const)); extern long double __roundl(long double __x) noexcept(true) __attribute((const)); +# 305 +extern long double truncl(long double __x) noexcept(true) __attribute((const)); extern long double __truncl(long double __x) noexcept(true) __attribute((const)); +# 310 +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); +# 317 +extern long lrintl(long double __x) noexcept(true); extern long __lrintl(long double __x) noexcept(true); +# 319 +__extension__ extern long long llrintl(long double __x) noexcept(true); extern long long __llrintl(long double __x) noexcept(true); +# 323 +extern long lroundl(long double __x) noexcept(true); extern long __lroundl(long double __x) noexcept(true); +# 325 +__extension__ extern long long llroundl(long double __x) noexcept(true); extern long long __llroundl(long double __x) noexcept(true); +# 329 +extern long double fdiml(long double __x, long double __y) noexcept(true); extern long double __fdiml(long double __x, long double __y) noexcept(true); +# 333 +extern long double fmaxl(long double __x, long double __y) noexcept(true) __attribute((const)); extern long double __fmaxl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 336 +extern long double fminl(long double __x, long double __y) noexcept(true) __attribute((const)); extern long double __fminl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 340 +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); +# 345 +extern long double roundevenl(long double __x) noexcept(true) __attribute((const)); extern long double __roundevenl(long double __x) noexcept(true) __attribute((const)); +# 349 +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); +# 354 +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); +# 360 +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); +# 366 +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); +# 370 +extern int canonicalizel(long double * __cx, const long double * __x) noexcept(true); +# 377 +extern long double fmaxmagl(long double __x, long double __y) noexcept(true) __attribute((const)); extern long double __fmaxmagl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 380 +extern long double fminmagl(long double __x, long double __y) noexcept(true) __attribute((const)); extern long double __fminmagl(long double __x, long double __y) noexcept(true) __attribute((const)); +# 385 +extern long double fmaximuml(long double __x, long double __y) noexcept(true) __attribute((const)); extern long double __fmaximuml(long double __x, long double __y) noexcept(true) __attribute((const)); +# 388 +extern long double fminimuml(long double __x, long double __y) noexcept(true) __attribute((const)); extern long double __fminimuml(long double __x, long double __y) noexcept(true) __attribute((const)); +# 391 +extern long double fmaximum_numl(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)); +# 394 +extern long double fminimum_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)); +# 397 +extern long double fmaximum_magl(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)); +# 400 +extern long double fminimum_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)); +# 403 +extern long double fmaximum_mag_numl(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)); +# 406 +extern long double fminimum_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)); +# 411 +extern int totalorderl(const long double * __x, const long double * __y) noexcept(true) +# 413 + __attribute((__pure__)); +# 416 +extern int totalordermagl(const long double * __x, const long double * __y) noexcept(true) +# 418 + __attribute((__pure__)); +# 421 +extern long double getpayloadl(const long double * __x) noexcept(true); extern long double __getpayloadl(const long double * __x) noexcept(true); +# 424 +extern int setpayloadl(long double * __x, long double __payload) noexcept(true); +# 427 +extern int setpayloadsigl(long double * __x, long double __payload) noexcept(true); +# 435 +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/x86_64-linux-gnu/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); +# 71 +extern _Float32 coshf32(_Float32 __x) noexcept(true); extern _Float32 __coshf32(_Float32 __x) noexcept(true); +# 73 +extern _Float32 sinhf32(_Float32 __x) noexcept(true); extern _Float32 __sinhf32(_Float32 __x) noexcept(true); +# 75 +extern _Float32 tanhf32(_Float32 __x) noexcept(true); extern _Float32 __tanhf32(_Float32 __x) noexcept(true); +# 79 +extern void sincosf32(_Float32 __x, _Float32 * __sinx, _Float32 * __cosx) noexcept(true); extern void __sincosf32(_Float32 __x, _Float32 * __sinx, _Float32 * __cosx) noexcept(true); +# 85 +extern _Float32 acoshf32(_Float32 __x) noexcept(true); extern _Float32 __acoshf32(_Float32 __x) noexcept(true); +# 87 +extern _Float32 asinhf32(_Float32 __x) noexcept(true); extern _Float32 __asinhf32(_Float32 __x) noexcept(true); +# 89 +extern _Float32 atanhf32(_Float32 __x) noexcept(true); extern _Float32 __atanhf32(_Float32 __x) noexcept(true); +# 95 +extern _Float32 expf32(_Float32 __x) noexcept(true); extern _Float32 __expf32(_Float32 __x) noexcept(true); +# 98 +extern _Float32 frexpf32(_Float32 __x, int * __exponent) noexcept(true); extern _Float32 __frexpf32(_Float32 __x, int * __exponent) noexcept(true); +# 101 +extern _Float32 ldexpf32(_Float32 __x, int __exponent) noexcept(true); extern _Float32 __ldexpf32(_Float32 __x, int __exponent) noexcept(true); +# 104 +extern _Float32 logf32(_Float32 __x) noexcept(true); extern _Float32 __logf32(_Float32 __x) noexcept(true); +# 107 +extern _Float32 log10f32(_Float32 __x) noexcept(true); extern _Float32 __log10f32(_Float32 __x) noexcept(true); +# 110 +extern _Float32 modff32(_Float32 __x, _Float32 * __iptr) noexcept(true); extern _Float32 __modff32(_Float32 __x, _Float32 * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 114 +extern _Float32 exp10f32(_Float32 __x) noexcept(true); extern _Float32 __exp10f32(_Float32 __x) noexcept(true); +# 119 +extern _Float32 expm1f32(_Float32 __x) noexcept(true); extern _Float32 __expm1f32(_Float32 __x) noexcept(true); +# 122 +extern _Float32 log1pf32(_Float32 __x) noexcept(true); extern _Float32 __log1pf32(_Float32 __x) noexcept(true); +# 125 +extern _Float32 logbf32(_Float32 __x) noexcept(true); extern _Float32 __logbf32(_Float32 __x) noexcept(true); +# 130 +extern _Float32 exp2f32(_Float32 __x) noexcept(true); extern _Float32 __exp2f32(_Float32 __x) noexcept(true); +# 133 +extern _Float32 log2f32(_Float32 __x) noexcept(true); extern _Float32 __log2f32(_Float32 __x) noexcept(true); +# 140 +extern _Float32 powf32(_Float32 __x, _Float32 __y) noexcept(true); extern _Float32 __powf32(_Float32 __x, _Float32 __y) noexcept(true); +# 143 +extern _Float32 sqrtf32(_Float32 __x) noexcept(true); extern _Float32 __sqrtf32(_Float32 __x) noexcept(true); +# 147 +extern _Float32 hypotf32(_Float32 __x, _Float32 __y) noexcept(true); extern _Float32 __hypotf32(_Float32 __x, _Float32 __y) noexcept(true); +# 152 +extern _Float32 cbrtf32(_Float32 __x) noexcept(true); extern _Float32 __cbrtf32(_Float32 __x) noexcept(true); +# 159 +extern _Float32 ceilf32(_Float32 __x) noexcept(true) __attribute((const)); extern _Float32 __ceilf32(_Float32 __x) noexcept(true) __attribute((const)); +# 162 +extern _Float32 fabsf32(_Float32 __x) noexcept(true) __attribute((const)); extern _Float32 __fabsf32(_Float32 __x) noexcept(true) __attribute((const)); +# 165 +extern _Float32 floorf32(_Float32 __x) noexcept(true) __attribute((const)); extern _Float32 __floorf32(_Float32 __x) noexcept(true) __attribute((const)); +# 168 +extern _Float32 fmodf32(_Float32 __x, _Float32 __y) noexcept(true); extern _Float32 __fmodf32(_Float32 __x, _Float32 __y) noexcept(true); +# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern _Float32 copysignf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); extern _Float32 __copysignf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 203 +extern _Float32 nanf32(const char * __tagb) noexcept(true); extern _Float32 __nanf32(const char * __tagb) noexcept(true); +# 220 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern _Float32 j0f32(_Float32) noexcept(true); extern _Float32 __j0f32(_Float32) noexcept(true); +# 221 +extern _Float32 j1f32(_Float32) noexcept(true); extern _Float32 __j1f32(_Float32) noexcept(true); +# 222 +extern _Float32 jnf32(int, _Float32) noexcept(true); extern _Float32 __jnf32(int, _Float32) noexcept(true); +# 223 +extern _Float32 y0f32(_Float32) noexcept(true); extern _Float32 __y0f32(_Float32) noexcept(true); +# 224 +extern _Float32 y1f32(_Float32) noexcept(true); extern _Float32 __y1f32(_Float32) noexcept(true); +# 225 +extern _Float32 ynf32(int, _Float32) noexcept(true); extern _Float32 __ynf32(int, _Float32) noexcept(true); +# 231 +extern _Float32 erff32(_Float32) noexcept(true); extern _Float32 __erff32(_Float32) noexcept(true); +# 232 +extern _Float32 erfcf32(_Float32) noexcept(true); extern _Float32 __erfcf32(_Float32) noexcept(true); +# 233 +extern _Float32 lgammaf32(_Float32) noexcept(true); extern _Float32 __lgammaf32(_Float32) noexcept(true); +# 238 +extern _Float32 tgammaf32(_Float32) noexcept(true); extern _Float32 __tgammaf32(_Float32) noexcept(true); +# 252 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern _Float32 lgammaf32_r(_Float32, int * __signgamp) noexcept(true); extern _Float32 __lgammaf32_r(_Float32, int * __signgamp) noexcept(true); +# 259 +extern _Float32 rintf32(_Float32 __x) noexcept(true); extern _Float32 __rintf32(_Float32 __x) noexcept(true); +# 262 +extern _Float32 nextafterf32(_Float32 __x, _Float32 __y) noexcept(true); extern _Float32 __nextafterf32(_Float32 __x, _Float32 __y) noexcept(true); +# 269 +extern _Float32 nextdownf32(_Float32 __x) noexcept(true); extern _Float32 __nextdownf32(_Float32 __x) noexcept(true); +# 271 +extern _Float32 nextupf32(_Float32 __x) noexcept(true); extern _Float32 __nextupf32(_Float32 __x) noexcept(true); +# 275 +extern _Float32 remainderf32(_Float32 __x, _Float32 __y) noexcept(true); extern _Float32 __remainderf32(_Float32 __x, _Float32 __y) noexcept(true); +# 279 +extern _Float32 scalbnf32(_Float32 __x, int __n) noexcept(true); extern _Float32 __scalbnf32(_Float32 __x, int __n) noexcept(true); +# 283 +extern int ilogbf32(_Float32 __x) noexcept(true); extern int __ilogbf32(_Float32 __x) noexcept(true); +# 288 +extern long llogbf32(_Float32 __x) noexcept(true); extern long __llogbf32(_Float32 __x) noexcept(true); +# 293 +extern _Float32 scalblnf32(_Float32 __x, long __n) noexcept(true); extern _Float32 __scalblnf32(_Float32 __x, long __n) noexcept(true); +# 297 +extern _Float32 nearbyintf32(_Float32 __x) noexcept(true); extern _Float32 __nearbyintf32(_Float32 __x) noexcept(true); +# 301 +extern _Float32 roundf32(_Float32 __x) noexcept(true) __attribute((const)); extern _Float32 __roundf32(_Float32 __x) noexcept(true) __attribute((const)); +# 305 +extern _Float32 truncf32(_Float32 __x) noexcept(true) __attribute((const)); extern _Float32 __truncf32(_Float32 __x) noexcept(true) __attribute((const)); +# 310 +extern _Float32 remquof32(_Float32 __x, _Float32 __y, int * __quo) noexcept(true); extern _Float32 __remquof32(_Float32 __x, _Float32 __y, int * __quo) noexcept(true); +# 317 +extern long lrintf32(_Float32 __x) noexcept(true); extern long __lrintf32(_Float32 __x) noexcept(true); +# 319 +__extension__ extern long long llrintf32(_Float32 __x) noexcept(true); extern long long __llrintf32(_Float32 __x) noexcept(true); +# 323 +extern long lroundf32(_Float32 __x) noexcept(true); extern long __lroundf32(_Float32 __x) noexcept(true); +# 325 +__extension__ extern long long llroundf32(_Float32 __x) noexcept(true); extern long long __llroundf32(_Float32 __x) noexcept(true); +# 329 +extern _Float32 fdimf32(_Float32 __x, _Float32 __y) noexcept(true); extern _Float32 __fdimf32(_Float32 __x, _Float32 __y) noexcept(true); +# 333 +extern _Float32 fmaxf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); extern _Float32 __fmaxf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 336 +extern _Float32 fminf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); extern _Float32 __fminf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 340 +extern _Float32 fmaf32(_Float32 __x, _Float32 __y, _Float32 __z) noexcept(true); extern _Float32 __fmaf32(_Float32 __x, _Float32 __y, _Float32 __z) noexcept(true); +# 345 +extern _Float32 roundevenf32(_Float32 __x) noexcept(true) __attribute((const)); extern _Float32 __roundevenf32(_Float32 __x) noexcept(true) __attribute((const)); +# 349 +extern __intmax_t fromfpf32(_Float32 __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpf32(_Float32 __x, int __round, unsigned __width) noexcept(true); +# 354 +extern __uintmax_t ufromfpf32(_Float32 __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpf32(_Float32 __x, int __round, unsigned __width) noexcept(true); +# 360 +extern __intmax_t fromfpxf32(_Float32 __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpxf32(_Float32 __x, int __round, unsigned __width) noexcept(true); +# 366 +extern __uintmax_t ufromfpxf32(_Float32 __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpxf32(_Float32 __x, int __round, unsigned __width) noexcept(true); +# 370 +extern int canonicalizef32(_Float32 * __cx, const _Float32 * __x) noexcept(true); +# 377 +extern _Float32 fmaxmagf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); extern _Float32 __fmaxmagf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 380 +extern _Float32 fminmagf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); extern _Float32 __fminmagf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 385 +extern _Float32 fmaximumf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); extern _Float32 __fmaximumf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 388 +extern _Float32 fminimumf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); extern _Float32 __fminimumf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 391 +extern _Float32 fmaximum_numf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); extern _Float32 __fmaximum_numf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 394 +extern _Float32 fminimum_numf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); extern _Float32 __fminimum_numf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 397 +extern _Float32 fmaximum_magf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); extern _Float32 __fmaximum_magf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 400 +extern _Float32 fminimum_magf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); extern _Float32 __fminimum_magf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 403 +extern _Float32 fmaximum_mag_numf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); extern _Float32 __fmaximum_mag_numf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 406 +extern _Float32 fminimum_mag_numf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); extern _Float32 __fminimum_mag_numf32(_Float32 __x, _Float32 __y) noexcept(true) __attribute((const)); +# 411 +extern int totalorderf32(const _Float32 * __x, const _Float32 * __y) noexcept(true) +# 413 + __attribute((__pure__)); +# 416 +extern int totalordermagf32(const _Float32 * __x, const _Float32 * __y) noexcept(true) +# 418 + __attribute((__pure__)); +# 421 +extern _Float32 getpayloadf32(const _Float32 * __x) noexcept(true); extern _Float32 __getpayloadf32(const _Float32 * __x) noexcept(true); +# 424 +extern int setpayloadf32(_Float32 * __x, _Float32 __payload) noexcept(true); +# 427 +extern int setpayloadsigf32(_Float32 * __x, _Float32 __payload) noexcept(true); +# 53 "/usr/include/x86_64-linux-gnu/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); +# 71 +extern _Float64 coshf64(_Float64 __x) noexcept(true); extern _Float64 __coshf64(_Float64 __x) noexcept(true); +# 73 +extern _Float64 sinhf64(_Float64 __x) noexcept(true); extern _Float64 __sinhf64(_Float64 __x) noexcept(true); +# 75 +extern _Float64 tanhf64(_Float64 __x) noexcept(true); extern _Float64 __tanhf64(_Float64 __x) noexcept(true); +# 79 +extern void sincosf64(_Float64 __x, _Float64 * __sinx, _Float64 * __cosx) noexcept(true); extern void __sincosf64(_Float64 __x, _Float64 * __sinx, _Float64 * __cosx) noexcept(true); +# 85 +extern _Float64 acoshf64(_Float64 __x) noexcept(true); extern _Float64 __acoshf64(_Float64 __x) noexcept(true); +# 87 +extern _Float64 asinhf64(_Float64 __x) noexcept(true); extern _Float64 __asinhf64(_Float64 __x) noexcept(true); +# 89 +extern _Float64 atanhf64(_Float64 __x) noexcept(true); extern _Float64 __atanhf64(_Float64 __x) noexcept(true); +# 95 +extern _Float64 expf64(_Float64 __x) noexcept(true); extern _Float64 __expf64(_Float64 __x) noexcept(true); +# 98 +extern _Float64 frexpf64(_Float64 __x, int * __exponent) noexcept(true); extern _Float64 __frexpf64(_Float64 __x, int * __exponent) noexcept(true); +# 101 +extern _Float64 ldexpf64(_Float64 __x, int __exponent) noexcept(true); extern _Float64 __ldexpf64(_Float64 __x, int __exponent) noexcept(true); +# 104 +extern _Float64 logf64(_Float64 __x) noexcept(true); extern _Float64 __logf64(_Float64 __x) noexcept(true); +# 107 +extern _Float64 log10f64(_Float64 __x) noexcept(true); extern _Float64 __log10f64(_Float64 __x) noexcept(true); +# 110 +extern _Float64 modff64(_Float64 __x, _Float64 * __iptr) noexcept(true); extern _Float64 __modff64(_Float64 __x, _Float64 * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 114 +extern _Float64 exp10f64(_Float64 __x) noexcept(true); extern _Float64 __exp10f64(_Float64 __x) noexcept(true); +# 119 +extern _Float64 expm1f64(_Float64 __x) noexcept(true); extern _Float64 __expm1f64(_Float64 __x) noexcept(true); +# 122 +extern _Float64 log1pf64(_Float64 __x) noexcept(true); extern _Float64 __log1pf64(_Float64 __x) noexcept(true); +# 125 +extern _Float64 logbf64(_Float64 __x) noexcept(true); extern _Float64 __logbf64(_Float64 __x) noexcept(true); +# 130 +extern _Float64 exp2f64(_Float64 __x) noexcept(true); extern _Float64 __exp2f64(_Float64 __x) noexcept(true); +# 133 +extern _Float64 log2f64(_Float64 __x) noexcept(true); extern _Float64 __log2f64(_Float64 __x) noexcept(true); +# 140 +extern _Float64 powf64(_Float64 __x, _Float64 __y) noexcept(true); extern _Float64 __powf64(_Float64 __x, _Float64 __y) noexcept(true); +# 143 +extern _Float64 sqrtf64(_Float64 __x) noexcept(true); extern _Float64 __sqrtf64(_Float64 __x) noexcept(true); +# 147 +extern _Float64 hypotf64(_Float64 __x, _Float64 __y) noexcept(true); extern _Float64 __hypotf64(_Float64 __x, _Float64 __y) noexcept(true); +# 152 +extern _Float64 cbrtf64(_Float64 __x) noexcept(true); extern _Float64 __cbrtf64(_Float64 __x) noexcept(true); +# 159 +extern _Float64 ceilf64(_Float64 __x) noexcept(true) __attribute((const)); extern _Float64 __ceilf64(_Float64 __x) noexcept(true) __attribute((const)); +# 162 +extern _Float64 fabsf64(_Float64 __x) noexcept(true) __attribute((const)); extern _Float64 __fabsf64(_Float64 __x) noexcept(true) __attribute((const)); +# 165 +extern _Float64 floorf64(_Float64 __x) noexcept(true) __attribute((const)); extern _Float64 __floorf64(_Float64 __x) noexcept(true) __attribute((const)); +# 168 +extern _Float64 fmodf64(_Float64 __x, _Float64 __y) noexcept(true); extern _Float64 __fmodf64(_Float64 __x, _Float64 __y) noexcept(true); +# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern _Float64 copysignf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); extern _Float64 __copysignf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 203 +extern _Float64 nanf64(const char * __tagb) noexcept(true); extern _Float64 __nanf64(const char * __tagb) noexcept(true); +# 220 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern _Float64 j0f64(_Float64) noexcept(true); extern _Float64 __j0f64(_Float64) noexcept(true); +# 221 +extern _Float64 j1f64(_Float64) noexcept(true); extern _Float64 __j1f64(_Float64) noexcept(true); +# 222 +extern _Float64 jnf64(int, _Float64) noexcept(true); extern _Float64 __jnf64(int, _Float64) noexcept(true); +# 223 +extern _Float64 y0f64(_Float64) noexcept(true); extern _Float64 __y0f64(_Float64) noexcept(true); +# 224 +extern _Float64 y1f64(_Float64) noexcept(true); extern _Float64 __y1f64(_Float64) noexcept(true); +# 225 +extern _Float64 ynf64(int, _Float64) noexcept(true); extern _Float64 __ynf64(int, _Float64) noexcept(true); +# 231 +extern _Float64 erff64(_Float64) noexcept(true); extern _Float64 __erff64(_Float64) noexcept(true); +# 232 +extern _Float64 erfcf64(_Float64) noexcept(true); extern _Float64 __erfcf64(_Float64) noexcept(true); +# 233 +extern _Float64 lgammaf64(_Float64) noexcept(true); extern _Float64 __lgammaf64(_Float64) noexcept(true); +# 238 +extern _Float64 tgammaf64(_Float64) noexcept(true); extern _Float64 __tgammaf64(_Float64) noexcept(true); +# 252 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern _Float64 lgammaf64_r(_Float64, int * __signgamp) noexcept(true); extern _Float64 __lgammaf64_r(_Float64, int * __signgamp) noexcept(true); +# 259 +extern _Float64 rintf64(_Float64 __x) noexcept(true); extern _Float64 __rintf64(_Float64 __x) noexcept(true); +# 262 +extern _Float64 nextafterf64(_Float64 __x, _Float64 __y) noexcept(true); extern _Float64 __nextafterf64(_Float64 __x, _Float64 __y) noexcept(true); +# 269 +extern _Float64 nextdownf64(_Float64 __x) noexcept(true); extern _Float64 __nextdownf64(_Float64 __x) noexcept(true); +# 271 +extern _Float64 nextupf64(_Float64 __x) noexcept(true); extern _Float64 __nextupf64(_Float64 __x) noexcept(true); +# 275 +extern _Float64 remainderf64(_Float64 __x, _Float64 __y) noexcept(true); extern _Float64 __remainderf64(_Float64 __x, _Float64 __y) noexcept(true); +# 279 +extern _Float64 scalbnf64(_Float64 __x, int __n) noexcept(true); extern _Float64 __scalbnf64(_Float64 __x, int __n) noexcept(true); +# 283 +extern int ilogbf64(_Float64 __x) noexcept(true); extern int __ilogbf64(_Float64 __x) noexcept(true); +# 288 +extern long llogbf64(_Float64 __x) noexcept(true); extern long __llogbf64(_Float64 __x) noexcept(true); +# 293 +extern _Float64 scalblnf64(_Float64 __x, long __n) noexcept(true); extern _Float64 __scalblnf64(_Float64 __x, long __n) noexcept(true); +# 297 +extern _Float64 nearbyintf64(_Float64 __x) noexcept(true); extern _Float64 __nearbyintf64(_Float64 __x) noexcept(true); +# 301 +extern _Float64 roundf64(_Float64 __x) noexcept(true) __attribute((const)); extern _Float64 __roundf64(_Float64 __x) noexcept(true) __attribute((const)); +# 305 +extern _Float64 truncf64(_Float64 __x) noexcept(true) __attribute((const)); extern _Float64 __truncf64(_Float64 __x) noexcept(true) __attribute((const)); +# 310 +extern _Float64 remquof64(_Float64 __x, _Float64 __y, int * __quo) noexcept(true); extern _Float64 __remquof64(_Float64 __x, _Float64 __y, int * __quo) noexcept(true); +# 317 +extern long lrintf64(_Float64 __x) noexcept(true); extern long __lrintf64(_Float64 __x) noexcept(true); +# 319 +__extension__ extern long long llrintf64(_Float64 __x) noexcept(true); extern long long __llrintf64(_Float64 __x) noexcept(true); +# 323 +extern long lroundf64(_Float64 __x) noexcept(true); extern long __lroundf64(_Float64 __x) noexcept(true); +# 325 +__extension__ extern long long llroundf64(_Float64 __x) noexcept(true); extern long long __llroundf64(_Float64 __x) noexcept(true); +# 329 +extern _Float64 fdimf64(_Float64 __x, _Float64 __y) noexcept(true); extern _Float64 __fdimf64(_Float64 __x, _Float64 __y) noexcept(true); +# 333 +extern _Float64 fmaxf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); extern _Float64 __fmaxf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 336 +extern _Float64 fminf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); extern _Float64 __fminf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 340 +extern _Float64 fmaf64(_Float64 __x, _Float64 __y, _Float64 __z) noexcept(true); extern _Float64 __fmaf64(_Float64 __x, _Float64 __y, _Float64 __z) noexcept(true); +# 345 +extern _Float64 roundevenf64(_Float64 __x) noexcept(true) __attribute((const)); extern _Float64 __roundevenf64(_Float64 __x) noexcept(true) __attribute((const)); +# 349 +extern __intmax_t fromfpf64(_Float64 __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpf64(_Float64 __x, int __round, unsigned __width) noexcept(true); +# 354 +extern __uintmax_t ufromfpf64(_Float64 __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpf64(_Float64 __x, int __round, unsigned __width) noexcept(true); +# 360 +extern __intmax_t fromfpxf64(_Float64 __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpxf64(_Float64 __x, int __round, unsigned __width) noexcept(true); +# 366 +extern __uintmax_t ufromfpxf64(_Float64 __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpxf64(_Float64 __x, int __round, unsigned __width) noexcept(true); +# 370 +extern int canonicalizef64(_Float64 * __cx, const _Float64 * __x) noexcept(true); +# 377 +extern _Float64 fmaxmagf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); extern _Float64 __fmaxmagf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 380 +extern _Float64 fminmagf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); extern _Float64 __fminmagf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 385 +extern _Float64 fmaximumf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); extern _Float64 __fmaximumf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 388 +extern _Float64 fminimumf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); extern _Float64 __fminimumf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 391 +extern _Float64 fmaximum_numf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); extern _Float64 __fmaximum_numf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 394 +extern _Float64 fminimum_numf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); extern _Float64 __fminimum_numf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 397 +extern _Float64 fmaximum_magf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); extern _Float64 __fmaximum_magf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 400 +extern _Float64 fminimum_magf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); extern _Float64 __fminimum_magf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 403 +extern _Float64 fmaximum_mag_numf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); extern _Float64 __fmaximum_mag_numf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 406 +extern _Float64 fminimum_mag_numf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); extern _Float64 __fminimum_mag_numf64(_Float64 __x, _Float64 __y) noexcept(true) __attribute((const)); +# 411 +extern int totalorderf64(const _Float64 * __x, const _Float64 * __y) noexcept(true) +# 413 + __attribute((__pure__)); +# 416 +extern int totalordermagf64(const _Float64 * __x, const _Float64 * __y) noexcept(true) +# 418 + __attribute((__pure__)); +# 421 +extern _Float64 getpayloadf64(const _Float64 * __x) noexcept(true); extern _Float64 __getpayloadf64(const _Float64 * __x) noexcept(true); +# 424 +extern int setpayloadf64(_Float64 * __x, _Float64 __payload) noexcept(true); +# 427 +extern int setpayloadsigf64(_Float64 * __x, _Float64 __payload) noexcept(true); +# 20 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/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); +# 71 +extern _Float128 coshf128(_Float128 __x) noexcept(true); extern _Float128 __coshf128(_Float128 __x) noexcept(true); +# 73 +extern _Float128 sinhf128(_Float128 __x) noexcept(true); extern _Float128 __sinhf128(_Float128 __x) noexcept(true); +# 75 +extern _Float128 tanhf128(_Float128 __x) noexcept(true); extern _Float128 __tanhf128(_Float128 __x) noexcept(true); +# 79 +extern void sincosf128(_Float128 __x, _Float128 * __sinx, _Float128 * __cosx) noexcept(true); extern void __sincosf128(_Float128 __x, _Float128 * __sinx, _Float128 * __cosx) noexcept(true); +# 85 +extern _Float128 acoshf128(_Float128 __x) noexcept(true); extern _Float128 __acoshf128(_Float128 __x) noexcept(true); +# 87 +extern _Float128 asinhf128(_Float128 __x) noexcept(true); extern _Float128 __asinhf128(_Float128 __x) noexcept(true); +# 89 +extern _Float128 atanhf128(_Float128 __x) noexcept(true); extern _Float128 __atanhf128(_Float128 __x) noexcept(true); +# 95 +extern _Float128 expf128(_Float128 __x) noexcept(true); extern _Float128 __expf128(_Float128 __x) noexcept(true); +# 98 +extern _Float128 frexpf128(_Float128 __x, int * __exponent) noexcept(true); extern _Float128 __frexpf128(_Float128 __x, int * __exponent) noexcept(true); +# 101 +extern _Float128 ldexpf128(_Float128 __x, int __exponent) noexcept(true); extern _Float128 __ldexpf128(_Float128 __x, int __exponent) noexcept(true); +# 104 +extern _Float128 logf128(_Float128 __x) noexcept(true); extern _Float128 __logf128(_Float128 __x) noexcept(true); +# 107 +extern _Float128 log10f128(_Float128 __x) noexcept(true); extern _Float128 __log10f128(_Float128 __x) noexcept(true); +# 110 +extern _Float128 modff128(_Float128 __x, _Float128 * __iptr) noexcept(true); extern _Float128 __modff128(_Float128 __x, _Float128 * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 114 +extern _Float128 exp10f128(_Float128 __x) noexcept(true); extern _Float128 __exp10f128(_Float128 __x) noexcept(true); +# 119 +extern _Float128 expm1f128(_Float128 __x) noexcept(true); extern _Float128 __expm1f128(_Float128 __x) noexcept(true); +# 122 +extern _Float128 log1pf128(_Float128 __x) noexcept(true); extern _Float128 __log1pf128(_Float128 __x) noexcept(true); +# 125 +extern _Float128 logbf128(_Float128 __x) noexcept(true); extern _Float128 __logbf128(_Float128 __x) noexcept(true); +# 130 +extern _Float128 exp2f128(_Float128 __x) noexcept(true); extern _Float128 __exp2f128(_Float128 __x) noexcept(true); +# 133 +extern _Float128 log2f128(_Float128 __x) noexcept(true); extern _Float128 __log2f128(_Float128 __x) noexcept(true); +# 140 +extern _Float128 powf128(_Float128 __x, _Float128 __y) noexcept(true); extern _Float128 __powf128(_Float128 __x, _Float128 __y) noexcept(true); +# 143 +extern _Float128 sqrtf128(_Float128 __x) noexcept(true); extern _Float128 __sqrtf128(_Float128 __x) noexcept(true); +# 147 +extern _Float128 hypotf128(_Float128 __x, _Float128 __y) noexcept(true); extern _Float128 __hypotf128(_Float128 __x, _Float128 __y) noexcept(true); +# 152 +extern _Float128 cbrtf128(_Float128 __x) noexcept(true); extern _Float128 __cbrtf128(_Float128 __x) noexcept(true); +# 159 +extern _Float128 ceilf128(_Float128 __x) noexcept(true) __attribute((const)); extern _Float128 __ceilf128(_Float128 __x) noexcept(true) __attribute((const)); +# 162 +extern _Float128 fabsf128(_Float128 __x) noexcept(true) __attribute((const)); extern _Float128 __fabsf128(_Float128 __x) noexcept(true) __attribute((const)); +# 165 +extern _Float128 floorf128(_Float128 __x) noexcept(true) __attribute((const)); extern _Float128 __floorf128(_Float128 __x) noexcept(true) __attribute((const)); +# 168 +extern _Float128 fmodf128(_Float128 __x, _Float128 __y) noexcept(true); extern _Float128 __fmodf128(_Float128 __x, _Float128 __y) noexcept(true); +# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern _Float128 copysignf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); extern _Float128 __copysignf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 203 +extern _Float128 nanf128(const char * __tagb) noexcept(true); extern _Float128 __nanf128(const char * __tagb) noexcept(true); +# 220 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern _Float128 j0f128(_Float128) noexcept(true); extern _Float128 __j0f128(_Float128) noexcept(true); +# 221 +extern _Float128 j1f128(_Float128) noexcept(true); extern _Float128 __j1f128(_Float128) noexcept(true); +# 222 +extern _Float128 jnf128(int, _Float128) noexcept(true); extern _Float128 __jnf128(int, _Float128) noexcept(true); +# 223 +extern _Float128 y0f128(_Float128) noexcept(true); extern _Float128 __y0f128(_Float128) noexcept(true); +# 224 +extern _Float128 y1f128(_Float128) noexcept(true); extern _Float128 __y1f128(_Float128) noexcept(true); +# 225 +extern _Float128 ynf128(int, _Float128) noexcept(true); extern _Float128 __ynf128(int, _Float128) noexcept(true); +# 231 +extern _Float128 erff128(_Float128) noexcept(true); extern _Float128 __erff128(_Float128) noexcept(true); +# 232 +extern _Float128 erfcf128(_Float128) noexcept(true); extern _Float128 __erfcf128(_Float128) noexcept(true); +# 233 +extern _Float128 lgammaf128(_Float128) noexcept(true); extern _Float128 __lgammaf128(_Float128) noexcept(true); +# 238 +extern _Float128 tgammaf128(_Float128) noexcept(true); extern _Float128 __tgammaf128(_Float128) noexcept(true); +# 252 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern _Float128 lgammaf128_r(_Float128, int * __signgamp) noexcept(true); extern _Float128 __lgammaf128_r(_Float128, int * __signgamp) noexcept(true); +# 259 +extern _Float128 rintf128(_Float128 __x) noexcept(true); extern _Float128 __rintf128(_Float128 __x) noexcept(true); +# 262 +extern _Float128 nextafterf128(_Float128 __x, _Float128 __y) noexcept(true); extern _Float128 __nextafterf128(_Float128 __x, _Float128 __y) noexcept(true); +# 269 +extern _Float128 nextdownf128(_Float128 __x) noexcept(true); extern _Float128 __nextdownf128(_Float128 __x) noexcept(true); +# 271 +extern _Float128 nextupf128(_Float128 __x) noexcept(true); extern _Float128 __nextupf128(_Float128 __x) noexcept(true); +# 275 +extern _Float128 remainderf128(_Float128 __x, _Float128 __y) noexcept(true); extern _Float128 __remainderf128(_Float128 __x, _Float128 __y) noexcept(true); +# 279 +extern _Float128 scalbnf128(_Float128 __x, int __n) noexcept(true); extern _Float128 __scalbnf128(_Float128 __x, int __n) noexcept(true); +# 283 +extern int ilogbf128(_Float128 __x) noexcept(true); extern int __ilogbf128(_Float128 __x) noexcept(true); +# 288 +extern long llogbf128(_Float128 __x) noexcept(true); extern long __llogbf128(_Float128 __x) noexcept(true); +# 293 +extern _Float128 scalblnf128(_Float128 __x, long __n) noexcept(true); extern _Float128 __scalblnf128(_Float128 __x, long __n) noexcept(true); +# 297 +extern _Float128 nearbyintf128(_Float128 __x) noexcept(true); extern _Float128 __nearbyintf128(_Float128 __x) noexcept(true); +# 301 +extern _Float128 roundf128(_Float128 __x) noexcept(true) __attribute((const)); extern _Float128 __roundf128(_Float128 __x) noexcept(true) __attribute((const)); +# 305 +extern _Float128 truncf128(_Float128 __x) noexcept(true) __attribute((const)); extern _Float128 __truncf128(_Float128 __x) noexcept(true) __attribute((const)); +# 310 +extern _Float128 remquof128(_Float128 __x, _Float128 __y, int * __quo) noexcept(true); extern _Float128 __remquof128(_Float128 __x, _Float128 __y, int * __quo) noexcept(true); +# 317 +extern long lrintf128(_Float128 __x) noexcept(true); extern long __lrintf128(_Float128 __x) noexcept(true); +# 319 +__extension__ extern long long llrintf128(_Float128 __x) noexcept(true); extern long long __llrintf128(_Float128 __x) noexcept(true); +# 323 +extern long lroundf128(_Float128 __x) noexcept(true); extern long __lroundf128(_Float128 __x) noexcept(true); +# 325 +__extension__ extern long long llroundf128(_Float128 __x) noexcept(true); extern long long __llroundf128(_Float128 __x) noexcept(true); +# 329 +extern _Float128 fdimf128(_Float128 __x, _Float128 __y) noexcept(true); extern _Float128 __fdimf128(_Float128 __x, _Float128 __y) noexcept(true); +# 333 +extern _Float128 fmaxf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); extern _Float128 __fmaxf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 336 +extern _Float128 fminf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); extern _Float128 __fminf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 340 +extern _Float128 fmaf128(_Float128 __x, _Float128 __y, _Float128 __z) noexcept(true); extern _Float128 __fmaf128(_Float128 __x, _Float128 __y, _Float128 __z) noexcept(true); +# 345 +extern _Float128 roundevenf128(_Float128 __x) noexcept(true) __attribute((const)); extern _Float128 __roundevenf128(_Float128 __x) noexcept(true) __attribute((const)); +# 349 +extern __intmax_t fromfpf128(_Float128 __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpf128(_Float128 __x, int __round, unsigned __width) noexcept(true); +# 354 +extern __uintmax_t ufromfpf128(_Float128 __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpf128(_Float128 __x, int __round, unsigned __width) noexcept(true); +# 360 +extern __intmax_t fromfpxf128(_Float128 __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpxf128(_Float128 __x, int __round, unsigned __width) noexcept(true); +# 366 +extern __uintmax_t ufromfpxf128(_Float128 __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpxf128(_Float128 __x, int __round, unsigned __width) noexcept(true); +# 370 +extern int canonicalizef128(_Float128 * __cx, const _Float128 * __x) noexcept(true); +# 377 +extern _Float128 fmaxmagf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); extern _Float128 __fmaxmagf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 380 +extern _Float128 fminmagf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); extern _Float128 __fminmagf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 385 +extern _Float128 fmaximumf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); extern _Float128 __fmaximumf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 388 +extern _Float128 fminimumf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); extern _Float128 __fminimumf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 391 +extern _Float128 fmaximum_numf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); extern _Float128 __fmaximum_numf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 394 +extern _Float128 fminimum_numf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); extern _Float128 __fminimum_numf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 397 +extern _Float128 fmaximum_magf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); extern _Float128 __fmaximum_magf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 400 +extern _Float128 fminimum_magf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); extern _Float128 __fminimum_magf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 403 +extern _Float128 fmaximum_mag_numf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); extern _Float128 __fmaximum_mag_numf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 406 +extern _Float128 fminimum_mag_numf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); extern _Float128 __fminimum_mag_numf128(_Float128 __x, _Float128 __y) noexcept(true) __attribute((const)); +# 411 +extern int totalorderf128(const _Float128 * __x, const _Float128 * __y) noexcept(true) +# 413 + __attribute((__pure__)); +# 416 +extern int totalordermagf128(const _Float128 * __x, const _Float128 * __y) noexcept(true) +# 418 + __attribute((__pure__)); +# 421 +extern _Float128 getpayloadf128(const _Float128 * __x) noexcept(true); extern _Float128 __getpayloadf128(const _Float128 * __x) noexcept(true); +# 424 +extern int setpayloadf128(_Float128 * __x, _Float128 __payload) noexcept(true); +# 427 +extern int setpayloadsigf128(_Float128 * __x, _Float128 __payload) noexcept(true); +# 53 "/usr/include/x86_64-linux-gnu/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); +# 71 +extern _Float32x coshf32x(_Float32x __x) noexcept(true); extern _Float32x __coshf32x(_Float32x __x) noexcept(true); +# 73 +extern _Float32x sinhf32x(_Float32x __x) noexcept(true); extern _Float32x __sinhf32x(_Float32x __x) noexcept(true); +# 75 +extern _Float32x tanhf32x(_Float32x __x) noexcept(true); extern _Float32x __tanhf32x(_Float32x __x) noexcept(true); +# 79 +extern void sincosf32x(_Float32x __x, _Float32x * __sinx, _Float32x * __cosx) noexcept(true); extern void __sincosf32x(_Float32x __x, _Float32x * __sinx, _Float32x * __cosx) noexcept(true); +# 85 +extern _Float32x acoshf32x(_Float32x __x) noexcept(true); extern _Float32x __acoshf32x(_Float32x __x) noexcept(true); +# 87 +extern _Float32x asinhf32x(_Float32x __x) noexcept(true); extern _Float32x __asinhf32x(_Float32x __x) noexcept(true); +# 89 +extern _Float32x atanhf32x(_Float32x __x) noexcept(true); extern _Float32x __atanhf32x(_Float32x __x) noexcept(true); +# 95 +extern _Float32x expf32x(_Float32x __x) noexcept(true); extern _Float32x __expf32x(_Float32x __x) noexcept(true); +# 98 +extern _Float32x frexpf32x(_Float32x __x, int * __exponent) noexcept(true); extern _Float32x __frexpf32x(_Float32x __x, int * __exponent) noexcept(true); +# 101 +extern _Float32x ldexpf32x(_Float32x __x, int __exponent) noexcept(true); extern _Float32x __ldexpf32x(_Float32x __x, int __exponent) noexcept(true); +# 104 +extern _Float32x logf32x(_Float32x __x) noexcept(true); extern _Float32x __logf32x(_Float32x __x) noexcept(true); +# 107 +extern _Float32x log10f32x(_Float32x __x) noexcept(true); extern _Float32x __log10f32x(_Float32x __x) noexcept(true); +# 110 +extern _Float32x modff32x(_Float32x __x, _Float32x * __iptr) noexcept(true); extern _Float32x __modff32x(_Float32x __x, _Float32x * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 114 +extern _Float32x exp10f32x(_Float32x __x) noexcept(true); extern _Float32x __exp10f32x(_Float32x __x) noexcept(true); +# 119 +extern _Float32x expm1f32x(_Float32x __x) noexcept(true); extern _Float32x __expm1f32x(_Float32x __x) noexcept(true); +# 122 +extern _Float32x log1pf32x(_Float32x __x) noexcept(true); extern _Float32x __log1pf32x(_Float32x __x) noexcept(true); +# 125 +extern _Float32x logbf32x(_Float32x __x) noexcept(true); extern _Float32x __logbf32x(_Float32x __x) noexcept(true); +# 130 +extern _Float32x exp2f32x(_Float32x __x) noexcept(true); extern _Float32x __exp2f32x(_Float32x __x) noexcept(true); +# 133 +extern _Float32x log2f32x(_Float32x __x) noexcept(true); extern _Float32x __log2f32x(_Float32x __x) noexcept(true); +# 140 +extern _Float32x powf32x(_Float32x __x, _Float32x __y) noexcept(true); extern _Float32x __powf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 143 +extern _Float32x sqrtf32x(_Float32x __x) noexcept(true); extern _Float32x __sqrtf32x(_Float32x __x) noexcept(true); +# 147 +extern _Float32x hypotf32x(_Float32x __x, _Float32x __y) noexcept(true); extern _Float32x __hypotf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 152 +extern _Float32x cbrtf32x(_Float32x __x) noexcept(true); extern _Float32x __cbrtf32x(_Float32x __x) noexcept(true); +# 159 +extern _Float32x ceilf32x(_Float32x __x) noexcept(true) __attribute((const)); extern _Float32x __ceilf32x(_Float32x __x) noexcept(true) __attribute((const)); +# 162 +extern _Float32x fabsf32x(_Float32x __x) noexcept(true) __attribute((const)); extern _Float32x __fabsf32x(_Float32x __x) noexcept(true) __attribute((const)); +# 165 +extern _Float32x floorf32x(_Float32x __x) noexcept(true) __attribute((const)); extern _Float32x __floorf32x(_Float32x __x) noexcept(true) __attribute((const)); +# 168 +extern _Float32x fmodf32x(_Float32x __x, _Float32x __y) noexcept(true); extern _Float32x __fmodf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern _Float32x copysignf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); extern _Float32x __copysignf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 203 +extern _Float32x nanf32x(const char * __tagb) noexcept(true); extern _Float32x __nanf32x(const char * __tagb) noexcept(true); +# 220 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern _Float32x j0f32x(_Float32x) noexcept(true); extern _Float32x __j0f32x(_Float32x) noexcept(true); +# 221 +extern _Float32x j1f32x(_Float32x) noexcept(true); extern _Float32x __j1f32x(_Float32x) noexcept(true); +# 222 +extern _Float32x jnf32x(int, _Float32x) noexcept(true); extern _Float32x __jnf32x(int, _Float32x) noexcept(true); +# 223 +extern _Float32x y0f32x(_Float32x) noexcept(true); extern _Float32x __y0f32x(_Float32x) noexcept(true); +# 224 +extern _Float32x y1f32x(_Float32x) noexcept(true); extern _Float32x __y1f32x(_Float32x) noexcept(true); +# 225 +extern _Float32x ynf32x(int, _Float32x) noexcept(true); extern _Float32x __ynf32x(int, _Float32x) noexcept(true); +# 231 +extern _Float32x erff32x(_Float32x) noexcept(true); extern _Float32x __erff32x(_Float32x) noexcept(true); +# 232 +extern _Float32x erfcf32x(_Float32x) noexcept(true); extern _Float32x __erfcf32x(_Float32x) noexcept(true); +# 233 +extern _Float32x lgammaf32x(_Float32x) noexcept(true); extern _Float32x __lgammaf32x(_Float32x) noexcept(true); +# 238 +extern _Float32x tgammaf32x(_Float32x) noexcept(true); extern _Float32x __tgammaf32x(_Float32x) noexcept(true); +# 252 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern _Float32x lgammaf32x_r(_Float32x, int * __signgamp) noexcept(true); extern _Float32x __lgammaf32x_r(_Float32x, int * __signgamp) noexcept(true); +# 259 +extern _Float32x rintf32x(_Float32x __x) noexcept(true); extern _Float32x __rintf32x(_Float32x __x) noexcept(true); +# 262 +extern _Float32x nextafterf32x(_Float32x __x, _Float32x __y) noexcept(true); extern _Float32x __nextafterf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 269 +extern _Float32x nextdownf32x(_Float32x __x) noexcept(true); extern _Float32x __nextdownf32x(_Float32x __x) noexcept(true); +# 271 +extern _Float32x nextupf32x(_Float32x __x) noexcept(true); extern _Float32x __nextupf32x(_Float32x __x) noexcept(true); +# 275 +extern _Float32x remainderf32x(_Float32x __x, _Float32x __y) noexcept(true); extern _Float32x __remainderf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 279 +extern _Float32x scalbnf32x(_Float32x __x, int __n) noexcept(true); extern _Float32x __scalbnf32x(_Float32x __x, int __n) noexcept(true); +# 283 +extern int ilogbf32x(_Float32x __x) noexcept(true); extern int __ilogbf32x(_Float32x __x) noexcept(true); +# 288 +extern long llogbf32x(_Float32x __x) noexcept(true); extern long __llogbf32x(_Float32x __x) noexcept(true); +# 293 +extern _Float32x scalblnf32x(_Float32x __x, long __n) noexcept(true); extern _Float32x __scalblnf32x(_Float32x __x, long __n) noexcept(true); +# 297 +extern _Float32x nearbyintf32x(_Float32x __x) noexcept(true); extern _Float32x __nearbyintf32x(_Float32x __x) noexcept(true); +# 301 +extern _Float32x roundf32x(_Float32x __x) noexcept(true) __attribute((const)); extern _Float32x __roundf32x(_Float32x __x) noexcept(true) __attribute((const)); +# 305 +extern _Float32x truncf32x(_Float32x __x) noexcept(true) __attribute((const)); extern _Float32x __truncf32x(_Float32x __x) noexcept(true) __attribute((const)); +# 310 +extern _Float32x remquof32x(_Float32x __x, _Float32x __y, int * __quo) noexcept(true); extern _Float32x __remquof32x(_Float32x __x, _Float32x __y, int * __quo) noexcept(true); +# 317 +extern long lrintf32x(_Float32x __x) noexcept(true); extern long __lrintf32x(_Float32x __x) noexcept(true); +# 319 +__extension__ extern long long llrintf32x(_Float32x __x) noexcept(true); extern long long __llrintf32x(_Float32x __x) noexcept(true); +# 323 +extern long lroundf32x(_Float32x __x) noexcept(true); extern long __lroundf32x(_Float32x __x) noexcept(true); +# 325 +__extension__ extern long long llroundf32x(_Float32x __x) noexcept(true); extern long long __llroundf32x(_Float32x __x) noexcept(true); +# 329 +extern _Float32x fdimf32x(_Float32x __x, _Float32x __y) noexcept(true); extern _Float32x __fdimf32x(_Float32x __x, _Float32x __y) noexcept(true); +# 333 +extern _Float32x fmaxf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); extern _Float32x __fmaxf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 336 +extern _Float32x fminf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); extern _Float32x __fminf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 340 +extern _Float32x fmaf32x(_Float32x __x, _Float32x __y, _Float32x __z) noexcept(true); extern _Float32x __fmaf32x(_Float32x __x, _Float32x __y, _Float32x __z) noexcept(true); +# 345 +extern _Float32x roundevenf32x(_Float32x __x) noexcept(true) __attribute((const)); extern _Float32x __roundevenf32x(_Float32x __x) noexcept(true) __attribute((const)); +# 349 +extern __intmax_t fromfpf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); +# 354 +extern __uintmax_t ufromfpf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); +# 360 +extern __intmax_t fromfpxf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpxf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); +# 366 +extern __uintmax_t ufromfpxf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpxf32x(_Float32x __x, int __round, unsigned __width) noexcept(true); +# 370 +extern int canonicalizef32x(_Float32x * __cx, const _Float32x * __x) noexcept(true); +# 377 +extern _Float32x fmaxmagf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); extern _Float32x __fmaxmagf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 380 +extern _Float32x fminmagf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); extern _Float32x __fminmagf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 385 +extern _Float32x fmaximumf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); extern _Float32x __fmaximumf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 388 +extern _Float32x fminimumf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); extern _Float32x __fminimumf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 391 +extern _Float32x fmaximum_numf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); extern _Float32x __fmaximum_numf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 394 +extern _Float32x fminimum_numf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); extern _Float32x __fminimum_numf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 397 +extern _Float32x fmaximum_magf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); extern _Float32x __fmaximum_magf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 400 +extern _Float32x fminimum_magf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); extern _Float32x __fminimum_magf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 403 +extern _Float32x fmaximum_mag_numf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); extern _Float32x __fmaximum_mag_numf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 406 +extern _Float32x fminimum_mag_numf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); extern _Float32x __fminimum_mag_numf32x(_Float32x __x, _Float32x __y) noexcept(true) __attribute((const)); +# 411 +extern int totalorderf32x(const _Float32x * __x, const _Float32x * __y) noexcept(true) +# 413 + __attribute((__pure__)); +# 416 +extern int totalordermagf32x(const _Float32x * __x, const _Float32x * __y) noexcept(true) +# 418 + __attribute((__pure__)); +# 421 +extern _Float32x getpayloadf32x(const _Float32x * __x) noexcept(true); extern _Float32x __getpayloadf32x(const _Float32x * __x) noexcept(true); +# 424 +extern int setpayloadf32x(_Float32x * __x, _Float32x __payload) noexcept(true); +# 427 +extern int setpayloadsigf32x(_Float32x * __x, _Float32x __payload) noexcept(true); +# 53 "/usr/include/x86_64-linux-gnu/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); +# 71 +extern _Float64x coshf64x(_Float64x __x) noexcept(true); extern _Float64x __coshf64x(_Float64x __x) noexcept(true); +# 73 +extern _Float64x sinhf64x(_Float64x __x) noexcept(true); extern _Float64x __sinhf64x(_Float64x __x) noexcept(true); +# 75 +extern _Float64x tanhf64x(_Float64x __x) noexcept(true); extern _Float64x __tanhf64x(_Float64x __x) noexcept(true); +# 79 +extern void sincosf64x(_Float64x __x, _Float64x * __sinx, _Float64x * __cosx) noexcept(true); extern void __sincosf64x(_Float64x __x, _Float64x * __sinx, _Float64x * __cosx) noexcept(true); +# 85 +extern _Float64x acoshf64x(_Float64x __x) noexcept(true); extern _Float64x __acoshf64x(_Float64x __x) noexcept(true); +# 87 +extern _Float64x asinhf64x(_Float64x __x) noexcept(true); extern _Float64x __asinhf64x(_Float64x __x) noexcept(true); +# 89 +extern _Float64x atanhf64x(_Float64x __x) noexcept(true); extern _Float64x __atanhf64x(_Float64x __x) noexcept(true); +# 95 +extern _Float64x expf64x(_Float64x __x) noexcept(true); extern _Float64x __expf64x(_Float64x __x) noexcept(true); +# 98 +extern _Float64x frexpf64x(_Float64x __x, int * __exponent) noexcept(true); extern _Float64x __frexpf64x(_Float64x __x, int * __exponent) noexcept(true); +# 101 +extern _Float64x ldexpf64x(_Float64x __x, int __exponent) noexcept(true); extern _Float64x __ldexpf64x(_Float64x __x, int __exponent) noexcept(true); +# 104 +extern _Float64x logf64x(_Float64x __x) noexcept(true); extern _Float64x __logf64x(_Float64x __x) noexcept(true); +# 107 +extern _Float64x log10f64x(_Float64x __x) noexcept(true); extern _Float64x __log10f64x(_Float64x __x) noexcept(true); +# 110 +extern _Float64x modff64x(_Float64x __x, _Float64x * __iptr) noexcept(true); extern _Float64x __modff64x(_Float64x __x, _Float64x * __iptr) noexcept(true) __attribute((__nonnull__(2))); +# 114 +extern _Float64x exp10f64x(_Float64x __x) noexcept(true); extern _Float64x __exp10f64x(_Float64x __x) noexcept(true); +# 119 +extern _Float64x expm1f64x(_Float64x __x) noexcept(true); extern _Float64x __expm1f64x(_Float64x __x) noexcept(true); +# 122 +extern _Float64x log1pf64x(_Float64x __x) noexcept(true); extern _Float64x __log1pf64x(_Float64x __x) noexcept(true); +# 125 +extern _Float64x logbf64x(_Float64x __x) noexcept(true); extern _Float64x __logbf64x(_Float64x __x) noexcept(true); +# 130 +extern _Float64x exp2f64x(_Float64x __x) noexcept(true); extern _Float64x __exp2f64x(_Float64x __x) noexcept(true); +# 133 +extern _Float64x log2f64x(_Float64x __x) noexcept(true); extern _Float64x __log2f64x(_Float64x __x) noexcept(true); +# 140 +extern _Float64x powf64x(_Float64x __x, _Float64x __y) noexcept(true); extern _Float64x __powf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 143 +extern _Float64x sqrtf64x(_Float64x __x) noexcept(true); extern _Float64x __sqrtf64x(_Float64x __x) noexcept(true); +# 147 +extern _Float64x hypotf64x(_Float64x __x, _Float64x __y) noexcept(true); extern _Float64x __hypotf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 152 +extern _Float64x cbrtf64x(_Float64x __x) noexcept(true); extern _Float64x __cbrtf64x(_Float64x __x) noexcept(true); +# 159 +extern _Float64x ceilf64x(_Float64x __x) noexcept(true) __attribute((const)); extern _Float64x __ceilf64x(_Float64x __x) noexcept(true) __attribute((const)); +# 162 +extern _Float64x fabsf64x(_Float64x __x) noexcept(true) __attribute((const)); extern _Float64x __fabsf64x(_Float64x __x) noexcept(true) __attribute((const)); +# 165 +extern _Float64x floorf64x(_Float64x __x) noexcept(true) __attribute((const)); extern _Float64x __floorf64x(_Float64x __x) noexcept(true) __attribute((const)); +# 168 +extern _Float64x fmodf64x(_Float64x __x, _Float64x __y) noexcept(true); extern _Float64x __fmodf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern _Float64x copysignf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); extern _Float64x __copysignf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 203 +extern _Float64x nanf64x(const char * __tagb) noexcept(true); extern _Float64x __nanf64x(const char * __tagb) noexcept(true); +# 220 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern _Float64x j0f64x(_Float64x) noexcept(true); extern _Float64x __j0f64x(_Float64x) noexcept(true); +# 221 +extern _Float64x j1f64x(_Float64x) noexcept(true); extern _Float64x __j1f64x(_Float64x) noexcept(true); +# 222 +extern _Float64x jnf64x(int, _Float64x) noexcept(true); extern _Float64x __jnf64x(int, _Float64x) noexcept(true); +# 223 +extern _Float64x y0f64x(_Float64x) noexcept(true); extern _Float64x __y0f64x(_Float64x) noexcept(true); +# 224 +extern _Float64x y1f64x(_Float64x) noexcept(true); extern _Float64x __y1f64x(_Float64x) noexcept(true); +# 225 +extern _Float64x ynf64x(int, _Float64x) noexcept(true); extern _Float64x __ynf64x(int, _Float64x) noexcept(true); +# 231 +extern _Float64x erff64x(_Float64x) noexcept(true); extern _Float64x __erff64x(_Float64x) noexcept(true); +# 232 +extern _Float64x erfcf64x(_Float64x) noexcept(true); extern _Float64x __erfcf64x(_Float64x) noexcept(true); +# 233 +extern _Float64x lgammaf64x(_Float64x) noexcept(true); extern _Float64x __lgammaf64x(_Float64x) noexcept(true); +# 238 +extern _Float64x tgammaf64x(_Float64x) noexcept(true); extern _Float64x __tgammaf64x(_Float64x) noexcept(true); +# 252 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 +extern _Float64x lgammaf64x_r(_Float64x, int * __signgamp) noexcept(true); extern _Float64x __lgammaf64x_r(_Float64x, int * __signgamp) noexcept(true); +# 259 +extern _Float64x rintf64x(_Float64x __x) noexcept(true); extern _Float64x __rintf64x(_Float64x __x) noexcept(true); +# 262 +extern _Float64x nextafterf64x(_Float64x __x, _Float64x __y) noexcept(true); extern _Float64x __nextafterf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 269 +extern _Float64x nextdownf64x(_Float64x __x) noexcept(true); extern _Float64x __nextdownf64x(_Float64x __x) noexcept(true); +# 271 +extern _Float64x nextupf64x(_Float64x __x) noexcept(true); extern _Float64x __nextupf64x(_Float64x __x) noexcept(true); +# 275 +extern _Float64x remainderf64x(_Float64x __x, _Float64x __y) noexcept(true); extern _Float64x __remainderf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 279 +extern _Float64x scalbnf64x(_Float64x __x, int __n) noexcept(true); extern _Float64x __scalbnf64x(_Float64x __x, int __n) noexcept(true); +# 283 +extern int ilogbf64x(_Float64x __x) noexcept(true); extern int __ilogbf64x(_Float64x __x) noexcept(true); +# 288 +extern long llogbf64x(_Float64x __x) noexcept(true); extern long __llogbf64x(_Float64x __x) noexcept(true); +# 293 +extern _Float64x scalblnf64x(_Float64x __x, long __n) noexcept(true); extern _Float64x __scalblnf64x(_Float64x __x, long __n) noexcept(true); +# 297 +extern _Float64x nearbyintf64x(_Float64x __x) noexcept(true); extern _Float64x __nearbyintf64x(_Float64x __x) noexcept(true); +# 301 +extern _Float64x roundf64x(_Float64x __x) noexcept(true) __attribute((const)); extern _Float64x __roundf64x(_Float64x __x) noexcept(true) __attribute((const)); +# 305 +extern _Float64x truncf64x(_Float64x __x) noexcept(true) __attribute((const)); extern _Float64x __truncf64x(_Float64x __x) noexcept(true) __attribute((const)); +# 310 +extern _Float64x remquof64x(_Float64x __x, _Float64x __y, int * __quo) noexcept(true); extern _Float64x __remquof64x(_Float64x __x, _Float64x __y, int * __quo) noexcept(true); +# 317 +extern long lrintf64x(_Float64x __x) noexcept(true); extern long __lrintf64x(_Float64x __x) noexcept(true); +# 319 +__extension__ extern long long llrintf64x(_Float64x __x) noexcept(true); extern long long __llrintf64x(_Float64x __x) noexcept(true); +# 323 +extern long lroundf64x(_Float64x __x) noexcept(true); extern long __lroundf64x(_Float64x __x) noexcept(true); +# 325 +__extension__ extern long long llroundf64x(_Float64x __x) noexcept(true); extern long long __llroundf64x(_Float64x __x) noexcept(true); +# 329 +extern _Float64x fdimf64x(_Float64x __x, _Float64x __y) noexcept(true); extern _Float64x __fdimf64x(_Float64x __x, _Float64x __y) noexcept(true); +# 333 +extern _Float64x fmaxf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); extern _Float64x __fmaxf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 336 +extern _Float64x fminf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); extern _Float64x __fminf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 340 +extern _Float64x fmaf64x(_Float64x __x, _Float64x __y, _Float64x __z) noexcept(true); extern _Float64x __fmaf64x(_Float64x __x, _Float64x __y, _Float64x __z) noexcept(true); +# 345 +extern _Float64x roundevenf64x(_Float64x __x) noexcept(true) __attribute((const)); extern _Float64x __roundevenf64x(_Float64x __x) noexcept(true) __attribute((const)); +# 349 +extern __intmax_t fromfpf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); +# 354 +extern __uintmax_t ufromfpf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); +# 360 +extern __intmax_t fromfpxf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); extern __intmax_t __fromfpxf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); +# 366 +extern __uintmax_t ufromfpxf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); extern __uintmax_t __ufromfpxf64x(_Float64x __x, int __round, unsigned __width) noexcept(true); +# 370 +extern int canonicalizef64x(_Float64x * __cx, const _Float64x * __x) noexcept(true); +# 377 +extern _Float64x fmaxmagf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); extern _Float64x __fmaxmagf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 380 +extern _Float64x fminmagf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); extern _Float64x __fminmagf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 385 +extern _Float64x fmaximumf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); extern _Float64x __fmaximumf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 388 +extern _Float64x fminimumf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); extern _Float64x __fminimumf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 391 +extern _Float64x fmaximum_numf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); extern _Float64x __fmaximum_numf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 394 +extern _Float64x fminimum_numf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); extern _Float64x __fminimum_numf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 397 +extern _Float64x fmaximum_magf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); extern _Float64x __fmaximum_magf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 400 +extern _Float64x fminimum_magf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); extern _Float64x __fminimum_magf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 403 +extern _Float64x fmaximum_mag_numf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); extern _Float64x __fmaximum_mag_numf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 406 +extern _Float64x fminimum_mag_numf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); extern _Float64x __fminimum_mag_numf64x(_Float64x __x, _Float64x __y) noexcept(true) __attribute((const)); +# 411 +extern int totalorderf64x(const _Float64x * __x, const _Float64x * __y) noexcept(true) +# 413 + __attribute((__pure__)); +# 416 +extern int totalordermagf64x(const _Float64x * __x, const _Float64x * __y) noexcept(true) +# 418 + __attribute((__pure__)); +# 421 +extern _Float64x getpayloadf64x(const _Float64x * __x) noexcept(true); extern _Float64x __getpayloadf64x(const _Float64x * __x) noexcept(true); +# 424 +extern int setpayloadf64x(_Float64x * __x, _Float64x __payload) noexcept(true); +# 427 +extern int setpayloadsigf64x(_Float64x * __x, _Float64x __payload) noexcept(true); +# 24 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/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/x86_64-linux-gnu/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/x86_64-linux-gnu/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/x86_64-linux-gnu/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/x86_64-linux-gnu/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/x86_64-linux-gnu/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/x86_64-linux-gnu/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/x86_64-linux-gnu/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/x86_64-linux-gnu/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/x86_64-linux-gnu/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/x86_64-linux-gnu/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/x86_64-linux-gnu/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); +# 854 "/usr/include/math.h" 3 +extern int signgam; +# 935 "/usr/include/math.h" 3 +enum { +# 936 +FP_NAN, +# 939 +FP_INFINITE, +# 942 +FP_ZERO, +# 945 +FP_SUBNORMAL, +# 948 +FP_NORMAL +# 951 +}; +# 23 "/usr/include/x86_64-linux-gnu/bits/iscanonical.h" 3 +extern int __iscanonicall(long double __x) noexcept(true) +# 24 + __attribute((const)); +# 46 "/usr/include/x86_64-linux-gnu/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 +} +# 1066 "/usr/include/math.h" 3 +extern "C++" { +# 1067 +inline int issignaling(float __val) { return __issignalingf(__val); } +# 1068 +inline int issignaling(double __val) { return __issignaling(__val); } +# 1070 +inline int issignaling(long double __val) +# 1071 +{ +# 1075 +return __issignalingl(__val); +# 1077 +} +# 1081 +inline int issignaling(_Float128 __val) { return __issignalingf128(__val); } +# 1083 +} +# 1097 "/usr/include/math.h" 3 +extern "C++" { +# 1128 "/usr/include/math.h" 3 +template< class __T> inline bool +# 1129 +iszero(__T __val) +# 1130 +{ +# 1131 +return __val == 0; +# 1132 +} +# 1134 +} +# 1363 "/usr/include/math.h" 3 +extern "C++" { +# 1364 +template< class > struct __iseqsig_type; +# 1366 +template<> struct __iseqsig_type< float> { +# 1368 +static int __call(float __x, float __y) throw() +# 1369 +{ +# 1370 +return __iseqsigf(__x, __y); +# 1371 +} +# 1372 +}; +# 1374 +template<> struct __iseqsig_type< double> { +# 1376 +static int __call(double __x, double __y) throw() +# 1377 +{ +# 1378 +return __iseqsig(__x, __y); +# 1379 +} +# 1380 +}; +# 1382 +template<> struct __iseqsig_type< long double> { +# 1384 +static int __call(long double __x, long double __y) throw() +# 1385 +{ +# 1387 +return __iseqsigl(__x, __y); +# 1391 +} +# 1392 +}; +# 1397 +template<> struct __iseqsig_type< __float128> { +# 1399 +static int __call(_Float128 __x, _Float128 __y) throw() +# 1400 +{ +# 1401 +return __iseqsigf128(__x, __y); +# 1402 +} +# 1403 +}; +# 1406 +template< class _T1, class _T2> inline int +# 1408 +iseqsig(_T1 __x, _T2 __y) throw() +# 1409 +{ +# 1411 +typedef __decltype(((__x + __y) + (0.0F))) _T3; +# 1415 +return __iseqsig_type< __decltype(((__x + __y) + (0.0F)))> ::__call(__x, __y); +# 1416 +} +# 1418 +} +# 1423 +} +# 77 "/usr/include/c++/11/cmath" 3 +extern "C++" { +# 79 +namespace std __attribute((__visibility__("default"))) { +# 83 +using ::acos; +# 87 +constexpr float acos(float __x) +# 88 +{ return __builtin_acosf(__x); } +# 91 +constexpr long double acos(long double __x) +# 92 +{ return __builtin_acosl(__x); } +# 95 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 99 +acos(_Tp __x) +# 100 +{ return __builtin_acos(__x); } +# 102 +using ::asin; +# 106 +constexpr float asin(float __x) +# 107 +{ return __builtin_asinf(__x); } +# 110 +constexpr long double asin(long double __x) +# 111 +{ return __builtin_asinl(__x); } +# 114 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 118 +asin(_Tp __x) +# 119 +{ return __builtin_asin(__x); } +# 121 +using ::atan; +# 125 +constexpr float atan(float __x) +# 126 +{ return __builtin_atanf(__x); } +# 129 +constexpr long double atan(long double __x) +# 130 +{ return __builtin_atanl(__x); } +# 133 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 137 +atan(_Tp __x) +# 138 +{ return __builtin_atan(__x); } +# 140 +using ::atan2; +# 144 +constexpr float atan2(float __y, float __x) +# 145 +{ return __builtin_atan2f(__y, __x); } +# 148 +constexpr long double atan2(long double __y, long double __x) +# 149 +{ return __builtin_atan2l(__y, __x); } +# 152 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 155 +atan2(_Tp __y, _Up __x) +# 156 +{ +# 157 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 158 +return atan2((__type)__y, (__type)__x); +# 159 +} +# 161 +using ::ceil; +# 165 +constexpr float ceil(float __x) +# 166 +{ return __builtin_ceilf(__x); } +# 169 +constexpr long double ceil(long double __x) +# 170 +{ return __builtin_ceill(__x); } +# 173 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 177 +ceil(_Tp __x) +# 178 +{ return __builtin_ceil(__x); } +# 180 +using ::cos; +# 184 +constexpr float cos(float __x) +# 185 +{ return __builtin_cosf(__x); } +# 188 +constexpr long double cos(long double __x) +# 189 +{ return __builtin_cosl(__x); } +# 192 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 196 +cos(_Tp __x) +# 197 +{ return __builtin_cos(__x); } +# 199 +using ::cosh; +# 203 +constexpr float cosh(float __x) +# 204 +{ return __builtin_coshf(__x); } +# 207 +constexpr long double cosh(long double __x) +# 208 +{ return __builtin_coshl(__x); } +# 211 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 215 +cosh(_Tp __x) +# 216 +{ return __builtin_cosh(__x); } +# 218 +using ::exp; +# 222 +constexpr float exp(float __x) +# 223 +{ return __builtin_expf(__x); } +# 226 +constexpr long double exp(long double __x) +# 227 +{ return __builtin_expl(__x); } +# 230 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 234 +exp(_Tp __x) +# 235 +{ return __builtin_exp(__x); } +# 237 +using ::fabs; +# 241 +constexpr float fabs(float __x) +# 242 +{ return __builtin_fabsf(__x); } +# 245 +constexpr long double fabs(long double __x) +# 246 +{ return __builtin_fabsl(__x); } +# 249 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 253 +fabs(_Tp __x) +# 254 +{ return __builtin_fabs(__x); } +# 256 +using ::floor; +# 260 +constexpr float floor(float __x) +# 261 +{ return __builtin_floorf(__x); } +# 264 +constexpr long double floor(long double __x) +# 265 +{ return __builtin_floorl(__x); } +# 268 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 272 +floor(_Tp __x) +# 273 +{ return __builtin_floor(__x); } +# 275 +using ::fmod; +# 279 +constexpr float fmod(float __x, float __y) +# 280 +{ return __builtin_fmodf(__x, __y); } +# 283 +constexpr long double fmod(long double __x, long double __y) +# 284 +{ return __builtin_fmodl(__x, __y); } +# 287 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 290 +fmod(_Tp __x, _Up __y) +# 291 +{ +# 292 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 293 +return fmod((__type)__x, (__type)__y); +# 294 +} +# 296 +using ::frexp; +# 300 +inline float frexp(float __x, int *__exp) +# 301 +{ return __builtin_frexpf(__x, __exp); } +# 304 +inline long double frexp(long double __x, int *__exp) +# 305 +{ return __builtin_frexpl(__x, __exp); } +# 308 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 312 +frexp(_Tp __x, int *__exp) +# 313 +{ return __builtin_frexp(__x, __exp); } +# 315 +using ::ldexp; +# 319 +constexpr float ldexp(float __x, int __exp) +# 320 +{ return __builtin_ldexpf(__x, __exp); } +# 323 +constexpr long double ldexp(long double __x, int __exp) +# 324 +{ return __builtin_ldexpl(__x, __exp); } +# 327 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 331 +ldexp(_Tp __x, int __exp) +# 332 +{ return __builtin_ldexp(__x, __exp); } +# 334 +using ::log; +# 338 +constexpr float log(float __x) +# 339 +{ return __builtin_logf(__x); } +# 342 +constexpr long double log(long double __x) +# 343 +{ return __builtin_logl(__x); } +# 346 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 350 +log(_Tp __x) +# 351 +{ return __builtin_log(__x); } +# 353 +using ::log10; +# 357 +constexpr float log10(float __x) +# 358 +{ return __builtin_log10f(__x); } +# 361 +constexpr long double log10(long double __x) +# 362 +{ return __builtin_log10l(__x); } +# 365 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 369 +log10(_Tp __x) +# 370 +{ return __builtin_log10(__x); } +# 372 +using ::modf; +# 376 +inline float modf(float __x, float *__iptr) +# 377 +{ return __builtin_modff(__x, __iptr); } +# 380 +inline long double modf(long double __x, long double *__iptr) +# 381 +{ return __builtin_modfl(__x, __iptr); } +# 384 +using ::pow; +# 388 +constexpr float pow(float __x, float __y) +# 389 +{ return __builtin_powf(__x, __y); } +# 392 +constexpr long double pow(long double __x, long double __y) +# 393 +{ return __builtin_powl(__x, __y); } +# 412 "/usr/include/c++/11/cmath" 3 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 415 +pow(_Tp __x, _Up __y) +# 416 +{ +# 417 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 418 +return pow((__type)__x, (__type)__y); +# 419 +} +# 421 +using ::sin; +# 425 +constexpr float sin(float __x) +# 426 +{ return __builtin_sinf(__x); } +# 429 +constexpr long double sin(long double __x) +# 430 +{ return __builtin_sinl(__x); } +# 433 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 437 +sin(_Tp __x) +# 438 +{ return __builtin_sin(__x); } +# 440 +using ::sinh; +# 444 +constexpr float sinh(float __x) +# 445 +{ return __builtin_sinhf(__x); } +# 448 +constexpr long double sinh(long double __x) +# 449 +{ return __builtin_sinhl(__x); } +# 452 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 456 +sinh(_Tp __x) +# 457 +{ return __builtin_sinh(__x); } +# 459 +using ::sqrt; +# 463 +constexpr float sqrt(float __x) +# 464 +{ return __builtin_sqrtf(__x); } +# 467 +constexpr long double sqrt(long double __x) +# 468 +{ return __builtin_sqrtl(__x); } +# 471 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 475 +sqrt(_Tp __x) +# 476 +{ return __builtin_sqrt(__x); } +# 478 +using ::tan; +# 482 +constexpr float tan(float __x) +# 483 +{ return __builtin_tanf(__x); } +# 486 +constexpr long double tan(long double __x) +# 487 +{ return __builtin_tanl(__x); } +# 490 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 494 +tan(_Tp __x) +# 495 +{ return __builtin_tan(__x); } +# 497 +using ::tanh; +# 501 +constexpr float tanh(float __x) +# 502 +{ return __builtin_tanhf(__x); } +# 505 +constexpr long double tanh(long double __x) +# 506 +{ return __builtin_tanhl(__x); } +# 509 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 513 +tanh(_Tp __x) +# 514 +{ return __builtin_tanh(__x); } +# 537 "/usr/include/c++/11/cmath" 3 +constexpr int fpclassify(float __x) +# 538 +{ return __builtin_fpclassify(0, 1, 4, 3, 2, __x); +# 539 +} +# 542 +constexpr int fpclassify(double __x) +# 543 +{ return __builtin_fpclassify(0, 1, 4, 3, 2, __x); +# 544 +} +# 547 +constexpr int fpclassify(long double __x) +# 548 +{ return __builtin_fpclassify(0, 1, 4, 3, 2, __x); +# 549 +} +# 553 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, int> ::__type +# 556 +fpclassify(_Tp __x) +# 557 +{ return (__x != 0) ? 4 : 2; } +# 562 +constexpr bool isfinite(float __x) +# 563 +{ return __builtin_isfinite(__x); } +# 566 +constexpr bool isfinite(double __x) +# 567 +{ return __builtin_isfinite(__x); } +# 570 +constexpr bool isfinite(long double __x) +# 571 +{ return __builtin_isfinite(__x); } +# 575 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, bool> ::__type +# 578 +isfinite(_Tp __x) +# 579 +{ return true; } +# 584 +constexpr bool isinf(float __x) +# 585 +{ return __builtin_isinf(__x); } +# 592 +constexpr bool isinf(double __x) +# 593 +{ return __builtin_isinf(__x); } +# 597 +constexpr bool isinf(long double __x) +# 598 +{ return __builtin_isinf(__x); } +# 602 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, bool> ::__type +# 605 +isinf(_Tp __x) +# 606 +{ return false; } +# 611 +constexpr bool isnan(float __x) +# 612 +{ return __builtin_isnan(__x); } +# 619 +constexpr bool isnan(double __x) +# 620 +{ return __builtin_isnan(__x); } +# 624 +constexpr bool isnan(long double __x) +# 625 +{ return __builtin_isnan(__x); } +# 629 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, bool> ::__type +# 632 +isnan(_Tp __x) +# 633 +{ return false; } +# 638 +constexpr bool isnormal(float __x) +# 639 +{ return __builtin_isnormal(__x); } +# 642 +constexpr bool isnormal(double __x) +# 643 +{ return __builtin_isnormal(__x); } +# 646 +constexpr bool isnormal(long double __x) +# 647 +{ return __builtin_isnormal(__x); } +# 651 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, bool> ::__type +# 654 +isnormal(_Tp __x) +# 655 +{ return (__x != 0) ? true : false; } +# 661 +constexpr bool signbit(float __x) +# 662 +{ return __builtin_signbit(__x); } +# 665 +constexpr bool signbit(double __x) +# 666 +{ return __builtin_signbit(__x); } +# 669 +constexpr bool signbit(long double __x) +# 670 +{ return __builtin_signbit(__x); } +# 674 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, bool> ::__type +# 677 +signbit(_Tp __x) +# 678 +{ return (__x < 0) ? true : false; } +# 683 +constexpr bool isgreater(float __x, float __y) +# 684 +{ return __builtin_isgreater(__x, __y); } +# 687 +constexpr bool isgreater(double __x, double __y) +# 688 +{ return __builtin_isgreater(__x, __y); } +# 691 +constexpr bool isgreater(long double __x, long double __y) +# 692 +{ return __builtin_isgreater(__x, __y); } +# 696 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__enable_if< __is_arithmetic< _Tp> ::__value && __is_arithmetic< _Up> ::__value, bool> ::__type +# 700 +isgreater(_Tp __x, _Up __y) +# 701 +{ +# 702 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 703 +return __builtin_isgreater((__type)__x, (__type)__y); +# 704 +} +# 709 +constexpr bool isgreaterequal(float __x, float __y) +# 710 +{ return __builtin_isgreaterequal(__x, __y); } +# 713 +constexpr bool isgreaterequal(double __x, double __y) +# 714 +{ return __builtin_isgreaterequal(__x, __y); } +# 717 +constexpr bool isgreaterequal(long double __x, long double __y) +# 718 +{ return __builtin_isgreaterequal(__x, __y); } +# 722 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__enable_if< __is_arithmetic< _Tp> ::__value && __is_arithmetic< _Up> ::__value, bool> ::__type +# 726 +isgreaterequal(_Tp __x, _Up __y) +# 727 +{ +# 728 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 729 +return __builtin_isgreaterequal((__type)__x, (__type)__y); +# 730 +} +# 735 +constexpr bool isless(float __x, float __y) +# 736 +{ return __builtin_isless(__x, __y); } +# 739 +constexpr bool isless(double __x, double __y) +# 740 +{ return __builtin_isless(__x, __y); } +# 743 +constexpr bool isless(long double __x, long double __y) +# 744 +{ return __builtin_isless(__x, __y); } +# 748 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__enable_if< __is_arithmetic< _Tp> ::__value && __is_arithmetic< _Up> ::__value, bool> ::__type +# 752 +isless(_Tp __x, _Up __y) +# 753 +{ +# 754 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 755 +return __builtin_isless((__type)__x, (__type)__y); +# 756 +} +# 761 +constexpr bool islessequal(float __x, float __y) +# 762 +{ return __builtin_islessequal(__x, __y); } +# 765 +constexpr bool islessequal(double __x, double __y) +# 766 +{ return __builtin_islessequal(__x, __y); } +# 769 +constexpr bool islessequal(long double __x, long double __y) +# 770 +{ return __builtin_islessequal(__x, __y); } +# 774 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__enable_if< __is_arithmetic< _Tp> ::__value && __is_arithmetic< _Up> ::__value, bool> ::__type +# 778 +islessequal(_Tp __x, _Up __y) +# 779 +{ +# 780 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 781 +return __builtin_islessequal((__type)__x, (__type)__y); +# 782 +} +# 787 +constexpr bool islessgreater(float __x, float __y) +# 788 +{ return __builtin_islessgreater(__x, __y); } +# 791 +constexpr bool islessgreater(double __x, double __y) +# 792 +{ return __builtin_islessgreater(__x, __y); } +# 795 +constexpr bool islessgreater(long double __x, long double __y) +# 796 +{ return __builtin_islessgreater(__x, __y); } +# 800 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__enable_if< __is_arithmetic< _Tp> ::__value && __is_arithmetic< _Up> ::__value, bool> ::__type +# 804 +islessgreater(_Tp __x, _Up __y) +# 805 +{ +# 806 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 807 +return __builtin_islessgreater((__type)__x, (__type)__y); +# 808 +} +# 813 +constexpr bool isunordered(float __x, float __y) +# 814 +{ return __builtin_isunordered(__x, __y); } +# 817 +constexpr bool isunordered(double __x, double __y) +# 818 +{ return __builtin_isunordered(__x, __y); } +# 821 +constexpr bool isunordered(long double __x, long double __y) +# 822 +{ return __builtin_isunordered(__x, __y); } +# 826 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__enable_if< __is_arithmetic< _Tp> ::__value && __is_arithmetic< _Up> ::__value, bool> ::__type +# 830 +isunordered(_Tp __x, _Up __y) +# 831 +{ +# 832 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 833 +return __builtin_isunordered((__type)__x, (__type)__y); +# 834 +} +# 1065 "/usr/include/c++/11/cmath" 3 +using ::double_t; +# 1066 +using ::float_t; +# 1069 +using ::acosh; +# 1070 +using ::acoshf; +# 1071 +using ::acoshl; +# 1073 +using ::asinh; +# 1074 +using ::asinhf; +# 1075 +using ::asinhl; +# 1077 +using ::atanh; +# 1078 +using ::atanhf; +# 1079 +using ::atanhl; +# 1081 +using ::cbrt; +# 1082 +using ::cbrtf; +# 1083 +using ::cbrtl; +# 1085 +using ::copysign; +# 1086 +using ::copysignf; +# 1087 +using ::copysignl; +# 1089 +using ::erf; +# 1090 +using ::erff; +# 1091 +using ::erfl; +# 1093 +using ::erfc; +# 1094 +using ::erfcf; +# 1095 +using ::erfcl; +# 1097 +using ::exp2; +# 1098 +using ::exp2f; +# 1099 +using ::exp2l; +# 1101 +using ::expm1; +# 1102 +using ::expm1f; +# 1103 +using ::expm1l; +# 1105 +using ::fdim; +# 1106 +using ::fdimf; +# 1107 +using ::fdiml; +# 1109 +using ::fma; +# 1110 +using ::fmaf; +# 1111 +using ::fmal; +# 1113 +using ::fmax; +# 1114 +using ::fmaxf; +# 1115 +using ::fmaxl; +# 1117 +using ::fmin; +# 1118 +using ::fminf; +# 1119 +using ::fminl; +# 1121 +using ::hypot; +# 1122 +using ::hypotf; +# 1123 +using ::hypotl; +# 1125 +using ::ilogb; +# 1126 +using ::ilogbf; +# 1127 +using ::ilogbl; +# 1129 +using ::lgamma; +# 1130 +using ::lgammaf; +# 1131 +using ::lgammal; +# 1134 +using ::llrint; +# 1135 +using ::llrintf; +# 1136 +using ::llrintl; +# 1138 +using ::llround; +# 1139 +using ::llroundf; +# 1140 +using ::llroundl; +# 1143 +using ::log1p; +# 1144 +using ::log1pf; +# 1145 +using ::log1pl; +# 1147 +using ::log2; +# 1148 +using ::log2f; +# 1149 +using ::log2l; +# 1151 +using ::logb; +# 1152 +using ::logbf; +# 1153 +using ::logbl; +# 1155 +using ::lrint; +# 1156 +using ::lrintf; +# 1157 +using ::lrintl; +# 1159 +using ::lround; +# 1160 +using ::lroundf; +# 1161 +using ::lroundl; +# 1163 +using ::nan; +# 1164 +using ::nanf; +# 1165 +using ::nanl; +# 1167 +using ::nearbyint; +# 1168 +using ::nearbyintf; +# 1169 +using ::nearbyintl; +# 1171 +using ::nextafter; +# 1172 +using ::nextafterf; +# 1173 +using ::nextafterl; +# 1175 +using ::nexttoward; +# 1176 +using ::nexttowardf; +# 1177 +using ::nexttowardl; +# 1179 +using ::remainder; +# 1180 +using ::remainderf; +# 1181 +using ::remainderl; +# 1183 +using ::remquo; +# 1184 +using ::remquof; +# 1185 +using ::remquol; +# 1187 +using ::rint; +# 1188 +using ::rintf; +# 1189 +using ::rintl; +# 1191 +using ::round; +# 1192 +using ::roundf; +# 1193 +using ::roundl; +# 1195 +using ::scalbln; +# 1196 +using ::scalblnf; +# 1197 +using ::scalblnl; +# 1199 +using ::scalbn; +# 1200 +using ::scalbnf; +# 1201 +using ::scalbnl; +# 1203 +using ::tgamma; +# 1204 +using ::tgammaf; +# 1205 +using ::tgammal; +# 1207 +using ::trunc; +# 1208 +using ::truncf; +# 1209 +using ::truncl; +# 1214 +constexpr float acosh(float __x) +# 1215 +{ return __builtin_acoshf(__x); } +# 1218 +constexpr long double acosh(long double __x) +# 1219 +{ return __builtin_acoshl(__x); } +# 1223 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 1226 +acosh(_Tp __x) +# 1227 +{ return __builtin_acosh(__x); } +# 1232 +constexpr float asinh(float __x) +# 1233 +{ return __builtin_asinhf(__x); } +# 1236 +constexpr long double asinh(long double __x) +# 1237 +{ return __builtin_asinhl(__x); } +# 1241 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 1244 +asinh(_Tp __x) +# 1245 +{ return __builtin_asinh(__x); } +# 1250 +constexpr float atanh(float __x) +# 1251 +{ return __builtin_atanhf(__x); } +# 1254 +constexpr long double atanh(long double __x) +# 1255 +{ return __builtin_atanhl(__x); } +# 1259 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 1262 +atanh(_Tp __x) +# 1263 +{ return __builtin_atanh(__x); } +# 1268 +constexpr float cbrt(float __x) +# 1269 +{ return __builtin_cbrtf(__x); } +# 1272 +constexpr long double cbrt(long double __x) +# 1273 +{ return __builtin_cbrtl(__x); } +# 1277 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 1280 +cbrt(_Tp __x) +# 1281 +{ return __builtin_cbrt(__x); } +# 1286 +constexpr float copysign(float __x, float __y) +# 1287 +{ return __builtin_copysignf(__x, __y); } +# 1290 +constexpr long double copysign(long double __x, long double __y) +# 1291 +{ return __builtin_copysignl(__x, __y); } +# 1295 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 1297 +copysign(_Tp __x, _Up __y) +# 1298 +{ +# 1299 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1300 +return copysign((__type)__x, (__type)__y); +# 1301 +} +# 1306 +constexpr float erf(float __x) +# 1307 +{ return __builtin_erff(__x); } +# 1310 +constexpr long double erf(long double __x) +# 1311 +{ return __builtin_erfl(__x); } +# 1315 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 1318 +erf(_Tp __x) +# 1319 +{ return __builtin_erf(__x); } +# 1324 +constexpr float erfc(float __x) +# 1325 +{ return __builtin_erfcf(__x); } +# 1328 +constexpr long double erfc(long double __x) +# 1329 +{ return __builtin_erfcl(__x); } +# 1333 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 1336 +erfc(_Tp __x) +# 1337 +{ return __builtin_erfc(__x); } +# 1342 +constexpr float exp2(float __x) +# 1343 +{ return __builtin_exp2f(__x); } +# 1346 +constexpr long double exp2(long double __x) +# 1347 +{ return __builtin_exp2l(__x); } +# 1351 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 1354 +exp2(_Tp __x) +# 1355 +{ return __builtin_exp2(__x); } +# 1360 +constexpr float expm1(float __x) +# 1361 +{ return __builtin_expm1f(__x); } +# 1364 +constexpr long double expm1(long double __x) +# 1365 +{ return __builtin_expm1l(__x); } +# 1369 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 1372 +expm1(_Tp __x) +# 1373 +{ return __builtin_expm1(__x); } +# 1378 +constexpr float fdim(float __x, float __y) +# 1379 +{ return __builtin_fdimf(__x, __y); } +# 1382 +constexpr long double fdim(long double __x, long double __y) +# 1383 +{ return __builtin_fdiml(__x, __y); } +# 1387 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 1389 +fdim(_Tp __x, _Up __y) +# 1390 +{ +# 1391 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1392 +return fdim((__type)__x, (__type)__y); +# 1393 +} +# 1398 +constexpr float fma(float __x, float __y, float __z) +# 1399 +{ return __builtin_fmaf(__x, __y, __z); } +# 1402 +constexpr long double fma(long double __x, long double __y, long double __z) +# 1403 +{ return __builtin_fmal(__x, __y, __z); } +# 1407 +template< class _Tp, class _Up, class _Vp> constexpr typename __gnu_cxx::__promote_3< _Tp, _Up, _Vp> ::__type +# 1409 +fma(_Tp __x, _Up __y, _Vp __z) +# 1410 +{ +# 1411 +typedef typename __gnu_cxx::__promote_3< _Tp, _Up, _Vp> ::__type __type; +# 1412 +return fma((__type)__x, (__type)__y, (__type)__z); +# 1413 +} +# 1418 +constexpr float fmax(float __x, float __y) +# 1419 +{ return __builtin_fmaxf(__x, __y); } +# 1422 +constexpr long double fmax(long double __x, long double __y) +# 1423 +{ return __builtin_fmaxl(__x, __y); } +# 1427 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 1429 +fmax(_Tp __x, _Up __y) +# 1430 +{ +# 1431 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1432 +return fmax((__type)__x, (__type)__y); +# 1433 +} +# 1438 +constexpr float fmin(float __x, float __y) +# 1439 +{ return __builtin_fminf(__x, __y); } +# 1442 +constexpr long double fmin(long double __x, long double __y) +# 1443 +{ return __builtin_fminl(__x, __y); } +# 1447 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 1449 +fmin(_Tp __x, _Up __y) +# 1450 +{ +# 1451 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1452 +return fmin((__type)__x, (__type)__y); +# 1453 +} +# 1458 +constexpr float hypot(float __x, float __y) +# 1459 +{ return __builtin_hypotf(__x, __y); } +# 1462 +constexpr long double hypot(long double __x, long double __y) +# 1463 +{ return __builtin_hypotl(__x, __y); } +# 1467 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 1469 +hypot(_Tp __x, _Up __y) +# 1470 +{ +# 1471 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1472 +return hypot((__type)__x, (__type)__y); +# 1473 +} +# 1478 +constexpr int ilogb(float __x) +# 1479 +{ return __builtin_ilogbf(__x); } +# 1482 +constexpr int ilogb(long double __x) +# 1483 +{ return __builtin_ilogbl(__x); } +# 1487 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, int> ::__type +# 1491 +ilogb(_Tp __x) +# 1492 +{ return __builtin_ilogb(__x); } +# 1497 +constexpr float lgamma(float __x) +# 1498 +{ return __builtin_lgammaf(__x); } +# 1501 +constexpr long double lgamma(long double __x) +# 1502 +{ return __builtin_lgammal(__x); } +# 1506 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 1509 +lgamma(_Tp __x) +# 1510 +{ return __builtin_lgamma(__x); } +# 1515 +constexpr long long llrint(float __x) +# 1516 +{ return __builtin_llrintf(__x); } +# 1519 +constexpr long long llrint(long double __x) +# 1520 +{ return __builtin_llrintl(__x); } +# 1524 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, long long> ::__type +# 1527 +llrint(_Tp __x) +# 1528 +{ return __builtin_llrint(__x); } +# 1533 +constexpr long long llround(float __x) +# 1534 +{ return __builtin_llroundf(__x); } +# 1537 +constexpr long long llround(long double __x) +# 1538 +{ return __builtin_llroundl(__x); } +# 1542 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, long long> ::__type +# 1545 +llround(_Tp __x) +# 1546 +{ return __builtin_llround(__x); } +# 1551 +constexpr float log1p(float __x) +# 1552 +{ return __builtin_log1pf(__x); } +# 1555 +constexpr long double log1p(long double __x) +# 1556 +{ return __builtin_log1pl(__x); } +# 1560 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 1563 +log1p(_Tp __x) +# 1564 +{ return __builtin_log1p(__x); } +# 1570 +constexpr float log2(float __x) +# 1571 +{ return __builtin_log2f(__x); } +# 1574 +constexpr long double log2(long double __x) +# 1575 +{ return __builtin_log2l(__x); } +# 1579 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 1582 +log2(_Tp __x) +# 1583 +{ return __builtin_log2(__x); } +# 1588 +constexpr float logb(float __x) +# 1589 +{ return __builtin_logbf(__x); } +# 1592 +constexpr long double logb(long double __x) +# 1593 +{ return __builtin_logbl(__x); } +# 1597 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 1600 +logb(_Tp __x) +# 1601 +{ return __builtin_logb(__x); } +# 1606 +constexpr long lrint(float __x) +# 1607 +{ return __builtin_lrintf(__x); } +# 1610 +constexpr long lrint(long double __x) +# 1611 +{ return __builtin_lrintl(__x); } +# 1615 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, long> ::__type +# 1618 +lrint(_Tp __x) +# 1619 +{ return __builtin_lrint(__x); } +# 1624 +constexpr long lround(float __x) +# 1625 +{ return __builtin_lroundf(__x); } +# 1628 +constexpr long lround(long double __x) +# 1629 +{ return __builtin_lroundl(__x); } +# 1633 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, long> ::__type +# 1636 +lround(_Tp __x) +# 1637 +{ return __builtin_lround(__x); } +# 1642 +constexpr float nearbyint(float __x) +# 1643 +{ return __builtin_nearbyintf(__x); } +# 1646 +constexpr long double nearbyint(long double __x) +# 1647 +{ return __builtin_nearbyintl(__x); } +# 1651 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 1654 +nearbyint(_Tp __x) +# 1655 +{ return __builtin_nearbyint(__x); } +# 1660 +constexpr float nextafter(float __x, float __y) +# 1661 +{ return __builtin_nextafterf(__x, __y); } +# 1664 +constexpr long double nextafter(long double __x, long double __y) +# 1665 +{ return __builtin_nextafterl(__x, __y); } +# 1669 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 1671 +nextafter(_Tp __x, _Up __y) +# 1672 +{ +# 1673 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1674 +return nextafter((__type)__x, (__type)__y); +# 1675 +} +# 1680 +constexpr float nexttoward(float __x, long double __y) +# 1681 +{ return __builtin_nexttowardf(__x, __y); } +# 1684 +constexpr long double nexttoward(long double __x, long double __y) +# 1685 +{ return __builtin_nexttowardl(__x, __y); } +# 1689 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 1692 +nexttoward(_Tp __x, long double __y) +# 1693 +{ return __builtin_nexttoward(__x, __y); } +# 1698 +constexpr float remainder(float __x, float __y) +# 1699 +{ return __builtin_remainderf(__x, __y); } +# 1702 +constexpr long double remainder(long double __x, long double __y) +# 1703 +{ return __builtin_remainderl(__x, __y); } +# 1707 +template< class _Tp, class _Up> constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 1709 +remainder(_Tp __x, _Up __y) +# 1710 +{ +# 1711 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1712 +return remainder((__type)__x, (__type)__y); +# 1713 +} +# 1718 +inline float remquo(float __x, float __y, int *__pquo) +# 1719 +{ return __builtin_remquof(__x, __y, __pquo); } +# 1722 +inline long double remquo(long double __x, long double __y, int *__pquo) +# 1723 +{ return __builtin_remquol(__x, __y, __pquo); } +# 1727 +template< class _Tp, class _Up> inline typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type +# 1729 +remquo(_Tp __x, _Up __y, int *__pquo) +# 1730 +{ +# 1731 +typedef typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type __type; +# 1732 +return remquo((__type)__x, (__type)__y, __pquo); +# 1733 +} +# 1738 +constexpr float rint(float __x) +# 1739 +{ return __builtin_rintf(__x); } +# 1742 +constexpr long double rint(long double __x) +# 1743 +{ return __builtin_rintl(__x); } +# 1747 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 1750 +rint(_Tp __x) +# 1751 +{ return __builtin_rint(__x); } +# 1756 +constexpr float round(float __x) +# 1757 +{ return __builtin_roundf(__x); } +# 1760 +constexpr long double round(long double __x) +# 1761 +{ return __builtin_roundl(__x); } +# 1765 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 1768 +round(_Tp __x) +# 1769 +{ return __builtin_round(__x); } +# 1774 +constexpr float scalbln(float __x, long __ex) +# 1775 +{ return __builtin_scalblnf(__x, __ex); } +# 1778 +constexpr long double scalbln(long double __x, long __ex) +# 1779 +{ return __builtin_scalblnl(__x, __ex); } +# 1783 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 1786 +scalbln(_Tp __x, long __ex) +# 1787 +{ return __builtin_scalbln(__x, __ex); } +# 1792 +constexpr float scalbn(float __x, int __ex) +# 1793 +{ return __builtin_scalbnf(__x, __ex); } +# 1796 +constexpr long double scalbn(long double __x, int __ex) +# 1797 +{ return __builtin_scalbnl(__x, __ex); } +# 1801 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 1804 +scalbn(_Tp __x, int __ex) +# 1805 +{ return __builtin_scalbn(__x, __ex); } +# 1810 +constexpr float tgamma(float __x) +# 1811 +{ return __builtin_tgammaf(__x); } +# 1814 +constexpr long double tgamma(long double __x) +# 1815 +{ return __builtin_tgammal(__x); } +# 1819 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 1822 +tgamma(_Tp __x) +# 1823 +{ return __builtin_tgamma(__x); } +# 1828 +constexpr float trunc(float __x) +# 1829 +{ return __builtin_truncf(__x); } +# 1832 +constexpr long double trunc(long double __x) +# 1833 +{ return __builtin_truncl(__x); } +# 1837 +template< class _Tp> constexpr typename __gnu_cxx::__enable_if< __is_integer< _Tp> ::__value, double> ::__type +# 1840 +trunc(_Tp __x) +# 1841 +{ return __builtin_trunc(__x); } +# 1852 "/usr/include/c++/11/cmath" 3 +template< class _Tp> inline _Tp +# 1854 +__hypot3(_Tp __x, _Tp __y, _Tp __z) +# 1855 +{ +# 1856 +__x = std::abs(__x); +# 1857 +__y = std::abs(__y); +# 1858 +__z = std::abs(__z); +# 1859 +if (_Tp __a = (__x < __y) ? (__y < __z) ? __z : __y : ((__x < __z) ? __z : __x)) { +# 1860 +return __a * std::sqrt((((__x / __a) * (__x / __a)) + ((__y / __a) * (__y / __a))) + ((__z / __a) * (__z / __a))); } else { +# 1864 +return {}; } +# 1865 +} +# 1868 +inline float hypot(float __x, float __y, float __z) +# 1869 +{ return std::__hypot3< float> (__x, __y, __z); } +# 1872 +inline double hypot(double __x, double __y, double __z) +# 1873 +{ return std::__hypot3< double> (__x, __y, __z); } +# 1876 +inline long double hypot(long double __x, long double __y, long double __z) +# 1877 +{ return std::__hypot3< long double> (__x, __y, __z); } +# 1879 +template< class _Tp, class _Up, class _Vp> __gnu_cxx::__promoted_t< _Tp, _Up, _Vp> +# 1881 +hypot(_Tp __x, _Up __y, _Vp __z) +# 1882 +{ +# 1883 +using __type = __gnu_cxx::__promoted_t< _Tp, _Up, _Vp> ; +# 1884 +return std::__hypot3< __gnu_cxx::__promoted_t< _Tp, _Up, _Vp> > (__x, __y, __z); +# 1885 +} +# 1932 "/usr/include/c++/11/cmath" 3 +} +# 33 "/usr/include/c++/11/bits/specfun.h" 3 +#pragma GCC visibility push ( default ) +# 42 "/usr/include/c++/11/bits/functexcept.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 48 +void __throw_bad_exception() __attribute((__noreturn__)); +# 52 +void __throw_bad_alloc() __attribute((__noreturn__)); +# 55 +void __throw_bad_array_new_length() __attribute((__noreturn__)); +# 59 +void __throw_bad_cast() __attribute((__noreturn__)); +# 62 +void __throw_bad_typeid() __attribute((__noreturn__)); +# 66 +void __throw_logic_error(const char *) __attribute((__noreturn__)); +# 69 +void __throw_domain_error(const char *) __attribute((__noreturn__)); +# 72 +void __throw_invalid_argument(const char *) __attribute((__noreturn__)); +# 75 +void __throw_length_error(const char *) __attribute((__noreturn__)); +# 78 +void __throw_out_of_range(const char *) __attribute((__noreturn__)); +# 81 +void __throw_out_of_range_fmt(const char *, ...) __attribute((__noreturn__)) +# 82 + __attribute((__format__(__gnu_printf__, 1, 2))); +# 85 +void __throw_runtime_error(const char *) __attribute((__noreturn__)); +# 88 +void __throw_range_error(const char *) __attribute((__noreturn__)); +# 91 +void __throw_overflow_error(const char *) __attribute((__noreturn__)); +# 94 +void __throw_underflow_error(const char *) __attribute((__noreturn__)); +# 98 +void __throw_ios_failure(const char *) __attribute((__noreturn__)); +# 101 +void __throw_ios_failure(const char *, int) __attribute((__noreturn__)); +# 105 +void __throw_system_error(int) __attribute((__noreturn__)); +# 109 +void __throw_future_error(int) __attribute((__noreturn__)); +# 113 +void __throw_bad_function_call() __attribute((__noreturn__)); +# 116 +} +# 37 "/usr/include/c++/11/ext/numeric_traits.h" 3 +namespace __gnu_cxx __attribute((__visibility__("default"))) { +# 50 "/usr/include/c++/11/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; +# 135 "/usr/include/c++/11/ext/numeric_traits.h" 3 +template< class _Tp> using __int_traits = __numeric_traits_integer< _Tp> ; +# 155 "/usr/include/c++/11/ext/numeric_traits.h" 3 +template< class _Value> +# 156 +struct __numeric_traits_floating { +# 159 +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))); +# 162 +static const bool __is_signed = true; +# 163 +static const int __digits10 = ((std::template __are_same< _Value, float> ::__value) ? 6 : ((std::template __are_same< _Value, double> ::__value) ? 15 : 18)); +# 164 +static const int __max_exponent10 = ((std::template __are_same< _Value, float> ::__value) ? 38 : ((std::template __are_same< _Value, double> ::__value) ? 308 : 4932)); +# 165 +}; +# 167 +template< class _Value> const int __numeric_traits_floating< _Value> ::__max_digits10; +# 170 +template< class _Value> const bool __numeric_traits_floating< _Value> ::__is_signed; +# 173 +template< class _Value> const int __numeric_traits_floating< _Value> ::__digits10; +# 176 +template< class _Value> const int __numeric_traits_floating< _Value> ::__max_exponent10; +# 184 +template< class _Value> +# 185 +struct __numeric_traits : public __numeric_traits_integer< _Value> { +# 187 +}; +# 190 +template<> struct __numeric_traits< float> : public __numeric_traits_floating< float> { +# 192 +}; +# 195 +template<> struct __numeric_traits< double> : public __numeric_traits_floating< double> { +# 197 +}; +# 200 +template<> struct __numeric_traits< long double> : public __numeric_traits_floating< long double> { +# 202 +}; +# 237 "/usr/include/c++/11/ext/numeric_traits.h" 3 +} +# 38 "/usr/include/c++/11/bits/move.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 47 +template< class _Tp> constexpr _Tp * +# 49 +__addressof(_Tp &__r) noexcept +# 50 +{ return __builtin_addressof(__r); } +# 55 +} +# 40 "/usr/include/c++/11/type_traits" 3 +namespace std __attribute((__visibility__("default"))) { +# 44 +template< class ..._Elements> class tuple; +# 47 +template< class _Tp> class reference_wrapper; +# 64 "/usr/include/c++/11/type_traits" 3 +template< class _Tp, _Tp __v> +# 65 +struct integral_constant { +# 67 +static constexpr inline _Tp value = (__v); +# 68 +typedef _Tp value_type; +# 69 +typedef integral_constant type; +# 70 +constexpr operator value_type() const noexcept { return value; } +# 75 +constexpr value_type operator()() const noexcept { return value; } +# 77 +}; +# 79 +template< class _Tp, _Tp __v> constexpr inline _Tp integral_constant< _Tp, __v> ::value; +# 83 +using true_type = integral_constant< bool, true> ; +# 86 +using false_type = integral_constant< bool, false> ; +# 90 +template< bool __v> using __bool_constant = integral_constant< bool, __v> ; +# 98 +template< bool __v> using bool_constant = integral_constant< bool, __v> ; +# 104 +template< bool , class , class > struct conditional; +# 108 +template< class _Type> +# 109 +struct __type_identity { +# 110 +using type = _Type; }; +# 112 +template< class _Tp> using __type_identity_t = typename __type_identity< _Tp> ::type; +# 115 +template< class ...> struct __or_; +# 119 +template<> struct __or_< > : public false_type { +# 121 +}; +# 123 +template< class _B1> +# 124 +struct __or_< _B1> : public _B1 { +# 126 +}; +# 128 +template< class _B1, class _B2> +# 129 +struct __or_< _B1, _B2> : public conditional< _B1::value, _B1, _B2> ::type { +# 131 +}; +# 133 +template< class _B1, class _B2, class _B3, class ..._Bn> +# 134 +struct __or_< _B1, _B2, _B3, _Bn...> : public conditional< _B1::value, _B1, std::__or_< _B2, _B3, _Bn...> > ::type { +# 136 +}; +# 138 +template< class ...> struct __and_; +# 142 +template<> struct __and_< > : public true_type { +# 144 +}; +# 146 +template< class _B1> +# 147 +struct __and_< _B1> : public _B1 { +# 149 +}; +# 151 +template< class _B1, class _B2> +# 152 +struct __and_< _B1, _B2> : public conditional< _B1::value, _B2, _B1> ::type { +# 154 +}; +# 156 +template< class _B1, class _B2, class _B3, class ..._Bn> +# 157 +struct __and_< _B1, _B2, _B3, _Bn...> : public conditional< _B1::value, std::__and_< _B2, _B3, _Bn...> , _B1> ::type { +# 159 +}; +# 161 +template< class _Pp> +# 162 +struct __not_ : public __bool_constant< !((bool)_Pp::value)> { +# 164 +}; +# 170 +template< class ..._Bn> constexpr inline bool +# 171 +__or_v = (__or_< _Bn...> ::value); +# 172 +template< class ..._Bn> constexpr inline bool +# 173 +__and_v = (__and_< _Bn...> ::value); +# 178 +template< class ..._Bn> +# 179 +struct conjunction : public __and_< _Bn...> { +# 181 +}; +# 183 +template< class ..._Bn> +# 184 +struct disjunction : public __or_< _Bn...> { +# 186 +}; +# 188 +template< class _Pp> +# 189 +struct negation : public __not_< _Pp> { +# 191 +}; +# 196 +template< class ..._Bn> constexpr inline bool +# 197 +conjunction_v = (conjunction< _Bn...> ::value); +# 199 +template< class ..._Bn> constexpr inline bool +# 200 +disjunction_v = (disjunction< _Bn...> ::value); +# 202 +template< class _Pp> constexpr inline bool +# 203 +negation_v = (negation< _Pp> ::value); +# 209 +template< class > struct is_reference; +# 211 +template< class > struct is_function; +# 213 +template< class > struct is_void; +# 215 +template< class > struct remove_cv; +# 217 +template< class > struct is_const; +# 221 +template< class > struct __is_array_unknown_bounds; +# 227 +template< class _Tp, size_t = sizeof(_Tp)> constexpr true_type +# 228 +__is_complete_or_unbounded(__type_identity< _Tp> ) +# 229 +{ return {}; } +# 231 +template< class _TypeIdentity, class +# 232 +_NestedType = typename _TypeIdentity::type> constexpr typename __or_< is_reference< _NestedType> , is_function< _NestedType> , is_void< _NestedType> , __is_array_unknown_bounds< _NestedType> > ::type +# 238 +__is_complete_or_unbounded(_TypeIdentity) +# 239 +{ return {}; } +# 246 +template< class _Tp> +# 247 +struct __success_type { +# 248 +typedef _Tp type; }; +# 250 +struct __failure_type { +# 251 +}; +# 254 +template< class _Tp> using __remove_cv_t = typename remove_cv< _Tp> ::type; +# 259 +template< class > +# 260 +struct __is_void_helper : public false_type { +# 261 +}; +# 264 +template<> struct __is_void_helper< void> : public true_type { +# 265 +}; +# 269 +template< class _Tp> +# 270 +struct is_void : public __is_void_helper< __remove_cv_t< _Tp> > ::type { +# 272 +}; +# 275 +template< class > +# 276 +struct __is_integral_helper : public false_type { +# 277 +}; +# 280 +template<> struct __is_integral_helper< bool> : public true_type { +# 281 +}; +# 284 +template<> struct __is_integral_helper< char> : public true_type { +# 285 +}; +# 288 +template<> struct __is_integral_helper< signed char> : public true_type { +# 289 +}; +# 292 +template<> struct __is_integral_helper< unsigned char> : public true_type { +# 293 +}; +# 300 +template<> struct __is_integral_helper< wchar_t> : public true_type { +# 301 +}; +# 311 "/usr/include/c++/11/type_traits" 3 +template<> struct __is_integral_helper< char16_t> : public true_type { +# 312 +}; +# 315 +template<> struct __is_integral_helper< char32_t> : public true_type { +# 316 +}; +# 319 +template<> struct __is_integral_helper< short> : public true_type { +# 320 +}; +# 323 +template<> struct __is_integral_helper< unsigned short> : public true_type { +# 324 +}; +# 327 +template<> struct __is_integral_helper< int> : public true_type { +# 328 +}; +# 331 +template<> struct __is_integral_helper< unsigned> : public true_type { +# 332 +}; +# 335 +template<> struct __is_integral_helper< long> : public true_type { +# 336 +}; +# 339 +template<> struct __is_integral_helper< unsigned long> : public true_type { +# 340 +}; +# 343 +template<> struct __is_integral_helper< long long> : public true_type { +# 344 +}; +# 347 +template<> struct __is_integral_helper< unsigned long long> : public true_type { +# 348 +}; +# 354 +template<> struct __is_integral_helper< __int128> : public true_type { +# 355 +}; +# 358 +template<> struct __is_integral_helper< unsigned __int128> : public true_type { +# 359 +}; +# 391 "/usr/include/c++/11/type_traits" 3 +template< class _Tp> +# 392 +struct is_integral : public __is_integral_helper< __remove_cv_t< _Tp> > ::type { +# 394 +}; +# 397 +template< class > +# 398 +struct __is_floating_point_helper : public false_type { +# 399 +}; +# 402 +template<> struct __is_floating_point_helper< float> : public true_type { +# 403 +}; +# 406 +template<> struct __is_floating_point_helper< double> : public true_type { +# 407 +}; +# 410 +template<> struct __is_floating_point_helper< long double> : public true_type { +# 411 +}; +# 421 "/usr/include/c++/11/type_traits" 3 +template< class _Tp> +# 422 +struct is_floating_point : public __is_floating_point_helper< __remove_cv_t< _Tp> > ::type { +# 424 +}; +# 427 +template< class > +# 428 +struct is_array : public false_type { +# 429 +}; +# 431 +template< class _Tp, size_t _Size> +# 432 +struct is_array< _Tp [_Size]> : public true_type { +# 433 +}; +# 435 +template< class _Tp> +# 436 +struct is_array< _Tp []> : public true_type { +# 437 +}; +# 439 +template< class > +# 440 +struct __is_pointer_helper : public false_type { +# 441 +}; +# 443 +template< class _Tp> +# 444 +struct __is_pointer_helper< _Tp *> : public true_type { +# 445 +}; +# 448 +template< class _Tp> +# 449 +struct is_pointer : public __is_pointer_helper< __remove_cv_t< _Tp> > ::type { +# 451 +}; +# 454 +template< class > +# 455 +struct is_lvalue_reference : public false_type { +# 456 +}; +# 458 +template< class _Tp> +# 459 +struct is_lvalue_reference< _Tp &> : public true_type { +# 460 +}; +# 463 +template< class > +# 464 +struct is_rvalue_reference : public false_type { +# 465 +}; +# 467 +template< class _Tp> +# 468 +struct is_rvalue_reference< _Tp &&> : public true_type { +# 469 +}; +# 471 +template< class > +# 472 +struct __is_member_object_pointer_helper : public false_type { +# 473 +}; +# 475 +template< class _Tp, class _Cp> +# 476 +struct __is_member_object_pointer_helper< _Tp (_Cp::*)> : public __not_< is_function< _Tp> > ::type { +# 477 +}; +# 480 +template< class _Tp> +# 481 +struct is_member_object_pointer : public __is_member_object_pointer_helper< __remove_cv_t< _Tp> > ::type { +# 483 +}; +# 485 +template< class > +# 486 +struct __is_member_function_pointer_helper : public false_type { +# 487 +}; +# 489 +template< class _Tp, class _Cp> +# 490 +struct __is_member_function_pointer_helper< _Tp (_Cp::*)> : public is_function< _Tp> ::type { +# 491 +}; +# 494 +template< class _Tp> +# 495 +struct is_member_function_pointer : public __is_member_function_pointer_helper< __remove_cv_t< _Tp> > ::type { +# 497 +}; +# 500 +template< class _Tp> +# 501 +struct is_enum : public integral_constant< bool, __is_enum(_Tp)> { +# 503 +}; +# 506 +template< class _Tp> +# 507 +struct is_union : public integral_constant< bool, __is_union(_Tp)> { +# 509 +}; +# 512 +template< class _Tp> +# 513 +struct is_class : public integral_constant< bool, __is_class(_Tp)> { +# 515 +}; +# 518 +template< class _Tp> +# 519 +struct is_function : public __bool_constant< !is_const< const _Tp> ::value> { +# 520 +}; +# 522 +template< class _Tp> +# 523 +struct is_function< _Tp &> : public false_type { +# 524 +}; +# 526 +template< class _Tp> +# 527 +struct is_function< _Tp &&> : public false_type { +# 528 +}; +# 532 +template< class > +# 533 +struct __is_null_pointer_helper : public false_type { +# 534 +}; +# 537 +template<> struct __is_null_pointer_helper< __decltype((nullptr))> : public true_type { +# 538 +}; +# 541 +template< class _Tp> +# 542 +struct is_null_pointer : public __is_null_pointer_helper< __remove_cv_t< _Tp> > ::type { +# 544 +}; +# 548 +template< class _Tp> +# 549 +struct __is_nullptr_t : public is_null_pointer< _Tp> { +# 551 +} __attribute((__deprecated__("use \'std::is_null_pointer\' instead"))); +# 556 +template< class _Tp> +# 557 +struct is_reference : public __or_< is_lvalue_reference< _Tp> , is_rvalue_reference< _Tp> > ::type { +# 560 +}; +# 563 +template< class _Tp> +# 564 +struct is_arithmetic : public __or_< is_integral< _Tp> , is_floating_point< _Tp> > ::type { +# 566 +}; +# 569 +template< class _Tp> +# 570 +struct is_fundamental : public __or_< is_arithmetic< _Tp> , is_void< _Tp> , is_null_pointer< _Tp> > ::type { +# 573 +}; +# 576 +template< class _Tp> +# 577 +struct is_object : public __not_< __or_< is_function< _Tp> , is_reference< _Tp> , is_void< _Tp> > > ::type { +# 580 +}; +# 582 +template< class > struct is_member_pointer; +# 586 +template< class _Tp> +# 587 +struct is_scalar : public __or_< is_arithmetic< _Tp> , is_enum< _Tp> , is_pointer< _Tp> , is_member_pointer< _Tp> , is_null_pointer< _Tp> > ::type { +# 590 +}; +# 593 +template< class _Tp> +# 594 +struct is_compound : public __not_< is_fundamental< _Tp> > ::type { +# 595 +}; +# 598 +template< class _Tp> +# 599 +struct __is_member_pointer_helper : public false_type { +# 600 +}; +# 602 +template< class _Tp, class _Cp> +# 603 +struct __is_member_pointer_helper< _Tp (_Cp::*)> : public true_type { +# 604 +}; +# 608 +template< class _Tp> +# 609 +struct is_member_pointer : public __is_member_pointer_helper< __remove_cv_t< _Tp> > ::type { +# 611 +}; +# 613 +template< class , class > struct is_same; +# 617 +template< class _Tp, class ..._Types> using __is_one_of = __or_< is_same< _Tp, _Types> ...> ; +# 621 +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> ; +# 640 "/usr/include/c++/11/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> ; +# 659 "/usr/include/c++/11/type_traits" 3 +template< class _Tp> using __is_standard_integer = __or_< __is_signed_integer< _Tp> , __is_unsigned_integer< _Tp> > ; +# 664 +template< class ...> using __void_t = void; +# 668 +template< class _Tp, class = void> +# 669 +struct __is_referenceable : public false_type { +# 671 +}; +# 673 +template< class _Tp> +# 674 +struct __is_referenceable< _Tp, __void_t< _Tp &> > : public true_type { +# 676 +}; +# 682 +template< class > +# 683 +struct is_const : public false_type { +# 684 +}; +# 686 +template< class _Tp> +# 687 +struct is_const< const _Tp> : public true_type { +# 688 +}; +# 691 +template< class > +# 692 +struct is_volatile : public false_type { +# 693 +}; +# 695 +template< class _Tp> +# 696 +struct is_volatile< volatile _Tp> : public true_type { +# 697 +}; +# 700 +template< class _Tp> +# 701 +struct is_trivial : public integral_constant< bool, __is_trivial(_Tp)> { +# 704 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 706 +}; +# 709 +template< class _Tp> +# 710 +struct is_trivially_copyable : public integral_constant< bool, __is_trivially_copyable(_Tp)> { +# 713 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 715 +}; +# 718 +template< class _Tp> +# 719 +struct is_standard_layout : public integral_constant< bool, __is_standard_layout(_Tp)> { +# 722 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 724 +}; +# 730 +template< class _Tp> +# 733 +struct is_pod : public integral_constant< bool, __is_pod(_Tp)> { +# 736 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 738 +}; +# 743 +template< class _Tp> +# 746 +struct +# 745 + [[__deprecated__]] is_literal_type : public integral_constant< bool, __is_literal_type(_Tp)> { +# 749 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 751 +}; +# 754 +template< class _Tp> +# 755 +struct is_empty : public integral_constant< bool, __is_empty(_Tp)> { +# 757 +}; +# 760 +template< class _Tp> +# 761 +struct is_polymorphic : public integral_constant< bool, __is_polymorphic(_Tp)> { +# 763 +}; +# 769 +template< class _Tp> +# 770 +struct is_final : public integral_constant< bool, __is_final(_Tp)> { +# 772 +}; +# 776 +template< class _Tp> +# 777 +struct is_abstract : public integral_constant< bool, __is_abstract(_Tp)> { +# 779 +}; +# 782 +template< class _Tp, bool +# 783 + = is_arithmetic< _Tp> ::value> +# 784 +struct __is_signed_helper : public false_type { +# 785 +}; +# 787 +template< class _Tp> +# 788 +struct __is_signed_helper< _Tp, true> : public integral_constant< bool, ((_Tp)(-1)) < ((_Tp)0)> { +# 790 +}; +# 794 +template< class _Tp> +# 795 +struct is_signed : public __is_signed_helper< _Tp> ::type { +# 797 +}; +# 800 +template< class _Tp> +# 801 +struct is_unsigned : public __and_< is_arithmetic< _Tp> , __not_< is_signed< _Tp> > > { +# 803 +}; +# 806 +template< class _Tp, class _Up = _Tp &&> _Up __declval(int); +# 810 +template< class _Tp> _Tp __declval(long); +# 815 +template< class _Tp> auto declval() noexcept->__decltype((__declval< _Tp> (0))); +# 818 +template< class , unsigned = 0U> struct extent; +# 821 +template< class > struct remove_all_extents; +# 825 +template< class _Tp> +# 826 +struct __is_array_known_bounds : public integral_constant< bool, (extent< _Tp> ::value > 0)> { +# 828 +}; +# 830 +template< class _Tp> +# 831 +struct __is_array_unknown_bounds : public __and_< is_array< _Tp> , __not_< extent< _Tp> > > { +# 833 +}; +# 842 "/usr/include/c++/11/type_traits" 3 +struct __do_is_destructible_impl { +# 844 +template< class _Tp, class = __decltype((declval< _Tp &> ().~_Tp()))> static true_type __test(int); +# 847 +template< class > static false_type __test(...); +# 849 +}; +# 851 +template< class _Tp> +# 852 +struct __is_destructible_impl : public __do_is_destructible_impl { +# 855 +typedef __decltype((__test< _Tp> (0))) type; +# 856 +}; +# 858 +template< class _Tp, bool +# 859 + = __or_< is_void< _Tp> , __is_array_unknown_bounds< _Tp> , is_function< _Tp> > ::value, bool +# 862 + = __or_< is_reference< _Tp> , is_scalar< _Tp> > ::value> struct __is_destructible_safe; +# 865 +template< class _Tp> +# 866 +struct __is_destructible_safe< _Tp, false, false> : public __is_destructible_impl< typename remove_all_extents< _Tp> ::type> ::type { +# 869 +}; +# 871 +template< class _Tp> +# 872 +struct __is_destructible_safe< _Tp, true, false> : public false_type { +# 873 +}; +# 875 +template< class _Tp> +# 876 +struct __is_destructible_safe< _Tp, false, true> : public true_type { +# 877 +}; +# 881 +template< class _Tp> +# 882 +struct is_destructible : public __is_destructible_safe< _Tp> ::type { +# 885 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 887 +}; +# 895 +struct __do_is_nt_destructible_impl { +# 897 +template< class _Tp> static __bool_constant< noexcept(declval< _Tp &> ().~_Tp())> __test(int); +# 901 +template< class > static false_type __test(...); +# 903 +}; +# 905 +template< class _Tp> +# 906 +struct __is_nt_destructible_impl : public __do_is_nt_destructible_impl { +# 909 +typedef __decltype((__test< _Tp> (0))) type; +# 910 +}; +# 912 +template< class _Tp, bool +# 913 + = __or_< is_void< _Tp> , __is_array_unknown_bounds< _Tp> , is_function< _Tp> > ::value, bool +# 916 + = __or_< is_reference< _Tp> , is_scalar< _Tp> > ::value> struct __is_nt_destructible_safe; +# 919 +template< class _Tp> +# 920 +struct __is_nt_destructible_safe< _Tp, false, false> : public __is_nt_destructible_impl< typename remove_all_extents< _Tp> ::type> ::type { +# 923 +}; +# 925 +template< class _Tp> +# 926 +struct __is_nt_destructible_safe< _Tp, true, false> : public false_type { +# 927 +}; +# 929 +template< class _Tp> +# 930 +struct __is_nt_destructible_safe< _Tp, false, true> : public true_type { +# 931 +}; +# 935 +template< class _Tp> +# 936 +struct is_nothrow_destructible : public __is_nt_destructible_safe< _Tp> ::type { +# 939 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 941 +}; +# 944 +template< class _Tp, class ..._Args> +# 945 +struct __is_constructible_impl : public __bool_constant< __is_constructible(_Tp, _Args...)> { +# 947 +}; +# 951 +template< class _Tp, class ..._Args> +# 952 +struct is_constructible : public __is_constructible_impl< _Tp, _Args...> { +# 955 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 957 +}; +# 960 +template< class _Tp> +# 961 +struct is_default_constructible : public __is_constructible_impl< _Tp> ::type { +# 964 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 966 +}; +# 969 +template< class _Tp, bool = __is_referenceable< _Tp> ::value> struct __is_copy_constructible_impl; +# 972 +template< class _Tp> +# 973 +struct __is_copy_constructible_impl< _Tp, false> : public false_type { +# 974 +}; +# 976 +template< class _Tp> +# 977 +struct __is_copy_constructible_impl< _Tp, true> : public __is_constructible_impl< _Tp, const _Tp &> { +# 979 +}; +# 983 +template< class _Tp> +# 984 +struct is_copy_constructible : public __is_copy_constructible_impl< _Tp> { +# 987 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 989 +}; +# 992 +template< class _Tp, bool = __is_referenceable< _Tp> ::value> struct __is_move_constructible_impl; +# 995 +template< class _Tp> +# 996 +struct __is_move_constructible_impl< _Tp, false> : public false_type { +# 997 +}; +# 999 +template< class _Tp> +# 1000 +struct __is_move_constructible_impl< _Tp, true> : public __is_constructible_impl< _Tp, _Tp &&> { +# 1002 +}; +# 1006 +template< class _Tp> +# 1007 +struct is_move_constructible : public __is_move_constructible_impl< _Tp> { +# 1010 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1012 +}; +# 1015 +template< class _Tp, class ..._Args> using __is_nothrow_constructible_impl = __bool_constant< __is_nothrow_constructible(_Tp, _Args...)> ; +# 1021 +template< class _Tp, class ..._Args> +# 1022 +struct is_nothrow_constructible : public __is_nothrow_constructible_impl< _Tp, _Args...> ::type { +# 1025 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1027 +}; +# 1030 +template< class _Tp> +# 1031 +struct is_nothrow_default_constructible : public __bool_constant< __is_nothrow_constructible(_Tp)> { +# 1034 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1036 +}; +# 1039 +template< class _Tp, bool = __is_referenceable< _Tp> ::value> struct __is_nothrow_copy_constructible_impl; +# 1042 +template< class _Tp> +# 1043 +struct __is_nothrow_copy_constructible_impl< _Tp, false> : public false_type { +# 1044 +}; +# 1046 +template< class _Tp> +# 1047 +struct __is_nothrow_copy_constructible_impl< _Tp, true> : public __is_nothrow_constructible_impl< _Tp, const _Tp &> { +# 1049 +}; +# 1053 +template< class _Tp> +# 1054 +struct is_nothrow_copy_constructible : public __is_nothrow_copy_constructible_impl< _Tp> ::type { +# 1057 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1059 +}; +# 1062 +template< class _Tp, bool = __is_referenceable< _Tp> ::value> struct __is_nothrow_move_constructible_impl; +# 1065 +template< class _Tp> +# 1066 +struct __is_nothrow_move_constructible_impl< _Tp, false> : public false_type { +# 1067 +}; +# 1069 +template< class _Tp> +# 1070 +struct __is_nothrow_move_constructible_impl< _Tp, true> : public __is_nothrow_constructible_impl< _Tp, _Tp &&> { +# 1072 +}; +# 1076 +template< class _Tp> +# 1077 +struct is_nothrow_move_constructible : public __is_nothrow_move_constructible_impl< _Tp> ::type { +# 1080 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1082 +}; +# 1085 +template< class _Tp, class _Up> +# 1086 +struct is_assignable : public __bool_constant< __is_assignable(_Tp, _Up)> { +# 1089 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1091 +}; +# 1093 +template< class _Tp, bool = __is_referenceable< _Tp> ::value> struct __is_copy_assignable_impl; +# 1096 +template< class _Tp> +# 1097 +struct __is_copy_assignable_impl< _Tp, false> : public false_type { +# 1098 +}; +# 1100 +template< class _Tp> +# 1101 +struct __is_copy_assignable_impl< _Tp, true> : public __bool_constant< __is_assignable(_Tp &, const _Tp &)> { +# 1103 +}; +# 1106 +template< class _Tp> +# 1107 +struct is_copy_assignable : public __is_copy_assignable_impl< _Tp> ::type { +# 1110 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1112 +}; +# 1114 +template< class _Tp, bool = __is_referenceable< _Tp> ::value> struct __is_move_assignable_impl; +# 1117 +template< class _Tp> +# 1118 +struct __is_move_assignable_impl< _Tp, false> : public false_type { +# 1119 +}; +# 1121 +template< class _Tp> +# 1122 +struct __is_move_assignable_impl< _Tp, true> : public __bool_constant< __is_assignable(_Tp &, _Tp &&)> { +# 1124 +}; +# 1127 +template< class _Tp> +# 1128 +struct is_move_assignable : public __is_move_assignable_impl< _Tp> ::type { +# 1131 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1133 +}; +# 1135 +template< class _Tp, class _Up> using __is_nothrow_assignable_impl = __bool_constant< __is_nothrow_assignable(_Tp, _Up)> ; +# 1140 +template< class _Tp, class _Up> +# 1141 +struct is_nothrow_assignable : public __is_nothrow_assignable_impl< _Tp, _Up> { +# 1144 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1146 +}; +# 1148 +template< class _Tp, bool = __is_referenceable< _Tp> ::value> struct __is_nt_copy_assignable_impl; +# 1151 +template< class _Tp> +# 1152 +struct __is_nt_copy_assignable_impl< _Tp, false> : public false_type { +# 1153 +}; +# 1155 +template< class _Tp> +# 1156 +struct __is_nt_copy_assignable_impl< _Tp, true> : public __is_nothrow_assignable_impl< _Tp &, const _Tp &> { +# 1158 +}; +# 1161 +template< class _Tp> +# 1162 +struct is_nothrow_copy_assignable : public __is_nt_copy_assignable_impl< _Tp> { +# 1165 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1167 +}; +# 1169 +template< class _Tp, bool = __is_referenceable< _Tp> ::value> struct __is_nt_move_assignable_impl; +# 1172 +template< class _Tp> +# 1173 +struct __is_nt_move_assignable_impl< _Tp, false> : public false_type { +# 1174 +}; +# 1176 +template< class _Tp> +# 1177 +struct __is_nt_move_assignable_impl< _Tp, true> : public __is_nothrow_assignable_impl< _Tp &, _Tp &&> { +# 1179 +}; +# 1182 +template< class _Tp> +# 1183 +struct is_nothrow_move_assignable : public __is_nt_move_assignable_impl< _Tp> { +# 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, class ..._Args> +# 1192 +struct is_trivially_constructible : public __bool_constant< __is_trivially_constructible(_Tp, _Args...)> { +# 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_trivially_default_constructible : public __bool_constant< __is_trivially_constructible(_Tp)> { +# 1204 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1206 +}; +# 1208 +struct __do_is_implicitly_default_constructible_impl { +# 1210 +template< class _Tp> static void __helper(const _Tp &); +# 1213 +template< class _Tp> static true_type __test(const _Tp &, __decltype((__helper< const _Tp &> ({}))) * = 0); +# 1217 +static false_type __test(...); +# 1218 +}; +# 1220 +template< class _Tp> +# 1221 +struct __is_implicitly_default_constructible_impl : public __do_is_implicitly_default_constructible_impl { +# 1224 +typedef __decltype((__test(declval< _Tp> ()))) type; +# 1225 +}; +# 1227 +template< class _Tp> +# 1228 +struct __is_implicitly_default_constructible_safe : public __is_implicitly_default_constructible_impl< _Tp> ::type { +# 1230 +}; +# 1232 +template< class _Tp> +# 1233 +struct __is_implicitly_default_constructible : public __and_< __is_constructible_impl< _Tp> , __is_implicitly_default_constructible_safe< _Tp> > { +# 1236 +}; +# 1238 +template< class _Tp, bool = __is_referenceable< _Tp> ::value> struct __is_trivially_copy_constructible_impl; +# 1241 +template< class _Tp> +# 1242 +struct __is_trivially_copy_constructible_impl< _Tp, false> : public false_type { +# 1243 +}; +# 1245 +template< class _Tp> +# 1246 +struct __is_trivially_copy_constructible_impl< _Tp, true> : public __and_< __is_copy_constructible_impl< _Tp> , integral_constant< bool, __is_trivially_constructible(_Tp, const _Tp &)> > { +# 1250 +}; +# 1253 +template< class _Tp> +# 1254 +struct is_trivially_copy_constructible : public __is_trivially_copy_constructible_impl< _Tp> { +# 1257 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1259 +}; +# 1261 +template< class _Tp, bool = __is_referenceable< _Tp> ::value> struct __is_trivially_move_constructible_impl; +# 1264 +template< class _Tp> +# 1265 +struct __is_trivially_move_constructible_impl< _Tp, false> : public false_type { +# 1266 +}; +# 1268 +template< class _Tp> +# 1269 +struct __is_trivially_move_constructible_impl< _Tp, true> : public __and_< __is_move_constructible_impl< _Tp> , integral_constant< bool, __is_trivially_constructible(_Tp, _Tp &&)> > { +# 1273 +}; +# 1276 +template< class _Tp> +# 1277 +struct is_trivially_move_constructible : public __is_trivially_move_constructible_impl< _Tp> { +# 1280 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1282 +}; +# 1285 +template< class _Tp, class _Up> +# 1286 +struct is_trivially_assignable : public __bool_constant< __is_trivially_assignable(_Tp, _Up)> { +# 1289 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1291 +}; +# 1293 +template< class _Tp, bool = __is_referenceable< _Tp> ::value> struct __is_trivially_copy_assignable_impl; +# 1296 +template< class _Tp> +# 1297 +struct __is_trivially_copy_assignable_impl< _Tp, false> : public false_type { +# 1298 +}; +# 1300 +template< class _Tp> +# 1301 +struct __is_trivially_copy_assignable_impl< _Tp, true> : public __bool_constant< __is_trivially_assignable(_Tp &, const _Tp &)> { +# 1303 +}; +# 1306 +template< class _Tp> +# 1307 +struct is_trivially_copy_assignable : public __is_trivially_copy_assignable_impl< _Tp> { +# 1310 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1312 +}; +# 1314 +template< class _Tp, bool = __is_referenceable< _Tp> ::value> struct __is_trivially_move_assignable_impl; +# 1317 +template< class _Tp> +# 1318 +struct __is_trivially_move_assignable_impl< _Tp, false> : public false_type { +# 1319 +}; +# 1321 +template< class _Tp> +# 1322 +struct __is_trivially_move_assignable_impl< _Tp, true> : public __bool_constant< __is_trivially_assignable(_Tp &, _Tp &&)> { +# 1324 +}; +# 1327 +template< class _Tp> +# 1328 +struct is_trivially_move_assignable : public __is_trivially_move_assignable_impl< _Tp> { +# 1331 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1333 +}; +# 1336 +template< class _Tp> +# 1337 +struct is_trivially_destructible : public __and_< __is_destructible_safe< _Tp> , __bool_constant< __has_trivial_destructor(_Tp)> > { +# 1341 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1343 +}; +# 1347 +template< class _Tp> +# 1348 +struct has_virtual_destructor : public integral_constant< bool, __has_virtual_destructor(_Tp)> { +# 1351 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1353 +}; +# 1359 +template< class _Tp> +# 1360 +struct alignment_of : public integral_constant< unsigned long, __alignof__(_Tp)> { +# 1363 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 1365 +}; +# 1368 +template< class > +# 1369 +struct rank : public integral_constant< unsigned long, 0UL> { +# 1370 +}; +# 1372 +template< class _Tp, size_t _Size> +# 1373 +struct rank< _Tp [_Size]> : public integral_constant< unsigned long, 1 + std::rank< _Tp> ::value> { +# 1374 +}; +# 1376 +template< class _Tp> +# 1377 +struct rank< _Tp []> : public integral_constant< unsigned long, 1 + std::rank< _Tp> ::value> { +# 1378 +}; +# 1381 +template< class , unsigned _Uint> +# 1382 +struct extent : public integral_constant< unsigned long, 0UL> { +# 1383 +}; +# 1385 +template< class _Tp, unsigned _Uint, size_t _Size> +# 1386 +struct extent< _Tp [_Size], _Uint> : public integral_constant< unsigned long, (_Uint == (0)) ? _Size : std::extent< _Tp, _Uint - (1)> ::value> { +# 1390 +}; +# 1392 +template< class _Tp, unsigned _Uint> +# 1393 +struct extent< _Tp [], _Uint> : public integral_constant< unsigned long, (_Uint == (0)) ? 0 : std::extent< _Tp, _Uint - (1)> ::value> { +# 1397 +}; +# 1403 +template< class _Tp, class _Up> +# 1404 +struct is_same : public integral_constant< bool, __is_same(_Tp, _Up)> { +# 1410 +}; +# 1420 "/usr/include/c++/11/type_traits" 3 +template< class _Base, class _Derived> +# 1421 +struct is_base_of : public integral_constant< bool, __is_base_of(_Base, _Derived)> { +# 1423 +}; +# 1425 +template< class _From, class _To, bool +# 1426 + = __or_< is_void< _From> , is_function< _To> , is_array< _To> > ::value> +# 1428 +struct __is_convertible_helper { +# 1430 +typedef typename is_void< _To> ::type type; +# 1431 +}; +# 1433 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" +template< class _From, class _To> +# 1436 +class __is_convertible_helper< _From, _To, false> { +# 1438 +template< class _To1> static void __test_aux(_To1) noexcept; +# 1441 +template< class _From1, class _To1, class +# 1442 + = __decltype((__test_aux< _To1> (std::declval< _From1> ())))> static true_type +# 1441 +__test(int); +# 1446 +template< class , class > static false_type __test(...); +# 1451 +public: typedef __decltype((__test< _From, _To> (0))) type; +# 1452 +}; +#pragma GCC diagnostic pop +# 1456 +template< class _From, class _To> +# 1457 +struct is_convertible : public __is_convertible_helper< _From, _To> ::type { +# 1459 +}; +# 1462 +template< class _ToElementType, class _FromElementType> using __is_array_convertible = is_convertible< _FromElementType (*)[], _ToElementType (*)[]> ; +# 1466 +template< class _From, class _To, bool +# 1467 + = __or_< is_void< _From> , is_function< _To> , is_array< _To> > ::value> +# 1469 +struct __is_nt_convertible_helper : public is_void< _To> { +# 1471 +}; +# 1473 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" +template< class _From, class _To> +# 1476 +class __is_nt_convertible_helper< _From, _To, false> { +# 1478 +template< class _To1> static void __test_aux(_To1) noexcept; +# 1481 +template< class _From1, class _To1> static __bool_constant< noexcept(__test_aux< _To1> (std::declval< _From1> ()))> __test(int); +# 1486 +template< class , class > static false_type __test(...); +# 1491 +public: using type = __decltype((__test< _From, _To> (0))); +# 1492 +}; +#pragma GCC diagnostic pop +# 1512 "/usr/include/c++/11/type_traits" 3 +template< class _Tp> +# 1513 +struct remove_const { +# 1514 +typedef _Tp type; }; +# 1516 +template< class _Tp> +# 1517 +struct remove_const< const _Tp> { +# 1518 +typedef _Tp type; }; +# 1521 +template< class _Tp> +# 1522 +struct remove_volatile { +# 1523 +typedef _Tp type; }; +# 1525 +template< class _Tp> +# 1526 +struct remove_volatile< volatile _Tp> { +# 1527 +typedef _Tp type; }; +# 1530 +template< class _Tp> +# 1531 +struct remove_cv { +# 1532 +using type = _Tp; }; +# 1534 +template< class _Tp> +# 1535 +struct remove_cv< const _Tp> { +# 1536 +using type = _Tp; }; +# 1538 +template< class _Tp> +# 1539 +struct remove_cv< volatile _Tp> { +# 1540 +using type = _Tp; }; +# 1542 +template< class _Tp> +# 1543 +struct remove_cv< const volatile _Tp> { +# 1544 +using type = _Tp; }; +# 1547 +template< class _Tp> +# 1548 +struct add_const { +# 1549 +typedef const _Tp type; }; +# 1552 +template< class _Tp> +# 1553 +struct add_volatile { +# 1554 +typedef volatile _Tp type; }; +# 1557 +template< class _Tp> +# 1558 +struct add_cv { +# 1561 +typedef typename add_const< typename add_volatile< _Tp> ::type> ::type type; +# 1562 +}; +# 1569 +template< class _Tp> using remove_const_t = typename remove_const< _Tp> ::type; +# 1573 +template< class _Tp> using remove_volatile_t = typename remove_volatile< _Tp> ::type; +# 1577 +template< class _Tp> using remove_cv_t = typename remove_cv< _Tp> ::type; +# 1581 +template< class _Tp> using add_const_t = typename add_const< _Tp> ::type; +# 1585 +template< class _Tp> using add_volatile_t = typename add_volatile< _Tp> ::type; +# 1589 +template< class _Tp> using add_cv_t = typename add_cv< _Tp> ::type; +# 1596 +template< class _Tp> +# 1597 +struct remove_reference { +# 1598 +typedef _Tp type; }; +# 1600 +template< class _Tp> +# 1601 +struct remove_reference< _Tp &> { +# 1602 +typedef _Tp type; }; +# 1604 +template< class _Tp> +# 1605 +struct remove_reference< _Tp &&> { +# 1606 +typedef _Tp type; }; +# 1608 +template< class _Tp, bool = __is_referenceable< _Tp> ::value> +# 1609 +struct __add_lvalue_reference_helper { +# 1610 +typedef _Tp type; }; +# 1612 +template< class _Tp> +# 1613 +struct __add_lvalue_reference_helper< _Tp, true> { +# 1614 +typedef _Tp &type; }; +# 1617 +template< class _Tp> +# 1618 +struct add_lvalue_reference : public __add_lvalue_reference_helper< _Tp> { +# 1620 +}; +# 1622 +template< class _Tp, bool = __is_referenceable< _Tp> ::value> +# 1623 +struct __add_rvalue_reference_helper { +# 1624 +typedef _Tp type; }; +# 1626 +template< class _Tp> +# 1627 +struct __add_rvalue_reference_helper< _Tp, true> { +# 1628 +typedef _Tp &&type; }; +# 1631 +template< class _Tp> +# 1632 +struct add_rvalue_reference : public __add_rvalue_reference_helper< _Tp> { +# 1634 +}; +# 1638 +template< class _Tp> using remove_reference_t = typename remove_reference< _Tp> ::type; +# 1642 +template< class _Tp> using add_lvalue_reference_t = typename add_lvalue_reference< _Tp> ::type; +# 1646 +template< class _Tp> using add_rvalue_reference_t = typename add_rvalue_reference< _Tp> ::type; +# 1655 +template< class _Unqualified, bool _IsConst, bool _IsVol> struct __cv_selector; +# 1658 +template< class _Unqualified> +# 1659 +struct __cv_selector< _Unqualified, false, false> { +# 1660 +typedef _Unqualified __type; }; +# 1662 +template< class _Unqualified> +# 1663 +struct __cv_selector< _Unqualified, false, true> { +# 1664 +typedef volatile _Unqualified __type; }; +# 1666 +template< class _Unqualified> +# 1667 +struct __cv_selector< _Unqualified, true, false> { +# 1668 +typedef const _Unqualified __type; }; +# 1670 +template< class _Unqualified> +# 1671 +struct __cv_selector< _Unqualified, true, true> { +# 1672 +typedef const volatile _Unqualified __type; }; +# 1674 +template< class _Qualified, class _Unqualified, bool +# 1675 +_IsConst = is_const< _Qualified> ::value, bool +# 1676 +_IsVol = is_volatile< _Qualified> ::value> +# 1677 +class __match_cv_qualifiers { +# 1679 +typedef __cv_selector< _Unqualified, _IsConst, _IsVol> __match; +# 1682 +public: typedef typename __cv_selector< _Unqualified, _IsConst, _IsVol> ::__type __type; +# 1683 +}; +# 1686 +template< class _Tp> +# 1687 +struct __make_unsigned { +# 1688 +typedef _Tp __type; }; +# 1691 +template<> struct __make_unsigned< char> { +# 1692 +typedef unsigned char __type; }; +# 1695 +template<> struct __make_unsigned< signed char> { +# 1696 +typedef unsigned char __type; }; +# 1699 +template<> struct __make_unsigned< short> { +# 1700 +typedef unsigned short __type; }; +# 1703 +template<> struct __make_unsigned< int> { +# 1704 +typedef unsigned __type; }; +# 1707 +template<> struct __make_unsigned< long> { +# 1708 +typedef unsigned long __type; }; +# 1711 +template<> struct __make_unsigned< long long> { +# 1712 +typedef unsigned long long __type; }; +# 1716 +template<> struct __make_unsigned< __int128> { +# 1717 +typedef unsigned __int128 __type; }; +# 1736 "/usr/include/c++/11/type_traits" 3 +template< class _Tp, bool +# 1737 +_IsInt = is_integral< _Tp> ::value, bool +# 1738 +_IsEnum = is_enum< _Tp> ::value> class __make_unsigned_selector; +# 1741 +template< class _Tp> +# 1742 +class __make_unsigned_selector< _Tp, true, false> { +# 1744 +using __unsigned_type = typename __make_unsigned< __remove_cv_t< _Tp> > ::__type; +# 1748 +public: using __type = typename __match_cv_qualifiers< _Tp, __unsigned_type> ::__type; +# 1750 +}; +# 1752 +class __make_unsigned_selector_base { +# 1755 +protected: template< class ...> struct _List { }; +# 1757 +template< class _Tp, class ..._Up> +# 1758 +struct _List< _Tp, _Up...> : public __make_unsigned_selector_base::_List< _Up...> { +# 1759 +static constexpr inline std::size_t __size = sizeof(_Tp); }; +# 1761 +template< size_t _Sz, class _Tp, bool = _Sz <= _Tp::__size> struct __select; +# 1764 +template< size_t _Sz, class _Uint, class ..._UInts> +# 1765 +struct __select< _Sz, _List< _Uint, _UInts...> , true> { +# 1766 +using __type = _Uint; }; +# 1768 +template< size_t _Sz, class _Uint, class ..._UInts> +# 1769 +struct __select< _Sz, _List< _Uint, _UInts...> , false> : public __make_unsigned_selector_base::__select< _Sz, _List< _UInts...> > { +# 1771 +}; +# 1772 +}; +# 1775 +template< class _Tp> +# 1776 +class __make_unsigned_selector< _Tp, false, true> : private __make_unsigned_selector_base { +# 1780 +using _UInts = _List< unsigned char, unsigned short, unsigned, unsigned long, unsigned long long> ; +# 1783 +using __unsigned_type = typename __select< sizeof(_Tp), _List< unsigned char, unsigned short, unsigned, unsigned long, unsigned long long> > ::__type; +# 1786 +public: using __type = typename __match_cv_qualifiers< _Tp, __unsigned_type> ::__type; +# 1788 +}; +# 1796 +template<> struct __make_unsigned< wchar_t> { +# 1798 +using __type = __make_unsigned_selector< wchar_t, false, true> ::__type; +# 1800 +}; +# 1813 "/usr/include/c++/11/type_traits" 3 +template<> struct __make_unsigned< char16_t> { +# 1815 +using __type = __make_unsigned_selector< char16_t, false, true> ::__type; +# 1817 +}; +# 1820 +template<> struct __make_unsigned< char32_t> { +# 1822 +using __type = __make_unsigned_selector< char32_t, false, true> ::__type; +# 1824 +}; +# 1831 +template< class _Tp> +# 1832 +struct make_unsigned { +# 1833 +typedef typename __make_unsigned_selector< _Tp> ::__type type; }; +# 1837 +template<> struct make_unsigned< bool> ; +# 1842 +template< class _Tp> +# 1843 +struct __make_signed { +# 1844 +typedef _Tp __type; }; +# 1847 +template<> struct __make_signed< char> { +# 1848 +typedef signed char __type; }; +# 1851 +template<> struct __make_signed< unsigned char> { +# 1852 +typedef signed char __type; }; +# 1855 +template<> struct __make_signed< unsigned short> { +# 1856 +typedef signed short __type; }; +# 1859 +template<> struct __make_signed< unsigned> { +# 1860 +typedef signed int __type; }; +# 1863 +template<> struct __make_signed< unsigned long> { +# 1864 +typedef signed long __type; }; +# 1867 +template<> struct __make_signed< unsigned long long> { +# 1868 +typedef signed long long __type; }; +# 1872 +template<> struct __make_signed< unsigned __int128> { +# 1873 +typedef __int128 __type; }; +# 1892 "/usr/include/c++/11/type_traits" 3 +template< class _Tp, bool +# 1893 +_IsInt = is_integral< _Tp> ::value, bool +# 1894 +_IsEnum = is_enum< _Tp> ::value> class __make_signed_selector; +# 1897 +template< class _Tp> +# 1898 +class __make_signed_selector< _Tp, true, false> { +# 1900 +using __signed_type = typename __make_signed< __remove_cv_t< _Tp> > ::__type; +# 1904 +public: using __type = typename __match_cv_qualifiers< _Tp, __signed_type> ::__type; +# 1906 +}; +# 1909 +template< class _Tp> +# 1910 +class __make_signed_selector< _Tp, false, true> { +# 1912 +typedef typename __make_unsigned_selector< _Tp> ::__type __unsigned_type; +# 1915 +public: typedef typename std::__make_signed_selector< __unsigned_type> ::__type __type; +# 1916 +}; +# 1924 +template<> struct __make_signed< wchar_t> { +# 1926 +using __type = __make_signed_selector< wchar_t, false, true> ::__type; +# 1928 +}; +# 1941 "/usr/include/c++/11/type_traits" 3 +template<> struct __make_signed< char16_t> { +# 1943 +using __type = __make_signed_selector< char16_t, false, true> ::__type; +# 1945 +}; +# 1948 +template<> struct __make_signed< char32_t> { +# 1950 +using __type = __make_signed_selector< char32_t, false, true> ::__type; +# 1952 +}; +# 1959 +template< class _Tp> +# 1960 +struct make_signed { +# 1961 +typedef typename __make_signed_selector< _Tp> ::__type type; }; +# 1965 +template<> struct make_signed< bool> ; +# 1969 +template< class _Tp> using make_signed_t = typename make_signed< _Tp> ::type; +# 1973 +template< class _Tp> using make_unsigned_t = typename make_unsigned< _Tp> ::type; +# 1980 +template< class _Tp> +# 1981 +struct remove_extent { +# 1982 +typedef _Tp type; }; +# 1984 +template< class _Tp, size_t _Size> +# 1985 +struct remove_extent< _Tp [_Size]> { +# 1986 +typedef _Tp type; }; +# 1988 +template< class _Tp> +# 1989 +struct remove_extent< _Tp []> { +# 1990 +typedef _Tp type; }; +# 1993 +template< class _Tp> +# 1994 +struct remove_all_extents { +# 1995 +typedef _Tp type; }; +# 1997 +template< class _Tp, size_t _Size> +# 1998 +struct remove_all_extents< _Tp [_Size]> { +# 1999 +typedef typename std::remove_all_extents< _Tp> ::type type; }; +# 2001 +template< class _Tp> +# 2002 +struct remove_all_extents< _Tp []> { +# 2003 +typedef typename std::remove_all_extents< _Tp> ::type type; }; +# 2007 +template< class _Tp> using remove_extent_t = typename remove_extent< _Tp> ::type; +# 2011 +template< class _Tp> using remove_all_extents_t = typename remove_all_extents< _Tp> ::type; +# 2017 +template< class _Tp, class > +# 2018 +struct __remove_pointer_helper { +# 2019 +typedef _Tp type; }; +# 2021 +template< class _Tp, class _Up> +# 2022 +struct __remove_pointer_helper< _Tp, _Up *> { +# 2023 +typedef _Up type; }; +# 2026 +template< class _Tp> +# 2027 +struct remove_pointer : public __remove_pointer_helper< _Tp, __remove_cv_t< _Tp> > { +# 2029 +}; +# 2031 +template< class _Tp, bool = __or_< __is_referenceable< _Tp> , is_void< _Tp> > ::value> +# 2033 +struct __add_pointer_helper { +# 2034 +typedef _Tp type; }; +# 2036 +template< class _Tp> +# 2037 +struct __add_pointer_helper< _Tp, true> { +# 2038 +typedef typename remove_reference< _Tp> ::type *type; }; +# 2041 +template< class _Tp> +# 2042 +struct add_pointer : public __add_pointer_helper< _Tp> { +# 2044 +}; +# 2048 +template< class _Tp> using remove_pointer_t = typename remove_pointer< _Tp> ::type; +# 2052 +template< class _Tp> using add_pointer_t = typename add_pointer< _Tp> ::type; +# 2056 +template< size_t _Len> +# 2057 +struct __aligned_storage_msa { +# 2059 +union __type { +# 2061 +unsigned char __data[_Len]; +# 2062 +struct __attribute((__aligned__)) { } __align; +# 2063 +}; +# 2064 +}; +# 2076 "/usr/include/c++/11/type_traits" 3 +template< size_t _Len, size_t _Align = __alignof__(typename __aligned_storage_msa< _Len> ::__type)> +# 2078 +struct aligned_storage { +# 2080 +union type { +# 2082 +unsigned char __data[_Len]; +# 2083 +struct __attribute((__aligned__(_Align))) { } __align; +# 2084 +}; +# 2085 +}; +# 2087 +template< class ..._Types> +# 2088 +struct __strictest_alignment { +# 2090 +static const size_t _S_alignment = (0); +# 2091 +static const size_t _S_size = (0); +# 2092 +}; +# 2094 +template< class _Tp, class ..._Types> +# 2095 +struct __strictest_alignment< _Tp, _Types...> { +# 2097 +static const size_t _S_alignment = ((__alignof__(_Tp) > __strictest_alignment< _Types...> ::_S_alignment) ? __alignof__(_Tp) : __strictest_alignment< _Types...> ::_S_alignment); +# 2100 +static const size_t _S_size = ((sizeof(_Tp) > __strictest_alignment< _Types...> ::_S_size) ? sizeof(_Tp) : __strictest_alignment< _Types...> ::_S_size); +# 2103 +}; +# 2115 "/usr/include/c++/11/type_traits" 3 +template< size_t _Len, class ..._Types> +# 2116 +struct aligned_union { +# 2119 +static_assert((sizeof...(_Types) != (0)), "At least one type is required"); +# 2121 +private: using __strictest = __strictest_alignment< _Types...> ; +# 2122 +static const size_t _S_len = ((_Len > __strictest::_S_size) ? _Len : __strictest::_S_size); +# 2126 +public: static const size_t alignment_value = (__strictest::_S_alignment); +# 2128 +typedef typename aligned_storage< _S_len, alignment_value> ::type type; +# 2129 +}; +# 2131 +template< size_t _Len, class ..._Types> const size_t aligned_union< _Len, _Types...> ::alignment_value; +# 2138 +template< class _Up, bool +# 2139 +_IsArray = is_array< _Up> ::value, bool +# 2140 +_IsFunction = is_function< _Up> ::value> struct __decay_selector; +# 2144 +template< class _Up> +# 2145 +struct __decay_selector< _Up, false, false> { +# 2146 +typedef __remove_cv_t< _Up> __type; }; +# 2148 +template< class _Up> +# 2149 +struct __decay_selector< _Up, true, false> { +# 2150 +typedef typename remove_extent< _Up> ::type *__type; }; +# 2152 +template< class _Up> +# 2153 +struct __decay_selector< _Up, false, true> { +# 2154 +typedef typename add_pointer< _Up> ::type __type; }; +# 2158 +template< class _Tp> +# 2159 +class decay { +# 2161 +typedef typename remove_reference< _Tp> ::type __remove_type; +# 2164 +public: typedef typename __decay_selector< __remove_type> ::__type type; +# 2165 +}; +# 2170 +template< class _Tp> +# 2171 +struct __strip_reference_wrapper { +# 2173 +typedef _Tp __type; +# 2174 +}; +# 2176 +template< class _Tp> +# 2177 +struct __strip_reference_wrapper< reference_wrapper< _Tp> > { +# 2179 +typedef _Tp &__type; +# 2180 +}; +# 2183 +template< class _Tp> using __decay_t = typename decay< _Tp> ::type; +# 2186 +template< class _Tp> using __decay_and_strip = __strip_reference_wrapper< __decay_t< _Tp> > ; +# 2192 +template< bool , class _Tp = void> +# 2193 +struct enable_if { +# 2194 +}; +# 2197 +template< class _Tp> +# 2198 +struct enable_if< true, _Tp> { +# 2199 +typedef _Tp type; }; +# 2204 +template< bool _Cond, class _Tp = void> using __enable_if_t = typename enable_if< _Cond, _Tp> ::type; +# 2208 +template< class ..._Cond> using _Require = __enable_if_t< __and_< _Cond...> ::value> ; +# 2212 +template< class _Tp> using __remove_cvref_t = typename remove_cv< typename remove_reference< _Tp> ::type> ::type; +# 2219 +template< bool _Cond, class _Iftrue, class _Iffalse> +# 2220 +struct conditional { +# 2221 +typedef _Iftrue type; }; +# 2224 +template< class _Iftrue, class _Iffalse> +# 2225 +struct conditional< false, _Iftrue, _Iffalse> { +# 2226 +typedef _Iffalse type; }; +# 2229 +template< class ..._Tp> struct common_type; +# 2235 +struct __do_common_type_impl { +# 2237 +template< class _Tp, class _Up> using __cond_t = __decltype((true ? std::declval< _Tp> () : std::declval< _Up> ())); +# 2243 +template< class _Tp, class _Up> static __success_type< __decay_t< __cond_t< _Tp, _Up> > > _S_test(int); +# 2255 "/usr/include/c++/11/type_traits" 3 +template< class , class > static __failure_type _S_test_2(...); +# 2259 +template< class _Tp, class _Up> static __decltype((_S_test_2< _Tp, _Up> (0))) _S_test(...); +# 2262 +}; +# 2266 +template<> struct common_type< > { +# 2267 +}; +# 2270 +template< class _Tp0> +# 2271 +struct common_type< _Tp0> : public std::common_type< _Tp0, _Tp0> { +# 2273 +}; +# 2276 +template< class _Tp1, class _Tp2, class +# 2277 +_Dp1 = __decay_t< _Tp1> , class _Dp2 = __decay_t< _Tp2> > +# 2278 +struct __common_type_impl { +# 2282 +using type = common_type< _Dp1, _Dp2> ; +# 2283 +}; +# 2285 +template< class _Tp1, class _Tp2> +# 2286 +struct __common_type_impl< _Tp1, _Tp2, _Tp1, _Tp2> : private __do_common_type_impl { +# 2291 +using type = __decltype((_S_test< _Tp1, _Tp2> (0))); +# 2292 +}; +# 2295 +template< class _Tp1, class _Tp2> +# 2296 +struct common_type< _Tp1, _Tp2> : public __common_type_impl< _Tp1, _Tp2> ::type { +# 2298 +}; +# 2300 +template< class ...> +# 2301 +struct __common_type_pack { +# 2302 +}; +# 2304 +template< class , class , class = void> struct __common_type_fold; +# 2308 +template< class _Tp1, class _Tp2, class ..._Rp> +# 2309 +struct common_type< _Tp1, _Tp2, _Rp...> : public __common_type_fold< std::common_type< _Tp1, _Tp2> , __common_type_pack< _Rp...> > { +# 2312 +}; +# 2317 +template< class _CTp, class ..._Rp> +# 2318 +struct __common_type_fold< _CTp, __common_type_pack< _Rp...> , __void_t< typename _CTp::type> > : public common_type< typename _CTp::type, _Rp...> { +# 2321 +}; +# 2324 +template< class _CTp, class _Rp> +# 2325 +struct __common_type_fold< _CTp, _Rp, void> { +# 2326 +}; +# 2328 +template< class _Tp, bool = is_enum< _Tp> ::value> +# 2329 +struct __underlying_type_impl { +# 2331 +using type = __underlying_type(_Tp); +# 2332 +}; +# 2334 +template< class _Tp> +# 2335 +struct __underlying_type_impl< _Tp, false> { +# 2336 +}; +# 2340 +template< class _Tp> +# 2341 +struct underlying_type : public __underlying_type_impl< _Tp> { +# 2343 +}; +# 2346 +template< class _Tp> +# 2347 +struct __declval_protector { +# 2349 +static const bool __stop = false; +# 2350 +}; +# 2357 +template< class _Tp> auto +# 2358 +declval() noexcept->__decltype((__declval< _Tp> (0))) +# 2359 +{ +# 2360 +static_assert((__declval_protector< _Tp> ::__stop), "declval() must not be used!"); +# 2362 +return __declval< _Tp> (0); +# 2363 +} +# 2366 +template< class _Signature> struct result_of; +# 2374 +struct __invoke_memfun_ref { }; +# 2375 +struct __invoke_memfun_deref { }; +# 2376 +struct __invoke_memobj_ref { }; +# 2377 +struct __invoke_memobj_deref { }; +# 2378 +struct __invoke_other { }; +# 2381 +template< class _Tp, class _Tag> +# 2382 +struct __result_of_success : public __success_type< _Tp> { +# 2383 +using __invoke_type = _Tag; }; +# 2386 +struct __result_of_memfun_ref_impl { +# 2388 +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); +# 2393 +template< class ...> static __failure_type _S_test(...); +# 2395 +}; +# 2397 +template< class _MemPtr, class _Arg, class ..._Args> +# 2398 +struct __result_of_memfun_ref : private __result_of_memfun_ref_impl { +# 2401 +typedef __decltype((_S_test< _MemPtr, _Arg, _Args...> (0))) type; +# 2402 +}; +# 2405 +struct __result_of_memfun_deref_impl { +# 2407 +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); +# 2412 +template< class ...> static __failure_type _S_test(...); +# 2414 +}; +# 2416 +template< class _MemPtr, class _Arg, class ..._Args> +# 2417 +struct __result_of_memfun_deref : private __result_of_memfun_deref_impl { +# 2420 +typedef __decltype((_S_test< _MemPtr, _Arg, _Args...> (0))) type; +# 2421 +}; +# 2424 +struct __result_of_memobj_ref_impl { +# 2426 +template< class _Fp, class _Tp1> static __result_of_success< __decltype((std::declval< _Tp1> ().*std::declval< _Fp> ())), __invoke_memobj_ref> _S_test(int); +# 2431 +template< class , class > static __failure_type _S_test(...); +# 2433 +}; +# 2435 +template< class _MemPtr, class _Arg> +# 2436 +struct __result_of_memobj_ref : private __result_of_memobj_ref_impl { +# 2439 +typedef __decltype((_S_test< _MemPtr, _Arg> (0))) type; +# 2440 +}; +# 2443 +struct __result_of_memobj_deref_impl { +# 2445 +template< class _Fp, class _Tp1> static __result_of_success< __decltype(((*std::declval< _Tp1> ()).*std::declval< _Fp> ())), __invoke_memobj_deref> _S_test(int); +# 2450 +template< class , class > static __failure_type _S_test(...); +# 2452 +}; +# 2454 +template< class _MemPtr, class _Arg> +# 2455 +struct __result_of_memobj_deref : private __result_of_memobj_deref_impl { +# 2458 +typedef __decltype((_S_test< _MemPtr, _Arg> (0))) type; +# 2459 +}; +# 2461 +template< class _MemPtr, class _Arg> struct __result_of_memobj; +# 2464 +template< class _Res, class _Class, class _Arg> +# 2465 +struct __result_of_memobj< _Res (_Class::*), _Arg> { +# 2467 +typedef __remove_cvref_t< _Arg> _Argval; +# 2468 +typedef _Res (_Class::*_MemPtr); +# 2473 +typedef typename conditional< __or_< is_same< _Argval, _Class> , is_base_of< _Class, _Argval> > ::value, __result_of_memobj_ref< _MemPtr, _Arg> , __result_of_memobj_deref< _MemPtr, _Arg> > ::type::type type; +# 2474 +}; +# 2476 +template< class _MemPtr, class _Arg, class ..._Args> struct __result_of_memfun; +# 2479 +template< class _Res, class _Class, class _Arg, class ..._Args> +# 2480 +struct __result_of_memfun< _Res (_Class::*), _Arg, _Args...> { +# 2482 +typedef typename remove_reference< _Arg> ::type _Argval; +# 2483 +typedef _Res (_Class::*_MemPtr); +# 2487 +typedef typename conditional< is_base_of< _Class, _Argval> ::value, __result_of_memfun_ref< _MemPtr, _Arg, _Args...> , __result_of_memfun_deref< _MemPtr, _Arg, _Args...> > ::type::type type; +# 2488 +}; +# 2495 +template< class _Tp, class _Up = __remove_cvref_t< _Tp> > +# 2496 +struct __inv_unwrap { +# 2498 +using type = _Tp; +# 2499 +}; +# 2501 +template< class _Tp, class _Up> +# 2502 +struct __inv_unwrap< _Tp, reference_wrapper< _Up> > { +# 2504 +using type = _Up &; +# 2505 +}; +# 2507 +template< bool , bool , class _Functor, class ..._ArgTypes> +# 2508 +struct __result_of_impl { +# 2510 +typedef __failure_type type; +# 2511 +}; +# 2513 +template< class _MemPtr, class _Arg> +# 2514 +struct __result_of_impl< true, false, _MemPtr, _Arg> : public __result_of_memobj< __decay_t< _MemPtr> , typename __inv_unwrap< _Arg> ::type> { +# 2517 +}; +# 2519 +template< class _MemPtr, class _Arg, class ..._Args> +# 2520 +struct __result_of_impl< false, true, _MemPtr, _Arg, _Args...> : public __result_of_memfun< __decay_t< _MemPtr> , typename __inv_unwrap< _Arg> ::type, _Args...> { +# 2523 +}; +# 2526 +struct __result_of_other_impl { +# 2528 +template< class _Fn, class ..._Args> static __result_of_success< __decltype((std::declval< _Fn> ()(std::declval< _Args> ()...))), __invoke_other> _S_test(int); +# 2533 +template< class ...> static __failure_type _S_test(...); +# 2535 +}; +# 2537 +template< class _Functor, class ..._ArgTypes> +# 2538 +struct __result_of_impl< false, false, _Functor, _ArgTypes...> : private __result_of_other_impl { +# 2541 +typedef __decltype((_S_test< _Functor, _ArgTypes...> (0))) type; +# 2542 +}; +# 2545 +template< class _Functor, class ..._ArgTypes> +# 2546 +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 { +# 2556 +}; +# 2559 +template< class _Functor, class ..._ArgTypes> +# 2560 +struct result_of< _Functor (_ArgTypes ...)> : public __invoke_result< _Functor, _ArgTypes...> { +# 2562 +}; +# 2566 +template< size_t _Len, size_t _Align = __alignof__(typename __aligned_storage_msa< _Len> ::__type)> using aligned_storage_t = typename aligned_storage< _Len, _Align> ::type; +# 2570 +template< size_t _Len, class ..._Types> using aligned_union_t = typename aligned_union< _Len, _Types...> ::type; +# 2574 +template< class _Tp> using decay_t = typename decay< _Tp> ::type; +# 2578 +template< bool _Cond, class _Tp = void> using enable_if_t = typename enable_if< _Cond, _Tp> ::type; +# 2582 +template< bool _Cond, class _Iftrue, class _Iffalse> using conditional_t = typename conditional< _Cond, _Iftrue, _Iffalse> ::type; +# 2586 +template< class ..._Tp> using common_type_t = typename common_type< _Tp...> ::type; +# 2590 +template< class _Tp> using underlying_type_t = typename underlying_type< _Tp> ::type; +# 2594 +template< class _Tp> using result_of_t = typename result_of< _Tp> ::type; +# 2601 +template< class ...> using void_t = void; +# 2607 +template< class _Default, class _AlwaysVoid, +# 2608 +template< class ...> class _Op, class ..._Args> +# 2609 +struct __detector { +# 2611 +using value_t = false_type; +# 2612 +using type = _Default; +# 2613 +}; +# 2616 +template< class _Default, template< class ...> class _Op, class ... +# 2617 +_Args> +# 2618 +struct __detector< _Default, __void_t< _Op< _Args...> > , _Op, _Args...> { +# 2620 +using value_t = true_type; +# 2621 +using type = _Op< _Args...> ; +# 2622 +}; +# 2625 +template< class _Default, template< class ...> class _Op, class ... +# 2626 +_Args> using __detected_or = __detector< _Default, void, _Op, _Args...> ; +# 2630 +template< class _Default, template< class ...> class _Op, class ... +# 2631 +_Args> using __detected_or_t = typename __detected_or< _Default, _Op, _Args...> ::type; +# 2649 "/usr/include/c++/11/type_traits" 3 +template< class _Tp> struct __is_swappable; +# 2652 +template< class _Tp> struct __is_nothrow_swappable; +# 2655 +template< class > +# 2656 +struct __is_tuple_like_impl : public false_type { +# 2657 +}; +# 2659 +template< class ..._Tps> +# 2660 +struct __is_tuple_like_impl< tuple< _Tps...> > : public true_type { +# 2661 +}; +# 2664 +template< class _Tp> +# 2665 +struct __is_tuple_like : public __is_tuple_like_impl< __remove_cvref_t< _Tp> > ::type { +# 2667 +}; +# 2670 +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); +# 2680 +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); +# 2688 +namespace __swappable_details { +# 2689 +using std::swap; +# 2691 +struct __do_is_swappable_impl { +# 2693 +template< class _Tp, class +# 2694 + = __decltype((swap(std::declval< _Tp &> (), std::declval< _Tp &> ())))> static true_type +# 2693 +__test(int); +# 2697 +template< class > static false_type __test(...); +# 2699 +}; +# 2701 +struct __do_is_nothrow_swappable_impl { +# 2703 +template< class _Tp> static __bool_constant< noexcept(swap(std::declval< _Tp &> (), std::declval< _Tp &> ()))> __test(int); +# 2708 +template< class > static false_type __test(...); +# 2710 +}; +# 2712 +} +# 2714 +template< class _Tp> +# 2715 +struct __is_swappable_impl : public __swappable_details::__do_is_swappable_impl { +# 2718 +typedef __decltype((__test< _Tp> (0))) type; +# 2719 +}; +# 2721 +template< class _Tp> +# 2722 +struct __is_nothrow_swappable_impl : public __swappable_details::__do_is_nothrow_swappable_impl { +# 2725 +typedef __decltype((__test< _Tp> (0))) type; +# 2726 +}; +# 2728 +template< class _Tp> +# 2729 +struct __is_swappable : public __is_swappable_impl< _Tp> ::type { +# 2731 +}; +# 2733 +template< class _Tp> +# 2734 +struct __is_nothrow_swappable : public __is_nothrow_swappable_impl< _Tp> ::type { +# 2736 +}; +# 2744 +template< class _Tp> +# 2745 +struct is_swappable : public __is_swappable_impl< _Tp> ::type { +# 2748 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 2750 +}; +# 2753 +template< class _Tp> +# 2754 +struct is_nothrow_swappable : public __is_nothrow_swappable_impl< _Tp> ::type { +# 2757 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 2759 +}; +# 2763 +template< class _Tp> constexpr inline bool +# 2764 +is_swappable_v = (is_swappable< _Tp> ::value); +# 2768 +template< class _Tp> constexpr inline bool +# 2769 +is_nothrow_swappable_v = (is_nothrow_swappable< _Tp> ::value); +# 2774 +namespace __swappable_with_details { +# 2775 +using std::swap; +# 2777 +struct __do_is_swappable_with_impl { +# 2779 +template< class _Tp, class _Up, class +# 2780 + = __decltype((swap(std::declval< _Tp> (), std::declval< _Up> ()))), class +# 2782 + = __decltype((swap(std::declval< _Up> (), std::declval< _Tp> ())))> static true_type +# 2779 +__test(int); +# 2785 +template< class , class > static false_type __test(...); +# 2787 +}; +# 2789 +struct __do_is_nothrow_swappable_with_impl { +# 2791 +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); +# 2798 +template< class , class > static false_type __test(...); +# 2800 +}; +# 2802 +} +# 2804 +template< class _Tp, class _Up> +# 2805 +struct __is_swappable_with_impl : public __swappable_with_details::__do_is_swappable_with_impl { +# 2808 +typedef __decltype((__test< _Tp, _Up> (0))) type; +# 2809 +}; +# 2812 +template< class _Tp> +# 2813 +struct __is_swappable_with_impl< _Tp &, _Tp &> : public __swappable_details::__do_is_swappable_impl { +# 2816 +typedef __decltype((__test< _Tp &> (0))) type; +# 2817 +}; +# 2819 +template< class _Tp, class _Up> +# 2820 +struct __is_nothrow_swappable_with_impl : public __swappable_with_details::__do_is_nothrow_swappable_with_impl { +# 2823 +typedef __decltype((__test< _Tp, _Up> (0))) type; +# 2824 +}; +# 2827 +template< class _Tp> +# 2828 +struct __is_nothrow_swappable_with_impl< _Tp &, _Tp &> : public __swappable_details::__do_is_nothrow_swappable_impl { +# 2831 +typedef __decltype((__test< _Tp &> (0))) type; +# 2832 +}; +# 2836 +template< class _Tp, class _Up> +# 2837 +struct is_swappable_with : public __is_swappable_with_impl< _Tp, _Up> ::type { +# 2840 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "first template argument must be a complete class or an unbounded array"); +# 2842 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Up> {})), "second template argument must be a complete class or an unbounded array"); +# 2844 +}; +# 2847 +template< class _Tp, class _Up> +# 2848 +struct is_nothrow_swappable_with : public __is_nothrow_swappable_with_impl< _Tp, _Up> ::type { +# 2851 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "first template argument must be a complete class or an unbounded array"); +# 2853 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Up> {})), "second template argument must be a complete class or an unbounded array"); +# 2855 +}; +# 2859 +template< class _Tp, class _Up> constexpr inline bool +# 2860 +is_swappable_with_v = (is_swappable_with< _Tp, _Up> ::value); +# 2864 +template< class _Tp, class _Up> constexpr inline bool +# 2865 +is_nothrow_swappable_with_v = (is_nothrow_swappable_with< _Tp, _Up> ::value); +# 2876 "/usr/include/c++/11/type_traits" 3 +template< class _Result, class _Ret, bool +# 2877 + = is_void< _Ret> ::value, class = void> +# 2878 +struct __is_invocable_impl : public false_type { +# 2881 +using __nothrow_type = false_type; +# 2882 +}; +# 2885 +template< class _Result, class _Ret> +# 2886 +struct __is_invocable_impl< _Result, _Ret, true, __void_t< typename _Result::type> > : public true_type { +# 2891 +using __nothrow_type = true_type; +# 2892 +}; +# 2894 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" +# 2897 +template< class _Result, class _Ret> +# 2898 +struct __is_invocable_impl< _Result, _Ret, false, __void_t< typename _Result::type> > { +# 2906 +private: static typename _Result::type _S_get() noexcept; +# 2908 +template< class _Tp> static void _S_conv(_Tp) noexcept; +# 2912 +template< class _Tp, bool _Check_Noex = false, class +# 2913 + = __decltype((_S_conv< _Tp> ((_S_get)()))), bool +# 2914 +_Noex = noexcept(_S_conv< _Tp> ((_S_get)()))> static __bool_constant< _Check_Noex ? _Noex : true> +# 2912 +_S_test(int); +# 2918 +template< class _Tp, bool = false> static false_type _S_test(...); +# 2924 +public: using type = __decltype((_S_test< _Ret> (1))); +# 2927 +using __nothrow_type = __decltype((_S_test< _Ret, true> (1))); +# 2928 +}; +#pragma GCC diagnostic pop +# 2931 +template< class _Fn, class ..._ArgTypes> +# 2932 +struct __is_invocable : public __is_invocable_impl< __invoke_result< _Fn, _ArgTypes...> , void> ::type { +# 2934 +}; +# 2936 +template< class _Fn, class _Tp, class ..._Args> constexpr bool +# 2937 +__call_is_nt(__invoke_memfun_ref) +# 2938 +{ +# 2939 +using _Up = typename __inv_unwrap< _Tp> ::type; +# 2940 +return noexcept((std::declval< typename __inv_unwrap< _Tp> ::type> ().*std::declval< _Fn> ())(std::declval< _Args> ()...)); +# 2942 +} +# 2944 +template< class _Fn, class _Tp, class ..._Args> constexpr bool +# 2945 +__call_is_nt(__invoke_memfun_deref) +# 2946 +{ +# 2947 +return noexcept(((*std::declval< _Tp> ()).*std::declval< _Fn> ())(std::declval< _Args> ()...)); +# 2949 +} +# 2951 +template< class _Fn, class _Tp> constexpr bool +# 2952 +__call_is_nt(__invoke_memobj_ref) +# 2953 +{ +# 2954 +using _Up = typename __inv_unwrap< _Tp> ::type; +# 2955 +return noexcept((std::declval< typename __inv_unwrap< _Tp> ::type> ().*std::declval< _Fn> ())); +# 2956 +} +# 2958 +template< class _Fn, class _Tp> constexpr bool +# 2959 +__call_is_nt(__invoke_memobj_deref) +# 2960 +{ +# 2961 +return noexcept(((*std::declval< _Tp> ()).*std::declval< _Fn> ())); +# 2962 +} +# 2964 +template< class _Fn, class ..._Args> constexpr bool +# 2965 +__call_is_nt(__invoke_other) +# 2966 +{ +# 2967 +return noexcept(std::declval< _Fn> ()(std::declval< _Args> ()...)); +# 2968 +} +# 2970 +template< class _Result, class _Fn, class ..._Args> +# 2971 +struct __call_is_nothrow : public __bool_constant< std::__call_is_nt< _Fn, _Args...> (typename _Result::__invoke_type{})> { +# 2975 +}; +# 2977 +template< class _Fn, class ..._Args> using __call_is_nothrow_ = __call_is_nothrow< __invoke_result< _Fn, _Args...> , _Fn, _Args...> ; +# 2982 +template< class _Fn, class ..._Args> +# 2983 +struct __is_nothrow_invocable : public __and_< __is_invocable< _Fn, _Args...> , __call_is_nothrow_< _Fn, _Args...> > ::type { +# 2986 +}; +# 2988 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" +struct __nonesuchbase { }; +# 2991 +struct __nonesuch : private __nonesuchbase { +# 2992 +~__nonesuch() = delete; +# 2993 +__nonesuch(const __nonesuch &) = delete; +# 2994 +void operator=(const __nonesuch &) = delete; +# 2995 +}; +#pragma GCC diagnostic pop +# 3003 +template< class _Functor, class ..._ArgTypes> +# 3004 +struct invoke_result : public __invoke_result< _Functor, _ArgTypes...> { +# 3007 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Functor> {})), "_Functor must be a complete class or an unbounded array"); +# 3009 +static_assert(((std::__is_complete_or_unbounded(__type_identity< _ArgTypes> {}) && ... )), "each argument type must be a complete class or an unbounded array"); +# 3012 +}; +# 3015 +template< class _Fn, class ..._Args> using invoke_result_t = typename invoke_result< _Fn, _Args...> ::type; +# 3019 +template< class _Fn, class ..._ArgTypes> +# 3020 +struct is_invocable : public __is_invocable_impl< __invoke_result< _Fn, _ArgTypes...> , void> ::type { +# 3023 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Fn> {})), "_Fn must be a complete class or an unbounded array"); +# 3025 +static_assert(((std::__is_complete_or_unbounded(__type_identity< _ArgTypes> {}) && ... )), "each argument type must be a complete class or an unbounded array"); +# 3028 +}; +# 3031 +template< class _Ret, class _Fn, class ..._ArgTypes> +# 3032 +struct is_invocable_r : public __is_invocable_impl< __invoke_result< _Fn, _ArgTypes...> , _Ret> ::type { +# 3035 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Fn> {})), "_Fn must be a complete class or an unbounded array"); +# 3037 +static_assert(((std::__is_complete_or_unbounded(__type_identity< _ArgTypes> {}) && ... )), "each argument type must be a complete class or an unbounded array"); +# 3040 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Ret> {})), "_Ret must be a complete class or an unbounded array"); +# 3042 +}; +# 3045 +template< class _Fn, class ..._ArgTypes> +# 3046 +struct is_nothrow_invocable : public __and_< __is_invocable_impl< __invoke_result< _Fn, _ArgTypes...> , void> , __call_is_nothrow_< _Fn, _ArgTypes...> > ::type { +# 3050 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Fn> {})), "_Fn must be a complete class or an unbounded array"); +# 3052 +static_assert(((std::__is_complete_or_unbounded(__type_identity< _ArgTypes> {}) && ... )), "each argument type must be a complete class or an unbounded array"); +# 3055 +}; +# 3058 +template< class _Result, class _Ret> using __is_nt_invocable_impl = typename __is_invocable_impl< _Result, _Ret> ::__nothrow_type; +# 3064 +template< class _Ret, class _Fn, class ..._ArgTypes> +# 3065 +struct is_nothrow_invocable_r : public __and_< __is_nt_invocable_impl< __invoke_result< _Fn, _ArgTypes...> , _Ret> , __call_is_nothrow_< _Fn, _ArgTypes...> > ::type { +# 3069 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Fn> {})), "_Fn must be a complete class or an unbounded array"); +# 3071 +static_assert(((std::__is_complete_or_unbounded(__type_identity< _ArgTypes> {}) && ... )), "each argument type must be a complete class or an unbounded array"); +# 3074 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Ret> {})), "_Ret must be a complete class or an unbounded array"); +# 3076 +}; +# 3094 "/usr/include/c++/11/type_traits" 3 +template< class _Tp> constexpr inline bool +# 3095 +is_void_v = (is_void< _Tp> ::value); +# 3096 +template< class _Tp> constexpr inline bool +# 3097 +is_null_pointer_v = (is_null_pointer< _Tp> ::value); +# 3098 +template< class _Tp> constexpr inline bool +# 3099 +is_integral_v = (is_integral< _Tp> ::value); +# 3100 +template< class _Tp> constexpr inline bool +# 3101 +is_floating_point_v = (is_floating_point< _Tp> ::value); +# 3102 +template< class _Tp> constexpr inline bool +# 3103 +is_array_v = (is_array< _Tp> ::value); +# 3104 +template< class _Tp> constexpr inline bool +# 3105 +is_pointer_v = (is_pointer< _Tp> ::value); +# 3106 +template< class _Tp> constexpr inline bool +# 3107 +is_lvalue_reference_v = (is_lvalue_reference< _Tp> ::value); +# 3109 +template< class _Tp> constexpr inline bool +# 3110 +is_rvalue_reference_v = (is_rvalue_reference< _Tp> ::value); +# 3112 +template< class _Tp> constexpr inline bool +# 3113 +is_member_object_pointer_v = (is_member_object_pointer< _Tp> ::value); +# 3115 +template< class _Tp> constexpr inline bool +# 3116 +is_member_function_pointer_v = (is_member_function_pointer< _Tp> ::value); +# 3118 +template< class _Tp> constexpr inline bool +# 3119 +is_enum_v = (is_enum< _Tp> ::value); +# 3120 +template< class _Tp> constexpr inline bool +# 3121 +is_union_v = (is_union< _Tp> ::value); +# 3122 +template< class _Tp> constexpr inline bool +# 3123 +is_class_v = (is_class< _Tp> ::value); +# 3124 +template< class _Tp> constexpr inline bool +# 3125 +is_function_v = (is_function< _Tp> ::value); +# 3126 +template< class _Tp> constexpr inline bool +# 3127 +is_reference_v = (is_reference< _Tp> ::value); +# 3128 +template< class _Tp> constexpr inline bool +# 3129 +is_arithmetic_v = (is_arithmetic< _Tp> ::value); +# 3130 +template< class _Tp> constexpr inline bool +# 3131 +is_fundamental_v = (is_fundamental< _Tp> ::value); +# 3132 +template< class _Tp> constexpr inline bool +# 3133 +is_object_v = (is_object< _Tp> ::value); +# 3134 +template< class _Tp> constexpr inline bool +# 3135 +is_scalar_v = (is_scalar< _Tp> ::value); +# 3136 +template< class _Tp> constexpr inline bool +# 3137 +is_compound_v = (is_compound< _Tp> ::value); +# 3138 +template< class _Tp> constexpr inline bool +# 3139 +is_member_pointer_v = (is_member_pointer< _Tp> ::value); +# 3140 +template< class _Tp> constexpr inline bool +# 3141 +is_const_v = (is_const< _Tp> ::value); +# 3142 +template< class _Tp> constexpr inline bool +# 3143 +is_volatile_v = (is_volatile< _Tp> ::value); +# 3144 +template< class _Tp> constexpr inline bool +# 3145 +is_trivial_v = (is_trivial< _Tp> ::value); +# 3146 +template< class _Tp> constexpr inline bool +# 3147 +is_trivially_copyable_v = (is_trivially_copyable< _Tp> ::value); +# 3149 +template< class _Tp> constexpr inline bool +# 3150 +is_standard_layout_v = (is_standard_layout< _Tp> ::value); +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +template< class _Tp> constexpr inline bool +# 3155 +is_pod_v = (is_pod< _Tp> ::value); +# 3156 +template< class _Tp> +# 3157 +[[__deprecated__]] constexpr inline bool +# 3158 +is_literal_type_v = (is_literal_type< _Tp> ::value); +#pragma GCC diagnostic pop +template< class _Tp> constexpr inline bool +# 3161 +is_empty_v = (is_empty< _Tp> ::value); +# 3162 +template< class _Tp> constexpr inline bool +# 3163 +is_polymorphic_v = (is_polymorphic< _Tp> ::value); +# 3164 +template< class _Tp> constexpr inline bool +# 3165 +is_abstract_v = (is_abstract< _Tp> ::value); +# 3166 +template< class _Tp> constexpr inline bool +# 3167 +is_final_v = (is_final< _Tp> ::value); +# 3168 +template< class _Tp> constexpr inline bool +# 3169 +is_signed_v = (is_signed< _Tp> ::value); +# 3170 +template< class _Tp> constexpr inline bool +# 3171 +is_unsigned_v = (is_unsigned< _Tp> ::value); +# 3172 +template< class _Tp, class ..._Args> constexpr inline bool +# 3173 +is_constructible_v = (is_constructible< _Tp, _Args...> ::value); +# 3175 +template< class _Tp> constexpr inline bool +# 3176 +is_default_constructible_v = (is_default_constructible< _Tp> ::value); +# 3178 +template< class _Tp> constexpr inline bool +# 3179 +is_copy_constructible_v = (is_copy_constructible< _Tp> ::value); +# 3181 +template< class _Tp> constexpr inline bool +# 3182 +is_move_constructible_v = (is_move_constructible< _Tp> ::value); +# 3184 +template< class _Tp, class _Up> constexpr inline bool +# 3185 +is_assignable_v = (is_assignable< _Tp, _Up> ::value); +# 3186 +template< class _Tp> constexpr inline bool +# 3187 +is_copy_assignable_v = (is_copy_assignable< _Tp> ::value); +# 3188 +template< class _Tp> constexpr inline bool +# 3189 +is_move_assignable_v = (is_move_assignable< _Tp> ::value); +# 3190 +template< class _Tp> constexpr inline bool +# 3191 +is_destructible_v = (is_destructible< _Tp> ::value); +# 3192 +template< class _Tp, class ..._Args> constexpr inline bool +# 3193 +is_trivially_constructible_v = (is_trivially_constructible< _Tp, _Args...> ::value); +# 3195 +template< class _Tp> constexpr inline bool +# 3196 +is_trivially_default_constructible_v = (is_trivially_default_constructible< _Tp> ::value); +# 3198 +template< class _Tp> constexpr inline bool +# 3199 +is_trivially_copy_constructible_v = (is_trivially_copy_constructible< _Tp> ::value); +# 3201 +template< class _Tp> constexpr inline bool +# 3202 +is_trivially_move_constructible_v = (is_trivially_move_constructible< _Tp> ::value); +# 3204 +template< class _Tp, class _Up> constexpr inline bool +# 3205 +is_trivially_assignable_v = (is_trivially_assignable< _Tp, _Up> ::value); +# 3207 +template< class _Tp> constexpr inline bool +# 3208 +is_trivially_copy_assignable_v = (is_trivially_copy_assignable< _Tp> ::value); +# 3210 +template< class _Tp> constexpr inline bool +# 3211 +is_trivially_move_assignable_v = (is_trivially_move_assignable< _Tp> ::value); +# 3213 +template< class _Tp> constexpr inline bool +# 3214 +is_trivially_destructible_v = (is_trivially_destructible< _Tp> ::value); +# 3216 +template< class _Tp, class ..._Args> constexpr inline bool +# 3217 +is_nothrow_constructible_v = (is_nothrow_constructible< _Tp, _Args...> ::value); +# 3219 +template< class _Tp> constexpr inline bool +# 3220 +is_nothrow_default_constructible_v = (is_nothrow_default_constructible< _Tp> ::value); +# 3222 +template< class _Tp> constexpr inline bool +# 3223 +is_nothrow_copy_constructible_v = (is_nothrow_copy_constructible< _Tp> ::value); +# 3225 +template< class _Tp> constexpr inline bool +# 3226 +is_nothrow_move_constructible_v = (is_nothrow_move_constructible< _Tp> ::value); +# 3228 +template< class _Tp, class _Up> constexpr inline bool +# 3229 +is_nothrow_assignable_v = (is_nothrow_assignable< _Tp, _Up> ::value); +# 3231 +template< class _Tp> constexpr inline bool +# 3232 +is_nothrow_copy_assignable_v = (is_nothrow_copy_assignable< _Tp> ::value); +# 3234 +template< class _Tp> constexpr inline bool +# 3235 +is_nothrow_move_assignable_v = (is_nothrow_move_assignable< _Tp> ::value); +# 3237 +template< class _Tp> constexpr inline bool +# 3238 +is_nothrow_destructible_v = (is_nothrow_destructible< _Tp> ::value); +# 3240 +template< class _Tp> constexpr inline bool +# 3241 +has_virtual_destructor_v = (has_virtual_destructor< _Tp> ::value); +# 3243 +template< class _Tp> constexpr inline size_t +# 3244 +alignment_of_v = (alignment_of< _Tp> ::value); +# 3245 +template< class _Tp> constexpr inline size_t +# 3246 +rank_v = (rank< _Tp> ::value); +# 3247 +template< class _Tp, unsigned _Idx = 0U> constexpr inline size_t +# 3248 +extent_v = (extent< _Tp, _Idx> ::value); +# 3250 +template< class _Tp, class _Up> constexpr inline bool +# 3251 +is_same_v = __is_same(_Tp, _Up); +# 3256 +template< class _Base, class _Derived> constexpr inline bool +# 3257 +is_base_of_v = (is_base_of< _Base, _Derived> ::value); +# 3258 +template< class _From, class _To> constexpr inline bool +# 3259 +is_convertible_v = (is_convertible< _From, _To> ::value); +# 3260 +template< class _Fn, class ..._Args> constexpr inline bool +# 3261 +is_invocable_v = (is_invocable< _Fn, _Args...> ::value); +# 3262 +template< class _Fn, class ..._Args> constexpr inline bool +# 3263 +is_nothrow_invocable_v = (is_nothrow_invocable< _Fn, _Args...> ::value); +# 3265 +template< class _Ret, class _Fn, class ..._Args> constexpr inline bool +# 3266 +is_invocable_r_v = (is_invocable_r< _Ret, _Fn, _Args...> ::value); +# 3268 +template< class _Ret, class _Fn, class ..._Args> constexpr inline bool +# 3269 +is_nothrow_invocable_r_v = (is_nothrow_invocable_r< _Ret, _Fn, _Args...> ::value); +# 3276 +template< class _Tp> +# 3277 +struct has_unique_object_representations : public bool_constant< __has_unique_object_representations(remove_cv_t< remove_all_extents_t< _Tp> > )> { +# 3282 +static_assert((std::__is_complete_or_unbounded(__type_identity< _Tp> {})), "template argument must be a complete class or an unbounded array"); +# 3284 +}; +# 3287 +template< class _Tp> constexpr inline bool +# 3288 +has_unique_object_representations_v = (has_unique_object_representations< _Tp> ::value); +# 3295 +template< class _Tp> +# 3296 +struct is_aggregate : public bool_constant< __is_aggregate(remove_cv_t< _Tp> )> { +# 3298 +}; +# 3301 +template< class _Tp> constexpr inline bool +# 3302 +is_aggregate_v = (is_aggregate< _Tp> ::value); +# 3599 "/usr/include/c++/11/type_traits" 3 +} +# 59 "/usr/include/c++/11/bits/move.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 74 "/usr/include/c++/11/bits/move.h" 3 +template< class _Tp> +# 75 +[[__nodiscard__]] constexpr _Tp && +# 77 +forward(typename remove_reference< _Tp> ::type &__t) noexcept +# 78 +{ return static_cast< _Tp &&>(__t); } +# 86 +template< class _Tp> +# 87 +[[__nodiscard__]] constexpr _Tp && +# 89 +forward(typename remove_reference< _Tp> ::type &&__t) noexcept +# 90 +{ +# 91 +static_assert((!std::template is_lvalue_reference< _Tp> ::value), "std::forward must not be used to convert an rvalue to an lvalue"); +# 93 +return static_cast< _Tp &&>(__t); +# 94 +} +# 101 +template< class _Tp> +# 102 +[[__nodiscard__]] constexpr typename remove_reference< _Tp> ::type && +# 104 +move(_Tp &&__t) noexcept +# 105 +{ return static_cast< typename remove_reference< _Tp> ::type &&>(__t); } +# 108 +template< class _Tp> +# 109 +struct __move_if_noexcept_cond : public __and_< __not_< is_nothrow_move_constructible< _Tp> > , is_copy_constructible< _Tp> > ::type { +# 111 +}; +# 121 "/usr/include/c++/11/bits/move.h" 3 +template< class _Tp> +# 122 +[[__nodiscard__]] constexpr typename conditional< __move_if_noexcept_cond< _Tp> ::value, const _Tp &, _Tp &&> ::type +# 125 +move_if_noexcept(_Tp &__x) noexcept +# 126 +{ return std::move(__x); } +# 142 "/usr/include/c++/11/bits/move.h" 3 +template< class _Tp> +# 143 +[[__nodiscard__]] constexpr _Tp * +# 145 +addressof(_Tp &__r) noexcept +# 146 +{ return std::__addressof(__r); } +# 150 +template < typename _Tp > + const _Tp * addressof ( const _Tp && ) = delete; +# 154 +template< class _Tp, class _Up = _Tp> inline _Tp +# 157 +__exchange(_Tp &__obj, _Up &&__new_val) +# 158 +{ +# 159 +_Tp __old_val = std::move(__obj); +# 160 +__obj = std::forward< _Up> (__new_val); +# 161 +return __old_val; +# 162 +} +# 186 "/usr/include/c++/11/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 +# 196 +swap(_Tp &__a, _Tp &__b) noexcept(__and_< is_nothrow_move_constructible< _Tp> , is_nothrow_move_assignable< _Tp> > ::value) +# 199 +{ +# 204 +_Tp __tmp = std::move(__a); +# 205 +__a = std::move(__b); +# 206 +__b = std::move(__tmp); +# 207 +} +# 212 +template< class _Tp, size_t _Nm> inline typename enable_if< __is_swappable< _Tp> ::value> ::type +# 220 +swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) noexcept(__is_nothrow_swappable< _Tp> ::value) +# 222 +{ +# 223 +for (size_t __n = (0); __n < _Nm; ++__n) { +# 224 +swap(__a[__n], __b[__n]); } +# 225 +} +# 229 +} +# 69 "/usr/include/c++/11/bits/stl_pair.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 80 "/usr/include/c++/11/bits/stl_pair.h" 3 +struct piecewise_construct_t { explicit piecewise_construct_t() = default;}; +# 83 +constexpr inline piecewise_construct_t piecewise_construct = piecewise_construct_t(); +# 89 +template< class ...> class tuple; +# 92 +template< size_t ...> struct _Index_tuple; +# 100 +template< bool , class _T1, class _T2> +# 101 +struct _PCC { +# 103 +template< class _U1, class _U2> static constexpr bool +# 104 +_ConstructiblePair() +# 105 +{ +# 106 +return __and_< is_constructible< _T1, const _U1 &> , is_constructible< _T2, const _U2 &> > ::value; +# 108 +} +# 110 +template< class _U1, class _U2> static constexpr bool +# 111 +_ImplicitlyConvertiblePair() +# 112 +{ +# 113 +return __and_< is_convertible< const _U1 &, _T1> , is_convertible< const _U2 &, _T2> > ::value; +# 115 +} +# 117 +template< class _U1, class _U2> static constexpr bool +# 118 +_MoveConstructiblePair() +# 119 +{ +# 120 +return __and_< is_constructible< _T1, _U1 &&> , is_constructible< _T2, _U2 &&> > ::value; +# 122 +} +# 124 +template< class _U1, class _U2> static constexpr bool +# 125 +_ImplicitlyMoveConvertiblePair() +# 126 +{ +# 127 +return __and_< is_convertible< _U1 &&, _T1> , is_convertible< _U2 &&, _T2> > ::value; +# 129 +} +# 131 +template< bool __implicit, class _U1, class _U2> static constexpr bool +# 132 +_CopyMovePair() +# 133 +{ +# 134 +using __do_converts = __and_< is_convertible< const _U1 &, _T1> , is_convertible< _U2 &&, _T2> > ; +# 136 +using __converts = typename conditional< __implicit, __and_< is_convertible< const _U1 &, _T1> , is_convertible< _U2 &&, _T2> > , __not_< __and_< is_convertible< const _U1 &, _T1> , is_convertible< _U2 &&, _T2> > > > ::type; +# 139 +return __and_< is_constructible< _T1, const _U1 &> , is_constructible< _T2, _U2 &&> , typename conditional< __implicit, __and_< is_convertible< const _U1 &, _T1> , is_convertible< _U2 &&, _T2> > , __not_< __and_< is_convertible< const _U1 &, _T1> , is_convertible< _U2 &&, _T2> > > > ::type> ::value; +# 143 +} +# 145 +template< bool __implicit, class _U1, class _U2> static constexpr bool +# 146 +_MoveCopyPair() +# 147 +{ +# 148 +using __do_converts = __and_< is_convertible< _U1 &&, _T1> , is_convertible< const _U2 &, _T2> > ; +# 150 +using __converts = typename conditional< __implicit, __and_< is_convertible< _U1 &&, _T1> , is_convertible< const _U2 &, _T2> > , __not_< __and_< is_convertible< _U1 &&, _T1> , is_convertible< const _U2 &, _T2> > > > ::type; +# 153 +return __and_< is_constructible< _T1, _U1 &&> , is_constructible< _T2, const _U2 &&> , typename conditional< __implicit, __and_< is_convertible< _U1 &&, _T1> , is_convertible< const _U2 &, _T2> > , __not_< __and_< is_convertible< _U1 &&, _T1> , is_convertible< const _U2 &, _T2> > > > ::type> ::value; +# 157 +} +# 158 +}; +# 160 +template< class _T1, class _T2> +# 161 +struct _PCC< false, _T1, _T2> { +# 163 +template< class _U1, class _U2> static constexpr bool +# 164 +_ConstructiblePair() +# 165 +{ +# 166 +return false; +# 167 +} +# 169 +template< class _U1, class _U2> static constexpr bool +# 170 +_ImplicitlyConvertiblePair() +# 171 +{ +# 172 +return false; +# 173 +} +# 175 +template< class _U1, class _U2> static constexpr bool +# 176 +_MoveConstructiblePair() +# 177 +{ +# 178 +return false; +# 179 +} +# 181 +template< class _U1, class _U2> static constexpr bool +# 182 +_ImplicitlyMoveConvertiblePair() +# 183 +{ +# 184 +return false; +# 185 +} +# 186 +}; +# 189 +template< class _U1, class _U2> class __pair_base { +# 192 +template< class _T1, class _T2> friend struct pair; +# 193 +__pair_base() = default; +# 194 +~__pair_base() = default; +# 195 +__pair_base(const __pair_base &) = default; +# 196 +__pair_base &operator=(const __pair_base &) = delete; +# 198 +}; +# 210 "/usr/include/c++/11/bits/stl_pair.h" 3 +template< class _T1, class _T2> +# 211 +struct pair : private __pair_base< _T1, _T2> { +# 214 +typedef _T1 first_type; +# 215 +typedef _T2 second_type; +# 217 +_T1 first; +# 218 +_T2 second; +# 225 +template< class _U1 = _T1, class +# 226 +_U2 = _T2, typename enable_if< __and_< __is_implicitly_default_constructible< _U1> , __is_implicitly_default_constructible< _U2> > ::value, bool> ::type +# 230 + = true> constexpr +# 232 +pair() : first(), second() +# 233 +{ } +# 236 +template< class _U1 = _T1, class +# 237 +_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 +# 244 + = false> constexpr explicit +# 245 +pair() : first(), second() +# 246 +{ } +# 256 "/usr/include/c++/11/bits/stl_pair.h" 3 +using _PCCP = _PCC< true, _T1, _T2> ; +# 260 +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 +# 265 + = true> constexpr +# 266 +pair(const _T1 &__a, const _T2 &__b) : first(__a), second(__b) +# 267 +{ } +# 270 +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 +# 275 + = false> constexpr explicit +# 276 +pair(const _T1 &__a, const _T2 &__b) : first(__a), second(__b) +# 277 +{ } +# 288 "/usr/include/c++/11/bits/stl_pair.h" 3 +template< class _U1, class _U2> using _PCCFP = _PCC< (!is_same< _T1, _U1> ::value) || (!is_same< _T2, _U2> ::value), _T1, _T2> ; +# 294 +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 +# 299 + = true> constexpr +# 300 +pair(const pair< _U1, _U2> &__p) : first((__p.first)), second((__p.second)) +# 301 +{ } +# 303 +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 +# 308 + = false> constexpr explicit +# 309 +pair(const pair< _U1, _U2> &__p) : first((__p.first)), second((__p.second)) +# 310 +{ } +# 314 +constexpr pair(const pair &) = default; +# 315 +constexpr pair(pair &&) = default; +# 318 +template< class _U1, typename enable_if< _PCC< true, _T1, _T2> ::template _MoveCopyPair< true, _U1, _T2> (), bool> ::type +# 321 + = true> constexpr +# 322 +pair(_U1 &&__x, const _T2 &__y) : first(std::forward< _U1> (__x)), second(__y) +# 323 +{ } +# 325 +template< class _U1, typename enable_if< _PCC< true, _T1, _T2> ::template _MoveCopyPair< false, _U1, _T2> (), bool> ::type +# 328 + = false> constexpr explicit +# 329 +pair(_U1 &&__x, const _T2 &__y) : first(std::forward< _U1> (__x)), second(__y) +# 330 +{ } +# 332 +template< class _U2, typename enable_if< _PCC< true, _T1, _T2> ::template _CopyMovePair< true, _T1, _U2> (), bool> ::type +# 335 + = true> constexpr +# 336 +pair(const _T1 &__x, _U2 &&__y) : first(__x), second(std::forward< _U2> (__y)) +# 337 +{ } +# 339 +template< class _U2, typename enable_if< _PCC< true, _T1, _T2> ::template _CopyMovePair< false, _T1, _U2> (), bool> ::type +# 342 + = false> explicit +# 343 +pair(const _T1 &__x, _U2 &&__y) : first(__x), second(std::forward< _U2> (__y)) +# 344 +{ } +# 346 +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 +# 351 + = true> constexpr +# 352 +pair(_U1 &&__x, _U2 &&__y) : first(std::forward< _U1> (__x)), second(std::forward< _U2> (__y)) +# 353 +{ } +# 355 +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 +# 360 + = false> constexpr explicit +# 361 +pair(_U1 &&__x, _U2 &&__y) : first(std::forward< _U1> (__x)), second(std::forward< _U2> (__y)) +# 362 +{ } +# 365 +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 +# 370 + = true> constexpr +# 371 +pair(pair< _U1, _U2> &&__p) : first(std::forward< _U1> ((__p.first))), second(std::forward< _U2> ((__p.second))) +# 373 +{ } +# 375 +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 +# 380 + = false> constexpr explicit +# 381 +pair(pair< _U1, _U2> &&__p) : first(std::forward< _U1> ((__p.first))), second(std::forward< _U2> ((__p.second))) +# 383 +{ } +# 385 +template< class ..._Args1, class ..._Args2> pair(std::piecewise_construct_t, tuple< _Args1...> , tuple< _Args2...> ); +# 390 +pair &operator=(typename conditional< __and_< is_copy_assignable< _T1> , is_copy_assignable< _T2> > ::value, const pair &, const std::__nonesuch &> ::type +# 393 +__p) +# 394 +{ +# 395 +(first) = (__p.first); +# 396 +(second) = (__p.second); +# 397 +return *this; +# 398 +} +# 401 +pair &operator=(typename conditional< __and_< is_move_assignable< _T1> , is_move_assignable< _T2> > ::value, pair &&, std::__nonesuch &&> ::type +# 404 +__p) noexcept(__and_< is_nothrow_move_assignable< _T1> , is_nothrow_move_assignable< _T2> > ::value) +# 407 +{ +# 408 +(first) = std::forward< first_type> ((__p.first)); +# 409 +(second) = std::forward< second_type> ((__p.second)); +# 410 +return *this; +# 411 +} +# 413 +template< class _U1, class _U2> typename enable_if< __and_< is_assignable< _T1 &, const _U1 &> , is_assignable< _T2 &, const _U2 &> > ::value, pair &> ::type +# 418 +operator=(const pair< _U1, _U2> &__p) +# 419 +{ +# 420 +(first) = (__p.first); +# 421 +(second) = (__p.second); +# 422 +return *this; +# 423 +} +# 425 +template< class _U1, class _U2> typename enable_if< __and_< is_assignable< _T1 &, _U1 &&> , is_assignable< _T2 &, _U2 &&> > ::value, pair &> ::type +# 430 +operator=(pair< _U1, _U2> &&__p) +# 431 +{ +# 432 +(first) = std::forward< _U1> ((__p.first)); +# 433 +(second) = std::forward< _U2> ((__p.second)); +# 434 +return *this; +# 435 +} +# 439 +void swap(pair &__p) noexcept(__and_< __is_nothrow_swappable< _T1> , __is_nothrow_swappable< _T2> > ::value) +# 442 +{ +# 443 +using std::swap; +# 444 +swap(first, __p.first); +# 445 +swap(second, __p.second); +# 446 +} +# 449 +private: template< class ..._Args1, std::size_t ..._Indexes1, class ... +# 450 +_Args2, std::size_t ..._Indexes2> +# 449 +pair(tuple< _Args1...> &, tuple< _Args2...> &, _Index_tuple< _Indexes1...> , _Index_tuple< _Indexes2...> ); +# 455 +}; +# 460 +template< class _T1, class _T2> pair(_T1, _T2)->pair< _T1, _T2> ; +# 464 +template< class _T1, class _T2> constexpr bool +# 466 +operator==(const pair< _T1, _T2> &__x, const pair< _T1, _T2> &__y) +# 467 +{ return ((__x.first) == (__y.first)) && ((__x.second) == (__y.second)); } +# 487 "/usr/include/c++/11/bits/stl_pair.h" 3 +template< class _T1, class _T2> constexpr bool +# 489 +operator<(const pair< _T1, _T2> &__x, const pair< _T1, _T2> &__y) +# 490 +{ return ((__x.first) < (__y.first)) || ((!((__y.first) < (__x.first))) && ((__x.second) < (__y.second))); +# 491 +} +# 494 +template< class _T1, class _T2> constexpr bool +# 496 +operator!=(const pair< _T1, _T2> &__x, const pair< _T1, _T2> &__y) +# 497 +{ return !(__x == __y); } +# 500 +template< class _T1, class _T2> constexpr bool +# 502 +operator>(const pair< _T1, _T2> &__x, const pair< _T1, _T2> &__y) +# 503 +{ return __y < __x; } +# 506 +template< class _T1, class _T2> constexpr bool +# 508 +operator<=(const pair< _T1, _T2> &__x, const pair< _T1, _T2> &__y) +# 509 +{ return !(__y < __x); } +# 512 +template< class _T1, class _T2> constexpr bool +# 514 +operator>=(const pair< _T1, _T2> &__x, const pair< _T1, _T2> &__y) +# 515 +{ return !(__x < __y); } +# 524 "/usr/include/c++/11/bits/stl_pair.h" 3 +template< class _T1, class _T2> inline typename enable_if< __and_< __is_swappable< _T1> , __is_swappable< _T2> > ::value> ::type +# 533 +swap(pair< _T1, _T2> &__x, pair< _T1, _T2> &__y) noexcept(noexcept(__x.swap(__y))) +# 535 +{ __x.swap(__y); } +# 538 +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; +# 564 "/usr/include/c++/11/bits/stl_pair.h" 3 +template< class _T1, class _T2> constexpr pair< typename __decay_and_strip< _T1> ::__type, typename __decay_and_strip< _T2> ::__type> +# 567 +make_pair(_T1 &&__x, _T2 &&__y) +# 568 +{ +# 569 +typedef typename __decay_and_strip< _T1> ::__type __ds_type1; +# 570 +typedef typename __decay_and_strip< _T2> ::__type __ds_type2; +# 571 +typedef pair< typename __decay_and_strip< _T1> ::__type, typename __decay_and_strip< _T2> ::__type> __pair_type; +# 572 +return __pair_type(std::forward< _T1> (__x), std::forward< _T2> (__y)); +# 573 +} +# 584 "/usr/include/c++/11/bits/stl_pair.h" 3 +} +# 74 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 93 "/usr/include/c++/11/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/include/c++/11/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 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/include/c++/11/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/include/c++/11/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> constexpr typename iterator_traits< _Iter> ::iterator_category +# 238 +__iterator_category(const _Iter &) +# 239 +{ return typename iterator_traits< _Iter> ::iterator_category(); } +# 244 +template< class _Iter> using __iterator_category_t = typename iterator_traits< _Iter> ::iterator_category; +# 248 +template< class _InIter> using _RequireInputIter = __enable_if_t< is_convertible< __iterator_category_t< _InIter> , input_iterator_tag> ::value> ; +# 253 +template< class _It, class +# 254 +_Cat = __iterator_category_t< _It> > +# 255 +struct __is_random_access_iter : public is_base_of< random_access_iterator_tag, _Cat> { +# 258 +typedef is_base_of< std::random_access_iterator_tag, _Cat> _Base; +# 259 +enum { __value = is_base_of< std::random_access_iterator_tag, _Cat> ::value}; +# 260 +}; +# 269 +} +# 67 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 73 +template< class > struct _List_iterator; +# 74 +template< class > struct _List_const_iterator; +# 77 +template< class _InputIterator> constexpr typename iterator_traits< _InputIterator> ::difference_type +# 80 +__distance(_InputIterator __first, _InputIterator __last, input_iterator_tag) +# 82 +{ +# 86 +typename iterator_traits< _InputIterator> ::difference_type __n = (0); +# 87 +while (__first != __last) +# 88 +{ +# 89 +++__first; +# 90 +++__n; +# 91 +} +# 92 +return __n; +# 93 +} +# 95 +template< class _RandomAccessIterator> constexpr typename iterator_traits< _RandomAccessIterator> ::difference_type +# 98 +__distance(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag) +# 100 +{ +# 104 +return __last - __first; +# 105 +} +# 109 +template< class _Tp> ptrdiff_t __distance(_List_iterator< _Tp> , _List_iterator< _Tp> , input_iterator_tag); +# 115 +template< class _Tp> ptrdiff_t __distance(_List_const_iterator< _Tp> , _List_const_iterator< _Tp> , input_iterator_tag); +# 135 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 3 +template< class _InputIterator> constexpr typename iterator_traits< _InputIterator> ::difference_type +# 138 +distance(_InputIterator __first, _InputIterator __last) +# 139 +{ +# 141 +return std::__distance(__first, __last, std::__iterator_category(__first)); +# 143 +} +# 145 +template< class _InputIterator, class _Distance> constexpr void +# 147 +__advance(_InputIterator &__i, _Distance __n, input_iterator_tag) +# 148 +{ +# 151 +do { if (__builtin_is_constant_evaluated() && (!((bool)(__n >= 0)))) { __builtin_unreachable(); } } while (false); +# 152 +while (__n--) { +# 153 +++__i; } +# 154 +} +# 156 +template< class _BidirectionalIterator, class _Distance> constexpr void +# 158 +__advance(_BidirectionalIterator &__i, _Distance __n, bidirectional_iterator_tag) +# 160 +{ +# 164 +if (__n > 0) { +# 165 +while (__n--) { +# 166 +++__i; } } else { +# 168 +while (__n++) { +# 169 +--__i; } } +# 170 +} +# 172 +template< class _RandomAccessIterator, class _Distance> constexpr void +# 174 +__advance(_RandomAccessIterator &__i, _Distance __n, random_access_iterator_tag) +# 176 +{ +# 180 +if (__builtin_constant_p(__n) && (__n == 1)) { +# 181 +++__i; } else { +# 182 +if (__builtin_constant_p(__n) && (__n == (-1))) { +# 183 +--__i; } else { +# 185 +__i += __n; } } +# 186 +} +# 200 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 3 +template< class _InputIterator, class _Distance> constexpr void +# 202 +advance(_InputIterator &__i, _Distance __n) +# 203 +{ +# 205 +typename iterator_traits< _InputIterator> ::difference_type __d = __n; +# 206 +std::__advance(__i, __d, std::__iterator_category(__i)); +# 207 +} +# 211 +template< class _InputIterator> constexpr _InputIterator +# 213 +next(_InputIterator __x, typename iterator_traits< _InputIterator> ::difference_type +# 214 +__n = 1) +# 215 +{ +# 218 +std::advance(__x, __n); +# 219 +return __x; +# 220 +} +# 222 +template< class _BidirectionalIterator> constexpr _BidirectionalIterator +# 224 +prev(_BidirectionalIterator __x, typename iterator_traits< _BidirectionalIterator> ::difference_type +# 225 +__n = 1) +# 226 +{ +# 230 +std::advance(__x, -__n); +# 231 +return __x; +# 232 +} +# 237 +} +# 42 "/usr/include/c++/11/bits/ptr_traits.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 46 +class __undefined; +# 49 +template< class _Tp, class _Up> +# 50 +struct __replace_first_arg { +# 51 +}; +# 53 +template< template< class , class ...> class _Template, class _Up, class +# 54 +_Tp, class ..._Types> +# 55 +struct __replace_first_arg< _Template< _Tp, _Types...> , _Up> { +# 56 +using type = _Template< _Up, _Types...> ; }; +# 58 +template< class _Tp, class _Up> using __replace_first_arg_t = typename __replace_first_arg< _Tp, _Up> ::type; +# 61 +template< class _Tp> using __make_not_void = typename conditional< is_void< _Tp> ::value, __undefined, _Tp> ::type; +# 65 +template< class _Ptr> +# 66 +struct __ptr_traits_elem_1 { +# 67 +}; +# 69 +template< template< class , class ...> class _SomePointer, class _Tp, class ... +# 70 +_Args> +# 71 +struct __ptr_traits_elem_1< _SomePointer< _Tp, _Args...> > { +# 73 +using element_type = _Tp; +# 74 +using pointer = _SomePointer< _Tp, _Args...> ; +# 77 +static pointer pointer_to(__make_not_void< element_type> &__e) +# 78 +{ return pointer::pointer_to(__e); } +# 79 +}; +# 81 +template< class _Ptr, class = void> +# 82 +struct __ptr_traits_elem : public __ptr_traits_elem_1< _Ptr> { +# 83 +}; +# 85 +template< class _Ptr> +# 86 +struct __ptr_traits_elem< _Ptr, __void_t< typename _Ptr::element_type> > { +# 88 +using element_type = typename _Ptr::element_type; +# 91 +static _Ptr pointer_to(__make_not_void< element_type> &__e) +# 92 +{ return _Ptr::pointer_to(__e); } +# 93 +}; +# 99 +template< class _Ptr> +# 100 +struct pointer_traits : public __ptr_traits_elem< _Ptr> { +# 104 +private: +# 103 +template< class _Tp> using __difference_type = typename _Tp::difference_type; +# 106 +template< class _Tp, class _Up, class = void> +# 107 +struct __rebind : public __replace_first_arg< _Tp, _Up> { }; +# 109 +template< class _Tp, class _Up> +# 110 +struct __rebind< _Tp, _Up, std::__void_t< typename _Tp::template rebind< _Up> > > { +# 111 +using type = typename _Tp::template rebind< _Up> ; }; +# 115 +public: using pointer = _Ptr; +# 118 +using difference_type = std::__detected_or_t< std::ptrdiff_t, __difference_type, _Ptr> ; +# 122 +template< class _Up> using rebind = typename __rebind< _Ptr, _Up> ::type; +# 124 +}; +# 130 +template< class _Tp> +# 131 +struct pointer_traits< _Tp *> { +# 134 +typedef _Tp *pointer; +# 136 +typedef _Tp element_type; +# 138 +typedef ptrdiff_t difference_type; +# 140 +template< class _Up> using rebind = _Up *; +# 149 +static pointer pointer_to(__make_not_void< element_type> &__r) noexcept +# 150 +{ return std::addressof(__r); } +# 151 +}; +# 154 +template< class _Ptr, class _Tp> using __ptr_rebind = typename pointer_traits< _Ptr> ::template rebind< _Tp> ; +# 157 +template< class _Tp> constexpr _Tp * +# 159 +__to_address(_Tp *__ptr) noexcept +# 160 +{ +# 161 +static_assert((!std::template is_function< _Tp> ::value), "not a function pointer"); +# 162 +return __ptr; +# 163 +} +# 166 +template< class _Ptr> constexpr typename pointer_traits< _Ptr> ::element_type * +# 168 +__to_address(const _Ptr &__ptr) +# 169 +{ return std::__to_address(__ptr.operator->()); } +# 215 "/usr/include/c++/11/bits/ptr_traits.h" 3 +} +# 88 "/usr/include/c++/11/bits/stl_iterator.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 127 "/usr/include/c++/11/bits/stl_iterator.h" 3 +template< class _Iterator> +# 128 +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> { +# 135 +template< class _Iter> friend class reverse_iterator; +# 147 "/usr/include/c++/11/bits/stl_iterator.h" 3 +protected: _Iterator current; +# 149 +typedef iterator_traits< _Iterator> __traits_type; +# 152 +public: typedef _Iterator iterator_type; +# 153 +typedef typename iterator_traits< _Iterator> ::pointer pointer; +# 155 +typedef typename iterator_traits< _Iterator> ::difference_type difference_type; +# 156 +typedef typename iterator_traits< _Iterator> ::reference reference; +# 178 "/usr/include/c++/11/bits/stl_iterator.h" 3 +constexpr reverse_iterator() : current() { } +# 184 +constexpr explicit reverse_iterator(iterator_type __x) : current(__x) { } +# 190 +constexpr reverse_iterator(const reverse_iterator &__x) : current(__x.current) +# 191 +{ } +# 194 +reverse_iterator &operator=(const reverse_iterator &) = default; +# 201 +template< class _Iter> constexpr +# 206 +reverse_iterator(const reverse_iterator< _Iter> &__x) : current((__x.current)) +# 207 +{ } +# 210 +template< class _Iter> constexpr reverse_iterator & +# 217 +operator=(const reverse_iterator< _Iter> &__x) +# 218 +{ +# 219 +(current) = (__x.current); +# 220 +return *this; +# 221 +} +# 228 +constexpr iterator_type base() const +# 229 +{ return current; } +# 242 "/usr/include/c++/11/bits/stl_iterator.h" 3 +constexpr reference operator*() const +# 243 +{ +# 244 +_Iterator __tmp = current; +# 245 +return *(--__tmp); +# 246 +} +# 254 +constexpr pointer operator->() const +# 259 +{ +# 262 +_Iterator __tmp = current; +# 263 +--__tmp; +# 264 +return _S_to_pointer(__tmp); +# 265 +} +# 273 +constexpr reverse_iterator &operator++() +# 274 +{ +# 275 +--(current); +# 276 +return *this; +# 277 +} +# 285 +constexpr reverse_iterator operator++(int) +# 286 +{ +# 287 +reverse_iterator __tmp = *this; +# 288 +--(current); +# 289 +return __tmp; +# 290 +} +# 298 +constexpr reverse_iterator &operator--() +# 299 +{ +# 300 +++(current); +# 301 +return *this; +# 302 +} +# 310 +constexpr reverse_iterator operator--(int) +# 311 +{ +# 312 +reverse_iterator __tmp = *this; +# 313 +++(current); +# 314 +return __tmp; +# 315 +} +# 323 +constexpr reverse_iterator operator+(difference_type __n) const +# 324 +{ return ((reverse_iterator)((current) - __n)); } +# 333 +constexpr reverse_iterator &operator+=(difference_type __n) +# 334 +{ +# 335 +(current) -= __n; +# 336 +return *this; +# 337 +} +# 345 +constexpr reverse_iterator operator-(difference_type __n) const +# 346 +{ return ((reverse_iterator)((current) + __n)); } +# 355 +constexpr reverse_iterator &operator-=(difference_type __n) +# 356 +{ +# 357 +(current) += __n; +# 358 +return *this; +# 359 +} +# 367 +constexpr reference operator[](difference_type __n) const +# 368 +{ return *((*this) + __n); } +# 398 "/usr/include/c++/11/bits/stl_iterator.h" 3 +private: +# 396 +template< class _Tp> static constexpr _Tp * +# 398 +_S_to_pointer(_Tp *__p) +# 399 +{ return __p; } +# 401 +template< class _Tp> static constexpr pointer +# 403 +_S_to_pointer(_Tp __t) +# 404 +{ return __t.operator->(); } +# 405 +}; +# 418 "/usr/include/c++/11/bits/stl_iterator.h" 3 +template< class _Iterator> constexpr bool +# 420 +operator==(const reverse_iterator< _Iterator> &__x, const reverse_iterator< _Iterator> & +# 421 +__y) +# 422 +{ return __x.base() == __y.base(); } +# 424 +template< class _Iterator> constexpr bool +# 426 +operator<(const reverse_iterator< _Iterator> &__x, const reverse_iterator< _Iterator> & +# 427 +__y) +# 428 +{ return __y.base() < __x.base(); } +# 430 +template< class _Iterator> constexpr bool +# 432 +operator!=(const reverse_iterator< _Iterator> &__x, const reverse_iterator< _Iterator> & +# 433 +__y) +# 434 +{ return !(__x == __y); } +# 436 +template< class _Iterator> constexpr bool +# 438 +operator>(const reverse_iterator< _Iterator> &__x, const reverse_iterator< _Iterator> & +# 439 +__y) +# 440 +{ return __y < __x; } +# 442 +template< class _Iterator> constexpr bool +# 444 +operator<=(const reverse_iterator< _Iterator> &__x, const reverse_iterator< _Iterator> & +# 445 +__y) +# 446 +{ return !(__y < __x); } +# 448 +template< class _Iterator> constexpr bool +# 450 +operator>=(const reverse_iterator< _Iterator> &__x, const reverse_iterator< _Iterator> & +# 451 +__y) +# 452 +{ return !(__x < __y); } +# 457 +template< class _IteratorL, class _IteratorR> constexpr bool +# 459 +operator==(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 460 +__y) +# 461 +{ return __x.base() == __y.base(); } +# 463 +template< class _IteratorL, class _IteratorR> constexpr bool +# 465 +operator<(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 466 +__y) +# 467 +{ return __x.base() > __y.base(); } +# 469 +template< class _IteratorL, class _IteratorR> constexpr bool +# 471 +operator!=(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 472 +__y) +# 473 +{ return __x.base() != __y.base(); } +# 475 +template< class _IteratorL, class _IteratorR> constexpr bool +# 477 +operator>(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 478 +__y) +# 479 +{ return __x.base() < __y.base(); } +# 481 +template< class _IteratorL, class _IteratorR> constexpr bool +# 483 +operator<=(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 484 +__y) +# 485 +{ return __x.base() >= __y.base(); } +# 487 +template< class _IteratorL, class _IteratorR> constexpr bool +# 489 +operator>=(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 490 +__y) +# 491 +{ return __x.base() <= __y.base(); } +# 575 "/usr/include/c++/11/bits/stl_iterator.h" 3 +template< class _IteratorL, class _IteratorR> constexpr auto +# 577 +operator-(const reverse_iterator< _IteratorL> &__x, const reverse_iterator< _IteratorR> & +# 578 +__y)->__decltype((__y.base() - __x.base())) +# 580 +{ return __y.base() - __x.base(); } +# 583 +template< class _Iterator> constexpr reverse_iterator< _Iterator> +# 585 +operator+(typename reverse_iterator< _Iterator> ::difference_type __n, const reverse_iterator< _Iterator> & +# 586 +__x) +# 587 +{ return ((reverse_iterator< _Iterator> )(__x.base() - __n)); } +# 591 +template< class _Iterator> constexpr reverse_iterator< _Iterator> +# 593 +__make_reverse_iterator(_Iterator __i) +# 594 +{ return ((reverse_iterator< _Iterator> )(__i)); } +# 602 +template< class _Iterator> constexpr reverse_iterator< _Iterator> +# 604 +make_reverse_iterator(_Iterator __i) +# 605 +{ return ((reverse_iterator< _Iterator> )(__i)); } +# 616 "/usr/include/c++/11/bits/stl_iterator.h" 3 +template< class _Iterator> auto +# 619 +__niter_base(reverse_iterator< _Iterator> __it)->__decltype((__make_reverse_iterator(__niter_base(__it.base())))) +# 621 +{ return __make_reverse_iterator(__niter_base(__it.base())); } +# 623 +template< class _Iterator> +# 624 +struct __is_move_iterator< reverse_iterator< _Iterator> > : public std::__is_move_iterator< _Iterator> { +# 626 +}; +# 628 +template< class _Iterator> auto +# 631 +__miter_base(reverse_iterator< _Iterator> __it)->__decltype((__make_reverse_iterator(__miter_base(__it.base())))) +# 633 +{ return __make_reverse_iterator(__miter_base(__it.base())); } +# 647 "/usr/include/c++/11/bits/stl_iterator.h" 3 +template< class _Container> +# 648 +class back_insert_iterator : public iterator< output_iterator_tag, void, void, void, void> { +# 652 +protected: _Container *container; +# 656 +public: typedef _Container container_type; +# 665 +explicit back_insert_iterator(_Container &__x) : container(std::__addressof(__x)) +# 666 +{ } +# 689 "/usr/include/c++/11/bits/stl_iterator.h" 3 +back_insert_iterator &operator=(const typename _Container::value_type &__value) +# 690 +{ +# 691 +(container)->push_back(__value); +# 692 +return *this; +# 693 +} +# 697 +back_insert_iterator &operator=(typename _Container::value_type &&__value) +# 698 +{ +# 699 +(container)->push_back(std::move(__value)); +# 700 +return *this; +# 701 +} +# 707 +back_insert_iterator &operator*() +# 708 +{ return *this; } +# 713 +back_insert_iterator &operator++() +# 714 +{ return *this; } +# 719 +back_insert_iterator operator++(int) +# 720 +{ return *this; } +# 721 +}; +# 734 "/usr/include/c++/11/bits/stl_iterator.h" 3 +template< class _Container> inline back_insert_iterator< _Container> +# 737 +back_inserter(_Container &__x) +# 738 +{ return ((back_insert_iterator< _Container> )(__x)); } +# 750 "/usr/include/c++/11/bits/stl_iterator.h" 3 +template< class _Container> +# 751 +class front_insert_iterator : public iterator< output_iterator_tag, void, void, void, void> { +# 755 +protected: _Container *container; +# 759 +public: typedef _Container container_type; +# 768 +explicit front_insert_iterator(_Container &__x) : container(std::__addressof(__x)) +# 769 +{ } +# 792 "/usr/include/c++/11/bits/stl_iterator.h" 3 +front_insert_iterator &operator=(const typename _Container::value_type &__value) +# 793 +{ +# 794 +(container)->push_front(__value); +# 795 +return *this; +# 796 +} +# 800 +front_insert_iterator &operator=(typename _Container::value_type &&__value) +# 801 +{ +# 802 +(container)->push_front(std::move(__value)); +# 803 +return *this; +# 804 +} +# 810 +front_insert_iterator &operator*() +# 811 +{ return *this; } +# 816 +front_insert_iterator &operator++() +# 817 +{ return *this; } +# 822 +front_insert_iterator operator++(int) +# 823 +{ return *this; } +# 824 +}; +# 837 "/usr/include/c++/11/bits/stl_iterator.h" 3 +template< class _Container> inline front_insert_iterator< _Container> +# 840 +front_inserter(_Container &__x) +# 841 +{ return ((front_insert_iterator< _Container> )(__x)); } +# 857 "/usr/include/c++/11/bits/stl_iterator.h" 3 +template< class _Container> +# 858 +class insert_iterator : public iterator< output_iterator_tag, void, void, void, void> { +# 868 +typedef typename _Container::iterator _Iter; +# 871 +protected: _Container *container; +# 872 +_Iter iter; +# 877 +public: typedef _Container container_type; +# 890 "/usr/include/c++/11/bits/stl_iterator.h" 3 +insert_iterator(_Container &__x, _Iter __i) : container(std::__addressof(__x)), iter(__i) +# 891 +{ } +# 927 "/usr/include/c++/11/bits/stl_iterator.h" 3 +insert_iterator &operator=(const typename _Container::value_type &__value) +# 928 +{ +# 929 +(iter) = (container)->insert(iter, __value); +# 930 +++(iter); +# 931 +return *this; +# 932 +} +# 936 +insert_iterator &operator=(typename _Container::value_type &&__value) +# 937 +{ +# 938 +(iter) = (container)->insert(iter, std::move(__value)); +# 939 +++(iter); +# 940 +return *this; +# 941 +} +# 947 +insert_iterator &operator*() +# 948 +{ return *this; } +# 953 +insert_iterator &operator++() +# 954 +{ return *this; } +# 959 +insert_iterator &operator++(int) +# 960 +{ return *this; } +# 961 +}; +# 981 "/usr/include/c++/11/bits/stl_iterator.h" 3 +template< class _Container> inline insert_iterator< _Container> +# 983 +inserter(_Container &__x, typename _Container::iterator __i) +# 984 +{ return insert_iterator< _Container> (__x, __i); } +# 990 +} +# 992 +namespace __gnu_cxx __attribute((__visibility__("default"))) { +# 1003 "/usr/include/c++/11/bits/stl_iterator.h" 3 +template< class _Iterator, class _Container> +# 1004 +class __normal_iterator { +# 1007 +protected: _Iterator _M_current; +# 1009 +typedef std::iterator_traits< _Iterator> __traits_type; +# 1012 +public: typedef _Iterator iterator_type; +# 1013 +typedef typename std::iterator_traits< _Iterator> ::iterator_category iterator_category; +# 1014 +typedef typename std::iterator_traits< _Iterator> ::value_type value_type; +# 1015 +typedef typename std::iterator_traits< _Iterator> ::difference_type difference_type; +# 1016 +typedef typename std::iterator_traits< _Iterator> ::reference reference; +# 1017 +typedef typename std::iterator_traits< _Iterator> ::pointer pointer; +# 1023 +constexpr __normal_iterator() noexcept : _M_current(_Iterator()) +# 1024 +{ } +# 1027 +explicit __normal_iterator(const _Iterator &__i) noexcept : _M_current(__i) +# 1028 +{ } +# 1031 +template< class _Iter> +# 1033 +__normal_iterator(const __normal_iterator< _Iter, typename __enable_if< std::__are_same< _Iter, typename _Container::pointer> ::__value, _Container> ::__type> & +# 1036 +__i) noexcept : _M_current(__i.base()) +# 1037 +{ } +# 1042 +reference operator*() const noexcept +# 1043 +{ return *(_M_current); } +# 1047 +pointer operator->() const noexcept +# 1048 +{ return _M_current; } +# 1052 +__normal_iterator &operator++() noexcept +# 1053 +{ +# 1054 +++(_M_current); +# 1055 +return *this; +# 1056 +} +# 1060 +__normal_iterator operator++(int) noexcept +# 1061 +{ return ((__normal_iterator)((_M_current)++)); } +# 1066 +__normal_iterator &operator--() noexcept +# 1067 +{ +# 1068 +--(_M_current); +# 1069 +return *this; +# 1070 +} +# 1074 +__normal_iterator operator--(int) noexcept +# 1075 +{ return ((__normal_iterator)((_M_current)--)); } +# 1080 +reference operator[](difference_type __n) const noexcept +# 1081 +{ return (_M_current)[__n]; } +# 1085 +__normal_iterator &operator+=(difference_type __n) noexcept +# 1086 +{ (_M_current) += __n; return *this; } +# 1090 +__normal_iterator operator+(difference_type __n) const noexcept +# 1091 +{ return ((__normal_iterator)((_M_current) + __n)); } +# 1095 +__normal_iterator &operator-=(difference_type __n) noexcept +# 1096 +{ (_M_current) -= __n; return *this; } +# 1100 +__normal_iterator operator-(difference_type __n) const noexcept +# 1101 +{ return ((__normal_iterator)((_M_current) - __n)); } +# 1105 +const _Iterator &base() const noexcept +# 1106 +{ return _M_current; } +# 1107 +}; +# 1152 "/usr/include/c++/11/bits/stl_iterator.h" 3 +template< class _IteratorL, class _IteratorR, class _Container> inline bool +# 1155 +operator==(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1156 +__rhs) noexcept +# 1158 +{ return __lhs.base() == __rhs.base(); } +# 1160 +template< class _Iterator, class _Container> inline bool +# 1163 +operator==(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1164 +__rhs) noexcept +# 1166 +{ return __lhs.base() == __rhs.base(); } +# 1168 +template< class _IteratorL, class _IteratorR, class _Container> inline bool +# 1171 +operator!=(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1172 +__rhs) noexcept +# 1174 +{ return __lhs.base() != __rhs.base(); } +# 1176 +template< class _Iterator, class _Container> inline bool +# 1179 +operator!=(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1180 +__rhs) noexcept +# 1182 +{ return __lhs.base() != __rhs.base(); } +# 1185 +template< class _IteratorL, class _IteratorR, class _Container> inline bool +# 1187 +operator<(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1188 +__rhs) noexcept +# 1190 +{ return __lhs.base() < __rhs.base(); } +# 1192 +template< class _Iterator, class _Container> inline bool +# 1195 +operator<(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1196 +__rhs) noexcept +# 1198 +{ return __lhs.base() < __rhs.base(); } +# 1200 +template< class _IteratorL, class _IteratorR, class _Container> inline bool +# 1202 +operator>(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1203 +__rhs) noexcept +# 1205 +{ return __lhs.base() > __rhs.base(); } +# 1207 +template< class _Iterator, class _Container> inline bool +# 1210 +operator>(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1211 +__rhs) noexcept +# 1213 +{ return __lhs.base() > __rhs.base(); } +# 1215 +template< class _IteratorL, class _IteratorR, class _Container> inline bool +# 1217 +operator<=(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1218 +__rhs) noexcept +# 1220 +{ return __lhs.base() <= __rhs.base(); } +# 1222 +template< class _Iterator, class _Container> inline bool +# 1225 +operator<=(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1226 +__rhs) noexcept +# 1228 +{ return __lhs.base() <= __rhs.base(); } +# 1230 +template< class _IteratorL, class _IteratorR, class _Container> inline bool +# 1232 +operator>=(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1233 +__rhs) noexcept +# 1235 +{ return __lhs.base() >= __rhs.base(); } +# 1237 +template< class _Iterator, class _Container> inline bool +# 1240 +operator>=(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1241 +__rhs) noexcept +# 1243 +{ return __lhs.base() >= __rhs.base(); } +# 1250 +template< class _IteratorL, class _IteratorR, class _Container> inline auto +# 1255 +operator-(const __normal_iterator< _IteratorL, _Container> &__lhs, const __normal_iterator< _IteratorR, _Container> & +# 1256 +__rhs) noexcept->__decltype((__lhs.base() - __rhs.base())) +# 1263 +{ return __lhs.base() - __rhs.base(); } +# 1265 +template< class _Iterator, class _Container> inline typename __normal_iterator< _Iterator, _Container> ::difference_type +# 1268 +operator-(const __normal_iterator< _Iterator, _Container> &__lhs, const __normal_iterator< _Iterator, _Container> & +# 1269 +__rhs) noexcept +# 1271 +{ return __lhs.base() - __rhs.base(); } +# 1273 +template< class _Iterator, class _Container> inline __normal_iterator< _Iterator, _Container> +# 1276 +operator+(typename __normal_iterator< _Iterator, _Container> ::difference_type +# 1277 +__n, const __normal_iterator< _Iterator, _Container> &__i) noexcept +# 1279 +{ return ((__normal_iterator< _Iterator, _Container> )(__i.base() + __n)); } +# 1282 +} +# 1284 +namespace std __attribute((__visibility__("default"))) { +# 1288 +template< class _Iterator, class _Container> _Iterator +# 1291 +__niter_base(__gnu_cxx::__normal_iterator< _Iterator, _Container> __it) noexcept(std::template is_nothrow_copy_constructible< _Iterator> ::value) +# 1293 +{ return __it.base(); } +# 1342 "/usr/include/c++/11/bits/stl_iterator.h" 3 +namespace __detail { +# 1358 "/usr/include/c++/11/bits/stl_iterator.h" 3 +} +# 1369 "/usr/include/c++/11/bits/stl_iterator.h" 3 +template< class _Iterator> +# 1370 +class move_iterator { +# 1375 +_Iterator _M_current; +# 1377 +using __traits_type = iterator_traits< _Iterator> ; +# 1379 +using __base_ref = typename iterator_traits< _Iterator> ::reference; +# 1382 +template< class _Iter2> friend class move_iterator; +# 1409 "/usr/include/c++/11/bits/stl_iterator.h" 3 +public: using iterator_type = _Iterator; +# 1422 "/usr/include/c++/11/bits/stl_iterator.h" 3 +typedef typename iterator_traits< _Iterator> ::iterator_category iterator_category; +# 1423 +typedef typename iterator_traits< _Iterator> ::value_type value_type; +# 1424 +typedef typename iterator_traits< _Iterator> ::difference_type difference_type; +# 1426 +typedef _Iterator pointer; +# 1431 +typedef typename conditional< is_reference< __base_ref> ::value, typename remove_reference< __base_ref> ::type &&, __base_ref> ::type reference; +# 1435 +constexpr move_iterator() : _M_current() +# 1436 +{ } +# 1439 +constexpr explicit move_iterator(iterator_type __i) : _M_current(std::move(__i)) +# 1440 +{ } +# 1442 +template< class _Iter> constexpr +# 1447 +move_iterator(const move_iterator< _Iter> &__i) : _M_current((__i._M_current)) +# 1448 +{ } +# 1450 +template< class _Iter> constexpr move_iterator & +# 1456 +operator=(const move_iterator< _Iter> &__i) +# 1457 +{ +# 1458 +(_M_current) = (__i._M_current); +# 1459 +return *this; +# 1460 +} +# 1464 +constexpr iterator_type base() const +# 1465 +{ return _M_current; } +# 1477 "/usr/include/c++/11/bits/stl_iterator.h" 3 +constexpr reference operator*() const +# 1481 +{ return static_cast< reference>(*(_M_current)); } +# 1485 +constexpr pointer operator->() const +# 1486 +{ return _M_current; } +# 1489 +constexpr move_iterator &operator++() +# 1490 +{ +# 1491 +++(_M_current); +# 1492 +return *this; +# 1493 +} +# 1496 +constexpr move_iterator operator++(int) +# 1497 +{ +# 1498 +move_iterator __tmp = *this; +# 1499 +++(_M_current); +# 1500 +return __tmp; +# 1501 +} +# 1510 +constexpr move_iterator &operator--() +# 1511 +{ +# 1512 +--(_M_current); +# 1513 +return *this; +# 1514 +} +# 1517 +constexpr move_iterator operator--(int) +# 1518 +{ +# 1519 +move_iterator __tmp = *this; +# 1520 +--(_M_current); +# 1521 +return __tmp; +# 1522 +} +# 1525 +constexpr move_iterator operator+(difference_type __n) const +# 1526 +{ return ((move_iterator)((_M_current) + __n)); } +# 1529 +constexpr move_iterator &operator+=(difference_type __n) +# 1530 +{ +# 1531 +(_M_current) += __n; +# 1532 +return *this; +# 1533 +} +# 1536 +constexpr move_iterator operator-(difference_type __n) const +# 1537 +{ return ((move_iterator)((_M_current) - __n)); } +# 1540 +constexpr move_iterator &operator-=(difference_type __n) +# 1541 +{ +# 1542 +(_M_current) -= __n; +# 1543 +return *this; +# 1544 +} +# 1547 +constexpr reference operator[](difference_type __n) const +# 1551 +{ return std::move((_M_current)[__n]); } +# 1581 "/usr/include/c++/11/bits/stl_iterator.h" 3 +}; +# 1583 +template< class _IteratorL, class _IteratorR> constexpr bool +# 1585 +operator==(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1586 +__y) +# 1590 +{ return __x.base() == __y.base(); } +# 1600 "/usr/include/c++/11/bits/stl_iterator.h" 3 +template< class _IteratorL, class _IteratorR> constexpr bool +# 1602 +operator!=(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1603 +__y) +# 1604 +{ return !(__x == __y); } +# 1607 +template< class _IteratorL, class _IteratorR> constexpr bool +# 1609 +operator<(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1610 +__y) +# 1614 +{ return __x.base() < __y.base(); } +# 1616 +template< class _IteratorL, class _IteratorR> constexpr bool +# 1618 +operator<=(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1619 +__y) +# 1623 +{ return !(__y < __x); } +# 1625 +template< class _IteratorL, class _IteratorR> constexpr bool +# 1627 +operator>(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1628 +__y) +# 1632 +{ return __y < __x; } +# 1634 +template< class _IteratorL, class _IteratorR> constexpr bool +# 1636 +operator>=(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1637 +__y) +# 1641 +{ return !(__x < __y); } +# 1646 +template< class _Iterator> constexpr bool +# 1648 +operator==(const move_iterator< _Iterator> &__x, const move_iterator< _Iterator> & +# 1649 +__y) +# 1650 +{ return __x.base() == __y.base(); } +# 1659 "/usr/include/c++/11/bits/stl_iterator.h" 3 +template< class _Iterator> constexpr bool +# 1661 +operator!=(const move_iterator< _Iterator> &__x, const move_iterator< _Iterator> & +# 1662 +__y) +# 1663 +{ return !(__x == __y); } +# 1665 +template< class _Iterator> constexpr bool +# 1667 +operator<(const move_iterator< _Iterator> &__x, const move_iterator< _Iterator> & +# 1668 +__y) +# 1669 +{ return __x.base() < __y.base(); } +# 1671 +template< class _Iterator> constexpr bool +# 1673 +operator<=(const move_iterator< _Iterator> &__x, const move_iterator< _Iterator> & +# 1674 +__y) +# 1675 +{ return !(__y < __x); } +# 1677 +template< class _Iterator> constexpr bool +# 1679 +operator>(const move_iterator< _Iterator> &__x, const move_iterator< _Iterator> & +# 1680 +__y) +# 1681 +{ return __y < __x; } +# 1683 +template< class _Iterator> constexpr bool +# 1685 +operator>=(const move_iterator< _Iterator> &__x, const move_iterator< _Iterator> & +# 1686 +__y) +# 1687 +{ return !(__x < __y); } +# 1691 +template< class _IteratorL, class _IteratorR> constexpr auto +# 1693 +operator-(const move_iterator< _IteratorL> &__x, const move_iterator< _IteratorR> & +# 1694 +__y)->__decltype((__x.base() - __y.base())) +# 1696 +{ return __x.base() - __y.base(); } +# 1698 +template< class _Iterator> constexpr move_iterator< _Iterator> +# 1700 +operator+(typename move_iterator< _Iterator> ::difference_type __n, const move_iterator< _Iterator> & +# 1701 +__x) +# 1702 +{ return __x + __n; } +# 1704 +template< class _Iterator> constexpr move_iterator< _Iterator> +# 1706 +make_move_iterator(_Iterator __i) +# 1707 +{ return ((move_iterator< _Iterator> )(std::move(__i))); } +# 1709 +template< class _Iterator, class _ReturnType = typename conditional< __move_if_noexcept_cond< typename iterator_traits< _Iterator> ::value_type> ::value, _Iterator, move_iterator< _Iterator> > ::type> constexpr _ReturnType +# 1714 +__make_move_if_noexcept_iterator(_Iterator __i) +# 1715 +{ return (_ReturnType)__i; } +# 1719 +template< class _Tp, class _ReturnType = typename conditional< __move_if_noexcept_cond< _Tp> ::value, const _Tp *, move_iterator< _Tp *> > ::type> constexpr _ReturnType +# 1723 +__make_move_if_noexcept_iterator(_Tp *__i) +# 1724 +{ return (_ReturnType)__i; } +# 2447 "/usr/include/c++/11/bits/stl_iterator.h" 3 +template< class _Iterator> auto +# 2450 +__niter_base(move_iterator< _Iterator> __it)->__decltype((make_move_iterator(__niter_base(__it.base())))) +# 2452 +{ return make_move_iterator(__niter_base(__it.base())); } +# 2454 +template< class _Iterator> +# 2455 +struct __is_move_iterator< move_iterator< _Iterator> > { +# 2457 +enum { __value = 1}; +# 2458 +typedef __true_type __type; +# 2459 +}; +# 2461 +template< class _Iterator> auto +# 2464 +__miter_base(move_iterator< _Iterator> __it)->__decltype((__miter_base(__it.base()))) +# 2466 +{ return __miter_base(__it.base()); } +# 2479 "/usr/include/c++/11/bits/stl_iterator.h" 3 +template< class _InputIterator> using __iter_key_t = remove_const_t< typename iterator_traits< _InputIterator> ::value_type::first_type> ; +# 2483 +template< class _InputIterator> using __iter_val_t = typename iterator_traits< _InputIterator> ::value_type::second_type; +# 2487 +template< class _T1, class _T2> struct pair; +# 2490 +template< class _InputIterator> using __iter_to_alloc_t = pair< add_const_t< __iter_key_t< _InputIterator> > , __iter_val_t< _InputIterator> > ; +# 2497 +} +# 48 "/usr/include/c++/11/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/include/c++/11/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 +} +# 79 "/usr/include/c++/11/bits/stl_algobase.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 87 +template< class _Tp, class _Up> constexpr int +# 90 +__memcmp(const _Tp *__first1, const _Up *__first2, size_t __num) +# 91 +{ +# 93 +static_assert((sizeof(_Tp) == sizeof(_Up)), "can be compared with memcmp"); +# 105 "/usr/include/c++/11/bits/stl_algobase.h" 3 +return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); +# 106 +} +# 149 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _ForwardIterator1, class _ForwardIterator2> inline void +# 152 +iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) +# 153 +{ +# 182 "/usr/include/c++/11/bits/stl_algobase.h" 3 +swap(*__a, *__b); +# 184 +} +# 198 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _ForwardIterator1, class _ForwardIterator2> _ForwardIterator2 +# 201 +swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 +# 202 +__first2) +# 203 +{ +# 209 +; +# 211 +for (; __first1 != __last1; (++__first1), ((void)(++__first2))) { +# 212 +std::iter_swap(__first1, __first2); } +# 213 +return __first2; +# 214 +} +# 227 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _Tp> constexpr const _Tp & +# 230 +min(const _Tp &__a, const _Tp &__b) +# 231 +{ +# 235 +if (__b < __a) { +# 236 +return __b; } +# 237 +return __a; +# 238 +} +# 251 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _Tp> constexpr const _Tp & +# 254 +max(const _Tp &__a, const _Tp &__b) +# 255 +{ +# 259 +if (__a < __b) { +# 260 +return __b; } +# 261 +return __a; +# 262 +} +# 275 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _Tp, class _Compare> constexpr const _Tp & +# 278 +min(const _Tp &__a, const _Tp &__b, _Compare __comp) +# 279 +{ +# 281 +if (__comp(__b, __a)) { +# 282 +return __b; } +# 283 +return __a; +# 284 +} +# 297 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _Tp, class _Compare> constexpr const _Tp & +# 300 +max(const _Tp &__a, const _Tp &__b, _Compare __comp) +# 301 +{ +# 303 +if (__comp(__a, __b)) { +# 304 +return __b; } +# 305 +return __a; +# 306 +} +# 310 +template< class _Iterator> inline _Iterator +# 313 +__niter_base(_Iterator __it) noexcept(std::template is_nothrow_copy_constructible< _Iterator> ::value) +# 315 +{ return __it; } +# 317 +template< class _Ite, class _Seq> _Ite __niter_base(const __gnu_debug::_Safe_iterator< _Ite, _Seq, random_access_iterator_tag> &); +# 325 +template< class _From, class _To> inline _From +# 328 +__niter_wrap(_From __from, _To __res) +# 329 +{ return __from + (__res - std::__niter_base(__from)); } +# 332 +template< class _Iterator> inline _Iterator +# 335 +__niter_wrap(const _Iterator &, _Iterator __res) +# 336 +{ return __res; } +# 344 +template< bool _IsMove, bool _IsSimple, class _Category> +# 345 +struct __copy_move { +# 347 +template< class _II, class _OI> static _OI +# 350 +__copy_m(_II __first, _II __last, _OI __result) +# 351 +{ +# 352 +for (; __first != __last; (++__result), ((void)(++__first))) { +# 353 +(*__result) = (*__first); } +# 354 +return __result; +# 355 +} +# 356 +}; +# 359 +template< class _Category> +# 360 +struct __copy_move< true, false, _Category> { +# 362 +template< class _II, class _OI> static _OI +# 365 +__copy_m(_II __first, _II __last, _OI __result) +# 366 +{ +# 367 +for (; __first != __last; (++__result), ((void)(++__first))) { +# 368 +(*__result) = std::move(*__first); } +# 369 +return __result; +# 370 +} +# 371 +}; +# 375 +template<> struct __copy_move< false, false, random_access_iterator_tag> { +# 377 +template< class _II, class _OI> static _OI +# 380 +__copy_m(_II __first, _II __last, _OI __result) +# 381 +{ +# 382 +typedef typename iterator_traits< _II> ::difference_type _Distance; +# 383 +for (_Distance __n = __last - __first; __n > 0; --__n) +# 384 +{ +# 385 +(*__result) = (*__first); +# 386 +++__first; +# 387 +++__result; +# 388 +} +# 389 +return __result; +# 390 +} +# 391 +}; +# 395 +template<> struct __copy_move< true, false, random_access_iterator_tag> { +# 397 +template< class _II, class _OI> static _OI +# 400 +__copy_m(_II __first, _II __last, _OI __result) +# 401 +{ +# 402 +typedef typename iterator_traits< _II> ::difference_type _Distance; +# 403 +for (_Distance __n = __last - __first; __n > 0; --__n) +# 404 +{ +# 405 +(*__result) = std::move(*__first); +# 406 +++__first; +# 407 +++__result; +# 408 +} +# 409 +return __result; +# 410 +} +# 411 +}; +# 414 +template< bool _IsMove> +# 415 +struct __copy_move< _IsMove, true, random_access_iterator_tag> { +# 417 +template< class _Tp> static _Tp * +# 420 +__copy_m(const _Tp *__first, const _Tp *__last, _Tp *__result) +# 421 +{ +# 423 +using __assignable = conditional< _IsMove, is_move_assignable< _Tp> , is_copy_assignable< _Tp> > ; +# 427 +static_assert((__assignable::type::value), "type is not assignable"); +# 429 +const ptrdiff_t _Num = __last - __first; +# 430 +if (_Num) { +# 431 +__builtin_memmove(__result, __first, sizeof(_Tp) * _Num); } +# 432 +return __result + _Num; +# 433 +} +# 434 +}; +# 438 +template< class _Tp, class _Ref, class _Ptr> struct _Deque_iterator; +# 441 +struct _Bit_iterator; +# 447 +template< class _CharT> struct char_traits; +# 450 +template< class _CharT, class _Traits> class istreambuf_iterator; +# 453 +template< class _CharT, class _Traits> class ostreambuf_iterator; +# 456 +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> > ); +# 462 +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> > ); +# 468 +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 *); +# 474 +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 *> ); +# 483 +template< bool _IsMove, class _II, class _OI> inline _OI +# 486 +__copy_move_a2(_II __first, _II __last, _OI __result) +# 487 +{ +# 488 +typedef typename iterator_traits< _II> ::iterator_category _Category; +# 494 +return std::template __copy_move< _IsMove, __memcpyable< _OI, _II> ::__value, typename iterator_traits< _II> ::iterator_category> ::__copy_m(__first, __last, __result); +# 496 +} +# 498 +template< bool _IsMove, class +# 499 +_Tp, class _Ref, class _Ptr, class _OI> _OI +# 498 +__copy_move_a1(_Deque_iterator< _Tp, _Ref, _Ptr> , _Deque_iterator< _Tp, _Ref, _Ptr> , _OI); +# 505 +template< bool _IsMove, class +# 506 +_ITp, class _IRef, class _IPtr, class _OTp> _Deque_iterator< _OTp, _OTp &, _OTp *> +# 505 +__copy_move_a1(_Deque_iterator< _ITp, _IRef, _IPtr> , _Deque_iterator< _ITp, _IRef, _IPtr> , _Deque_iterator< _OTp, _OTp &, _OTp *> ); +# 512 +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 *> ); +# 518 +template< bool _IsMove, class _II, class _OI> inline _OI +# 521 +__copy_move_a1(_II __first, _II __last, _OI __result) +# 522 +{ return std::__copy_move_a2< _IsMove> (__first, __last, __result); } +# 524 +template< bool _IsMove, class _II, class _OI> inline _OI +# 527 +__copy_move_a(_II __first, _II __last, _OI __result) +# 528 +{ +# 529 +return std::__niter_wrap(__result, std::__copy_move_a1< _IsMove> (std::__niter_base(__first), std::__niter_base(__last), std::__niter_base(__result))); +# 533 +} +# 535 +template< bool _IsMove, class +# 536 +_Ite, class _Seq, class _Cat, class _OI> _OI +# 535 +__copy_move_a(const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &, const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &, _OI); +# 542 +template< bool _IsMove, class +# 543 +_II, class _Ite, class _Seq, class _Cat> __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> +# 542 +__copy_move_a(_II, _II, const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &); +# 548 +template< bool _IsMove, class +# 549 +_IIte, class _ISeq, class _ICat, class +# 550 +_OIte, class _OSeq, class _OCat> __gnu_debug::_Safe_iterator< _OIte, _OSeq, _OCat> +# 548 +__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> &); +# 556 +template< class _InputIterator, class _Size, class _OutputIterator> _OutputIterator +# 559 +__copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, bool) +# 561 +{ +# 562 +if (__n > 0) +# 563 +{ +# 564 +while (true) +# 565 +{ +# 566 +(*__result) = (*__first); +# 567 +++__result; +# 568 +if ((--__n) > 0) { +# 569 +++__first; } else { +# 571 +break; } +# 572 +} +# 573 +} +# 574 +return __result; +# 575 +} +# 577 +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); +# 583 +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); +# 608 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _II, class _OI> inline _OI +# 611 +copy(_II __first, _II __last, _OI __result) +# 612 +{ +# 617 +; +# 619 +return std::__copy_move_a< __is_move_iterator< _II> ::__value> (std::__miter_base(__first), std::__miter_base(__last), __result); +# 621 +} +# 641 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _II, class _OI> inline _OI +# 644 +move(_II __first, _II __last, _OI __result) +# 645 +{ +# 650 +; +# 652 +return std::__copy_move_a< true> (std::__miter_base(__first), std::__miter_base(__last), __result); +# 654 +} +# 661 +template< bool _IsMove, bool _IsSimple, class _Category> +# 662 +struct __copy_move_backward { +# 664 +template< class _BI1, class _BI2> static _BI2 +# 667 +__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) +# 668 +{ +# 669 +while (__first != __last) { +# 670 +(*(--__result)) = (*(--__last)); } +# 671 +return __result; +# 672 +} +# 673 +}; +# 676 +template< class _Category> +# 677 +struct __copy_move_backward< true, false, _Category> { +# 679 +template< class _BI1, class _BI2> static _BI2 +# 682 +__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) +# 683 +{ +# 684 +while (__first != __last) { +# 685 +(*(--__result)) = std::move(*(--__last)); } +# 686 +return __result; +# 687 +} +# 688 +}; +# 692 +template<> struct __copy_move_backward< false, false, random_access_iterator_tag> { +# 694 +template< class _BI1, class _BI2> static _BI2 +# 697 +__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) +# 698 +{ +# 700 +typename iterator_traits< _BI1> ::difference_type __n = __last - __first; +# 701 +for (; __n > 0; --__n) { +# 702 +(*(--__result)) = (*(--__last)); } +# 703 +return __result; +# 704 +} +# 705 +}; +# 709 +template<> struct __copy_move_backward< true, false, random_access_iterator_tag> { +# 711 +template< class _BI1, class _BI2> static _BI2 +# 714 +__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) +# 715 +{ +# 717 +typename iterator_traits< _BI1> ::difference_type __n = __last - __first; +# 718 +for (; __n > 0; --__n) { +# 719 +(*(--__result)) = std::move(*(--__last)); } +# 720 +return __result; +# 721 +} +# 722 +}; +# 725 +template< bool _IsMove> +# 726 +struct __copy_move_backward< _IsMove, true, random_access_iterator_tag> { +# 728 +template< class _Tp> static _Tp * +# 731 +__copy_move_b(const _Tp *__first, const _Tp *__last, _Tp *__result) +# 732 +{ +# 734 +using __assignable = conditional< _IsMove, is_move_assignable< _Tp> , is_copy_assignable< _Tp> > ; +# 738 +static_assert((__assignable::type::value), "type is not assignable"); +# 740 +const ptrdiff_t _Num = __last - __first; +# 741 +if (_Num) { +# 742 +__builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); } +# 743 +return __result - _Num; +# 744 +} +# 745 +}; +# 747 +template< bool _IsMove, class _BI1, class _BI2> inline _BI2 +# 750 +__copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) +# 751 +{ +# 752 +typedef typename iterator_traits< _BI1> ::iterator_category _Category; +# 758 +return std::template __copy_move_backward< _IsMove, __memcpyable< _BI2, _BI1> ::__value, typename iterator_traits< _BI1> ::iterator_category> ::__copy_move_b(__first, __last, __result); +# 763 +} +# 765 +template< bool _IsMove, class _BI1, class _BI2> inline _BI2 +# 768 +__copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) +# 769 +{ return std::__copy_move_backward_a2< _IsMove> (__first, __last, __result); } +# 771 +template< bool _IsMove, class +# 772 +_Tp, class _Ref, class _Ptr, class _OI> _OI +# 771 +__copy_move_backward_a1(_Deque_iterator< _Tp, _Ref, _Ptr> , _Deque_iterator< _Tp, _Ref, _Ptr> , _OI); +# 778 +template< bool _IsMove, class +# 779 +_ITp, class _IRef, class _IPtr, class _OTp> _Deque_iterator< _OTp, _OTp &, _OTp *> +# 778 +__copy_move_backward_a1(_Deque_iterator< _ITp, _IRef, _IPtr> , _Deque_iterator< _ITp, _IRef, _IPtr> , _Deque_iterator< _OTp, _OTp &, _OTp *> ); +# 786 +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 *> ); +# 793 +template< bool _IsMove, class _II, class _OI> inline _OI +# 796 +__copy_move_backward_a(_II __first, _II __last, _OI __result) +# 797 +{ +# 798 +return std::__niter_wrap(__result, std::__copy_move_backward_a1< _IsMove> (std::__niter_base(__first), std::__niter_base(__last), std::__niter_base(__result))); +# 802 +} +# 804 +template< bool _IsMove, class +# 805 +_Ite, class _Seq, class _Cat, class _OI> _OI +# 804 +__copy_move_backward_a(const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &, const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &, _OI); +# 812 +template< bool _IsMove, class +# 813 +_II, class _Ite, class _Seq, class _Cat> __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> +# 812 +__copy_move_backward_a(_II, _II, const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> &); +# 818 +template< bool _IsMove, class +# 819 +_IIte, class _ISeq, class _ICat, class +# 820 +_OIte, class _OSeq, class _OCat> __gnu_debug::_Safe_iterator< _OIte, _OSeq, _OCat> +# 818 +__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> &); +# 845 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _BI1, class _BI2> inline _BI2 +# 848 +copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) +# 849 +{ +# 856 +; +# 858 +return std::__copy_move_backward_a< __is_move_iterator< _BI1> ::__value> (std::__miter_base(__first), std::__miter_base(__last), __result); +# 860 +} +# 881 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _BI1, class _BI2> inline _BI2 +# 884 +move_backward(_BI1 __first, _BI1 __last, _BI2 __result) +# 885 +{ +# 892 +; +# 894 +return std::__copy_move_backward_a< true> (std::__miter_base(__first), std::__miter_base(__last), __result); +# 897 +} +# 904 +template< class _ForwardIterator, class _Tp> inline typename __gnu_cxx::__enable_if< !__is_scalar< _Tp> ::__value, void> ::__type +# 908 +__fill_a1(_ForwardIterator __first, _ForwardIterator __last, const _Tp & +# 909 +__value) +# 910 +{ +# 911 +for (; __first != __last; ++__first) { +# 912 +(*__first) = __value; } +# 913 +} +# 915 +template< class _ForwardIterator, class _Tp> inline typename __gnu_cxx::__enable_if< __is_scalar< _Tp> ::__value, void> ::__type +# 919 +__fill_a1(_ForwardIterator __first, _ForwardIterator __last, const _Tp & +# 920 +__value) +# 921 +{ +# 922 +const _Tp __tmp = __value; +# 923 +for (; __first != __last; ++__first) { +# 924 +(*__first) = __tmp; } +# 925 +} +# 928 +template< class _Tp> inline typename __gnu_cxx::__enable_if< __is_byte< _Tp> ::__value, void> ::__type +# 932 +__fill_a1(_Tp *__first, _Tp *__last, const _Tp &__c) +# 933 +{ +# 934 +const _Tp __tmp = __c; +# 943 "/usr/include/c++/11/bits/stl_algobase.h" 3 +if (const size_t __len = __last - __first) { +# 944 +__builtin_memset(__first, static_cast< unsigned char>(__tmp), __len); } +# 945 +} +# 947 +template< class _Ite, class _Cont, class _Tp> inline void +# 950 +__fill_a1(__gnu_cxx::__normal_iterator< _Ite, _Cont> __first, __gnu_cxx::__normal_iterator< _Ite, _Cont> +# 951 +__last, const _Tp & +# 952 +__value) +# 953 +{ std::__fill_a1(__first.base(), __last.base(), __value); } +# 955 +template< class _Tp, class _VTp> void __fill_a1(const _Deque_iterator< _Tp, _Tp &, _Tp *> &, const _Deque_iterator< _Tp, _Tp &, _Tp *> &, const _VTp &); +# 962 +void __fill_a1(_Bit_iterator, _Bit_iterator, const bool &); +# 965 +template< class _FIte, class _Tp> inline void +# 968 +__fill_a(_FIte __first, _FIte __last, const _Tp &__value) +# 969 +{ std::__fill_a1(__first, __last, __value); } +# 971 +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 &); +# 989 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _ForwardIterator, class _Tp> inline void +# 992 +fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp &__value) +# 993 +{ +# 997 +; +# 999 +std::__fill_a(__first, __last, __value); +# 1000 +} +# 1004 +constexpr int __size_to_integer(int __n) { return __n; } +# 1006 +constexpr unsigned __size_to_integer(unsigned __n) { return __n; } +# 1008 +constexpr long __size_to_integer(long __n) { return __n; } +# 1010 +constexpr unsigned long __size_to_integer(unsigned long __n) { return __n; } +# 1012 +constexpr long long __size_to_integer(long long __n) { return __n; } +# 1014 +constexpr unsigned long long __size_to_integer(unsigned long long __n) { return __n; } +# 1018 +constexpr __int128 __size_to_integer(__int128 __n) { return __n; } +# 1020 +constexpr unsigned __int128 __size_to_integer(unsigned __int128 __n) { return __n; } +# 1042 "/usr/include/c++/11/bits/stl_algobase.h" 3 +constexpr long long __size_to_integer(float __n) { return (long long)__n; } +# 1044 +constexpr long long __size_to_integer(double __n) { return (long long)__n; } +# 1046 +constexpr long long __size_to_integer(long double __n) { return (long long)__n; } +# 1052 +template< class _OutputIterator, class _Size, class _Tp> inline typename __gnu_cxx::__enable_if< !__is_scalar< _Tp> ::__value, _OutputIterator> ::__type +# 1056 +__fill_n_a1(_OutputIterator __first, _Size __n, const _Tp &__value) +# 1057 +{ +# 1058 +for (; __n > 0; (--__n), ((void)(++__first))) { +# 1059 +(*__first) = __value; } +# 1060 +return __first; +# 1061 +} +# 1063 +template< class _OutputIterator, class _Size, class _Tp> inline typename __gnu_cxx::__enable_if< __is_scalar< _Tp> ::__value, _OutputIterator> ::__type +# 1067 +__fill_n_a1(_OutputIterator __first, _Size __n, const _Tp &__value) +# 1068 +{ +# 1069 +const _Tp __tmp = __value; +# 1070 +for (; __n > 0; (--__n), ((void)(++__first))) { +# 1071 +(*__first) = __tmp; } +# 1072 +return __first; +# 1073 +} +# 1075 +template< class _Ite, class _Seq, class _Cat, class _Size, class +# 1076 +_Tp> __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> +# 1075 +__fill_n_a(const __gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat> & __first, _Size __n, const _Tp & __value, input_iterator_tag); +# 1082 +template< class _OutputIterator, class _Size, class _Tp> inline _OutputIterator +# 1085 +__fill_n_a(_OutputIterator __first, _Size __n, const _Tp &__value, output_iterator_tag) +# 1087 +{ +# 1089 +static_assert((is_integral< _Size> {}), "fill_n must pass integral size"); +# 1091 +return __fill_n_a1(__first, __n, __value); +# 1092 +} +# 1094 +template< class _OutputIterator, class _Size, class _Tp> inline _OutputIterator +# 1097 +__fill_n_a(_OutputIterator __first, _Size __n, const _Tp &__value, input_iterator_tag) +# 1099 +{ +# 1101 +static_assert((is_integral< _Size> {}), "fill_n must pass integral size"); +# 1103 +return __fill_n_a1(__first, __n, __value); +# 1104 +} +# 1106 +template< class _OutputIterator, class _Size, class _Tp> inline _OutputIterator +# 1109 +__fill_n_a(_OutputIterator __first, _Size __n, const _Tp &__value, random_access_iterator_tag) +# 1111 +{ +# 1113 +static_assert((is_integral< _Size> {}), "fill_n must pass integral size"); +# 1115 +if (__n <= 0) { +# 1116 +return __first; } +# 1118 +; +# 1120 +std::__fill_a(__first, __first + __n, __value); +# 1121 +return __first + __n; +# 1122 +} +# 1141 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _OI, class _Size, class _Tp> inline _OI +# 1144 +fill_n(_OI __first, _Size __n, const _Tp &__value) +# 1145 +{ +# 1149 +return std::__fill_n_a(__first, std::__size_to_integer(__n), __value, std::__iterator_category(__first)); +# 1151 +} +# 1153 +template< bool _BoolType> +# 1154 +struct __equal { +# 1156 +template< class _II1, class _II2> static bool +# 1159 +equal(_II1 __first1, _II1 __last1, _II2 __first2) +# 1160 +{ +# 1161 +for (; __first1 != __last1; (++__first1), ((void)(++__first2))) { +# 1162 +if (!((*__first1) == (*__first2))) { +# 1163 +return false; } } +# 1164 +return true; +# 1165 +} +# 1166 +}; +# 1169 +template<> struct __equal< true> { +# 1171 +template< class _Tp> static bool +# 1174 +equal(const _Tp *__first1, const _Tp *__last1, const _Tp *__first2) +# 1175 +{ +# 1176 +if (const size_t __len = __last1 - __first1) { +# 1177 +return !std::__memcmp(__first1, __first2, __len); } +# 1178 +return true; +# 1179 +} +# 1180 +}; +# 1182 +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); +# 1189 +template< class _Tp1, class _Ref1, class _Ptr1, class +# 1190 +_Tp2, class _Ref2, class _Ptr2> bool +# 1189 +__equal_aux1(_Deque_iterator< _Tp1, _Ref1, _Ptr1> , _Deque_iterator< _Tp1, _Ref1, _Ptr1> , _Deque_iterator< _Tp2, _Ref2, _Ptr2> ); +# 1196 +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> ); +# 1202 +template< class _II1, class _II2> inline bool +# 1205 +__equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2) +# 1206 +{ +# 1207 +typedef typename iterator_traits< _II1> ::value_type _ValueType1; +# 1208 +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); +# 1211 +return std::template __equal< __simple> ::equal(__first1, __last1, __first2); +# 1212 +} +# 1214 +template< class _II1, class _II2> inline bool +# 1217 +__equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) +# 1218 +{ +# 1219 +return std::__equal_aux1(std::__niter_base(__first1), std::__niter_base(__last1), std::__niter_base(__first2)); +# 1222 +} +# 1224 +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); +# 1230 +template< class _II1, class _II2, class _Seq2, class _Cat2> bool __equal_aux(_II1, _II1, const __gnu_debug::_Safe_iterator< _II2, _Seq2, _Cat2> &); +# 1235 +template< class _II1, class _Seq1, class _Cat1, class +# 1236 +_II2, class _Seq2, class _Cat2> bool +# 1235 +__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> &); +# 1242 +template< class , class > +# 1243 +struct __lc_rai { +# 1245 +template< class _II1, class _II2> static _II1 +# 1248 +__newlast1(_II1, _II1 __last1, _II2, _II2) +# 1249 +{ return __last1; } +# 1251 +template< class _II> static bool +# 1254 +__cnd2(_II __first, _II __last) +# 1255 +{ return __first != __last; } +# 1256 +}; +# 1259 +template<> struct __lc_rai< random_access_iterator_tag, random_access_iterator_tag> { +# 1261 +template< class _RAI1, class _RAI2> static _RAI1 +# 1264 +__newlast1(_RAI1 __first1, _RAI1 __last1, _RAI2 +# 1265 +__first2, _RAI2 __last2) +# 1266 +{ +# 1268 +const typename iterator_traits< _RAI1> ::difference_type __diff1 = __last1 - __first1; +# 1270 +const typename iterator_traits< _RAI2> ::difference_type __diff2 = __last2 - __first2; +# 1271 +return (__diff2 < __diff1) ? __first1 + __diff2 : __last1; +# 1272 +} +# 1274 +template< class _RAI> static bool +# 1276 +__cnd2(_RAI, _RAI) +# 1277 +{ return true; } +# 1278 +}; +# 1280 +template< class _II1, class _II2, class _Compare> bool +# 1283 +__lexicographical_compare_impl(_II1 __first1, _II1 __last1, _II2 +# 1284 +__first2, _II2 __last2, _Compare +# 1285 +__comp) +# 1286 +{ +# 1287 +typedef typename iterator_traits< _II1> ::iterator_category _Category1; +# 1288 +typedef typename iterator_traits< _II2> ::iterator_category _Category2; +# 1289 +typedef __lc_rai< typename iterator_traits< _II1> ::iterator_category, typename iterator_traits< _II2> ::iterator_category> __rai_type; +# 1291 +__last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); +# 1292 +for (; (__first1 != __last1) && __rai_type::__cnd2(__first2, __last2); (++__first1), ((void)(++__first2))) +# 1294 +{ +# 1295 +if (__comp(__first1, __first2)) { +# 1296 +return true; } +# 1297 +if (__comp(__first2, __first1)) { +# 1298 +return false; } +# 1299 +} +# 1300 +return (__first1 == __last1) && (__first2 != __last2); +# 1301 +} +# 1303 +template< bool _BoolType> +# 1304 +struct __lexicographical_compare { +# 1306 +template< class _II1, class _II2> static bool +# 1309 +__lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) +# 1310 +{ +# 1311 +using __gnu_cxx::__ops::__iter_less_iter; +# 1312 +return std::__lexicographical_compare_impl(__first1, __last1, __first2, __last2, __iter_less_iter()); +# 1315 +} +# 1317 +template< class _II1, class _II2> static int +# 1320 +__3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) +# 1321 +{ +# 1322 +while (__first1 != __last1) +# 1323 +{ +# 1324 +if (__first2 == __last2) { +# 1325 +return +1; } +# 1326 +if ((*__first1) < (*__first2)) { +# 1327 +return -1; } +# 1328 +if ((*__first2) < (*__first1)) { +# 1329 +return +1; } +# 1330 +++__first1; +# 1331 +++__first2; +# 1332 +} +# 1333 +return ((int)(__first2 == __last2)) - 1; +# 1334 +} +# 1335 +}; +# 1338 +template<> struct __lexicographical_compare< true> { +# 1340 +template< class _Tp, class _Up> static bool +# 1343 +__lc(const _Tp *__first1, const _Tp *__last1, const _Up * +# 1344 +__first2, const _Up *__last2) +# 1345 +{ return __3way(__first1, __last1, __first2, __last2) < 0; } +# 1347 +template< class _Tp, class _Up> static ptrdiff_t +# 1350 +__3way(const _Tp *__first1, const _Tp *__last1, const _Up * +# 1351 +__first2, const _Up *__last2) +# 1352 +{ +# 1353 +const size_t __len1 = __last1 - __first1; +# 1354 +const size_t __len2 = __last2 - __first2; +# 1355 +if (const size_t __len = std::min(__len1, __len2)) { +# 1356 +if (int __result = std::__memcmp(__first1, __first2, __len)) { +# 1357 +return __result; } } +# 1358 +return (ptrdiff_t)(__len1 - __len2); +# 1359 +} +# 1360 +}; +# 1362 +template< class _II1, class _II2> inline bool +# 1365 +__lexicographical_compare_aux1(_II1 __first1, _II1 __last1, _II2 +# 1366 +__first2, _II2 __last2) +# 1367 +{ +# 1368 +typedef typename iterator_traits< _II1> ::value_type _ValueType1; +# 1369 +typedef typename iterator_traits< _II2> ::value_type _ValueType2; +# 1370 +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); +# 1383 +return std::template __lexicographical_compare< __simple> ::__lc(__first1, __last1, __first2, __last2); +# 1385 +} +# 1387 +template< class _Tp1, class _Ref1, class _Ptr1, class +# 1388 +_Tp2> bool +# 1387 +__lexicographical_compare_aux1(_Deque_iterator< _Tp1, _Ref1, _Ptr1> , _Deque_iterator< _Tp1, _Ref1, _Ptr1> , _Tp2 *, _Tp2 *); +# 1395 +template< class _Tp1, class +# 1396 +_Tp2, class _Ref2, class _Ptr2> bool +# 1395 +__lexicographical_compare_aux1(_Tp1 *, _Tp1 *, _Deque_iterator< _Tp2, _Ref2, _Ptr2> , _Deque_iterator< _Tp2, _Ref2, _Ptr2> ); +# 1402 +template< class _Tp1, class _Ref1, class _Ptr1, class +# 1403 +_Tp2, class _Ref2, class _Ptr2> bool +# 1402 +__lexicographical_compare_aux1(_Deque_iterator< _Tp1, _Ref1, _Ptr1> , _Deque_iterator< _Tp1, _Ref1, _Ptr1> , _Deque_iterator< _Tp2, _Ref2, _Ptr2> , _Deque_iterator< _Tp2, _Ref2, _Ptr2> ); +# 1411 +template< class _II1, class _II2> inline bool +# 1414 +__lexicographical_compare_aux(_II1 __first1, _II1 __last1, _II2 +# 1415 +__first2, _II2 __last2) +# 1416 +{ +# 1417 +return std::__lexicographical_compare_aux1(std::__niter_base(__first1), std::__niter_base(__last1), std::__niter_base(__first2), std::__niter_base(__last2)); +# 1421 +} +# 1423 +template< class _Iter1, class _Seq1, class _Cat1, class +# 1424 +_II2> bool +# 1423 +__lexicographical_compare_aux(const __gnu_debug::_Safe_iterator< _Iter1, _Seq1, _Cat1> &, const __gnu_debug::_Safe_iterator< _Iter1, _Seq1, _Cat1> &, _II2, _II2); +# 1431 +template< class _II1, class +# 1432 +_Iter2, class _Seq2, class _Cat2> bool +# 1431 +__lexicographical_compare_aux(_II1, _II1, const __gnu_debug::_Safe_iterator< _Iter2, _Seq2, _Cat2> &, const __gnu_debug::_Safe_iterator< _Iter2, _Seq2, _Cat2> &); +# 1439 +template< class _Iter1, class _Seq1, class _Cat1, class +# 1440 +_Iter2, class _Seq2, class _Cat2> bool +# 1439 +__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> &); +# 1448 +template< class _ForwardIterator, class _Tp, class _Compare> _ForwardIterator +# 1451 +__lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp & +# 1452 +__val, _Compare __comp) +# 1453 +{ +# 1455 +typedef typename iterator_traits< _ForwardIterator> ::difference_type _DistanceType; +# 1457 +_DistanceType __len = std::distance(__first, __last); +# 1459 +while (__len > 0) +# 1460 +{ +# 1461 +_DistanceType __half = __len >> 1; +# 1462 +_ForwardIterator __middle = __first; +# 1463 +std::advance(__middle, __half); +# 1464 +if (__comp(__middle, __val)) +# 1465 +{ +# 1466 +__first = __middle; +# 1467 +++__first; +# 1468 +__len = ((__len - __half) - 1); +# 1469 +} else { +# 1471 +__len = __half; } +# 1472 +} +# 1473 +return __first; +# 1474 +} +# 1487 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _ForwardIterator, class _Tp> inline _ForwardIterator +# 1490 +lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp & +# 1491 +__val) +# 1492 +{ +# 1497 +; +# 1499 +return std::__lower_bound(__first, __last, __val, __gnu_cxx::__ops::__iter_less_val()); +# 1501 +} +# 1506 +constexpr int __lg(int __n) +# 1507 +{ return ((((int)sizeof(int)) * 8) - 1) - __builtin_clz(__n); } +# 1510 +constexpr unsigned __lg(unsigned __n) +# 1511 +{ return ((((int)sizeof(int)) * 8) - 1) - __builtin_clz(__n); } +# 1514 +constexpr long __lg(long __n) +# 1515 +{ return ((((int)sizeof(long)) * 8) - 1) - __builtin_clzl(__n); } +# 1518 +constexpr unsigned long __lg(unsigned long __n) +# 1519 +{ return ((((int)sizeof(long)) * 8) - 1) - __builtin_clzl(__n); } +# 1522 +constexpr long long __lg(long long __n) +# 1523 +{ return ((((int)sizeof(long long)) * 8) - 1) - __builtin_clzll(__n); } +# 1526 +constexpr unsigned long long __lg(unsigned long long __n) +# 1527 +{ return ((((int)sizeof(long long)) * 8) - 1) - __builtin_clzll(__n); } +# 1543 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _II1, class _II2> inline bool +# 1546 +equal(_II1 __first1, _II1 __last1, _II2 __first2) +# 1547 +{ +# 1554 +; +# 1556 +return std::__equal_aux(__first1, __last1, __first2); +# 1557 +} +# 1574 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _IIter1, class _IIter2, class _BinaryPredicate> inline bool +# 1577 +equal(_IIter1 __first1, _IIter1 __last1, _IIter2 +# 1578 +__first2, _BinaryPredicate __binary_pred) +# 1579 +{ +# 1583 +; +# 1585 +for (; __first1 != __last1; (++__first1), ((void)(++__first2))) { +# 1586 +if (!((bool)__binary_pred(*__first1, *__first2))) { +# 1587 +return false; } } +# 1588 +return true; +# 1589 +} +# 1593 +template< class _II1, class _II2> inline bool +# 1596 +__equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) +# 1597 +{ +# 1598 +using _RATag = random_access_iterator_tag; +# 1599 +using _Cat1 = typename iterator_traits< _II1> ::iterator_category; +# 1600 +using _Cat2 = typename iterator_traits< _II2> ::iterator_category; +# 1601 +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> > ; +# 1602 +if (_RAIters()) +# 1603 +{ +# 1604 +auto __d1 = std::distance(__first1, __last1); +# 1605 +auto __d2 = std::distance(__first2, __last2); +# 1606 +if (__d1 != __d2) { +# 1607 +return false; } +# 1608 +return std::equal(__first1, __last1, __first2); +# 1609 +} +# 1611 +for (; (__first1 != __last1) && (__first2 != __last2); (++__first1), ((void)(++__first2))) { +# 1613 +if (!((*__first1) == (*__first2))) { +# 1614 +return false; } } +# 1615 +return (__first1 == __last1) && (__first2 == __last2); +# 1616 +} +# 1619 +template< class _II1, class _II2, class _BinaryPredicate> inline bool +# 1622 +__equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, _BinaryPredicate +# 1623 +__binary_pred) +# 1624 +{ +# 1625 +using _RATag = random_access_iterator_tag; +# 1626 +using _Cat1 = typename iterator_traits< _II1> ::iterator_category; +# 1627 +using _Cat2 = typename iterator_traits< _II2> ::iterator_category; +# 1628 +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> > ; +# 1629 +if (_RAIters()) +# 1630 +{ +# 1631 +auto __d1 = std::distance(__first1, __last1); +# 1632 +auto __d2 = std::distance(__first2, __last2); +# 1633 +if (__d1 != __d2) { +# 1634 +return false; } +# 1635 +return std::equal(__first1, __last1, __first2, __binary_pred); +# 1637 +} +# 1639 +for (; (__first1 != __last1) && (__first2 != __last2); (++__first1), ((void)(++__first2))) { +# 1641 +if (!((bool)__binary_pred(*__first1, *__first2))) { +# 1642 +return false; } } +# 1643 +return (__first1 == __last1) && (__first2 == __last2); +# 1644 +} +# 1664 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _II1, class _II2> inline bool +# 1667 +equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) +# 1668 +{ +# 1675 +; +# 1676 +; +# 1678 +return std::__equal4(__first1, __last1, __first2, __last2); +# 1679 +} +# 1697 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _IIter1, class _IIter2, class _BinaryPredicate> inline bool +# 1700 +equal(_IIter1 __first1, _IIter1 __last1, _IIter2 +# 1701 +__first2, _IIter2 __last2, _BinaryPredicate __binary_pred) +# 1702 +{ +# 1706 +; +# 1707 +; +# 1709 +return std::__equal4(__first1, __last1, __first2, __last2, __binary_pred); +# 1711 +} +# 1729 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _II1, class _II2> inline bool +# 1732 +lexicographical_compare(_II1 __first1, _II1 __last1, _II2 +# 1733 +__first2, _II2 __last2) +# 1734 +{ +# 1744 +; +# 1745 +; +# 1747 +return std::__lexicographical_compare_aux(__first1, __last1, __first2, __last2); +# 1749 +} +# 1764 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _II1, class _II2, class _Compare> inline bool +# 1767 +lexicographical_compare(_II1 __first1, _II1 __last1, _II2 +# 1768 +__first2, _II2 __last2, _Compare __comp) +# 1769 +{ +# 1773 +; +# 1774 +; +# 1776 +return std::__lexicographical_compare_impl(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__comp)); +# 1779 +} +# 1877 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _InputIterator1, class _InputIterator2, class +# 1878 +_BinaryPredicate> pair< _InputIterator1, _InputIterator2> +# 1881 +__mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 +# 1882 +__first2, _BinaryPredicate __binary_pred) +# 1883 +{ +# 1884 +while ((__first1 != __last1) && __binary_pred(__first1, __first2)) +# 1885 +{ +# 1886 +++__first1; +# 1887 +++__first2; +# 1888 +} +# 1889 +return pair< _InputIterator1, _InputIterator2> (__first1, __first2); +# 1890 +} +# 1905 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _InputIterator1, class _InputIterator2> inline pair< _InputIterator1, _InputIterator2> +# 1908 +mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 +# 1909 +__first2) +# 1910 +{ +# 1917 +; +# 1919 +return std::__mismatch(__first1, __last1, __first2, __gnu_cxx::__ops::__iter_equal_to_iter()); +# 1921 +} +# 1939 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _InputIterator1, class _InputIterator2, class +# 1940 +_BinaryPredicate> inline pair< _InputIterator1, _InputIterator2> +# 1943 +mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 +# 1944 +__first2, _BinaryPredicate __binary_pred) +# 1945 +{ +# 1949 +; +# 1951 +return std::__mismatch(__first1, __last1, __first2, __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); +# 1953 +} +# 1957 +template< class _InputIterator1, class _InputIterator2, class +# 1958 +_BinaryPredicate> pair< _InputIterator1, _InputIterator2> +# 1961 +__mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 +# 1962 +__first2, _InputIterator2 __last2, _BinaryPredicate +# 1963 +__binary_pred) +# 1964 +{ +# 1965 +while ((__first1 != __last1) && (__first2 != __last2) && __binary_pred(__first1, __first2)) +# 1967 +{ +# 1968 +++__first1; +# 1969 +++__first2; +# 1970 +} +# 1971 +return pair< _InputIterator1, _InputIterator2> (__first1, __first2); +# 1972 +} +# 1988 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _InputIterator1, class _InputIterator2> inline pair< _InputIterator1, _InputIterator2> +# 1991 +mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 +# 1992 +__first2, _InputIterator2 __last2) +# 1993 +{ +# 2000 +; +# 2001 +; +# 2003 +return std::__mismatch(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_equal_to_iter()); +# 2005 +} +# 2024 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _InputIterator1, class _InputIterator2, class +# 2025 +_BinaryPredicate> inline pair< _InputIterator1, _InputIterator2> +# 2028 +mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 +# 2029 +__first2, _InputIterator2 __last2, _BinaryPredicate +# 2030 +__binary_pred) +# 2031 +{ +# 2035 +; +# 2036 +; +# 2038 +return std::__mismatch(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); +# 2040 +} +# 2046 +template< class _InputIterator, class _Predicate> inline _InputIterator +# 2049 +__find_if(_InputIterator __first, _InputIterator __last, _Predicate +# 2050 +__pred, input_iterator_tag) +# 2051 +{ +# 2052 +while ((__first != __last) && (!__pred(__first))) { +# 2053 +++__first; } +# 2054 +return __first; +# 2055 +} +# 2058 +template< class _RandomAccessIterator, class _Predicate> _RandomAccessIterator +# 2061 +__find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, _Predicate +# 2062 +__pred, random_access_iterator_tag) +# 2063 +{ +# 2065 +typename iterator_traits< _RandomAccessIterator> ::difference_type __trip_count = (__last - __first) >> 2; +# 2067 +for (; __trip_count > 0; --__trip_count) +# 2068 +{ +# 2069 +if (__pred(__first)) { +# 2070 +return __first; } +# 2071 +++__first; +# 2073 +if (__pred(__first)) { +# 2074 +return __first; } +# 2075 +++__first; +# 2077 +if (__pred(__first)) { +# 2078 +return __first; } +# 2079 +++__first; +# 2081 +if (__pred(__first)) { +# 2082 +return __first; } +# 2083 +++__first; +# 2084 +} +# 2086 +switch (__last - __first) +# 2087 +{ +# 2088 +case 3: +# 2089 +if (__pred(__first)) { +# 2090 +return __first; } +# 2091 +++__first; +# 2093 +case 2: +# 2094 +if (__pred(__first)) { +# 2095 +return __first; } +# 2096 +++__first; +# 2098 +case 1: +# 2099 +if (__pred(__first)) { +# 2100 +return __first; } +# 2101 +++__first; +# 2103 +case 0: +# 2104 +default: +# 2105 +return __last; +# 2106 +} +# 2107 +} +# 2109 +template< class _Iterator, class _Predicate> inline _Iterator +# 2112 +__find_if(_Iterator __first, _Iterator __last, _Predicate __pred) +# 2113 +{ +# 2114 +return __find_if(__first, __last, __pred, std::__iterator_category(__first)); +# 2116 +} +# 2118 +template< class _InputIterator, class _Predicate> typename iterator_traits< _InputIterator> ::difference_type +# 2121 +__count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) +# 2122 +{ +# 2123 +typename iterator_traits< _InputIterator> ::difference_type __n = (0); +# 2124 +for (; __first != __last; ++__first) { +# 2125 +if (__pred(__first)) { +# 2126 +++__n; } } +# 2127 +return __n; +# 2128 +} +# 2131 +template< class _ForwardIterator1, class _ForwardIterator2, class +# 2132 +_BinaryPredicate> bool +# 2135 +__is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 +# 2136 +__first2, _BinaryPredicate __pred) +# 2137 +{ +# 2140 +for (; __first1 != __last1; (++__first1), ((void)(++__first2))) { +# 2141 +if (!__pred(__first1, __first2)) { +# 2142 +break; } } +# 2144 +if (__first1 == __last1) { +# 2145 +return true; } +# 2149 +_ForwardIterator2 __last2 = __first2; +# 2150 +std::advance(__last2, std::distance(__first1, __last1)); +# 2151 +for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) +# 2152 +{ +# 2153 +if (__scan != std::__find_if(__first1, __scan, __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) { +# 2155 +continue; } +# 2157 +auto __matches = std::__count_if(__first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); +# 2160 +if ((0 == __matches) || (std::__count_if(__scan, __last1, __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) != __matches)) { +# 2164 +return false; } +# 2165 +} +# 2166 +return true; +# 2167 +} +# 2181 "/usr/include/c++/11/bits/stl_algobase.h" 3 +template< class _ForwardIterator1, class _ForwardIterator2> inline bool +# 2184 +is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 +# 2185 +__first2) +# 2186 +{ +# 2193 +; +# 2195 +return std::__is_permutation(__first1, __last1, __first2, __gnu_cxx::__ops::__iter_equal_to_iter()); +# 2197 +} +# 2201 +} +# 158 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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 +}; +# 1635 "/usr/include/c++/11/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; }; +# 1668 "/usr/include/c++/11/limits" 3 +template<> struct numeric_limits< float> { +# 1670 +static constexpr inline bool is_specialized = true; +# 1673 +static constexpr float min() noexcept { return (1.1754944E-38F); } +# 1676 +static constexpr float max() noexcept { return (3.4028235E38F); } +# 1680 +static constexpr float lowest() noexcept { return -(3.4028235E38F); } +# 1683 +static constexpr inline int digits = 24; +# 1684 +static constexpr inline int digits10 = 6; +# 1686 +static constexpr inline int max_digits10 = ((2) + (((24) * 643L) / (2136))); +# 1689 +static constexpr inline bool is_signed = true; +# 1690 +static constexpr inline bool is_integer = false; +# 1691 +static constexpr inline bool is_exact = false; +# 1692 +static constexpr inline int radix = 2; +# 1695 +static constexpr float epsilon() noexcept { return (1.1920929E-7F); } +# 1698 +static constexpr float round_error() noexcept { return (0.5F); } +# 1700 +static constexpr inline int min_exponent = (-125); +# 1701 +static constexpr inline int min_exponent10 = (-37); +# 1702 +static constexpr inline int max_exponent = 128; +# 1703 +static constexpr inline int max_exponent10 = 38; +# 1705 +static constexpr inline bool has_infinity = (1); +# 1706 +static constexpr inline bool has_quiet_NaN = (1); +# 1707 +static constexpr inline bool has_signaling_NaN = has_quiet_NaN; +# 1708 +static constexpr inline float_denorm_style has_denorm = (((bool)1) ? denorm_present : denorm_absent); +# 1710 +static constexpr inline bool has_denorm_loss = false; +# 1714 +static constexpr float infinity() noexcept { return __builtin_huge_valf(); } +# 1717 +static constexpr float quiet_NaN() noexcept { return __builtin_nanf(""); } +# 1720 +static constexpr float signaling_NaN() noexcept { return __builtin_nansf(""); } +# 1723 +static constexpr float denorm_min() noexcept { return (1.4E-45F); } +# 1725 +static constexpr inline bool is_iec559 = (has_infinity && has_quiet_NaN && (has_denorm == (denorm_present))); +# 1727 +static constexpr inline bool is_bounded = true; +# 1728 +static constexpr inline bool is_modulo = false; +# 1730 +static constexpr inline bool traps = false; +# 1731 +static constexpr inline bool tinyness_before = false; +# 1733 +static constexpr inline float_round_style round_style = round_to_nearest; +# 1735 +}; +# 1743 +template<> struct numeric_limits< double> { +# 1745 +static constexpr inline bool is_specialized = true; +# 1748 +static constexpr double min() noexcept { return (double)(2.2250738585072013831E-308L); } +# 1751 +static constexpr double max() noexcept { return (double)(1.7976931348623157081E308L); } +# 1755 +static constexpr double lowest() noexcept { return -((double)(1.7976931348623157081E308L)); } +# 1758 +static constexpr inline int digits = 53; +# 1759 +static constexpr inline int digits10 = 15; +# 1761 +static constexpr inline int max_digits10 = ((2) + (((53) * 643L) / (2136))); +# 1764 +static constexpr inline bool is_signed = true; +# 1765 +static constexpr inline bool is_integer = false; +# 1766 +static constexpr inline bool is_exact = false; +# 1767 +static constexpr inline int radix = 2; +# 1770 +static constexpr double epsilon() noexcept { return (double)(2.2204460492503130808E-16L); } +# 1773 +static constexpr double round_error() noexcept { return (0.5); } +# 1775 +static constexpr inline int min_exponent = (-1021); +# 1776 +static constexpr inline int min_exponent10 = (-307); +# 1777 +static constexpr inline int max_exponent = 1024; +# 1778 +static constexpr inline int max_exponent10 = 308; +# 1780 +static constexpr inline bool has_infinity = (1); +# 1781 +static constexpr inline bool has_quiet_NaN = (1); +# 1782 +static constexpr inline bool has_signaling_NaN = has_quiet_NaN; +# 1783 +static constexpr inline float_denorm_style has_denorm = (((bool)1) ? denorm_present : denorm_absent); +# 1785 +static constexpr inline bool has_denorm_loss = false; +# 1789 +static constexpr double infinity() noexcept { return __builtin_huge_val(); } +# 1792 +static constexpr double quiet_NaN() noexcept { return __builtin_nan(""); } +# 1795 +static constexpr double signaling_NaN() noexcept { return __builtin_nans(""); } +# 1798 +static constexpr double denorm_min() noexcept { return (double)(4.940656458412465442E-324L); } +# 1800 +static constexpr inline bool is_iec559 = (has_infinity && has_quiet_NaN && (has_denorm == (denorm_present))); +# 1802 +static constexpr inline bool is_bounded = true; +# 1803 +static constexpr inline bool is_modulo = false; +# 1805 +static constexpr inline bool traps = false; +# 1806 +static constexpr inline bool tinyness_before = false; +# 1808 +static constexpr inline float_round_style round_style = round_to_nearest; +# 1810 +}; +# 1818 +template<> struct numeric_limits< long double> { +# 1820 +static constexpr inline bool is_specialized = true; +# 1823 +static constexpr long double min() noexcept { return (3.3621031431120935063E-4932L); } +# 1826 +static constexpr long double max() noexcept { return (1.189731495357231765E4932L); } +# 1830 +static constexpr long double lowest() noexcept { return -(1.189731495357231765E4932L); } +# 1833 +static constexpr inline int digits = 64; +# 1834 +static constexpr inline int digits10 = 18; +# 1836 +static constexpr inline int max_digits10 = ((2) + (((64) * 643L) / (2136))); +# 1839 +static constexpr inline bool is_signed = true; +# 1840 +static constexpr inline bool is_integer = false; +# 1841 +static constexpr inline bool is_exact = false; +# 1842 +static constexpr inline int radix = 2; +# 1845 +static constexpr long double epsilon() noexcept { return (1.084202172485504434E-19L); } +# 1848 +static constexpr long double round_error() noexcept { return (0.5L); } +# 1850 +static constexpr inline int min_exponent = (-16381); +# 1851 +static constexpr inline int min_exponent10 = (-4931); +# 1852 +static constexpr inline int max_exponent = 16384; +# 1853 +static constexpr inline int max_exponent10 = 4932; +# 1855 +static constexpr inline bool has_infinity = (1); +# 1856 +static constexpr inline bool has_quiet_NaN = (1); +# 1857 +static constexpr inline bool has_signaling_NaN = has_quiet_NaN; +# 1858 +static constexpr inline float_denorm_style has_denorm = (((bool)1) ? denorm_present : denorm_absent); +# 1860 +static constexpr inline bool has_denorm_loss = false; +# 1864 +static constexpr long double infinity() noexcept { return __builtin_huge_vall(); } +# 1867 +static constexpr long double quiet_NaN() noexcept { return __builtin_nanl(""); } +# 1870 +static constexpr long double signaling_NaN() noexcept { return __builtin_nansl(""); } +# 1873 +static constexpr long double denorm_min() noexcept { return (3.6E-4951L); } +# 1875 +static constexpr inline bool is_iec559 = (has_infinity && has_quiet_NaN && (has_denorm == (denorm_present))); +# 1877 +static constexpr inline bool is_bounded = true; +# 1878 +static constexpr inline bool is_modulo = false; +# 1880 +static constexpr inline bool traps = false; +# 1881 +static constexpr inline bool tinyness_before = false; +# 1883 +static constexpr inline float_round_style round_style = round_to_nearest; +# 1885 +}; +# 1892 +} +# 39 "/usr/include/c++/11/tr1/special_function_util.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 50 "/usr/include/c++/11/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/include/c++/11/tr1/special_function_util.h" 3 +template< class _Tp> inline bool +# 115 +__isnan(_Tp __x) +# 116 +{ return std::isnan(__x); } +# 133 "/usr/include/c++/11/tr1/special_function_util.h" 3 +} +# 139 +} +# 51 "/usr/include/c++/11/tr1/gamma.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 65 "/usr/include/c++/11/tr1/gamma.tcc" 3 +namespace __detail { +# 76 "/usr/include/c++/11/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/include/c++/11/tr1/gamma.tcc" 3 +template< class _Tp> inline _Tp +# 141 +__bernoulli(int __n) +# 142 +{ return __bernoulli_series< _Tp> (__n); } +# 153 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/gamma.tcc" 3 +template< class _Tp> inline _Tp +# 339 +__gamma(_Tp __x) +# 340 +{ return std::exp(__log_gamma(__x)); } +# 356 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/bessel_function.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 71 "/usr/include/c++/11/tr1/bessel_function.tcc" 3 +namespace __detail { +# 98 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/beta_function.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 65 "/usr/include/c++/11/tr1/beta_function.tcc" 3 +namespace __detail { +# 79 "/usr/include/c++/11/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/include/c++/11/tr1/beta_function.tcc" 3 +return __bet; +# 112 +} +# 127 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/ell_integral.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 59 "/usr/include/c++/11/tr1/ell_integral.tcc" 3 +namespace __detail { +# 76 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/exp_integral.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 64 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 +namespace __detail { +# 66 +template< class _Tp> _Tp __expint_E1(_Tp); +# 81 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/hypergeometric.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 60 "/usr/include/c++/11/tr1/hypergeometric.tcc" 3 +namespace __detail { +# 83 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/legendre_function.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 65 "/usr/include/c++/11/tr1/legendre_function.tcc" 3 +namespace __detail { +# 80 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/modified_bessel_func.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 65 "/usr/include/c++/11/tr1/modified_bessel_func.tcc" 3 +namespace __detail { +# 83 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/poly_hermite.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 56 "/usr/include/c++/11/tr1/poly_hermite.tcc" 3 +namespace __detail { +# 72 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/poly_laguerre.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 60 "/usr/include/c++/11/tr1/poly_laguerre.tcc" 3 +namespace __detail { +# 75 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/tr1/riemann_zeta.tcc" 3 +namespace std __attribute((__visibility__("default"))) { +# 63 "/usr/include/c++/11/tr1/riemann_zeta.tcc" 3 +namespace __detail { +# 78 "/usr/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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/include/c++/11/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 +} +# 61 "/usr/include/c++/11/bits/specfun.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 206 "/usr/include/c++/11/bits/specfun.h" 3 +inline float assoc_laguerref(unsigned __n, unsigned __m, float __x) +# 207 +{ return __detail::__assoc_laguerre< float> (__n, __m, __x); } +# 216 +inline long double assoc_laguerrel(unsigned __n, unsigned __m, long double __x) +# 217 +{ return __detail::__assoc_laguerre< long double> (__n, __m, __x); } +# 250 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 252 +assoc_laguerre(unsigned __n, unsigned __m, _Tp __x) +# 253 +{ +# 254 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 255 +return __detail::__assoc_laguerre< typename __gnu_cxx::__promote< _Tp> ::__type> (__n, __m, __x); +# 256 +} +# 267 "/usr/include/c++/11/bits/specfun.h" 3 +inline float assoc_legendref(unsigned __l, unsigned __m, float __x) +# 268 +{ return __detail::__assoc_legendre_p< float> (__l, __m, __x); } +# 276 +inline long double assoc_legendrel(unsigned __l, unsigned __m, long double __x) +# 277 +{ return __detail::__assoc_legendre_p< long double> (__l, __m, __x); } +# 296 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 298 +assoc_legendre(unsigned __l, unsigned __m, _Tp __x) +# 299 +{ +# 300 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 301 +return __detail::__assoc_legendre_p< typename __gnu_cxx::__promote< _Tp> ::__type> (__l, __m, __x); +# 302 +} +# 312 "/usr/include/c++/11/bits/specfun.h" 3 +inline float betaf(float __a, float __b) +# 313 +{ return __detail::__beta< float> (__a, __b); } +# 322 +inline long double betal(long double __a, long double __b) +# 323 +{ return __detail::__beta< long double> (__a, __b); } +# 341 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tpa, class _Tpb> inline typename __gnu_cxx::__promote_2< _Tpa, _Tpb> ::__type +# 343 +beta(_Tpa __a, _Tpb __b) +# 344 +{ +# 345 +typedef typename __gnu_cxx::__promote_2< _Tpa, _Tpb> ::__type __type; +# 346 +return __detail::__beta< typename __gnu_cxx::__promote_2< _Tpa, _Tpb> ::__type> (__a, __b); +# 347 +} +# 358 "/usr/include/c++/11/bits/specfun.h" 3 +inline float comp_ellint_1f(float __k) +# 359 +{ return __detail::__comp_ellint_1< float> (__k); } +# 368 +inline long double comp_ellint_1l(long double __k) +# 369 +{ return __detail::__comp_ellint_1< long double> (__k); } +# 389 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 391 +comp_ellint_1(_Tp __k) +# 392 +{ +# 393 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 394 +return __detail::__comp_ellint_1< typename __gnu_cxx::__promote< _Tp> ::__type> (__k); +# 395 +} +# 406 "/usr/include/c++/11/bits/specfun.h" 3 +inline float comp_ellint_2f(float __k) +# 407 +{ return __detail::__comp_ellint_2< float> (__k); } +# 416 +inline long double comp_ellint_2l(long double __k) +# 417 +{ return __detail::__comp_ellint_2< long double> (__k); } +# 436 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 438 +comp_ellint_2(_Tp __k) +# 439 +{ +# 440 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 441 +return __detail::__comp_ellint_2< typename __gnu_cxx::__promote< _Tp> ::__type> (__k); +# 442 +} +# 453 "/usr/include/c++/11/bits/specfun.h" 3 +inline float comp_ellint_3f(float __k, float __nu) +# 454 +{ return __detail::__comp_ellint_3< float> (__k, __nu); } +# 463 +inline long double comp_ellint_3l(long double __k, long double __nu) +# 464 +{ return __detail::__comp_ellint_3< long double> (__k, __nu); } +# 487 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tp, class _Tpn> inline typename __gnu_cxx::__promote_2< _Tp, _Tpn> ::__type +# 489 +comp_ellint_3(_Tp __k, _Tpn __nu) +# 490 +{ +# 491 +typedef typename __gnu_cxx::__promote_2< _Tp, _Tpn> ::__type __type; +# 492 +return __detail::__comp_ellint_3< typename __gnu_cxx::__promote_2< _Tp, _Tpn> ::__type> (__k, __nu); +# 493 +} +# 504 "/usr/include/c++/11/bits/specfun.h" 3 +inline float cyl_bessel_if(float __nu, float __x) +# 505 +{ return __detail::__cyl_bessel_i< float> (__nu, __x); } +# 514 +inline long double cyl_bessel_il(long double __nu, long double __x) +# 515 +{ return __detail::__cyl_bessel_i< long double> (__nu, __x); } +# 533 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tpnu, class _Tp> inline typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type +# 535 +cyl_bessel_i(_Tpnu __nu, _Tp __x) +# 536 +{ +# 537 +typedef typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type __type; +# 538 +return __detail::__cyl_bessel_i< typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type> (__nu, __x); +# 539 +} +# 550 "/usr/include/c++/11/bits/specfun.h" 3 +inline float cyl_bessel_jf(float __nu, float __x) +# 551 +{ return __detail::__cyl_bessel_j< float> (__nu, __x); } +# 560 +inline long double cyl_bessel_jl(long double __nu, long double __x) +# 561 +{ return __detail::__cyl_bessel_j< long double> (__nu, __x); } +# 579 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tpnu, class _Tp> inline typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type +# 581 +cyl_bessel_j(_Tpnu __nu, _Tp __x) +# 582 +{ +# 583 +typedef typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type __type; +# 584 +return __detail::__cyl_bessel_j< typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type> (__nu, __x); +# 585 +} +# 596 "/usr/include/c++/11/bits/specfun.h" 3 +inline float cyl_bessel_kf(float __nu, float __x) +# 597 +{ return __detail::__cyl_bessel_k< float> (__nu, __x); } +# 606 +inline long double cyl_bessel_kl(long double __nu, long double __x) +# 607 +{ return __detail::__cyl_bessel_k< long double> (__nu, __x); } +# 631 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tpnu, class _Tp> inline typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type +# 633 +cyl_bessel_k(_Tpnu __nu, _Tp __x) +# 634 +{ +# 635 +typedef typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type __type; +# 636 +return __detail::__cyl_bessel_k< typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type> (__nu, __x); +# 637 +} +# 648 "/usr/include/c++/11/bits/specfun.h" 3 +inline float cyl_neumannf(float __nu, float __x) +# 649 +{ return __detail::__cyl_neumann_n< float> (__nu, __x); } +# 658 +inline long double cyl_neumannl(long double __nu, long double __x) +# 659 +{ return __detail::__cyl_neumann_n< long double> (__nu, __x); } +# 679 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tpnu, class _Tp> inline typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type +# 681 +cyl_neumann(_Tpnu __nu, _Tp __x) +# 682 +{ +# 683 +typedef typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type __type; +# 684 +return __detail::__cyl_neumann_n< typename __gnu_cxx::__promote_2< _Tpnu, _Tp> ::__type> (__nu, __x); +# 685 +} +# 696 "/usr/include/c++/11/bits/specfun.h" 3 +inline float ellint_1f(float __k, float __phi) +# 697 +{ return __detail::__ellint_1< float> (__k, __phi); } +# 706 +inline long double ellint_1l(long double __k, long double __phi) +# 707 +{ return __detail::__ellint_1< long double> (__k, __phi); } +# 727 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tp, class _Tpp> inline typename __gnu_cxx::__promote_2< _Tp, _Tpp> ::__type +# 729 +ellint_1(_Tp __k, _Tpp __phi) +# 730 +{ +# 731 +typedef typename __gnu_cxx::__promote_2< _Tp, _Tpp> ::__type __type; +# 732 +return __detail::__ellint_1< typename __gnu_cxx::__promote_2< _Tp, _Tpp> ::__type> (__k, __phi); +# 733 +} +# 744 "/usr/include/c++/11/bits/specfun.h" 3 +inline float ellint_2f(float __k, float __phi) +# 745 +{ return __detail::__ellint_2< float> (__k, __phi); } +# 754 +inline long double ellint_2l(long double __k, long double __phi) +# 755 +{ return __detail::__ellint_2< long double> (__k, __phi); } +# 775 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tp, class _Tpp> inline typename __gnu_cxx::__promote_2< _Tp, _Tpp> ::__type +# 777 +ellint_2(_Tp __k, _Tpp __phi) +# 778 +{ +# 779 +typedef typename __gnu_cxx::__promote_2< _Tp, _Tpp> ::__type __type; +# 780 +return __detail::__ellint_2< typename __gnu_cxx::__promote_2< _Tp, _Tpp> ::__type> (__k, __phi); +# 781 +} +# 792 "/usr/include/c++/11/bits/specfun.h" 3 +inline float ellint_3f(float __k, float __nu, float __phi) +# 793 +{ return __detail::__ellint_3< float> (__k, __nu, __phi); } +# 802 +inline long double ellint_3l(long double __k, long double __nu, long double __phi) +# 803 +{ return __detail::__ellint_3< long double> (__k, __nu, __phi); } +# 828 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tp, class _Tpn, class _Tpp> inline typename __gnu_cxx::__promote_3< _Tp, _Tpn, _Tpp> ::__type +# 830 +ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi) +# 831 +{ +# 832 +typedef typename __gnu_cxx::__promote_3< _Tp, _Tpn, _Tpp> ::__type __type; +# 833 +return __detail::__ellint_3< typename __gnu_cxx::__promote_3< _Tp, _Tpn, _Tpp> ::__type> (__k, __nu, __phi); +# 834 +} +# 844 "/usr/include/c++/11/bits/specfun.h" 3 +inline float expintf(float __x) +# 845 +{ return __detail::__expint< float> (__x); } +# 854 +inline long double expintl(long double __x) +# 855 +{ return __detail::__expint< long double> (__x); } +# 868 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 870 +expint(_Tp __x) +# 871 +{ +# 872 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 873 +return __detail::__expint< typename __gnu_cxx::__promote< _Tp> ::__type> (__x); +# 874 +} +# 885 "/usr/include/c++/11/bits/specfun.h" 3 +inline float hermitef(unsigned __n, float __x) +# 886 +{ return __detail::__poly_hermite< float> (__n, __x); } +# 895 +inline long double hermitel(unsigned __n, long double __x) +# 896 +{ return __detail::__poly_hermite< long double> (__n, __x); } +# 916 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 918 +hermite(unsigned __n, _Tp __x) +# 919 +{ +# 920 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 921 +return __detail::__poly_hermite< typename __gnu_cxx::__promote< _Tp> ::__type> (__n, __x); +# 922 +} +# 933 "/usr/include/c++/11/bits/specfun.h" 3 +inline float laguerref(unsigned __n, float __x) +# 934 +{ return __detail::__laguerre< float> (__n, __x); } +# 943 +inline long double laguerrel(unsigned __n, long double __x) +# 944 +{ return __detail::__laguerre< long double> (__n, __x); } +# 960 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 962 +laguerre(unsigned __n, _Tp __x) +# 963 +{ +# 964 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 965 +return __detail::__laguerre< typename __gnu_cxx::__promote< _Tp> ::__type> (__n, __x); +# 966 +} +# 977 "/usr/include/c++/11/bits/specfun.h" 3 +inline float legendref(unsigned __l, float __x) +# 978 +{ return __detail::__poly_legendre_p< float> (__l, __x); } +# 987 +inline long double legendrel(unsigned __l, long double __x) +# 988 +{ return __detail::__poly_legendre_p< long double> (__l, __x); } +# 1005 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 1007 +legendre(unsigned __l, _Tp __x) +# 1008 +{ +# 1009 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 1010 +return __detail::__poly_legendre_p< typename __gnu_cxx::__promote< _Tp> ::__type> (__l, __x); +# 1011 +} +# 1022 "/usr/include/c++/11/bits/specfun.h" 3 +inline float riemann_zetaf(float __s) +# 1023 +{ return __detail::__riemann_zeta< float> (__s); } +# 1032 +inline long double riemann_zetal(long double __s) +# 1033 +{ return __detail::__riemann_zeta< long double> (__s); } +# 1056 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 1058 +riemann_zeta(_Tp __s) +# 1059 +{ +# 1060 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 1061 +return __detail::__riemann_zeta< typename __gnu_cxx::__promote< _Tp> ::__type> (__s); +# 1062 +} +# 1073 "/usr/include/c++/11/bits/specfun.h" 3 +inline float sph_besself(unsigned __n, float __x) +# 1074 +{ return __detail::__sph_bessel< float> (__n, __x); } +# 1083 +inline long double sph_bessell(unsigned __n, long double __x) +# 1084 +{ return __detail::__sph_bessel< long double> (__n, __x); } +# 1100 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 1102 +sph_bessel(unsigned __n, _Tp __x) +# 1103 +{ +# 1104 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 1105 +return __detail::__sph_bessel< typename __gnu_cxx::__promote< _Tp> ::__type> (__n, __x); +# 1106 +} +# 1117 "/usr/include/c++/11/bits/specfun.h" 3 +inline float sph_legendref(unsigned __l, unsigned __m, float __theta) +# 1118 +{ return __detail::__sph_legendre< float> (__l, __m, __theta); } +# 1128 "/usr/include/c++/11/bits/specfun.h" 3 +inline long double sph_legendrel(unsigned __l, unsigned __m, long double __theta) +# 1129 +{ return __detail::__sph_legendre< long double> (__l, __m, __theta); } +# 1147 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 1149 +sph_legendre(unsigned __l, unsigned __m, _Tp __theta) +# 1150 +{ +# 1151 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 1152 +return __detail::__sph_legendre< typename __gnu_cxx::__promote< _Tp> ::__type> (__l, __m, __theta); +# 1153 +} +# 1164 "/usr/include/c++/11/bits/specfun.h" 3 +inline float sph_neumannf(unsigned __n, float __x) +# 1165 +{ return __detail::__sph_neumann< float> (__n, __x); } +# 1174 +inline long double sph_neumannl(unsigned __n, long double __x) +# 1175 +{ return __detail::__sph_neumann< long double> (__n, __x); } +# 1191 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tp> inline typename __gnu_cxx::__promote< _Tp> ::__type +# 1193 +sph_neumann(unsigned __n, _Tp __x) +# 1194 +{ +# 1195 +typedef typename __gnu_cxx::__promote< _Tp> ::__type __type; +# 1196 +return __detail::__sph_neumann< typename __gnu_cxx::__promote< _Tp> ::__type> (__n, __x); +# 1197 +} +# 1202 +} +# 1205 +namespace __gnu_cxx __attribute((__visibility__("default"))) { +# 1219 "/usr/include/c++/11/bits/specfun.h" 3 +inline float airy_aif(float __x) +# 1220 +{ +# 1221 +float __Ai, __Bi, __Aip, __Bip; +# 1222 +std::__detail::__airy< float> (__x, __Ai, __Bi, __Aip, __Bip); +# 1223 +return __Ai; +# 1224 +} +# 1230 +inline long double airy_ail(long double __x) +# 1231 +{ +# 1232 +long double __Ai, __Bi, __Aip, __Bip; +# 1233 +std::__detail::__airy< long double> (__x, __Ai, __Bi, __Aip, __Bip); +# 1234 +return __Ai; +# 1235 +} +# 1240 +template< class _Tp> inline typename __promote< _Tp> ::__type +# 1242 +airy_ai(_Tp __x) +# 1243 +{ +# 1244 +typedef typename __promote< _Tp> ::__type __type; +# 1245 +__type __Ai, __Bi, __Aip, __Bip; +# 1246 +std::__detail::__airy< typename __promote< _Tp> ::__type> (__x, __Ai, __Bi, __Aip, __Bip); +# 1247 +return __Ai; +# 1248 +} +# 1254 +inline float airy_bif(float __x) +# 1255 +{ +# 1256 +float __Ai, __Bi, __Aip, __Bip; +# 1257 +std::__detail::__airy< float> (__x, __Ai, __Bi, __Aip, __Bip); +# 1258 +return __Bi; +# 1259 +} +# 1265 +inline long double airy_bil(long double __x) +# 1266 +{ +# 1267 +long double __Ai, __Bi, __Aip, __Bip; +# 1268 +std::__detail::__airy< long double> (__x, __Ai, __Bi, __Aip, __Bip); +# 1269 +return __Bi; +# 1270 +} +# 1275 +template< class _Tp> inline typename __promote< _Tp> ::__type +# 1277 +airy_bi(_Tp __x) +# 1278 +{ +# 1279 +typedef typename __promote< _Tp> ::__type __type; +# 1280 +__type __Ai, __Bi, __Aip, __Bip; +# 1281 +std::__detail::__airy< typename __promote< _Tp> ::__type> (__x, __Ai, __Bi, __Aip, __Bip); +# 1282 +return __Bi; +# 1283 +} +# 1295 "/usr/include/c++/11/bits/specfun.h" 3 +inline float conf_hypergf(float __a, float __c, float __x) +# 1296 +{ return std::__detail::__conf_hyperg< float> (__a, __c, __x); } +# 1306 "/usr/include/c++/11/bits/specfun.h" 3 +inline long double conf_hypergl(long double __a, long double __c, long double __x) +# 1307 +{ return std::__detail::__conf_hyperg< long double> (__a, __c, __x); } +# 1325 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tpa, class _Tpc, class _Tp> inline typename __promote_3< _Tpa, _Tpc, _Tp> ::__type +# 1327 +conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x) +# 1328 +{ +# 1329 +typedef typename __promote_3< _Tpa, _Tpc, _Tp> ::__type __type; +# 1330 +return std::__detail::__conf_hyperg< typename __promote_3< _Tpa, _Tpc, _Tp> ::__type> (__a, __c, __x); +# 1331 +} +# 1343 "/usr/include/c++/11/bits/specfun.h" 3 +inline float hypergf(float __a, float __b, float __c, float __x) +# 1344 +{ return std::__detail::__hyperg< float> (__a, __b, __c, __x); } +# 1354 "/usr/include/c++/11/bits/specfun.h" 3 +inline long double hypergl(long double __a, long double __b, long double __c, long double __x) +# 1355 +{ return std::__detail::__hyperg< long double> (__a, __b, __c, __x); } +# 1374 "/usr/include/c++/11/bits/specfun.h" 3 +template< class _Tpa, class _Tpb, class _Tpc, class _Tp> inline typename __promote_4< _Tpa, _Tpb, _Tpc, _Tp> ::__type +# 1376 +hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x) +# 1377 +{ +# 1379 +typedef typename __promote_4< _Tpa, _Tpb, _Tpc, _Tp> ::__type __type; +# 1380 +return std::__detail::__hyperg< typename __promote_4< _Tpa, _Tpb, _Tpc, _Tp> ::__type> (__a, __b, __c, __x); +# 1381 +} +# 1385 +} +# 1938 "/usr/include/c++/11/cmath" 3 +} +# 1388 "/usr/include/c++/11/bits/specfun.h" 3 +#pragma GCC visibility pop +# 38 "/usr/include/c++/11/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; +# 10626 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +namespace std { +# 10627 +constexpr bool signbit(float x); +# 10628 +constexpr bool signbit(double x); +# 10629 +constexpr bool signbit(long double x); +# 10630 +constexpr bool isfinite(float x); +# 10631 +constexpr bool isfinite(double x); +# 10632 +constexpr bool isfinite(long double x); +# 10633 +constexpr bool isnan(float x); +# 10638 +constexpr bool isnan(double x); +# 10640 +constexpr bool isnan(long double x); +# 10641 +constexpr bool isinf(float x); +# 10646 +constexpr bool isinf(double x); +# 10648 +constexpr bool isinf(long double x); +# 10649 +} +# 10805 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +namespace std { +# 10807 +template< class T> extern T __pow_helper(T, int); +# 10808 +template< class T> extern T __cmath_power(T, unsigned); +# 10809 +} +# 10811 +using std::abs; +# 10812 +using std::fabs; +# 10813 +using std::ceil; +# 10814 +using std::floor; +# 10815 +using std::sqrt; +# 10817 +using std::pow; +# 10819 +using std::log; +# 10820 +using std::log10; +# 10821 +using std::fmod; +# 10822 +using std::modf; +# 10823 +using std::exp; +# 10824 +using std::frexp; +# 10825 +using std::ldexp; +# 10826 +using std::asin; +# 10827 +using std::sin; +# 10828 +using std::sinh; +# 10829 +using std::acos; +# 10830 +using std::cos; +# 10831 +using std::cosh; +# 10832 +using std::atan; +# 10833 +using std::atan2; +# 10834 +using std::tan; +# 10835 +using std::tanh; +# 11206 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +namespace std { +# 11215 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern inline long long abs(long long); +# 11225 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern inline long abs(long); +# 11226 +extern constexpr float abs(float); +# 11227 +extern constexpr double abs(double); +# 11228 +extern constexpr float fabs(float); +# 11229 +extern constexpr float ceil(float); +# 11230 +extern constexpr float floor(float); +# 11231 +extern constexpr float sqrt(float); +# 11232 +extern constexpr float pow(float, float); +# 11237 +template< class _Tp, class _Up> extern constexpr typename __gnu_cxx::__promote_2< _Tp, _Up> ::__type pow(_Tp, _Up); +# 11247 +extern constexpr float log(float); +# 11248 +extern constexpr float log10(float); +# 11249 +extern constexpr float fmod(float, float); +# 11250 +extern inline float modf(float, float *); +# 11251 +extern constexpr float exp(float); +# 11252 +extern inline float frexp(float, int *); +# 11253 +extern constexpr float ldexp(float, int); +# 11254 +extern constexpr float asin(float); +# 11255 +extern constexpr float sin(float); +# 11256 +extern constexpr float sinh(float); +# 11257 +extern constexpr float acos(float); +# 11258 +extern constexpr float cos(float); +# 11259 +extern constexpr float cosh(float); +# 11260 +extern constexpr float atan(float); +# 11261 +extern constexpr float atan2(float, float); +# 11262 +extern constexpr float tan(float); +# 11263 +extern constexpr float tanh(float); +# 11350 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +} +# 11456 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +namespace std { +# 11457 +constexpr float logb(float a); +# 11458 +constexpr int ilogb(float a); +# 11459 +constexpr float scalbn(float a, int b); +# 11460 +constexpr float scalbln(float a, long b); +# 11461 +constexpr float exp2(float a); +# 11462 +constexpr float expm1(float a); +# 11463 +constexpr float log2(float a); +# 11464 +constexpr float log1p(float a); +# 11465 +constexpr float acosh(float a); +# 11466 +constexpr float asinh(float a); +# 11467 +constexpr float atanh(float a); +# 11468 +constexpr float hypot(float a, float b); +# 11469 +constexpr float cbrt(float a); +# 11470 +constexpr float erf(float a); +# 11471 +constexpr float erfc(float a); +# 11472 +constexpr float lgamma(float a); +# 11473 +constexpr float tgamma(float a); +# 11474 +constexpr float copysign(float a, float b); +# 11475 +constexpr float nextafter(float a, float b); +# 11476 +constexpr float remainder(float a, float b); +# 11477 +inline float remquo(float a, float b, int * quo); +# 11478 +constexpr float round(float a); +# 11479 +constexpr long lround(float a); +# 11480 +constexpr long long llround(float a); +# 11481 +constexpr float trunc(float a); +# 11482 +constexpr float rint(float a); +# 11483 +constexpr long lrint(float a); +# 11484 +constexpr long long llrint(float a); +# 11485 +constexpr float nearbyint(float a); +# 11486 +constexpr float fdim(float a, float b); +# 11487 +constexpr float fma(float a, float b, float c); +# 11488 +constexpr float fmax(float a, float b); +# 11489 +constexpr float fmin(float a, float b); +# 11490 +} +# 11595 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline float exp10(const float a); +# 11597 +static inline float rsqrt(const float a); +# 11599 +static inline float rcbrt(const float a); +# 11601 +static inline float sinpi(const float a); +# 11603 +static inline float cospi(const float a); +# 11605 +static inline void sincospi(const float a, float *const sptr, float *const cptr); +# 11607 +static inline void sincos(const float a, float *const sptr, float *const cptr); +# 11609 +static inline float j0(const float a); +# 11611 +static inline float j1(const float a); +# 11613 +static inline float jn(const int n, const float a); +# 11615 +static inline float y0(const float a); +# 11617 +static inline float y1(const float a); +# 11619 +static inline float yn(const int n, const float a); +# 11621 +__attribute__((unused)) static inline float cyl_bessel_i0(const float a); +# 11623 +__attribute__((unused)) static inline float cyl_bessel_i1(const float a); +# 11625 +static inline float erfinv(const float a); +# 11627 +static inline float erfcinv(const float a); +# 11629 +static inline float normcdfinv(const float a); +# 11631 +static inline float normcdf(const float a); +# 11633 +static inline float erfcx(const float a); +# 11635 +static inline double copysign(const double a, const float b); +# 11637 +static inline double copysign(const float a, const double b); +# 11645 +static inline unsigned min(const unsigned a, const unsigned b); +# 11653 +static inline unsigned min(const int a, const unsigned b); +# 11661 +static inline unsigned min(const unsigned a, const int b); +# 11669 +static inline long min(const long a, const long b); +# 11677 +static inline unsigned long min(const unsigned long a, const unsigned long b); +# 11685 +static inline unsigned long min(const long a, const unsigned long b); +# 11693 +static inline unsigned long min(const unsigned long a, const long b); +# 11701 +static inline long long min(const long long a, const long long b); +# 11709 +static inline unsigned long long min(const unsigned long long a, const unsigned long long b); +# 11717 +static inline unsigned long long min(const long long a, const unsigned long long b); +# 11725 +static inline unsigned long long min(const unsigned long long a, const long long b); +# 11736 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline float min(const float a, const float b); +# 11747 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline double min(const double a, const double b); +# 11757 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline double min(const float a, const double b); +# 11767 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline double min(const double a, const float b); +# 11775 +static inline unsigned max(const unsigned a, const unsigned b); +# 11783 +static inline unsigned max(const int a, const unsigned b); +# 11791 +static inline unsigned max(const unsigned a, const int b); +# 11799 +static inline long max(const long a, const long b); +# 11807 +static inline unsigned long max(const unsigned long a, const unsigned long b); +# 11815 +static inline unsigned long max(const long a, const unsigned long b); +# 11823 +static inline unsigned long max(const unsigned long a, const long b); +# 11831 +static inline long long max(const long long a, const long long b); +# 11839 +static inline unsigned long long max(const unsigned long long a, const unsigned long long b); +# 11847 +static inline unsigned long long max(const long long a, const unsigned long long b); +# 11855 +static inline unsigned long long max(const unsigned long long a, const long long b); +# 11866 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline float max(const float a, const float b); +# 11877 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline double max(const double a, const double b); +# 11887 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline double max(const float a, const double b); +# 11897 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +static inline double max(const double a, const float b); +# 11909 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +extern "C" { +# 11910 +__attribute__((unused)) inline void *__nv_aligned_device_malloc(size_t size, size_t align) +# 11911 +{int volatile ___ = 1;(void)size;(void)align; +# 11914 +::exit(___);} +#if 0 +# 11911 +{ +# 11912 +__attribute__((unused)) void *__nv_aligned_device_malloc_impl(size_t, size_t); +# 11913 +return __nv_aligned_device_malloc_impl(size, align); +# 11914 +} +#endif +# 11915 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/math_functions.h" +} +# 758 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +extern "C" { +# 3215 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline int __vimax_s32_relu(const int a, const int b); +# 3227 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __vimax_s16x2_relu(const unsigned a, const unsigned b); +# 3236 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline int __vimin_s32_relu(const int a, const int b); +# 3248 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __vimin_s16x2_relu(const unsigned a, const unsigned b); +# 3257 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline int __vimax3_s32(const int a, const int b, const int c); +# 3269 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __vimax3_s16x2(const unsigned a, const unsigned b, const unsigned c); +# 3278 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __vimax3_u32(const unsigned a, const unsigned b, const unsigned c); +# 3290 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __vimax3_u16x2(const unsigned a, const unsigned b, const unsigned c); +# 3299 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline int __vimin3_s32(const int a, const int b, const int c); +# 3311 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __vimin3_s16x2(const unsigned a, const unsigned b, const unsigned c); +# 3320 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __vimin3_u32(const unsigned a, const unsigned b, const unsigned c); +# 3332 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __vimin3_u16x2(const unsigned a, const unsigned b, const unsigned c); +# 3341 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline int __vimax3_s32_relu(const int a, const int b, const int c); +# 3353 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __vimax3_s16x2_relu(const unsigned a, const unsigned b, const unsigned c); +# 3362 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline int __vimin3_s32_relu(const int a, const int b, const int c); +# 3374 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __vimin3_s16x2_relu(const unsigned a, const unsigned b, const unsigned c); +# 3383 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline int __viaddmax_s32(const int a, const int b, const int c); +# 3395 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __viaddmax_s16x2(const unsigned a, const unsigned b, const unsigned c); +# 3404 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __viaddmax_u32(const unsigned a, const unsigned b, const unsigned c); +# 3416 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __viaddmax_u16x2(const unsigned a, const unsigned b, const unsigned c); +# 3425 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline int __viaddmin_s32(const int a, const int b, const int c); +# 3437 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __viaddmin_s16x2(const unsigned a, const unsigned b, const unsigned c); +# 3446 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __viaddmin_u32(const unsigned a, const unsigned b, const unsigned c); +# 3458 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __viaddmin_u16x2(const unsigned a, const unsigned b, const unsigned c); +# 3468 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline int __viaddmax_s32_relu(const int a, const int b, const int c); +# 3480 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __viaddmax_s16x2_relu(const unsigned a, const unsigned b, const unsigned c); +# 3490 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline int __viaddmin_s32_relu(const int a, const int b, const int c); +# 3502 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __viaddmin_s16x2_relu(const unsigned a, const unsigned b, const unsigned c); +# 3511 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline int __vibmax_s32(const int a, const int b, bool *const pred); +# 3520 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __vibmax_u32(const unsigned a, const unsigned b, bool *const pred); +# 3529 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline int __vibmin_s32(const int a, const int b, bool *const pred); +# 3538 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __vibmin_u32(const unsigned a, const unsigned b, bool *const pred); +# 3552 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __vibmax_s16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo); +# 3566 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __vibmax_u16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo); +# 3580 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __vibmin_s16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo); +# 3594 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +static inline unsigned __vibmin_u16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo); +# 3601 +} +# 108 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +static inline int __vimax_s32_relu(const int a, const int b) { +# 115 +int ans = max(a, b); +# 117 +return (ans > 0) ? ans : 0; +# 119 +} +# 121 +static inline unsigned __vimax_s16x2_relu(const unsigned a, const unsigned b) { +# 122 +unsigned res; +# 130 +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 131 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 133 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 134 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 137 +short aS_lo = *((short *)(&aU_lo)); +# 138 +short aS_hi = *((short *)(&aU_hi)); +# 140 +short bS_lo = *((short *)(&bU_lo)); +# 141 +short bS_hi = *((short *)(&bU_hi)); +# 144 +short ansS_lo = (short)max(aS_lo, bS_lo); +# 145 +short ansS_hi = (short)max(aS_hi, bS_hi); +# 148 +if (ansS_lo < 0) { ansS_lo = (0); } +# 149 +if (ansS_hi < 0) { ansS_hi = (0); } +# 152 +unsigned short ansU_lo = *((unsigned short *)(&ansS_lo)); +# 153 +unsigned short ansU_hi = *((unsigned short *)(&ansS_hi)); +# 156 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 159 +return res; +# 160 +} +# 162 +static inline int __vimin_s32_relu(const int a, const int b) { +# 169 +int ans = min(a, b); +# 171 +return (ans > 0) ? ans : 0; +# 173 +} +# 175 +static inline unsigned __vimin_s16x2_relu(const unsigned a, const unsigned b) { +# 176 +unsigned res; +# 184 +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 185 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 187 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 188 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 191 +short aS_lo = *((short *)(&aU_lo)); +# 192 +short aS_hi = *((short *)(&aU_hi)); +# 194 +short bS_lo = *((short *)(&bU_lo)); +# 195 +short bS_hi = *((short *)(&bU_hi)); +# 198 +short ansS_lo = (short)min(aS_lo, bS_lo); +# 199 +short ansS_hi = (short)min(aS_hi, bS_hi); +# 202 +if (ansS_lo < 0) { ansS_lo = (0); } +# 203 +if (ansS_hi < 0) { ansS_hi = (0); } +# 206 +unsigned short ansU_lo = *((unsigned short *)(&ansS_lo)); +# 207 +unsigned short ansU_hi = *((unsigned short *)(&ansS_hi)); +# 210 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 213 +return res; +# 214 +} +# 216 +static inline int __vimax3_s32(const int a, const int b, const int c) { +# 226 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +return max(max(a, b), c); +# 228 +} +# 230 +static inline unsigned __vimax3_s16x2(const unsigned a, const unsigned b, const unsigned c) { +# 231 +unsigned res; +# 243 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 244 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 246 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 247 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 249 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 250 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 253 +short aS_lo = *((short *)(&aU_lo)); +# 254 +short aS_hi = *((short *)(&aU_hi)); +# 256 +short bS_lo = *((short *)(&bU_lo)); +# 257 +short bS_hi = *((short *)(&bU_hi)); +# 259 +short cS_lo = *((short *)(&cU_lo)); +# 260 +short cS_hi = *((short *)(&cU_hi)); +# 263 +short ansS_lo = (short)max(max(aS_lo, bS_lo), cS_lo); +# 264 +short ansS_hi = (short)max(max(aS_hi, bS_hi), cS_hi); +# 267 +unsigned short ansU_lo = *((unsigned short *)(&ansS_lo)); +# 268 +unsigned short ansU_hi = *((unsigned short *)(&ansS_hi)); +# 271 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 273 +return res; +# 274 +} +# 276 +static inline unsigned __vimax3_u32(const unsigned a, const unsigned b, const unsigned c) { +# 286 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +return max(max(a, b), c); +# 288 +} +# 290 +static inline unsigned __vimax3_u16x2(const unsigned a, const unsigned b, const unsigned c) { +# 291 +unsigned res; +# 302 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 303 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 305 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 306 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 308 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 309 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 312 +unsigned short ansU_lo = (unsigned short)max(max(aU_lo, bU_lo), cU_lo); +# 313 +unsigned short ansU_hi = (unsigned short)max(max(aU_hi, bU_hi), cU_hi); +# 316 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 319 +return res; +# 320 +} +# 322 +static inline int __vimin3_s32(const int a, const int b, const int c) { +# 332 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +return min(min(a, b), c); +# 334 +} +# 336 +static inline unsigned __vimin3_s16x2(const unsigned a, const unsigned b, const unsigned c) { +# 337 +unsigned res; +# 348 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 349 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 351 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 352 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 354 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 355 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 358 +short aS_lo = *((short *)(&aU_lo)); +# 359 +short aS_hi = *((short *)(&aU_hi)); +# 361 +short bS_lo = *((short *)(&bU_lo)); +# 362 +short bS_hi = *((short *)(&bU_hi)); +# 364 +short cS_lo = *((short *)(&cU_lo)); +# 365 +short cS_hi = *((short *)(&cU_hi)); +# 368 +short ansS_lo = (short)min(min(aS_lo, bS_lo), cS_lo); +# 369 +short ansS_hi = (short)min(min(aS_hi, bS_hi), cS_hi); +# 372 +unsigned short ansU_lo = *((unsigned short *)(&ansS_lo)); +# 373 +unsigned short ansU_hi = *((unsigned short *)(&ansS_hi)); +# 376 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 379 +return res; +# 380 +} +# 382 +static inline unsigned __vimin3_u32(const unsigned a, const unsigned b, const unsigned c) { +# 392 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +return min(min(a, b), c); +# 394 +} +# 396 +static inline unsigned __vimin3_u16x2(const unsigned a, const unsigned b, const unsigned c) { +# 397 +unsigned res; +# 408 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 409 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 411 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 412 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 414 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 415 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 418 +unsigned short ansU_lo = (unsigned short)min(min(aU_lo, bU_lo), cU_lo); +# 419 +unsigned short ansU_hi = (unsigned short)min(min(aU_hi, bU_hi), cU_hi); +# 422 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 425 +return res; +# 426 +} +# 428 +static inline int __vimax3_s32_relu(const int a, const int b, const int c) { +# 438 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +int ans = max(max(a, b), c); +# 440 +return (ans > 0) ? ans : 0; +# 442 +} +# 444 +static inline unsigned __vimax3_s16x2_relu(const unsigned a, const unsigned b, const unsigned c) { +# 445 +unsigned res; +# 456 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 457 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 459 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 460 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 462 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 463 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 466 +short aS_lo = *((short *)(&aU_lo)); +# 467 +short aS_hi = *((short *)(&aU_hi)); +# 469 +short bS_lo = *((short *)(&bU_lo)); +# 470 +short bS_hi = *((short *)(&bU_hi)); +# 472 +short cS_lo = *((short *)(&cU_lo)); +# 473 +short cS_hi = *((short *)(&cU_hi)); +# 476 +short ansS_lo = (short)max(max(aS_lo, bS_lo), cS_lo); +# 477 +short ansS_hi = (short)max(max(aS_hi, bS_hi), cS_hi); +# 480 +if (ansS_lo < 0) { ansS_lo = (0); } +# 481 +if (ansS_hi < 0) { ansS_hi = (0); } +# 484 +unsigned short ansU_lo = *((unsigned short *)(&ansS_lo)); +# 485 +unsigned short ansU_hi = *((unsigned short *)(&ansS_hi)); +# 488 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 491 +return res; +# 492 +} +# 494 +static inline int __vimin3_s32_relu(const int a, const int b, const int c) { +# 504 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +int ans = min(min(a, b), c); +# 506 +return (ans > 0) ? ans : 0; +# 508 +} +# 510 +static inline unsigned __vimin3_s16x2_relu(const unsigned a, const unsigned b, const unsigned c) { +# 511 +unsigned res; +# 522 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 523 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 525 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 526 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 528 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 529 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 532 +short aS_lo = *((short *)(&aU_lo)); +# 533 +short aS_hi = *((short *)(&aU_hi)); +# 535 +short bS_lo = *((short *)(&bU_lo)); +# 536 +short bS_hi = *((short *)(&bU_hi)); +# 538 +short cS_lo = *((short *)(&cU_lo)); +# 539 +short cS_hi = *((short *)(&cU_hi)); +# 542 +short ansS_lo = (short)min(min(aS_lo, bS_lo), cS_lo); +# 543 +short ansS_hi = (short)min(min(aS_hi, bS_hi), cS_hi); +# 546 +if (ansS_lo < 0) { ansS_lo = (0); } +# 547 +if (ansS_hi < 0) { ansS_hi = (0); } +# 550 +unsigned short ansU_lo = *((unsigned short *)(&ansS_lo)); +# 551 +unsigned short ansU_hi = *((unsigned short *)(&ansS_hi)); +# 554 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 557 +return res; +# 558 +} +# 560 +static inline int __viaddmax_s32(const int a, const int b, const int c) { +# 570 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +return max(a + b, c); +# 572 +} +# 574 +static inline unsigned __viaddmax_s16x2(const unsigned a, const unsigned b, const unsigned c) { +# 575 +unsigned res; +# 586 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 587 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 589 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 590 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 592 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 593 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 596 +short aS_lo = *((short *)(&aU_lo)); +# 597 +short aS_hi = *((short *)(&aU_hi)); +# 599 +short bS_lo = *((short *)(&bU_lo)); +# 600 +short bS_hi = *((short *)(&bU_hi)); +# 602 +short cS_lo = *((short *)(&cU_lo)); +# 603 +short cS_hi = *((short *)(&cU_hi)); +# 606 +short ansS_lo = (short)max((short)(aS_lo + bS_lo), cS_lo); +# 607 +short ansS_hi = (short)max((short)(aS_hi + bS_hi), cS_hi); +# 610 +unsigned short ansU_lo = *((unsigned short *)(&ansS_lo)); +# 611 +unsigned short ansU_hi = *((unsigned short *)(&ansS_hi)); +# 614 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 617 +return res; +# 618 +} +# 620 +static inline unsigned __viaddmax_u32(const unsigned a, const unsigned b, const unsigned c) { +# 630 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +return max(a + b, c); +# 632 +} +# 634 +static inline unsigned __viaddmax_u16x2(const unsigned a, const unsigned b, const unsigned c) { +# 635 +unsigned res; +# 646 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 647 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 649 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 650 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 652 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 653 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 656 +unsigned short ansU_lo = (unsigned short)max((unsigned short)(aU_lo + bU_lo), cU_lo); +# 657 +unsigned short ansU_hi = (unsigned short)max((unsigned short)(aU_hi + bU_hi), cU_hi); +# 660 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 663 +return res; +# 664 +} +# 666 +static inline int __viaddmin_s32(const int a, const int b, const int c) { +# 676 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +return min(a + b, c); +# 678 +} +# 680 +static inline unsigned __viaddmin_s16x2(const unsigned a, const unsigned b, const unsigned c) { +# 681 +unsigned res; +# 692 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 693 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 695 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 696 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 698 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 699 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 702 +short aS_lo = *((short *)(&aU_lo)); +# 703 +short aS_hi = *((short *)(&aU_hi)); +# 705 +short bS_lo = *((short *)(&bU_lo)); +# 706 +short bS_hi = *((short *)(&bU_hi)); +# 708 +short cS_lo = *((short *)(&cU_lo)); +# 709 +short cS_hi = *((short *)(&cU_hi)); +# 712 +short ansS_lo = (short)min((short)(aS_lo + bS_lo), cS_lo); +# 713 +short ansS_hi = (short)min((short)(aS_hi + bS_hi), cS_hi); +# 716 +unsigned short ansU_lo = *((unsigned short *)(&ansS_lo)); +# 717 +unsigned short ansU_hi = *((unsigned short *)(&ansS_hi)); +# 720 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 723 +return res; +# 724 +} +# 726 +static inline unsigned __viaddmin_u32(const unsigned a, const unsigned b, const unsigned c) { +# 736 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +return min(a + b, c); +# 738 +} +# 740 +static inline unsigned __viaddmin_u16x2(const unsigned a, const unsigned b, const unsigned c) { +# 741 +unsigned res; +# 752 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 753 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 755 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 756 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 758 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 759 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 762 +unsigned short ansU_lo = (unsigned short)min((unsigned short)(aU_lo + bU_lo), cU_lo); +# 763 +unsigned short ansU_hi = (unsigned short)min((unsigned short)(aU_hi + bU_hi), cU_hi); +# 766 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 769 +return res; +# 770 +} +# 772 +static inline int __viaddmax_s32_relu(const int a, const int b, const int c) { +# 782 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +int ans = max(a + b, c); +# 784 +return (ans > 0) ? ans : 0; +# 786 +} +# 788 +static inline unsigned __viaddmax_s16x2_relu(const unsigned a, const unsigned b, const unsigned c) { +# 789 +unsigned res; +# 800 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 801 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 803 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 804 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 806 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 807 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 810 +short aS_lo = *((short *)(&aU_lo)); +# 811 +short aS_hi = *((short *)(&aU_hi)); +# 813 +short bS_lo = *((short *)(&bU_lo)); +# 814 +short bS_hi = *((short *)(&bU_hi)); +# 816 +short cS_lo = *((short *)(&cU_lo)); +# 817 +short cS_hi = *((short *)(&cU_hi)); +# 820 +short ansS_lo = (short)max((short)(aS_lo + bS_lo), cS_lo); +# 821 +short ansS_hi = (short)max((short)(aS_hi + bS_hi), cS_hi); +# 823 +if (ansS_lo < 0) { ansS_lo = (0); } +# 824 +if (ansS_hi < 0) { ansS_hi = (0); } +# 827 +unsigned short ansU_lo = *((unsigned short *)(&ansS_lo)); +# 828 +unsigned short ansU_hi = *((unsigned short *)(&ansS_hi)); +# 831 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 834 +return res; +# 835 +} +# 837 +static inline int __viaddmin_s32_relu(const int a, const int b, const int c) { +# 847 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +int ans = min(a + b, c); +# 849 +return (ans > 0) ? ans : 0; +# 851 +} +# 853 +static inline unsigned __viaddmin_s16x2_relu(const unsigned a, const unsigned b, const unsigned c) { +# 854 +unsigned res; +# 865 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 866 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 868 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 869 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 871 +unsigned short cU_lo = (unsigned short)(c & 65535U); +# 872 +unsigned short cU_hi = (unsigned short)(c >> 16); +# 875 +short aS_lo = *((short *)(&aU_lo)); +# 876 +short aS_hi = *((short *)(&aU_hi)); +# 878 +short bS_lo = *((short *)(&bU_lo)); +# 879 +short bS_hi = *((short *)(&bU_hi)); +# 881 +short cS_lo = *((short *)(&cU_lo)); +# 882 +short cS_hi = *((short *)(&cU_hi)); +# 885 +short ansS_lo = (short)min((short)(aS_lo + bS_lo), cS_lo); +# 886 +short ansS_hi = (short)min((short)(aS_hi + bS_hi), cS_hi); +# 888 +if (ansS_lo < 0) { ansS_lo = (0); } +# 889 +if (ansS_hi < 0) { ansS_hi = (0); } +# 892 +unsigned short ansU_lo = *((unsigned short *)(&ansS_lo)); +# 893 +unsigned short ansU_hi = *((unsigned short *)(&ansS_hi)); +# 896 +res = (((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16)); +# 899 +return res; +# 900 +} +# 904 +static inline int __vibmax_s32(const int a, const int b, bool *const pred) { +# 918 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +int ans = max(a, b); +# 920 +(*pred) = (a >= b); +# 921 +return ans; +# 923 +} +# 925 +static inline unsigned __vibmax_u32(const unsigned a, const unsigned b, bool *const pred) { +# 939 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +unsigned ans = max(a, b); +# 941 +(*pred) = (a >= b); +# 942 +return ans; +# 944 +} +# 947 +static inline int __vibmin_s32(const int a, const int b, bool *const pred) { +# 961 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +int ans = min(a, b); +# 963 +(*pred) = (a <= b); +# 964 +return ans; +# 966 +} +# 969 +static inline unsigned __vibmin_u32(const unsigned a, const unsigned b, bool *const pred) { +# 983 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +unsigned ans = min(a, b); +# 985 +(*pred) = (a <= b); +# 986 +return ans; +# 988 +} +# 990 +static inline unsigned __vibmax_s16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo) { +# 1012 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 1013 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 1015 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 1016 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 1019 +short aS_lo = *((short *)(&aU_lo)); +# 1020 +short aS_hi = *((short *)(&aU_hi)); +# 1022 +short bS_lo = *((short *)(&bU_lo)); +# 1023 +short bS_hi = *((short *)(&bU_hi)); +# 1026 +short ansS_lo = (short)max(aS_lo, bS_lo); +# 1027 +short ansS_hi = (short)max(aS_hi, bS_hi); +# 1029 +(*pred_hi) = (aS_hi >= bS_hi); +# 1030 +(*pred_lo) = (aS_lo >= bS_lo); +# 1033 +unsigned short ansU_lo = *((unsigned short *)(&ansS_lo)); +# 1034 +unsigned short ansU_hi = *((unsigned short *)(&ansS_hi)); +# 1037 +unsigned ans = ((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16); +# 1039 +return ans; +# 1041 +} +# 1043 +static inline unsigned __vibmax_u16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo) { +# 1065 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 1066 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 1068 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 1069 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 1072 +unsigned short ansU_lo = (unsigned short)max(aU_lo, bU_lo); +# 1073 +unsigned short ansU_hi = (unsigned short)max(aU_hi, bU_hi); +# 1075 +(*pred_hi) = (aU_hi >= bU_hi); +# 1076 +(*pred_lo) = (aU_lo >= bU_lo); +# 1079 +unsigned ans = ((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16); +# 1081 +return ans; +# 1083 +} +# 1085 +static inline unsigned __vibmin_s16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo) { +# 1107 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 1108 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 1110 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 1111 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 1114 +short aS_lo = *((short *)(&aU_lo)); +# 1115 +short aS_hi = *((short *)(&aU_hi)); +# 1117 +short bS_lo = *((short *)(&bU_lo)); +# 1118 +short bS_hi = *((short *)(&bU_hi)); +# 1121 +short ansS_lo = (short)min(aS_lo, bS_lo); +# 1122 +short ansS_hi = (short)min(aS_hi, bS_hi); +# 1124 +(*pred_hi) = (aS_hi <= bS_hi); +# 1125 +(*pred_lo) = (aS_lo <= bS_lo); +# 1128 +unsigned short ansU_lo = *((unsigned short *)(&ansS_lo)); +# 1129 +unsigned short ansU_hi = *((unsigned short *)(&ansS_hi)); +# 1132 +unsigned ans = ((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16); +# 1134 +return ans; +# 1136 +} +# 1138 +static inline unsigned __vibmin_u16x2(const unsigned a, const unsigned b, bool *const pred_hi, bool *const pred_lo) { +# 1160 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.hpp" +unsigned short aU_lo = (unsigned short)(a & 65535U); +# 1161 +unsigned short aU_hi = (unsigned short)(a >> 16); +# 1163 +unsigned short bU_lo = (unsigned short)(b & 65535U); +# 1164 +unsigned short bU_hi = (unsigned short)(b >> 16); +# 1167 +unsigned short ansU_lo = (unsigned short)min(aU_lo, bU_lo); +# 1168 +unsigned short ansU_hi = (unsigned short)min(aU_hi, bU_hi); +# 1170 +(*pred_hi) = (aU_hi <= bU_hi); +# 1171 +(*pred_lo) = (aU_lo <= bU_lo); +# 1174 +unsigned ans = ((unsigned)ansU_lo) | (((unsigned)ansU_hi) << 16); +# 1176 +return ans; +# 1178 +} +# 89 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/device_atomic_functions.h" +extern "C" { +# 160 +} +# 169 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_double_functions.h" +extern "C" { +# 1142 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +# 95 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +extern "C" { +# 1508 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +} +# 1515 +__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 +# 1515 +{ } +#endif +# 1517 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +__attribute__((unused)) static inline int syncthreads_count(bool pred) {int volatile ___ = 1;(void)pred;::exit(___);} +#if 0 +# 1517 +{ } +#endif +# 1519 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +__attribute__((unused)) static inline bool syncthreads_and(bool pred) {int volatile ___ = 1;(void)pred;::exit(___);} +#if 0 +# 1519 +{ } +#endif +# 1521 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +__attribute__((unused)) static inline bool syncthreads_or(bool pred) {int volatile ___ = 1;(void)pred;::exit(___);} +#if 0 +# 1521 +{ } +#endif +# 1526 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +__attribute__((unused)) static inline unsigned __isGlobal(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1526 +{ } +#endif +# 1527 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +__attribute__((unused)) static inline unsigned __isShared(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1527 +{ } +#endif +# 1528 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +__attribute__((unused)) static inline unsigned __isConstant(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1528 +{ } +#endif +# 1529 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +__attribute__((unused)) static inline unsigned __isLocal(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1529 +{ } +#endif +# 1531 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_20_intrinsics.h" +__attribute__((unused)) static inline unsigned __isGridConstant(const void *ptr) {int volatile ___ = 1;(void)ptr;::exit(___);} +#if 0 +# 1531 +{ } +#endif +# 1533 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +# 1533 +{ } +#endif +# 1534 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +# 1534 +{ } +#endif +# 1535 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +# 1535 +{ } +#endif +# 1536 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +# 1536 +{ } +#endif +# 1538 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +# 1538 +{ } +#endif +# 1541 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +# 1541 +{ } +#endif +# 1542 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +# 1542 +{ } +#endif +# 1543 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +# 1543 +{ } +#endif +# 1544 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +# 1544 +{ } +#endif +# 1546 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +# 1546 +{ } +#endif +# 123 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/sm_30_intrinsics.h" +__attribute__((unused)) static inline unsigned __activemask() {int volatile ___ = 1;::exit(___);} +#if 0 +# 131 +{ } +#endif +# 140 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_80_rt.h" +} +# 92 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_90_rt.h" +__attribute__((unused)) static inline unsigned __clusterDimIsSpecified() {int volatile ___ = 1;::exit(___);} +#if 0 +# 97 +{ } +#endif +# 98 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_90_rt.h" +__attribute__((unused)) static inline dim3 __clusterDim() {int volatile ___ = 1;::exit(___);} +#if 0 +# 98 +{ } +#endif +# 99 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_90_rt.h" +__attribute__((unused)) static inline dim3 __clusterRelativeBlockIdx() {int volatile ___ = 1;::exit(___);} +#if 0 +# 99 +{ } +#endif +# 100 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_90_rt.h" +__attribute__((unused)) static inline dim3 __clusterGridDimInClusters() {int volatile ___ = 1;::exit(___);} +#if 0 +# 100 +{ } +#endif +# 101 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_90_rt.h" +__attribute__((unused)) static inline dim3 __clusterIdx() {int volatile ___ = 1;::exit(___);} +#if 0 +# 101 +{ } +#endif +# 102 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_90_rt.h" +__attribute__((unused)) static inline unsigned __clusterRelativeBlockRank() {int volatile ___ = 1;::exit(___);} +#if 0 +# 102 +{ } +#endif +# 103 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_90_rt.h" +__attribute__((unused)) static inline unsigned __clusterSizeInBlocks() {int volatile ___ = 1;::exit(___);} +#if 0 +# 103 +{ } +#endif +# 104 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_90_rt.h" +__attribute__((unused)) static inline void __cluster_barrier_arrive() {int volatile ___ = 1;::exit(___);} +#if 0 +# 104 +{ } +#endif +# 105 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_90_rt.h" +__attribute__((unused)) static inline void __cluster_barrier_arrive_relaxed() {int volatile ___ = 1;::exit(___);} +#if 0 +# 105 +{ } +#endif +# 106 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_90_rt.h" +__attribute__((unused)) static inline void __cluster_barrier_wait() {int volatile ___ = 1;::exit(___);} +#if 0 +# 106 +{ } +#endif +# 107 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/sm_90_rt.h" +__attribute__((unused)) static inline void __threadfence_cluster() {int volatile ___ = 1;::exit(___);} +#if 0 +# 107 +{ } +#endif +# 109 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +# 65 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +# 3641 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/crt/device_functions.h" +extern "C" unsigned __cudaPushCallConfiguration(dim3 gridDim, dim3 blockDim, size_t sharedMem = 0, CUstream_st * stream = 0); +# 68 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 +} +# 67 "/usr/include/c++/11/bits/stl_relops.h" 3 +namespace std __attribute((__visibility__("default"))) { +# 71 +namespace rel_ops { +# 85 "/usr/include/c++/11/bits/stl_relops.h" 3 +template< class _Tp> inline bool +# 87 +operator!=(const _Tp &__x, const _Tp &__y) +# 88 +{ return !(__x == __y); } +# 98 "/usr/include/c++/11/bits/stl_relops.h" 3 +template< class _Tp> inline bool +# 100 +operator>(const _Tp &__x, const _Tp &__y) +# 101 +{ return __y < __x; } +# 111 "/usr/include/c++/11/bits/stl_relops.h" 3 +template< class _Tp> inline bool +# 113 +operator<=(const _Tp &__x, const _Tp &__y) +# 114 +{ return !(__y < __x); } +# 124 "/usr/include/c++/11/bits/stl_relops.h" 3 +template< class _Tp> inline bool +# 126 +operator>=(const _Tp &__x, const _Tp &__y) +# 127 +{ return !(__x < __y); } +# 128 +} +# 131 +} +# 39 "/usr/include/c++/11/initializer_list" 3 +#pragma GCC visibility push ( default ) +# 43 +namespace std { +# 46 +template< class _E> +# 47 +class initializer_list { +# 50 +public: typedef _E value_type; +# 51 +typedef const _E &reference; +# 52 +typedef const _E &const_reference; +# 53 +typedef size_t size_type; +# 54 +typedef const _E *iterator; +# 55 +typedef const _E *const_iterator; +# 58 +private: iterator _M_array; +# 59 +size_type _M_len; +# 62 +constexpr initializer_list(const_iterator __a, size_type __l) : _M_array(__a), _M_len(__l) +# 63 +{ } +# 66 +public: constexpr initializer_list() noexcept : _M_array((0)), _M_len((0)) +# 67 +{ } +# 71 +constexpr size_type size() const noexcept { return _M_len; } +# 75 +constexpr const_iterator begin() const noexcept { return _M_array; } +# 79 +constexpr const_iterator end() const noexcept { return begin() + size(); } +# 80 +}; +# 88 +template< class _Tp> constexpr const _Tp * +# 90 +begin(initializer_list< _Tp> __ils) noexcept +# 91 +{ return __ils.begin(); } +# 99 +template< class _Tp> constexpr const _Tp * +# 101 +end(initializer_list< _Tp> __ils) noexcept +# 102 +{ return __ils.end(); } +# 103 +} +# 105 +#pragma GCC visibility pop +# 82 "/usr/include/c++/11/utility" 3 +namespace std __attribute((__visibility__("default"))) { +# 87 +template< class _Tp> struct tuple_size; +# 94 +template< class _Tp, class +# 95 +_Up = typename remove_cv< _Tp> ::type, class +# 96 + = typename enable_if< is_same< _Tp, _Up> ::value> ::type, size_t +# 97 + = tuple_size< _Tp> ::value> using __enable_if_has_tuple_size = _Tp; +# 100 +template< class _Tp> +# 101 +struct tuple_size< const __enable_if_has_tuple_size< _Tp> > : public std::tuple_size< _Tp> { +# 102 +}; +# 104 +template< class _Tp> +# 105 +struct tuple_size< volatile __enable_if_has_tuple_size< _Tp> > : public std::tuple_size< _Tp> { +# 106 +}; +# 108 +template< class _Tp> +# 109 +struct tuple_size< const volatile __enable_if_has_tuple_size< _Tp> > : public std::tuple_size< _Tp> { +# 110 +}; +# 113 +template< size_t __i, class _Tp> struct tuple_element; +# 117 +template< size_t __i, class _Tp> using __tuple_element_t = typename tuple_element< __i, _Tp> ::type; +# 120 +template< size_t __i, class _Tp> +# 121 +struct tuple_element< __i, const _Tp> { +# 123 +typedef typename add_const< __tuple_element_t< __i, _Tp> > ::type type; +# 124 +}; +# 126 +template< size_t __i, class _Tp> +# 127 +struct tuple_element< __i, volatile _Tp> { +# 129 +typedef typename add_volatile< __tuple_element_t< __i, _Tp> > ::type type; +# 130 +}; +# 132 +template< size_t __i, class _Tp> +# 133 +struct tuple_element< __i, const volatile _Tp> { +# 135 +typedef typename add_cv< __tuple_element_t< __i, _Tp> > ::type type; +# 136 +}; +# 144 +template< size_t __i, class _Tp> using tuple_element_t = typename tuple_element< __i, _Tp> ::type; +# 151 +template< class _T1, class _T2> +# 152 +struct __is_tuple_like_impl< pair< _T1, _T2> > : public true_type { +# 153 +}; +# 156 +template< class _Tp1, class _Tp2> +# 157 +struct tuple_size< pair< _Tp1, _Tp2> > : public integral_constant< unsigned long, 2UL> { +# 158 +}; +# 161 +template< class _Tp1, class _Tp2> +# 162 +struct tuple_element< 0, pair< _Tp1, _Tp2> > { +# 163 +typedef _Tp1 type; }; +# 166 +template< class _Tp1, class _Tp2> +# 167 +struct tuple_element< 1, pair< _Tp1, _Tp2> > { +# 168 +typedef _Tp2 type; }; +# 170 +template< size_t _Int> struct __pair_get; +# 174 +template<> struct __pair_get< 0UL> { +# 176 +template< class _Tp1, class _Tp2> static constexpr _Tp1 & +# 178 +__get(pair< _Tp1, _Tp2> &__pair) noexcept +# 179 +{ return __pair.first; } +# 181 +template< class _Tp1, class _Tp2> static constexpr _Tp1 && +# 183 +__move_get(pair< _Tp1, _Tp2> &&__pair) noexcept +# 184 +{ return std::forward< _Tp1> ((__pair.first)); } +# 186 +template< class _Tp1, class _Tp2> static constexpr const _Tp1 & +# 188 +__const_get(const pair< _Tp1, _Tp2> &__pair) noexcept +# 189 +{ return __pair.first; } +# 191 +template< class _Tp1, class _Tp2> static constexpr const _Tp1 && +# 193 +__const_move_get(const pair< _Tp1, _Tp2> &&__pair) noexcept +# 194 +{ return std::forward< const _Tp1> ((__pair.first)); } +# 195 +}; +# 198 +template<> struct __pair_get< 1UL> { +# 200 +template< class _Tp1, class _Tp2> static constexpr _Tp2 & +# 202 +__get(pair< _Tp1, _Tp2> &__pair) noexcept +# 203 +{ return __pair.second; } +# 205 +template< class _Tp1, class _Tp2> static constexpr _Tp2 && +# 207 +__move_get(pair< _Tp1, _Tp2> &&__pair) noexcept +# 208 +{ return std::forward< _Tp2> ((__pair.second)); } +# 210 +template< class _Tp1, class _Tp2> static constexpr const _Tp2 & +# 212 +__const_get(const pair< _Tp1, _Tp2> &__pair) noexcept +# 213 +{ return __pair.second; } +# 215 +template< class _Tp1, class _Tp2> static constexpr const _Tp2 && +# 217 +__const_move_get(const pair< _Tp1, _Tp2> &&__pair) noexcept +# 218 +{ return std::forward< const _Tp2> ((__pair.second)); } +# 219 +}; +# 221 +template< size_t _Int, class _Tp1, class _Tp2> constexpr typename tuple_element< _Int, pair< _Tp1, _Tp2> > ::type & +# 223 +get(pair< _Tp1, _Tp2> &__in) noexcept +# 224 +{ return __pair_get< _Int> ::__get(__in); } +# 226 +template< size_t _Int, class _Tp1, class _Tp2> constexpr typename tuple_element< _Int, pair< _Tp1, _Tp2> > ::type && +# 228 +get(pair< _Tp1, _Tp2> &&__in) noexcept +# 229 +{ return __pair_get< _Int> ::__move_get(std::move(__in)); } +# 231 +template< size_t _Int, class _Tp1, class _Tp2> constexpr const typename tuple_element< _Int, pair< _Tp1, _Tp2> > ::type & +# 233 +get(const pair< _Tp1, _Tp2> &__in) noexcept +# 234 +{ return __pair_get< _Int> ::__const_get(__in); } +# 236 +template< size_t _Int, class _Tp1, class _Tp2> constexpr const typename tuple_element< _Int, pair< _Tp1, _Tp2> > ::type && +# 238 +get(const pair< _Tp1, _Tp2> &&__in) noexcept +# 239 +{ return __pair_get< _Int> ::__const_move_get(std::move(__in)); } +# 245 +template< class _Tp, class _Up> constexpr _Tp & +# 247 +get(pair< _Tp, _Up> &__p) noexcept +# 248 +{ return __p.first; } +# 250 +template< class _Tp, class _Up> constexpr const _Tp & +# 252 +get(const pair< _Tp, _Up> &__p) noexcept +# 253 +{ return __p.first; } +# 255 +template< class _Tp, class _Up> constexpr _Tp && +# 257 +get(pair< _Tp, _Up> &&__p) noexcept +# 258 +{ return std::move((__p.first)); } +# 260 +template< class _Tp, class _Up> constexpr const _Tp && +# 262 +get(const pair< _Tp, _Up> &&__p) noexcept +# 263 +{ return std::move((__p.first)); } +# 265 +template< class _Tp, class _Up> constexpr _Tp & +# 267 +get(pair< _Up, _Tp> &__p) noexcept +# 268 +{ return __p.second; } +# 270 +template< class _Tp, class _Up> constexpr const _Tp & +# 272 +get(const pair< _Up, _Tp> &__p) noexcept +# 273 +{ return __p.second; } +# 275 +template< class _Tp, class _Up> constexpr _Tp && +# 277 +get(pair< _Up, _Tp> &&__p) noexcept +# 278 +{ return std::move((__p.second)); } +# 280 +template< class _Tp, class _Up> constexpr const _Tp && +# 282 +get(const pair< _Up, _Tp> &&__p) noexcept +# 283 +{ return std::move((__p.second)); } +# 288 +template< class _Tp, class _Up = _Tp> inline _Tp +# 291 +exchange(_Tp &__obj, _Up &&__new_val) +# 292 +{ return std::__exchange(__obj, std::forward< _Up> (__new_val)); } +# 298 +template< size_t ..._Indexes> struct _Index_tuple { }; +# 301 +template< size_t _Num> +# 302 +struct _Build_index_tuple { +# 312 "/usr/include/c++/11/utility" 3 +using __type = _Index_tuple< __integer_pack(_Num)...> ; +# 314 +}; +# 321 +template< class _Tp, _Tp ..._Idx> +# 322 +struct integer_sequence { +# 324 +typedef _Tp value_type; +# 325 +static constexpr size_t size() noexcept { return sizeof...(_Idx); } +# 326 +}; +# 329 +template< class _Tp, _Tp _Num> using make_integer_sequence = integer_sequence< _Tp, __integer_pack(_Num)...> ; +# 338 +template< size_t ..._Idx> using index_sequence = integer_sequence< unsigned long, _Idx...> ; +# 342 +template< size_t _Num> using make_index_sequence = make_integer_sequence< unsigned long, _Num> ; +# 346 +template< class ..._Types> using index_sequence_for = make_index_sequence< sizeof...(_Types)> ; +# 352 +struct in_place_t { +# 353 +explicit in_place_t() = default; +# 354 +}; +# 356 +constexpr inline in_place_t in_place{}; +# 358 +template< class _Tp> struct in_place_type_t { +# 360 +explicit in_place_type_t() = default; +# 361 +}; +# 363 +template< class _Tp> constexpr inline in_place_type_t< _Tp> +# 364 +in_place_type{}; +# 366 +template< size_t _Idx> struct in_place_index_t { +# 368 +explicit in_place_index_t() = default; +# 369 +}; +# 371 +template< size_t _Idx> constexpr inline in_place_index_t< _Idx> +# 372 +in_place_index{}; +# 374 +template< class > constexpr inline bool +# 375 +__is_in_place_type_v = false; +# 377 +template< class _Tp> constexpr inline bool +# 378 +__is_in_place_type_v< in_place_type_t< _Tp> > = true; +# 380 +template< class _Tp> using __is_in_place_type = bool_constant< __is_in_place_type_v< _Tp> > ; +# 384 +template< class _Tp> +# 385 +[[nodiscard]] constexpr add_const_t< _Tp> & +# 387 +as_const(_Tp &__t) noexcept +# 388 +{ return __t; } +# 390 +template < typename _Tp > + void as_const ( const _Tp && ) = delete; +# 477 "/usr/include/c++/11/utility" 3 +} +# 206 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 207 +cudaLaunchKernel(const T * +# 208 +func, dim3 +# 209 +gridDim, dim3 +# 210 +blockDim, void ** +# 211 +args, size_t +# 212 +sharedMem = 0, cudaStream_t +# 213 +stream = 0) +# 215 +{ +# 216 +return ::cudaLaunchKernel((const void *)func, gridDim, blockDim, args, sharedMem, stream); +# 217 +} +# 277 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class ...ExpTypes, class ...ActTypes> static inline cudaError_t +# 278 +cudaLaunchKernelEx(const cudaLaunchConfig_t * +# 279 +config, void (* +# 280 +kernel)(ExpTypes ...), ActTypes &&... +# 281 +args) +# 283 +{ +# 284 +return [&](ExpTypes ...coercedArgs) { +# 285 +void *pArgs[] = {(&coercedArgs)...}; +# 286 +return ::cudaLaunchKernelExC(config, (const void *)(kernel), pArgs); +# 287 +} (std::forward< ActTypes> (args)...); +# 288 +} +# 340 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 341 +cudaLaunchCooperativeKernel(const T * +# 342 +func, dim3 +# 343 +gridDim, dim3 +# 344 +blockDim, void ** +# 345 +args, size_t +# 346 +sharedMem = 0, cudaStream_t +# 347 +stream = 0) +# 349 +{ +# 350 +return ::cudaLaunchCooperativeKernel((const void *)func, gridDim, blockDim, args, sharedMem, stream); +# 351 +} +# 384 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +static inline cudaError_t cudaEventCreate(cudaEvent_t * +# 385 +event, unsigned +# 386 +flags) +# 388 +{ +# 389 +return ::cudaEventCreateWithFlags(event, flags); +# 390 +} +# 428 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +static inline cudaError_t cudaGraphInstantiate(cudaGraphExec_t * +# 429 +pGraphExec, cudaGraph_t +# 430 +graph, cudaGraphNode_t * +# 431 +pErrorNode, char * +# 432 +pLogBuffer, size_t +# 433 +bufferSize) +# 435 +{ +# 436 +(void)pErrorNode; +# 437 +(void)pLogBuffer; +# 438 +(void)bufferSize; +# 439 +return ::cudaGraphInstantiate(pGraphExec, graph, 0); +# 440 +} +# 499 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +static inline cudaError_t cudaMallocHost(void ** +# 500 +ptr, size_t +# 501 +size, unsigned +# 502 +flags) +# 504 +{ +# 505 +return ::cudaHostAlloc(ptr, size, flags); +# 506 +} +# 508 +template< class T> static inline cudaError_t +# 509 +cudaHostAlloc(T ** +# 510 +ptr, size_t +# 511 +size, unsigned +# 512 +flags) +# 514 +{ +# 515 +return ::cudaHostAlloc((void **)((void *)ptr), size, flags); +# 516 +} +# 518 +template< class T> static inline cudaError_t +# 519 +cudaHostGetDevicePointer(T ** +# 520 +pDevice, void * +# 521 +pHost, unsigned +# 522 +flags) +# 524 +{ +# 525 +return ::cudaHostGetDevicePointer((void **)((void *)pDevice), pHost, flags); +# 526 +} +# 628 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 629 +cudaMallocManaged(T ** +# 630 +devPtr, size_t +# 631 +size, unsigned +# 632 +flags = 1) +# 634 +{ +# 635 +return ::cudaMallocManaged((void **)((void *)devPtr), size, flags); +# 636 +} +# 646 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> cudaError_t +# 647 +cudaMemAdvise(T * +# 648 +devPtr, size_t +# 649 +count, cudaMemoryAdvise +# 650 +advice, cudaMemLocation +# 651 +location) +# 653 +{ +# 654 +return ::cudaMemAdvise_v2((const void *)devPtr, count, advice, location); +# 655 +} +# 657 +template< class T> static inline cudaError_t +# 658 +cudaMemPrefetchAsync(T * +# 659 +devPtr, size_t +# 660 +count, cudaMemLocation +# 661 +location, unsigned +# 662 +flags, cudaStream_t +# 663 +stream = 0) +# 665 +{ +# 666 +return ::cudaMemPrefetchAsync_v2((const void *)devPtr, count, location, flags, stream); +# 667 +} +# 749 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 750 +cudaStreamAttachMemAsync(cudaStream_t +# 751 +stream, T * +# 752 +devPtr, size_t +# 753 +length = 0, unsigned +# 754 +flags = 4) +# 756 +{ +# 757 +return ::cudaStreamAttachMemAsync(stream, (void *)devPtr, length, flags); +# 758 +} +# 760 +template< class T> inline cudaError_t +# 761 +cudaMalloc(T ** +# 762 +devPtr, size_t +# 763 +size) +# 765 +{ +# 766 +return ::cudaMalloc((void **)((void *)devPtr), size); +# 767 +} +# 769 +template< class T> static inline cudaError_t +# 770 +cudaMallocHost(T ** +# 771 +ptr, size_t +# 772 +size, unsigned +# 773 +flags = 0) +# 775 +{ +# 776 +return cudaMallocHost((void **)((void *)ptr), size, flags); +# 777 +} +# 779 +template< class T> static inline cudaError_t +# 780 +cudaMallocPitch(T ** +# 781 +devPtr, size_t * +# 782 +pitch, size_t +# 783 +width, size_t +# 784 +height) +# 786 +{ +# 787 +return ::cudaMallocPitch((void **)((void *)devPtr), pitch, width, height); +# 788 +} +# 799 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +static inline cudaError_t cudaMallocAsync(void ** +# 800 +ptr, size_t +# 801 +size, cudaMemPool_t +# 802 +memPool, cudaStream_t +# 803 +stream) +# 805 +{ +# 806 +return ::cudaMallocFromPoolAsync(ptr, size, memPool, stream); +# 807 +} +# 809 +template< class T> static inline cudaError_t +# 810 +cudaMallocAsync(T ** +# 811 +ptr, size_t +# 812 +size, cudaMemPool_t +# 813 +memPool, cudaStream_t +# 814 +stream) +# 816 +{ +# 817 +return ::cudaMallocFromPoolAsync((void **)((void *)ptr), size, memPool, stream); +# 818 +} +# 820 +template< class T> static inline cudaError_t +# 821 +cudaMallocAsync(T ** +# 822 +ptr, size_t +# 823 +size, cudaStream_t +# 824 +stream) +# 826 +{ +# 827 +return ::cudaMallocAsync((void **)((void *)ptr), size, stream); +# 828 +} +# 830 +template< class T> static inline cudaError_t +# 831 +cudaMallocFromPoolAsync(T ** +# 832 +ptr, size_t +# 833 +size, cudaMemPool_t +# 834 +memPool, cudaStream_t +# 835 +stream) +# 837 +{ +# 838 +return ::cudaMallocFromPoolAsync((void **)((void *)ptr), size, memPool, stream); +# 839 +} +# 878 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 879 +cudaMemcpyToSymbol(const T & +# 880 +symbol, const void * +# 881 +src, size_t +# 882 +count, size_t +# 883 +offset = 0, cudaMemcpyKind +# 884 +kind = cudaMemcpyHostToDevice) +# 886 +{ +# 887 +return ::cudaMemcpyToSymbol((const void *)(&symbol), src, count, offset, kind); +# 888 +} +# 932 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 933 +cudaMemcpyToSymbolAsync(const T & +# 934 +symbol, const void * +# 935 +src, size_t +# 936 +count, size_t +# 937 +offset = 0, cudaMemcpyKind +# 938 +kind = cudaMemcpyHostToDevice, cudaStream_t +# 939 +stream = 0) +# 941 +{ +# 942 +return ::cudaMemcpyToSymbolAsync((const void *)(&symbol), src, count, offset, kind, stream); +# 943 +} +# 980 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 981 +cudaMemcpyFromSymbol(void * +# 982 +dst, const T & +# 983 +symbol, size_t +# 984 +count, size_t +# 985 +offset = 0, cudaMemcpyKind +# 986 +kind = cudaMemcpyDeviceToHost) +# 988 +{ +# 989 +return ::cudaMemcpyFromSymbol(dst, (const void *)(&symbol), count, offset, kind); +# 990 +} +# 1034 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1035 +cudaMemcpyFromSymbolAsync(void * +# 1036 +dst, const T & +# 1037 +symbol, size_t +# 1038 +count, size_t +# 1039 +offset = 0, cudaMemcpyKind +# 1040 +kind = cudaMemcpyDeviceToHost, cudaStream_t +# 1041 +stream = 0) +# 1043 +{ +# 1044 +return ::cudaMemcpyFromSymbolAsync(dst, (const void *)(&symbol), count, offset, kind, stream); +# 1045 +} +# 1103 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1104 +cudaGraphAddMemcpyNodeToSymbol(cudaGraphNode_t * +# 1105 +pGraphNode, cudaGraph_t +# 1106 +graph, const cudaGraphNode_t * +# 1107 +pDependencies, size_t +# 1108 +numDependencies, const T & +# 1109 +symbol, const void * +# 1110 +src, size_t +# 1111 +count, size_t +# 1112 +offset, cudaMemcpyKind +# 1113 +kind) +# 1114 +{ +# 1115 +return ::cudaGraphAddMemcpyNodeToSymbol(pGraphNode, graph, pDependencies, numDependencies, (const void *)(&symbol), src, count, offset, kind); +# 1116 +} +# 1174 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1175 +cudaGraphAddMemcpyNodeFromSymbol(cudaGraphNode_t * +# 1176 +pGraphNode, cudaGraph_t +# 1177 +graph, const cudaGraphNode_t * +# 1178 +pDependencies, size_t +# 1179 +numDependencies, void * +# 1180 +dst, const T & +# 1181 +symbol, size_t +# 1182 +count, size_t +# 1183 +offset, cudaMemcpyKind +# 1184 +kind) +# 1185 +{ +# 1186 +return ::cudaGraphAddMemcpyNodeFromSymbol(pGraphNode, graph, pDependencies, numDependencies, dst, (const void *)(&symbol), count, offset, kind); +# 1187 +} +# 1225 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1226 +cudaGraphMemcpyNodeSetParamsToSymbol(cudaGraphNode_t +# 1227 +node, const T & +# 1228 +symbol, const void * +# 1229 +src, size_t +# 1230 +count, size_t +# 1231 +offset, cudaMemcpyKind +# 1232 +kind) +# 1233 +{ +# 1234 +return ::cudaGraphMemcpyNodeSetParamsToSymbol(node, (const void *)(&symbol), src, count, offset, kind); +# 1235 +} +# 1273 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1274 +cudaGraphMemcpyNodeSetParamsFromSymbol(cudaGraphNode_t +# 1275 +node, void * +# 1276 +dst, const T & +# 1277 +symbol, size_t +# 1278 +count, size_t +# 1279 +offset, cudaMemcpyKind +# 1280 +kind) +# 1281 +{ +# 1282 +return ::cudaGraphMemcpyNodeSetParamsFromSymbol(node, dst, (const void *)(&symbol), count, offset, kind); +# 1283 +} +# 1331 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1332 +cudaGraphExecMemcpyNodeSetParamsToSymbol(cudaGraphExec_t +# 1333 +hGraphExec, cudaGraphNode_t +# 1334 +node, const T & +# 1335 +symbol, const void * +# 1336 +src, size_t +# 1337 +count, size_t +# 1338 +offset, cudaMemcpyKind +# 1339 +kind) +# 1340 +{ +# 1341 +return ::cudaGraphExecMemcpyNodeSetParamsToSymbol(hGraphExec, node, (const void *)(&symbol), src, count, offset, kind); +# 1342 +} +# 1390 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1391 +cudaGraphExecMemcpyNodeSetParamsFromSymbol(cudaGraphExec_t +# 1392 +hGraphExec, cudaGraphNode_t +# 1393 +node, void * +# 1394 +dst, const T & +# 1395 +symbol, size_t +# 1396 +count, size_t +# 1397 +offset, cudaMemcpyKind +# 1398 +kind) +# 1399 +{ +# 1400 +return ::cudaGraphExecMemcpyNodeSetParamsFromSymbol(hGraphExec, node, dst, (const void *)(&symbol), count, offset, kind); +# 1401 +} +# 1404 +static inline cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphNode_t *hErrorNode_out, cudaGraphExecUpdateResult *updateResult_out) +# 1405 +{ +# 1406 +cudaGraphExecUpdateResultInfo resultInfo; +# 1407 +cudaError_t status = cudaGraphExecUpdate(hGraphExec, hGraph, &resultInfo); +# 1408 +if (hErrorNode_out) { +# 1409 +(*hErrorNode_out) = (resultInfo.errorNode); +# 1410 +} +# 1411 +if (updateResult_out) { +# 1412 +(*updateResult_out) = (resultInfo.result); +# 1413 +} +# 1414 +return status; +# 1415 +} +# 1443 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1444 +cudaUserObjectCreate(cudaUserObject_t * +# 1445 +object_out, T * +# 1446 +objectToWrap, unsigned +# 1447 +initialRefcount, unsigned +# 1448 +flags) +# 1449 +{ +# 1450 +return ::cudaUserObjectCreate(object_out, objectToWrap, [](void * +# 1453 +vpObj) { delete (reinterpret_cast< T *>(vpObj)); } , initialRefcount, flags); +# 1456 +} +# 1458 +template< class T> static inline cudaError_t +# 1459 +cudaUserObjectCreate(cudaUserObject_t * +# 1460 +object_out, T * +# 1461 +objectToWrap, unsigned +# 1462 +initialRefcount, cudaUserObjectFlags +# 1463 +flags) +# 1464 +{ +# 1465 +return cudaUserObjectCreate(object_out, objectToWrap, initialRefcount, (unsigned)flags); +# 1466 +} +# 1493 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1494 +cudaGetSymbolAddress(void ** +# 1495 +devPtr, const T & +# 1496 +symbol) +# 1498 +{ +# 1499 +return ::cudaGetSymbolAddress(devPtr, (const void *)(&symbol)); +# 1500 +} +# 1525 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1526 +cudaGetSymbolSize(size_t * +# 1527 +size, const T & +# 1528 +symbol) +# 1530 +{ +# 1531 +return ::cudaGetSymbolSize(size, (const void *)(&symbol)); +# 1532 +} +# 1577 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 1578 +cudaFuncSetCacheConfig(T * +# 1579 +func, cudaFuncCache +# 1580 +cacheConfig) +# 1582 +{ +# 1583 +return ::cudaFuncSetCacheConfig((const void *)func, cacheConfig); +# 1584 +} +# 1586 +template< class T> +# 1588 +__attribute((deprecated)) static inline cudaError_t +# 1589 +cudaFuncSetSharedMemConfig(T * +# 1590 +func, cudaSharedMemConfig +# 1591 +config) +# 1593 +{ +# 1595 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 1600 +return ::cudaFuncSetSharedMemConfig((const void *)func, config); +# 1602 +#pragma GCC diagnostic pop +# 1604 +} +# 1636 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> inline cudaError_t +# 1637 +cudaOccupancyMaxActiveBlocksPerMultiprocessor(int * +# 1638 +numBlocks, T +# 1639 +func, int +# 1640 +blockSize, size_t +# 1641 +dynamicSMemSize) +# 1642 +{ +# 1643 +return ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, (const void *)func, blockSize, dynamicSMemSize, 0); +# 1644 +} +# 1688 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> inline cudaError_t +# 1689 +cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int * +# 1690 +numBlocks, T +# 1691 +func, int +# 1692 +blockSize, size_t +# 1693 +dynamicSMemSize, unsigned +# 1694 +flags) +# 1695 +{ +# 1696 +return ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, (const void *)func, blockSize, dynamicSMemSize, flags); +# 1697 +} +# 1702 +class __cudaOccupancyB2DHelper { +# 1703 +size_t n; +# 1705 +public: __cudaOccupancyB2DHelper(size_t n_) : n(n_) { } +# 1706 +size_t operator()(int) +# 1707 +{ +# 1708 +return n; +# 1709 +} +# 1710 +}; +# 1758 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class UnaryFunction, class T> static inline cudaError_t +# 1759 +cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(int * +# 1760 +minGridSize, int * +# 1761 +blockSize, T +# 1762 +func, UnaryFunction +# 1763 +blockSizeToDynamicSMemSize, int +# 1764 +blockSizeLimit = 0, unsigned +# 1765 +flags = 0) +# 1766 +{ +# 1767 +cudaError_t status; +# 1770 +int device; +# 1771 +cudaFuncAttributes attr; +# 1774 +int maxThreadsPerMultiProcessor; +# 1775 +int warpSize; +# 1776 +int devMaxThreadsPerBlock; +# 1777 +int multiProcessorCount; +# 1778 +int funcMaxThreadsPerBlock; +# 1779 +int occupancyLimit; +# 1780 +int granularity; +# 1783 +int maxBlockSize = 0; +# 1784 +int numBlocks = 0; +# 1785 +int maxOccupancy = 0; +# 1788 +int blockSizeToTryAligned; +# 1789 +int blockSizeToTry; +# 1790 +int blockSizeLimitAligned; +# 1791 +int occupancyInBlocks; +# 1792 +int occupancyInThreads; +# 1793 +size_t dynamicSMemSize; +# 1799 +if (((!minGridSize) || (!blockSize)) || (!func)) { +# 1800 +return cudaErrorInvalidValue; +# 1801 +} +# 1807 +status = ::cudaGetDevice(&device); +# 1808 +if (status != (cudaSuccess)) { +# 1809 +return status; +# 1810 +} +# 1812 +status = cudaDeviceGetAttribute(&maxThreadsPerMultiProcessor, cudaDevAttrMaxThreadsPerMultiProcessor, device); +# 1816 +if (status != (cudaSuccess)) { +# 1817 +return status; +# 1818 +} +# 1820 +status = cudaDeviceGetAttribute(&warpSize, cudaDevAttrWarpSize, device); +# 1824 +if (status != (cudaSuccess)) { +# 1825 +return status; +# 1826 +} +# 1828 +status = cudaDeviceGetAttribute(&devMaxThreadsPerBlock, cudaDevAttrMaxThreadsPerBlock, device); +# 1832 +if (status != (cudaSuccess)) { +# 1833 +return status; +# 1834 +} +# 1836 +status = cudaDeviceGetAttribute(&multiProcessorCount, cudaDevAttrMultiProcessorCount, device); +# 1840 +if (status != (cudaSuccess)) { +# 1841 +return status; +# 1842 +} +# 1844 +status = cudaFuncGetAttributes(&attr, func); +# 1845 +if (status != (cudaSuccess)) { +# 1846 +return status; +# 1847 +} +# 1849 +funcMaxThreadsPerBlock = (attr.maxThreadsPerBlock); +# 1855 +occupancyLimit = maxThreadsPerMultiProcessor; +# 1856 +granularity = warpSize; +# 1858 +if (blockSizeLimit == 0) { +# 1859 +blockSizeLimit = devMaxThreadsPerBlock; +# 1860 +} +# 1862 +if (devMaxThreadsPerBlock < blockSizeLimit) { +# 1863 +blockSizeLimit = devMaxThreadsPerBlock; +# 1864 +} +# 1866 +if (funcMaxThreadsPerBlock < blockSizeLimit) { +# 1867 +blockSizeLimit = funcMaxThreadsPerBlock; +# 1868 +} +# 1870 +blockSizeLimitAligned = (((blockSizeLimit + (granularity - 1)) / granularity) * granularity); +# 1872 +for (blockSizeToTryAligned = blockSizeLimitAligned; blockSizeToTryAligned > 0; blockSizeToTryAligned -= granularity) { +# 1876 +if (blockSizeLimit < blockSizeToTryAligned) { +# 1877 +blockSizeToTry = blockSizeLimit; +# 1878 +} else { +# 1879 +blockSizeToTry = blockSizeToTryAligned; +# 1880 +} +# 1882 +dynamicSMemSize = blockSizeToDynamicSMemSize(blockSizeToTry); +# 1884 +status = cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(&occupancyInBlocks, func, blockSizeToTry, dynamicSMemSize, flags); +# 1891 +if (status != (cudaSuccess)) { +# 1892 +return status; +# 1893 +} +# 1895 +occupancyInThreads = (blockSizeToTry * occupancyInBlocks); +# 1897 +if (occupancyInThreads > maxOccupancy) { +# 1898 +maxBlockSize = blockSizeToTry; +# 1899 +numBlocks = occupancyInBlocks; +# 1900 +maxOccupancy = occupancyInThreads; +# 1901 +} +# 1905 +if (occupancyLimit == maxOccupancy) { +# 1906 +break; +# 1907 +} +# 1908 +} +# 1916 +(*minGridSize) = (numBlocks * multiProcessorCount); +# 1917 +(*blockSize) = maxBlockSize; +# 1919 +return status; +# 1920 +} +# 1954 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class UnaryFunction, class T> static inline cudaError_t +# 1955 +cudaOccupancyMaxPotentialBlockSizeVariableSMem(int * +# 1956 +minGridSize, int * +# 1957 +blockSize, T +# 1958 +func, UnaryFunction +# 1959 +blockSizeToDynamicSMemSize, int +# 1960 +blockSizeLimit = 0) +# 1961 +{ +# 1962 +return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, blockSizeToDynamicSMemSize, blockSizeLimit, 0); +# 1963 +} +# 2000 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2001 +cudaOccupancyMaxPotentialBlockSize(int * +# 2002 +minGridSize, int * +# 2003 +blockSize, T +# 2004 +func, size_t +# 2005 +dynamicSMemSize = 0, int +# 2006 +blockSizeLimit = 0) +# 2007 +{ +# 2008 +return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, ((__cudaOccupancyB2DHelper)(dynamicSMemSize)), blockSizeLimit, 0); +# 2009 +} +# 2038 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2039 +cudaOccupancyAvailableDynamicSMemPerBlock(size_t * +# 2040 +dynamicSmemSize, T +# 2041 +func, int +# 2042 +numBlocks, int +# 2043 +blockSize) +# 2044 +{ +# 2045 +return ::cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, (const void *)func, numBlocks, blockSize); +# 2046 +} +# 2097 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2098 +cudaOccupancyMaxPotentialBlockSizeWithFlags(int * +# 2099 +minGridSize, int * +# 2100 +blockSize, T +# 2101 +func, size_t +# 2102 +dynamicSMemSize = 0, int +# 2103 +blockSizeLimit = 0, unsigned +# 2104 +flags = 0) +# 2105 +{ +# 2106 +return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, ((__cudaOccupancyB2DHelper)(dynamicSMemSize)), blockSizeLimit, flags); +# 2107 +} +# 2141 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2142 +cudaOccupancyMaxPotentialClusterSize(int * +# 2143 +clusterSize, T * +# 2144 +func, const cudaLaunchConfig_t * +# 2145 +config) +# 2146 +{ +# 2147 +return ::cudaOccupancyMaxPotentialClusterSize(clusterSize, (const void *)func, config); +# 2148 +} +# 2184 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2185 +cudaOccupancyMaxActiveClusters(int * +# 2186 +numClusters, T * +# 2187 +func, const cudaLaunchConfig_t * +# 2188 +config) +# 2189 +{ +# 2190 +return ::cudaOccupancyMaxActiveClusters(numClusters, (const void *)func, config); +# 2191 +} +# 2224 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> inline cudaError_t +# 2225 +cudaFuncGetAttributes(cudaFuncAttributes * +# 2226 +attr, T * +# 2227 +entry) +# 2229 +{ +# 2230 +return ::cudaFuncGetAttributes(attr, (const void *)entry); +# 2231 +} +# 2286 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2287 +cudaFuncSetAttribute(T * +# 2288 +entry, cudaFuncAttribute +# 2289 +attr, int +# 2290 +value) +# 2292 +{ +# 2293 +return ::cudaFuncSetAttribute((const void *)entry, attr, value); +# 2294 +} +# 2318 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2319 +cudaFuncGetName(const char ** +# 2320 +name, const T * +# 2321 +func) +# 2323 +{ +# 2324 +return ::cudaFuncGetName(name, (const void *)func); +# 2325 +} +# 2341 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +template< class T> static inline cudaError_t +# 2342 +cudaGetKernel(cudaKernel_t * +# 2343 +kernelPtr, const T * +# 2344 +entryFuncAddr) +# 2346 +{ +# 2347 +return ::cudaGetKernel(kernelPtr, (const void *)entryFuncAddr); +# 2348 +} +# 2359 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include/cuda_runtime.h" +#pragma GCC diagnostic pop +# 492 "CMakeCUDACompilerId.cu" +const char *info_compiler = ("INFO:compiler[NVIDIA]"); +# 494 +const char *info_simulate = ("INFO:simulate[GNU]"); +# 819 "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') + ((4 / 10000000) % 10)), (('0') + ((4 / 1000000) % 10)), (('0') + ((4 / 100000) % 10)), (('0') + ((4 / 10000) % 10)), (('0') + ((4 / 1000) % 10)), (('0') + ((4 / 100) % 10)), (('0') + ((4 / 10) % 10)), (('0') + (4 % 10)), '.', (('0') + ((131 / 10000000) % 10)), (('0') + ((131 / 1000000) % 10)), (('0') + ((131 / 100000) % 10)), (('0') + ((131 / 10000) % 10)), (('0') + ((131 / 1000) % 10)), (('0') + ((131 / 100) % 10)), (('0') + ((131 / 10) % 10)), (('0') + (131 % 10)), ']', '\000'}; +# 848 "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') + ((11 / 10000000) % 10)), (('0') + ((11 / 1000000) % 10)), (('0') + ((11 / 100000) % 10)), (('0') + ((11 / 10000) % 10)), (('0') + ((11 / 1000) % 10)), (('0') + ((11 / 100) % 10)), (('0') + ((11 / 10) % 10)), (('0') + (11 % 10)), '.', (('0') + ((4 / 10000000) % 10)), (('0') + ((4 / 1000000) % 10)), (('0') + ((4 / 100000) % 10)), (('0') + ((4 / 10000) % 10)), (('0') + ((4 / 1000) % 10)), (('0') + ((4 / 100) % 10)), (('0') + ((4 / 10) % 10)), (('0') + (4 % 10)), ']', '\000'}; +# 868 +const char *info_platform = ("INFO:platform[Linux]"); +# 869 +const char *info_arch = ("INFO:arch[]"); +# 874 +const char *info_host_compiler = ("INFO:host_compiler[GNU]"); +# 879 +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') + ((11 / 10000000) % 10)), (('0') + ((11 / 1000000) % 10)), (('0') + ((11 / 100000) % 10)), (('0') + ((11 / 10000) % 10)), (('0') + ((11 / 1000) % 10)), (('0') + ((11 / 100) % 10)), (('0') + ((11 / 10) % 10)), (('0') + (11 % 10)), '.', (('0') + ((4 / 10000000) % 10)), (('0') + ((4 / 1000000) % 10)), (('0') + ((4 / 100000) % 10)), (('0') + ((4 / 10000) % 10)), (('0') + ((4 / 1000) % 10)), (('0') + ((4 / 100) % 10)), (('0') + ((4 / 10) % 10)), (('0') + (4 % 10)), '.', (('0') + ((0 / 10000000) % 10)), (('0') + ((0 / 1000000) % 10)), (('0') + ((0 / 100000) % 10)), (('0') + ((0 / 10000) % 10)), (('0') + ((0 / 1000) % 10)), (('0') + ((0 / 100) % 10)), (('0') + ((0 / 10) % 10)), (('0') + (0 % 10)), ']', '\000'}; +# 911 "CMakeCUDACompilerId.cu" +const char *info_language_standard_default = ("INFO:standard_default[17]"); +# 929 +const char *info_language_extensions_default = ("INFO:extensions_default[ON]"); +# 940 +int main(int argc, char *argv[]) +# 941 +{ +# 942 +int require = 0; +# 943 +require += (info_compiler[argc]); +# 944 +require += (info_platform[argc]); +# 946 +require += (info_version[argc]); +# 949 +require += (info_simulate[argc]); +# 952 +require += (info_simulate_version[argc]); +# 955 +require += (info_host_compiler[argc]); +# 958 +require += (info_host_compiler_version[argc]); +# 960 +require += (info_language_standard_default[argc]); +# 961 +require += (info_language_extensions_default[argc]); +# 962 +(void)argv; +# 963 +return require; +# 964 +} + +# 1 "CMakeCUDACompilerId.cudafe1.stub.c" +#define _NV_ANON_NAMESPACE _GLOBAL__N__804f93ba_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/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.gpu b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.gpu new file mode 100644 index 0000000..5f64d40 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.gpu @@ -0,0 +1,379 @@ +typedef char __nv_bool; +# 209 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 3 +typedef unsigned long size_t; +#include "crt/device_runtime.h" +# 280 "/usr/include/x86_64-linux-gnu/c++/11/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 +#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 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.stub.c b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.stub.c new file mode 100644 index 0000000..2ebe7e6 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/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/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.fatbin b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.fatbin new file mode 100644 index 0000000000000000000000000000000000000000..194326b73b509772117ace7877df68cf80ab0419 GIT binary patch literal 1112 zcmcIjOH0E*5S~r?ka%hF;xPzbw@_oL;GqYV97K8%yhw>{Yzl1>vZ1sh_)GjF9{fjw zM-RScH?wK_0HNSO_WQocJhD5R?%VYXgBrLcP-XyQF0#PPv|g*gz|jJ+Uf`SP)A{9v z!PrriUK;QUkA=VwBNH>0p;LCC18p#Htza+UA`oekdUwb)&L^2x*b_lGm;n!`d=%bC ziuAqlc$j!`pj4bhX_U@mU#Y|&bFZI{qVS)K7k0T$o9Hru4!iLBO8LtL&w~D-N%c+m zMfiy*7Gd>6D7O}JJ0{1mGI~|0L*;G>HPHC9gk5Bt@}DWGIyD3e^ z$UZw#pzUV>@_aEgCYggv`8IjifMCo)^{) zbe=4~T^?gMnA@R7Cx|XSB|Mp>|J9}dg0p1_-4%UmH5w+oA6R_qCjx&OyUiVor(QDj bQ(H`W$4!fSgF)g8(G#Nw-)=b;nlAGT^ZRyL literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.fatbin.c b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.fatbin.c new file mode 100644 index 0000000..2def4bc --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/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,0x0000000000000448,0x0000004801010002,0x0000000000000368\n" +".quad 0x0000000000000000,0x0000003400010007,0x0000000000000000,0x0000000000000011\n" +".quad 0x0000000000000000,0x0000000000000000,0x0000000000000000,0x33010102464c457f\n" +".quad 0x0000000000000007,0x0000007c00be0002,0x0000000000000000,0x00000000000002f8\n" +".quad 0x0000000000000178,0x0038004000340534,0x0001000600400002,0x7472747368732e00\n" +".quad 0x747274732e006261,0x746d79732e006261,0x746d79732e006261,0x78646e68735f6261\n" +".quad 0x666e692e766e2e00,0x61632e766e2e006f,0x0068706172676c6c,0x746f72702e766e2e\n" +".quad 0x6e2e00657079746f,0x63612e6c65722e76,0x732e00006e6f6974,0x0062617472747368\n" +".quad 0x006261747274732e,0x006261746d79732e,0x5f6261746d79732e,0x6e2e0078646e6873\n" +".quad 0x2e006f666e692e76,0x676c6c61632e766e,0x766e2e0068706172,0x79746f746f72702e\n" +".quad 0x722e766e2e006570,0x6f697463612e6c65,0x000000000000006e,0x0000000000000000\n" +".quad 0x0000000000000000,0x0000000000000000,0x0004000300000032,0x0000000000000000\n" +".quad 0x0000000000000000,0x000500030000004e,0x0000000000000000,0x0000000000000000\n" +".quad 0xffffffff00000000,0xfffffffe00000000,0xfffffffd00000000,0xfffffffc00000000\n" +".quad 0x0000000000000073,0x3605002511000000,0x0000000000000000,0x0000000000000000\n" +".quad 0x0000000000000000,0x0000000000000000,0x0000000000000000,0x0000000000000000\n" +".quad 0x0000000000000000,0x0000000000000000,0x0000000300000001,0x0000000000000000\n" +".quad 0x0000000000000000,0x0000000000000040,0x000000000000005d,0x0000000000000000\n" +".quad 0x0000000000000001,0x0000000000000000,0x000000030000000b,0x0000000000000000\n" +".quad 0x0000000000000000,0x000000000000009d,0x000000000000005d,0x0000000000000000\n" +".quad 0x0000000000000001,0x0000000000000000,0x0000000200000013,0x0000000000000000\n" +".quad 0x0000000000000000,0x0000000000000100,0x0000000000000048,0x0000000300000002\n" +".quad 0x0000000000000008,0x0000000000000018,0x7000000100000032,0x0000000000000000\n" +".quad 0x0000000000000000,0x0000000000000148,0x0000000000000020,0x0000000000000003\n" +".quad 0x0000000000000004,0x0000000000000008,0x7000000b0000004e,0x0000000000000000\n" +".quad 0x0000000000000000,0x0000000000000168,0x0000000000000010,0x0000000000000000\n" +".quad 0x0000000000000008,0x0000000000000008,0x0000000500000006,0x00000000000002f8\n" +".quad 0x0000000000000000,0x0000000000000000,0x0000000000000070,0x0000000000000070\n" +".quad 0x0000000000000008,0x0000000500000001,0x00000000000002f8,0x0000000000000000\n" +".quad 0x0000000000000000,0x0000000000000070,0x0000000000000070,0x0000000000000008\n" +".quad 0x0000005801010001,0x0000000000000040,0x0000004800000039,0x0000003400080004\n" +".quad 0x0000000000000000,0x0000000000002011,0x0000000000000000,0x0000000000000044\n" +".quad 0x0000000000000000,0x0000000000000050,0x0000000000000000,0x22f000032f2f0a3c\n" +".quad 0x6f69737265762e0a,0x742e0a342e38206e,0x6d73207465677261,0x6464612e0a32355f\n" +".quad 0x7a69735f73736572, 0x0a0a0a0a34362065, 0x0000000000000000\n" +".text\n"); +#ifdef __cplusplus +extern "C" { +#endif +extern const unsigned long long fatbinData[139]; +#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/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.module_id b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.module_id new file mode 100644 index 0000000..3b2d605 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.module_id @@ -0,0 +1 @@ +_804f93ba_22_CMakeCUDACompilerId_cu_bd57c623 \ No newline at end of file diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.o b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.o new file mode 100644 index 0000000000000000000000000000000000000000..32a11cca9fda35ea97490b1f4cd097a6bc3a6f8f GIT binary patch literal 6736 zcmc&&eTZDu6~AwH^U?KVH(JGyR9>Pj(dx_2WKCj-GI4g|TbgWE>qzLDKHtu~-Fal@ z&G6>Ux+^gTgu=3j@gE7;mO!CR|0vpj#E-HpR0-{0sURqb_(uyXMr`RnOWAgN&b{Z% z+`0QkMJYWn@1FZRANSmIzvsEav7>#KC73Mnkm%GH72?WwJA6*EIdQYNN&Iu@j(-*1 z#lN|W&#t*kg*A6^3rf$Q`XfsgpS|iXwm!LBSVw`obQ2a!g{$rb*Sa$Fx)@qsu?p+G zaHaTyG#Yw+VEF&1-8;hdPG^lYXo44HUfjjYt5-HQHr%Cl71N=m%YFXpaL3E#RTTfJ zolKB!??{yonf1%7@qacp&Ua}JyPZbS4UG+;zrzp~VYHTt@Z(T6-s|wPUC=x%HB}hk z9o=-%_{7l@hf4KYBdiAT)Wj3xW8+6o35hntTC3_O!PFxY#Zz5ITBXb0n+xJ*SdXSg zBxSOWVn#+4li8Os9d)&2+GpDK6jB4?nW@LMsbgW(nkUeYOO+|&EA?jLwY&3Wfm0u3 z`(0MOgWzaJI6;XYmHoKvm4g|-RZXTc2S^gkCqaanXtrf1Cd{sDS^R3&^Cq6~j-MDS z9xHg`V?s=RUVO_E!@?a&_8aOT&YN{?vuUU!8^TLVdoG_ZHOQz&ktFy7+ zsK{C)t|#?mp%KVh98?{@lt427$Ii80Zf3Ip^$SY2CZ3SET!9*@SXg=+$ic#v<-e(1 zhqBqx-tm30Wq+so%{UwmW9X%$9Jw$H*dy3PoC~4W5j00Qy zeVLZ5X3l0|#~*dFcas1tahx#sm?PMZar{>h<8kC`iS^85!kQnpZohWh_VW<$ZsZ3MhXPaiClA!}7_F{Tal8?#2(xpX$he zjyTXA_+fdmBmV>9K=<$g#05#m5U#ShE-$N^$0gt;FO|B(BIDeh0b*`@DGyTI6z z*;ih8Odlki=P#Efz~Ky0%J7vrr&_-py|zd)FTvLWJV!9DU!-5b5AkzY0g}0eav6Sz za}x(p2=p=hFiu{d9M1rRg7IvlkmMMG?rx}C?cGC&A#?(CK;i@K{e=BIN`7qe!|}v~ zj}tD(Sh<3^`5odq#Vb;8GmaYlqP=|D2EPVaAbgL3Um$$Mz~2P? z28f^MlU%EyvkW-LLMF2Kpa=eG58Q%{B+bvx9=OOK_fH4;;@FWqU3$mMPN`M)XM&7V zYBYrRlVjPe=S6c~7==kt_G*6Q&q5g|DBGuGGk!81MisdKRRa%hq^8yZ>7nV*fwZ^k z;m!i}wE10V2W$Wcut+wDb{MfH~aWFGESGeCpMm7N5 zNLP{pfnu#*Zb9F|vIo~VX)@w@n5d(El5auhUDwUC=O=BW)j2?hmjvI6qB$j zJ4i{xgldWMo(_`=wS$>Zi5l}0pJM=IESL*R!Q*hD1`yJpkx^qDg(wM=g~zDHJlr6s z{nBZ0q;>P_sLLLVdeF@fbAqnf>5(eLFVoFW3RUBAQ8j*)s2aXT6xTIG3aa|iYzt-+ zG}ireFvOeR52EIWkudWNW1&(_l5xoJaXD}Va8FFdO?V+H3wZ0zhlyH^c%MUpWhc*S zJhPGZsY2qoXW(5H=|>ulYn}0mhU1&!Fx3|{9QStCe_6v({|wcCqv1P&XZ?3H9QD_! z{=SBP4{;Ud2Jb)EFWmDPzm4`+?(el^|3d@k`^upn_``%_zHH6Eui?8i{4C+zF7^%S zqK4yGaGaMkKf5*jRZSnZKEZLm+XMeg5Bx*T|DBruRSmyO!-18AV$44ipBIeZOak7k z8UHQeeEu-LOt?)Y;Cv5RF>t;Qd}81nC%m%xb2WK`??>;{(^8|qg0Zp zo&*lu`0sH%o zTwc(4DWK0Uxgi})(Y*v1o+IY`y-4;p$aFH@u7D6@G3{4KaZNV{-n4%ku(bT0r2JhX zd#vI)!uFiMw6@XY4SG7x)4<~Sj5ek{s+nUCkQliRze3z;2s!Ucs$w!!l!z__e15XN GY5!jvv)@qw literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.ptx b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.ptx new file mode 100644 index 0000000..4fa6b10 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.ptx @@ -0,0 +1,14 @@ +// +// Generated by NVIDIA NVVM Compiler +// +// Compiler Build ID: CL-34097967 +// Cuda compilation tools, release 12.4, V12.4.131 +// Based on NVVM 7.0.1 +// + +.version 8.4 +.target sm_52 +.address_size 64 + + + diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.sm_52.cubin b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.sm_52.cubin new file mode 100644 index 0000000000000000000000000000000000000000..894b6aa3c023ef33dc2a4e4f3f24d861343e048f GIT binary patch literal 872 zcmb<-^>JfjWHe@HfB+_jeGD~FHi-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!1RHPCr2LujR0V4 literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/a_dlink.fatbin b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/a_dlink.fatbin new file mode 100644 index 0000000000000000000000000000000000000000..e693947f165753a80880668a9edc424d78a0fafd GIT binary patch literal 960 zcmcIiJx{|x4E0?}TZyF=3nL3_h7whbT|gZWVqruml$NWMCQ))it%Src;Xg1l@Q>IT z_^5qnM^RG=sS+OY-t+m{Nqkoy*KZ1X@Y(_w8k8C%Gpv0UpaTjb5s3X7-$tL$F3z=5 zCmlZ2@D5M4!cXnRQhAJm2u5%U8lP>P1z~AQTiEyxnc!;SwZq%er1wh*)5mb0&N4?P zagsa~ac-Q-i_B(rl~0{2rb!r2>^w{Vxq0m?n{~_ z(t(fuF$6;qyCSV)WA(1ph#TH83h??w!alNX{ui$J%YT4%d^M_`j_@G5n-o+-bGjrj z4m|+7eB~!lAa_?rW3k5!;FX? z1W`no)870a-0L2efj#J-;6EUE@gQDg*L+kY4vIPw|^?-XYb0-$AOlgy?zh9aqn*^rLKLb{OM5S zt1;tel;f1iY_V@pr6y_Cf;gmSQ}!tHky-aiSyo2aLKWB`y#>EuI3#zE*Rfc{i zP@x;OqBxAb8d;*(SB$T9HEIQoHRT4YZaY}&YNPITI?d4QwY1j@yKy&O@A=vb{f_I^ z<90Xr$;ney4x4#`#?+3XfvXzVdo(omg#_ULtp8*EFX?CyJ$qPD zk_Y=hH4O1v%%4dz8bf%ZCkVza%K5g!lf*KC@Q{8xygy2{g^~TbTq>Q(9<9{+LEO*g za&Ez$JCW;aH}^1~cjpRj{umF?+~@;p!x}DMt)Rb~z@$(6$%Z)hZzyMN#yPZma%zJX z{VQSkAP4btY46OFOli-=bqaw04MDv-)JJ`;?U1pNFC5k)yES0oyg4ac<~&R|y=6(D zUK@Eu`VcR1q7gWztA{m^yV^uown~#+hh8cXIe&QL>@%WcI_+SYUb22oRc~L(&sD4S ze#2Yv;!?lX4$5B8==jQjl_2z+?I`xc3+=!Q*DGRjY(t^jF(;|CYZN52YoZ$xI7F{~&Uo@TNd;4{A5d()yJC!> z8~ZLD;uBHq)t8A0zZvvh`h(E(!+4!D_^s+v=&kt4nts5@5*M`(PJ~HTG|Jo!wxI?m z(}0Iaq1Q#@CclfEaE_5Zq`{SakaKs0ak;M?u5OEAX?y)7$f023inU?u^Smnq- z&MkXP{vv&lO)Ig@KTk2>TVX28S6=EwE{M%POW3IXZH(w2AmK~i8-!tg=`)#H=6QZs z0M>|wh`y7u^#K1YF+YvL7M|eCWZ*v8{cABlD}k(K{Q^HG137K}Q|8Z0AZwfdkZ^<+ zd0f;c_fPtS^M^M>_=1m`8#y+4{wXeaFJX93Z2nHd?7b&Qz2T?#cQ`4r`-lHWNAchC L`d_5DFm3)<7Y`3@ literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/a_dlink.reg.c b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/a_dlink.reg.c new file mode 100644 index 0000000..af69ecb --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/a_dlink.reg.c @@ -0,0 +1 @@ +#define NUM_PRELINKED_OBJECTS 0 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/a_dlink.sm_52.cubin b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/tmp/a_dlink.sm_52.cubin new file mode 100644 index 0000000000000000000000000000000000000000..894b6aa3c023ef33dc2a4e4f3f24d861343e048f GIT binary patch literal 872 zcmb<-^>JfjWHe@HfB+_jeGD~FHi-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!1RHPCr2LujR0V4 literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCXX/CMakeCXXCompilerId.cpp b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCXX/CMakeCXXCompilerId.cpp new file mode 100644 index 0000000..b35f567 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCXX/CMakeCXXCompilerId.cpp @@ -0,0 +1,949 @@ +/* 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(__RENESAS__) +# define COMPILER_ID "Renesas" +/* __RENESAS_VERSION__ = 0xVVRRPP00 */ +# define COMPILER_VERSION_MAJOR HEX(__RENESAS_VERSION__ >> 24 & 0xFF) +# define COMPILER_VERSION_MINOR HEX(__RENESAS_VERSION__ >> 16 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__RENESAS_VERSION__ >> 8 & 0xFF) + +#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 + +#elif defined(__DCC__) && defined(_DIAB_TOOL) +# define COMPILER_ID "Diab" + # define COMPILER_VERSION_MAJOR DEC(__VERSION_MAJOR_NUMBER__) + # define COMPILER_VERSION_MINOR DEC(__VERSION_MINOR_NUMBER__) + # define COMPILER_VERSION_PATCH DEC(__VERSION_ARCH_FEATURE_NUMBER__) + # define COMPILER_VERSION_TWEAK DEC(__VERSION_BUG_FIX_NUMBER__) + + + +/* 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 + +#elif defined(__RENESAS__) +# if defined(__CCRX__) +# define ARCHITECTURE_ID "RX" + +# elif defined(__CCRL__) +# define ARCHITECTURE_ID "RL78" + +# elif defined(__CCRH__) +# define ARCHITECTURE_ID "RH850" + +# 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(__RENESAS__)) && \ + !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/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCXX/a.out b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCXX/a.out new file mode 100755 index 0000000000000000000000000000000000000000..f42a64b331bded04287f0a0c90c22f4b073c82c9 GIT binary patch literal 16096 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 literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/CMakeConfigureLog.yaml b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/CMakeConfigureLog.yaml new file mode 100644 index 0000000..bb4a7f4 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/CMakeConfigureLog.yaml @@ -0,0 +1,3018 @@ + +--- +events: + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineSystem.cmake:12 (find_program)" + - "CMakeLists.txt:2 (project)" + mode: "program" + variable: "CMAKE_UNAME" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: true + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "uname" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/sbin/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/.npm-global/bin/" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/" + - "/home/richard/.local/bin/" + - "/home/richard/miniconda3/condabin/" + - "/home/richard/.cargo/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/usr/lib/wsl/lib/" + - "/usr/local/go/bin/" + - "/home/richard/go/bin/" + searched_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/uname" + - "/home/richard/miniconda3/envs/bilateral-cuda124/sbin/uname" + - "/home/richard/miniconda3/envs/bilateral-cuda124/uname" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/uname" + - "/home/richard/.npm-global/bin/uname" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/uname" + - "/home/richard/.local/bin/uname" + - "/home/richard/miniconda3/condabin/uname" + - "/home/richard/.cargo/bin/uname" + - "/usr/local/sbin/uname" + - "/usr/local/bin/uname" + - "/usr/sbin/uname" + found: "/usr/bin/uname" + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "message-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineSystem.cmake:212 (message)" + - "CMakeLists.txt:2 (project)" + message: | + The system is: Linux - 6.6.87.2-microsoft-standard-WSL2 - x86_64 + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeNinjaFindMake.cmake:5 (find_program)" + - "CMakeLists.txt:2 (project)" + mode: "program" + variable: "CMAKE_MAKE_PROGRAM" + description: "Program used to build from build.ninja files." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: true + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "ninja-build" + - "ninja" + - "samu" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/sbin/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/.npm-global/bin/" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/" + - "/home/richard/.local/bin/" + - "/home/richard/miniconda3/condabin/" + - "/home/richard/.cargo/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/usr/lib/wsl/lib/" + - "/usr/local/go/bin/" + - "/home/richard/go/bin/" + searched_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/ninja-build" + found: "/home/richard/miniconda3/envs/bilateral-cuda124/bin/ninja" + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompiler.cmake:73 (find_program)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCUDACompiler.cmake:39 (_cmake_find_compiler)" + - "CMakeLists.txt:2 (project)" + mode: "program" + variable: "CMAKE_CUDA_COMPILER" + description: "CUDA compiler" + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: true + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "nvcc" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/sbin/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/.npm-global/bin/" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/" + - "/home/richard/.local/bin/" + - "/home/richard/miniconda3/condabin/" + - "/home/richard/.cargo/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/usr/lib/wsl/lib/" + - "/usr/local/go/bin/" + - "/home/richard/go/bin/" + found: "/home/richard/miniconda3/envs/bilateral-cuda124/bin/nvcc" + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "message-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake:1290 (message)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCUDACompiler.cmake:99 (CMAKE_DETERMINE_COMPILER_ID_VENDOR)" + - "CMakeLists.txt:2 (project)" + message: | + Checking whether the CUDA compiler is NVIDIA using "" matched "nvcc: [^ + ]+ Cuda compiler driver": + nvcc: NVIDIA (R) Cuda compiler driver + Copyright (c) 2005-2024 NVIDIA Corporation + Built on Thu_Mar_28_02:18:24_PDT_2024 + Cuda compilation tools, release 12.4, V12.4.131 + Build cuda_12.4.r12.4/compiler.34097967_0 + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake:462 (find_file)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake:500 (CMAKE_DETERMINE_COMPILER_ID_WRITE)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake:8 (CMAKE_DETERMINE_COMPILER_ID_BUILD)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake:53 (__determine_compiler_id_test)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCUDACompiler.cmake:163 (CMAKE_DETERMINE_COMPILER_ID)" + - "CMakeLists.txt:2 (project)" + mode: "file" + variable: "src_in" + description: "Path to a file." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: true + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "CMakeCUDACompilerId.cu.in" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/" + found: "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCUDACompilerId.cu.in" + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "message-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake:17 (message)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake:53 (__determine_compiler_id_test)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCUDACompiler.cmake:163 (CMAKE_DETERMINE_COMPILER_ID)" + - "CMakeLists.txt:2 (project)" + message: | + Compiling the CUDA compiler identification source file "CMakeCUDACompilerId.cu" succeeded. + Compiler: /home/richard/miniconda3/envs/bilateral-cuda124/bin/nvcc + Build flags: + Id flags: --keep;--keep-dir;tmp -v + + The output was: + 0 + #$ _NVVM_BRANCH_=nvvm + #$ _NVVM_BRANCH_SUFFIX_= + #$ _SPACE_= + #$ _CUDART_=cudart + #$ _HERE_=/home/richard/miniconda3/envs/bilateral-cuda124/bin + #$ _THERE_=/home/richard/miniconda3/envs/bilateral-cuda124/bin + #$ _TARGET_SIZE_= + #$ _TARGET_DIR_= + #$ _TARGET_SIZE_=64 + #$ TOP=/home/richard/miniconda3/envs/bilateral-cuda124/bin/.. + #$ NVVMIR_LIBRARY_DIR=/home/richard/miniconda3/envs/bilateral-cuda124/bin/../nvvm/libdevice + #$ LD_LIBRARY_PATH=/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib:/home/richard/miniconda3/envs/bilateral-cuda124/lib:/usr/lib/wsl/lib:/home/richard/miniconda3/envs/bilateral-cuda124/lib + #$ PATH=/home/richard/miniconda3/envs/bilateral-cuda124/bin/../nvvm/bin:/home/richard/miniconda3/envs/bilateral-cuda124/bin:/home/richard/miniconda3/envs/bilateral-cuda124/bin:/home/richard/.npm-global/bin:/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli:/home/richard/.npm-global/bin:/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli:/home/richard/.npm-global/bin:/home/richard/.local/bin:/home/richard/miniconda3/envs/bilateral-cuda124/bin:/home/richard/miniconda3/condabin:/home/richard/.cargo/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/usr/lib/wsl/lib:/usr/local/go/bin:/home/richard/go/bin:/usr/local/go/bin:/home/richard/go/bin:/usr/local/go/bin:/home/richard/go/bin + #$ INCLUDES="-I/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" + #$ LIBRARIES= "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib" + #$ CUDAFE_FLAGS= + #$ PTXAS_FLAGS= + #$ rm tmp/a_dlink.reg.c + #$ gcc -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -E -x c++ -D__CUDACC__ -D__NVCC__ "-I/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=4 -D__CUDACC_VER_BUILD__=131 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=4 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp4.ii" + #$ cudafe++ --c++17 --gnu_version=110400 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/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" + #$ gcc -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/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=4 -D__CUDACC_VER_BUILD__=131 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=4 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp1.ii" + #$ cicc --c++17 --gnu_version=110400 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/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" + #$ gcc -D__CUDA_ARCH__=520 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -c -x c++ -DCUDA_DOUBLE_MATH_FUNCTIONS -Wno-psabi "-I/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" -m64 "tmp/CMakeCUDACompilerId.cudafe1.cpp" -o "tmp/CMakeCUDACompilerId.o" + #$ nvlink -m64 --arch=sm_52 --register-link-binaries="tmp/a_dlink.reg.c" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib" -cpu-arch=X86_64 "tmp/CMakeCUDACompilerId.o" -lcudadevrt -o "tmp/a_dlink.sm_52.cubin" --host-ccbin "gcc" + #$ 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" + #$ gcc -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/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=4 -D__CUDACC_VER_BUILD__=131 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=4 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -m64 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/crt/link.stub" -o "tmp/a_dlink.o" + #$ g++ -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCUDA/a.out + The host compiler identification is GNU + + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCUDACompiler.cmake:186 (include)" + - "CMakeLists.txt:2 (project)" + mode: "program" + variable: "CMAKE_AR" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "ar" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/.npm-global/bin/" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/" + - "/home/richard/.local/bin/" + - "/home/richard/miniconda3/condabin/" + - "/home/richard/.cargo/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/usr/lib/wsl/lib/" + - "/usr/local/go/bin/" + - "/home/richard/go/bin/" + searched_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/ar" + - "/home/richard/.npm-global/bin/ar" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/ar" + - "/home/richard/.local/bin/ar" + - "/home/richard/miniconda3/condabin/ar" + - "/home/richard/.cargo/bin/ar" + - "/usr/local/sbin/ar" + - "/usr/local/bin/ar" + - "/usr/sbin/ar" + found: "/usr/bin/ar" + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCUDACompiler.cmake:186 (include)" + - "CMakeLists.txt:2 (project)" + mode: "program" + variable: "CMAKE_RANLIB" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "ranlib" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/.npm-global/bin/" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/" + - "/home/richard/.local/bin/" + - "/home/richard/miniconda3/condabin/" + - "/home/richard/.cargo/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/usr/lib/wsl/lib/" + - "/usr/local/go/bin/" + - "/home/richard/go/bin/" + searched_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/ranlib" + - "/home/richard/.npm-global/bin/ranlib" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/ranlib" + - "/home/richard/.local/bin/ranlib" + - "/home/richard/miniconda3/condabin/ranlib" + - "/home/richard/.cargo/bin/ranlib" + - "/usr/local/sbin/ranlib" + - "/usr/local/bin/ranlib" + - "/usr/sbin/ranlib" + found: "/usr/bin/ranlib" + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCUDACompiler.cmake:186 (include)" + - "CMakeLists.txt:2 (project)" + mode: "program" + variable: "CMAKE_STRIP" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "strip" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/.npm-global/bin/" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/" + - "/home/richard/.local/bin/" + - "/home/richard/miniconda3/condabin/" + - "/home/richard/.cargo/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/usr/lib/wsl/lib/" + - "/usr/local/go/bin/" + - "/home/richard/go/bin/" + searched_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/strip" + - "/home/richard/.npm-global/bin/strip" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/strip" + - "/home/richard/.local/bin/strip" + - "/home/richard/miniconda3/condabin/strip" + - "/home/richard/.cargo/bin/strip" + - "/usr/local/sbin/strip" + - "/usr/local/bin/strip" + - "/usr/sbin/strip" + found: "/usr/bin/strip" + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCUDACompiler.cmake:186 (include)" + - "CMakeLists.txt:2 (project)" + mode: "program" + variable: "CMAKE_LINKER" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "ld" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/.npm-global/bin/" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/" + - "/home/richard/.local/bin/" + - "/home/richard/miniconda3/condabin/" + - "/home/richard/.cargo/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/usr/lib/wsl/lib/" + - "/usr/local/go/bin/" + - "/home/richard/go/bin/" + searched_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/ld" + - "/home/richard/.npm-global/bin/ld" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/ld" + - "/home/richard/.local/bin/ld" + - "/home/richard/miniconda3/condabin/ld" + - "/home/richard/.cargo/bin/ld" + - "/usr/local/sbin/ld" + - "/usr/local/bin/ld" + - "/usr/sbin/ld" + found: "/usr/bin/ld" + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCUDACompiler.cmake:186 (include)" + - "CMakeLists.txt:2 (project)" + mode: "program" + variable: "CMAKE_NM" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "nm" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/.npm-global/bin/" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/" + - "/home/richard/.local/bin/" + - "/home/richard/miniconda3/condabin/" + - "/home/richard/.cargo/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/usr/lib/wsl/lib/" + - "/usr/local/go/bin/" + - "/home/richard/go/bin/" + searched_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/nm" + - "/home/richard/.npm-global/bin/nm" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/nm" + - "/home/richard/.local/bin/nm" + - "/home/richard/miniconda3/condabin/nm" + - "/home/richard/.cargo/bin/nm" + - "/usr/local/sbin/nm" + - "/usr/local/bin/nm" + - "/usr/sbin/nm" + found: "/usr/bin/nm" + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCUDACompiler.cmake:186 (include)" + - "CMakeLists.txt:2 (project)" + mode: "program" + variable: "CMAKE_OBJDUMP" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "objdump" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/.npm-global/bin/" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/" + - "/home/richard/.local/bin/" + - "/home/richard/miniconda3/condabin/" + - "/home/richard/.cargo/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/usr/lib/wsl/lib/" + - "/usr/local/go/bin/" + - "/home/richard/go/bin/" + searched_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/objdump" + - "/home/richard/.npm-global/bin/objdump" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/objdump" + - "/home/richard/.local/bin/objdump" + - "/home/richard/miniconda3/condabin/objdump" + - "/home/richard/.cargo/bin/objdump" + - "/usr/local/sbin/objdump" + - "/usr/local/bin/objdump" + - "/usr/sbin/objdump" + found: "/usr/bin/objdump" + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCUDACompiler.cmake:186 (include)" + - "CMakeLists.txt:2 (project)" + mode: "program" + variable: "CMAKE_OBJCOPY" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "objcopy" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/.npm-global/bin/" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/" + - "/home/richard/.local/bin/" + - "/home/richard/miniconda3/condabin/" + - "/home/richard/.cargo/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/usr/lib/wsl/lib/" + - "/usr/local/go/bin/" + - "/home/richard/go/bin/" + searched_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/objcopy" + - "/home/richard/.npm-global/bin/objcopy" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/objcopy" + - "/home/richard/.local/bin/objcopy" + - "/home/richard/miniconda3/condabin/objcopy" + - "/home/richard/.cargo/bin/objcopy" + - "/usr/local/sbin/objcopy" + - "/usr/local/bin/objcopy" + - "/usr/sbin/objcopy" + found: "/usr/bin/objcopy" + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCUDACompiler.cmake:186 (include)" + - "CMakeLists.txt:2 (project)" + mode: "program" + variable: "CMAKE_READELF" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "readelf" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/.npm-global/bin/" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/" + - "/home/richard/.local/bin/" + - "/home/richard/miniconda3/condabin/" + - "/home/richard/.cargo/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/usr/lib/wsl/lib/" + - "/usr/local/go/bin/" + - "/home/richard/go/bin/" + searched_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/readelf" + - "/home/richard/.npm-global/bin/readelf" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/readelf" + - "/home/richard/.local/bin/readelf" + - "/home/richard/miniconda3/condabin/readelf" + - "/home/richard/.cargo/bin/readelf" + - "/usr/local/sbin/readelf" + - "/usr/local/bin/readelf" + - "/usr/sbin/readelf" + found: "/usr/bin/readelf" + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCUDACompiler.cmake:186 (include)" + - "CMakeLists.txt:2 (project)" + mode: "program" + variable: "CMAKE_DLLTOOL" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "dlltool" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/.npm-global/bin/" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/" + - "/home/richard/.local/bin/" + - "/home/richard/miniconda3/condabin/" + - "/home/richard/.cargo/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/usr/lib/wsl/lib/" + - "/usr/local/go/bin/" + - "/home/richard/go/bin/" + searched_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/dlltool" + - "/home/richard/.npm-global/bin/dlltool" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/dlltool" + - "/home/richard/.local/bin/dlltool" + - "/home/richard/miniconda3/condabin/dlltool" + - "/home/richard/.cargo/bin/dlltool" + - "/usr/local/sbin/dlltool" + - "/usr/local/bin/dlltool" + - "/usr/sbin/dlltool" + - "/usr/bin/dlltool" + - "/sbin/dlltool" + - "/bin/dlltool" + - "/usr/games/dlltool" + - "/usr/local/games/dlltool" + - "/usr/lib/wsl/lib/dlltool" + - "/usr/local/go/bin/dlltool" + - "/home/richard/go/bin/dlltool" + found: false + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCUDACompiler.cmake:186 (include)" + - "CMakeLists.txt:2 (project)" + mode: "program" + variable: "CMAKE_ADDR2LINE" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "addr2line" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/.npm-global/bin/" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/" + - "/home/richard/.local/bin/" + - "/home/richard/miniconda3/condabin/" + - "/home/richard/.cargo/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/usr/lib/wsl/lib/" + - "/usr/local/go/bin/" + - "/home/richard/go/bin/" + searched_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/addr2line" + - "/home/richard/.npm-global/bin/addr2line" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/addr2line" + - "/home/richard/.local/bin/addr2line" + - "/home/richard/miniconda3/condabin/addr2line" + - "/home/richard/.cargo/bin/addr2line" + - "/usr/local/sbin/addr2line" + - "/usr/local/bin/addr2line" + - "/usr/sbin/addr2line" + found: "/usr/bin/addr2line" + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCUDACompiler.cmake:186 (include)" + - "CMakeLists.txt:2 (project)" + mode: "program" + variable: "CMAKE_TAPI" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "tapi" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/.npm-global/bin/" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/" + - "/home/richard/.local/bin/" + - "/home/richard/miniconda3/condabin/" + - "/home/richard/.cargo/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/usr/lib/wsl/lib/" + - "/usr/local/go/bin/" + - "/home/richard/go/bin/" + searched_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/tapi" + - "/home/richard/.npm-global/bin/tapi" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/tapi" + - "/home/richard/.local/bin/tapi" + - "/home/richard/miniconda3/condabin/tapi" + - "/home/richard/.cargo/bin/tapi" + - "/usr/local/sbin/tapi" + - "/usr/local/bin/tapi" + - "/usr/sbin/tapi" + - "/usr/bin/tapi" + - "/sbin/tapi" + - "/bin/tapi" + - "/usr/games/tapi" + - "/usr/local/games/tapi" + - "/usr/lib/wsl/lib/tapi" + - "/usr/local/go/bin/tapi" + - "/home/richard/go/bin/tapi" + found: false + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeNVCCParseImplicitInfo.cmake:97 (find_program)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCUDACompiler.cmake:295 (cmake_nvcc_parse_implicit_info)" + - "CMakeLists.txt:2 (project)" + mode: "program" + variable: "_nvcc_find_host_link_launcher" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: true + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "g++" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/nvvm/bin/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/.npm-global/bin/" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/" + - "/home/richard/.local/bin/" + - "/home/richard/miniconda3/condabin/" + - "/home/richard/.cargo/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/usr/lib/wsl/lib/" + - "/usr/local/go/bin/" + - "/home/richard/go/bin/" + searched_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/nvvm/bin/g++" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/g++" + - "/home/richard/.npm-global/bin/g++" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/g++" + - "/home/richard/.local/bin/g++" + - "/home/richard/miniconda3/condabin/g++" + - "/home/richard/.cargo/bin/g++" + - "/usr/local/sbin/g++" + - "/usr/local/bin/g++" + - "/usr/sbin/g++" + found: "/usr/bin/g++" + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "message-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeNVCCParseImplicitInfo.cmake:136 (message)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCUDACompiler.cmake:295 (cmake_nvcc_parse_implicit_info)" + - "CMakeLists.txt:2 (project)" + message: | + Parsed CUDA nvcc implicit link information: + found 'PATH=' string: [/home/richard/miniconda3/envs/bilateral-cuda124/bin/../nvvm/bin:/home/richard/miniconda3/envs/bilateral-cuda124/bin:/home/richard/miniconda3/envs/bilateral-cuda124/bin:/home/richard/.npm-global/bin:/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli:/home/richard/.npm-global/bin:/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli:/home/richard/.npm-global/bin:/home/richard/.local/bin:/home/richard/miniconda3/envs/bilateral-cuda124/bin:/home/richard/miniconda3/condabin:/home/richard/.cargo/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/usr/lib/wsl/lib:/usr/local/go/bin:/home/richard/go/bin:/usr/local/go/bin:/home/richard/go/bin:/usr/local/go/bin:/home/richard/go/bin] + found 'LIBRARIES=' string: ["-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib"] + found 'INCLUDES=' string: ["-I/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" ] + no 'SYSTEM_INCLUDES=' string found in nvcc output: + #$ _NVVM_BRANCH_=nvvm + #$ _NVVM_BRANCH_SUFFIX_= + #$ _SPACE_= + #$ _CUDART_=cudart + #$ _HERE_=/home/richard/miniconda3/envs/bilateral-cuda124/bin + #$ _THERE_=/home/richard/miniconda3/envs/bilateral-cuda124/bin + #$ _TARGET_SIZE_= + #$ _TARGET_DIR_= + #$ _TARGET_SIZE_=64 + #$ TOP=/home/richard/miniconda3/envs/bilateral-cuda124/bin/.. + #$ NVVMIR_LIBRARY_DIR=/home/richard/miniconda3/envs/bilateral-cuda124/bin/../nvvm/libdevice + #$ LD_LIBRARY_PATH=/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib:/home/richard/miniconda3/envs/bilateral-cuda124/lib:/usr/lib/wsl/lib:/home/richard/miniconda3/envs/bilateral-cuda124/lib + #$ PATH=/home/richard/miniconda3/envs/bilateral-cuda124/bin/../nvvm/bin:/home/richard/miniconda3/envs/bilateral-cuda124/bin:/home/richard/miniconda3/envs/bilateral-cuda124/bin:/home/richard/.npm-global/bin:/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli:/home/richard/.npm-global/bin:/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli:/home/richard/.npm-global/bin:/home/richard/.local/bin:/home/richard/miniconda3/envs/bilateral-cuda124/bin:/home/richard/miniconda3/condabin:/home/richard/.cargo/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/usr/lib/wsl/lib:/usr/local/go/bin:/home/richard/go/bin:/usr/local/go/bin:/home/richard/go/bin:/usr/local/go/bin:/home/richard/go/bin + #$ INCLUDES="-I/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" + #$ LIBRARIES= "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib" + #$ CUDAFE_FLAGS= + #$ PTXAS_FLAGS= + #$ rm tmp/a_dlink.reg.c + #$ gcc -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -E -x c++ -D__CUDACC__ -D__NVCC__ "-I/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=4 -D__CUDACC_VER_BUILD__=131 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=4 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp4.ii" + #$ cudafe++ --c++17 --gnu_version=110400 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/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" + #$ gcc -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/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=4 -D__CUDACC_VER_BUILD__=131 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=4 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp1.ii" + #$ cicc --c++17 --gnu_version=110400 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/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" + #$ gcc -D__CUDA_ARCH__=520 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -c -x c++ -DCUDA_DOUBLE_MATH_FUNCTIONS -Wno-psabi "-I/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" -m64 "tmp/CMakeCUDACompilerId.cudafe1.cpp" -o "tmp/CMakeCUDACompilerId.o" + #$ nvlink -m64 --arch=sm_52 --register-link-binaries="tmp/a_dlink.reg.c" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib" -cpu-arch=X86_64 "tmp/CMakeCUDACompilerId.o" -lcudadevrt -o "tmp/a_dlink.sm_52.cubin" --host-ccbin "gcc" + #$ 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" + #$ gcc -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/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=4 -D__CUDACC_VER_BUILD__=131 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=4 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -m64 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/crt/link.stub" -o "tmp/a_dlink.o" + #$ g++ -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" + + considering line: [#$ rm tmp/a_dlink.reg.c] + considering line: [gcc -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -E -x c++ -D__CUDACC__ -D__NVCC__ "-I/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=4 -D__CUDACC_VER_BUILD__=131 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=4 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp4.ii" ] + considering line: [cudafe++ --c++17 --gnu_version=110400 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/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: [gcc -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/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=4 -D__CUDACC_VER_BUILD__=131 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=4 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp1.ii" ] + considering line: [cicc --c++17 --gnu_version=110400 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/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: [gcc -D__CUDA_ARCH__=520 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -c -x c++ -DCUDA_DOUBLE_MATH_FUNCTIONS -Wno-psabi "-I/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib" -cpu-arch=X86_64 "tmp/CMakeCUDACompilerId.o" -lcudadevrt -o "tmp/a_dlink.sm_52.cubin" --host-ccbin "gcc"] + 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: [gcc -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/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=4 -D__CUDACC_VER_BUILD__=131 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=4 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -m64 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/crt/link.stub" -o "tmp/a_dlink.o" ] + considering line: [g++ -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" ] + extracted link line: [g++ -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" ] + considering line: [] + extracted link launcher name: [g++] + found link launcher absolute path: [/usr/bin/g++] + + 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 g++ -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" ] + arg [cuda-fake-ld] ==> ignore + arg [g++] ==> 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/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs] ==> dir [/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs] + arg [-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib] ==> dir [/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 [/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs] ==> [/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs] + collapse library dir [/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib] ==> [/home/richard/miniconda3/envs/bilateral-cuda124/lib] + implicit libs: [cudadevrt;cudart_static;rt;pthread;dl] + implicit objs: [] + implicit dirs: [/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs;/home/richard/miniconda3/envs/bilateral-cuda124/lib] + implicit fwks: [] + + + - + kind: "message-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeNVCCParseImplicitInfo.cmake:165 (message)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCUDACompiler.cmake:295 (cmake_nvcc_parse_implicit_info)" + - "CMakeLists.txt:2 (project)" + message: | + Parsed CUDA nvcc include information: + found 'PATH=' string: [/home/richard/miniconda3/envs/bilateral-cuda124/bin/../nvvm/bin:/home/richard/miniconda3/envs/bilateral-cuda124/bin:/home/richard/miniconda3/envs/bilateral-cuda124/bin:/home/richard/.npm-global/bin:/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli:/home/richard/.npm-global/bin:/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli:/home/richard/.npm-global/bin:/home/richard/.local/bin:/home/richard/miniconda3/envs/bilateral-cuda124/bin:/home/richard/miniconda3/condabin:/home/richard/.cargo/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/usr/lib/wsl/lib:/usr/local/go/bin:/home/richard/go/bin:/usr/local/go/bin:/home/richard/go/bin:/usr/local/go/bin:/home/richard/go/bin] + found 'LIBRARIES=' string: ["-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib"] + found 'INCLUDES=' string: ["-I/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" ] + no 'SYSTEM_INCLUDES=' string found in nvcc output: + #$ _NVVM_BRANCH_=nvvm + #$ _NVVM_BRANCH_SUFFIX_= + #$ _SPACE_= + #$ _CUDART_=cudart + #$ _HERE_=/home/richard/miniconda3/envs/bilateral-cuda124/bin + #$ _THERE_=/home/richard/miniconda3/envs/bilateral-cuda124/bin + #$ _TARGET_SIZE_= + #$ _TARGET_DIR_= + #$ _TARGET_SIZE_=64 + #$ TOP=/home/richard/miniconda3/envs/bilateral-cuda124/bin/.. + #$ NVVMIR_LIBRARY_DIR=/home/richard/miniconda3/envs/bilateral-cuda124/bin/../nvvm/libdevice + #$ LD_LIBRARY_PATH=/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib:/home/richard/miniconda3/envs/bilateral-cuda124/lib:/usr/lib/wsl/lib:/home/richard/miniconda3/envs/bilateral-cuda124/lib + #$ PATH=/home/richard/miniconda3/envs/bilateral-cuda124/bin/../nvvm/bin:/home/richard/miniconda3/envs/bilateral-cuda124/bin:/home/richard/miniconda3/envs/bilateral-cuda124/bin:/home/richard/.npm-global/bin:/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli:/home/richard/.npm-global/bin:/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli:/home/richard/.npm-global/bin:/home/richard/.local/bin:/home/richard/miniconda3/envs/bilateral-cuda124/bin:/home/richard/miniconda3/condabin:/home/richard/.cargo/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/usr/lib/wsl/lib:/usr/local/go/bin:/home/richard/go/bin:/usr/local/go/bin:/home/richard/go/bin:/usr/local/go/bin:/home/richard/go/bin + #$ INCLUDES="-I/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" + #$ LIBRARIES= "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib" + #$ CUDAFE_FLAGS= + #$ PTXAS_FLAGS= + #$ rm tmp/a_dlink.reg.c + #$ gcc -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -E -x c++ -D__CUDACC__ -D__NVCC__ "-I/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=4 -D__CUDACC_VER_BUILD__=131 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=4 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp4.ii" + #$ cudafe++ --c++17 --gnu_version=110400 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/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" + #$ gcc -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/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=4 -D__CUDACC_VER_BUILD__=131 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=4 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp1.ii" + #$ cicc --c++17 --gnu_version=110400 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/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" + #$ gcc -D__CUDA_ARCH__=520 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -c -x c++ -DCUDA_DOUBLE_MATH_FUNCTIONS -Wno-psabi "-I/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" -m64 "tmp/CMakeCUDACompilerId.cudafe1.cpp" -o "tmp/CMakeCUDACompilerId.o" + #$ nvlink -m64 --arch=sm_52 --register-link-binaries="tmp/a_dlink.reg.c" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib" -cpu-arch=X86_64 "tmp/CMakeCUDACompilerId.o" -lcudadevrt -o "tmp/a_dlink.sm_52.cubin" --host-ccbin "gcc" + #$ 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" + #$ gcc -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/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=4 -D__CUDACC_VER_BUILD__=131 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=4 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -m64 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/crt/link.stub" -o "tmp/a_dlink.o" + #$ g++ -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" + + considering line: [#$ rm tmp/a_dlink.reg.c] + considering line: [gcc -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -E -x c++ -D__CUDACC__ -D__NVCC__ "-I/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=4 -D__CUDACC_VER_BUILD__=131 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=4 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp4.ii" ] + considering line: [cudafe++ --c++17 --gnu_version=110400 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/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: [gcc -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/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=4 -D__CUDACC_VER_BUILD__=131 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=4 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" -o "tmp/CMakeCUDACompilerId.cpp1.ii" ] + considering line: [cicc --c++17 --gnu_version=110400 --display_error_number --orig_src_file_name "CMakeCUDACompilerId.cu" --orig_src_path_name "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/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: [gcc -D__CUDA_ARCH__=520 -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -c -x c++ -DCUDA_DOUBLE_MATH_FUNCTIONS -Wno-psabi "-I/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib" -cpu-arch=X86_64 "tmp/CMakeCUDACompilerId.o" -lcudadevrt -o "tmp/a_dlink.sm_52.cubin" --host-ccbin "gcc"] + 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: [gcc -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/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include" -D__CUDACC_VER_MAJOR__=12 -D__CUDACC_VER_MINOR__=4 -D__CUDACC_VER_BUILD__=131 -D__CUDA_API_VER_MAJOR__=12 -D__CUDA_API_VER_MINOR__=4 -D__NVCC_DIAG_PRAGMA_SUPPORT__=1 -m64 "/home/richard/miniconda3/envs/bilateral-cuda124/bin/crt/link.stub" -o "tmp/a_dlink.o" ] + considering line: [g++ -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" ] + extracted link line: [g++ -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" ] + considering line: [] + extracted link launcher name: [g++] + found link launcher absolute path: [/usr/bin/g++] + + 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 g++ -D__CUDA_ARCH_LIST__=520 -D__NV_LEGACY_LAUNCH -m64 -Wl,--start-group "tmp/a_dlink.o" "tmp/CMakeCUDACompilerId.o" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs" "-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib" -lcudadevrt -lcudart_static -lrt -lpthread -ldl -Wl,--end-group -o "a.out" ] + arg [cuda-fake-ld] ==> ignore + arg [g++] ==> 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/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs] ==> dir [/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs] + arg [-L/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib] ==> dir [/home/richard/miniconda3/envs/bilateral-cuda124/bin/../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 [/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib/stubs] ==> [/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs] + collapse library dir [/home/richard/miniconda3/envs/bilateral-cuda124/bin/../lib] ==> [/home/richard/miniconda3/envs/bilateral-cuda124/lib] + implicit libs: [cudadevrt;cudart_static;rt;pthread;dl] + implicit objs: [] + implicit dirs: [/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs;/home/richard/miniconda3/envs/bilateral-cuda124/lib] + implicit fwks: [] + + + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompiler.cmake:54 (find_program)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:69 (_cmake_find_compiler)" + - "CMakeLists.txt:2 (project)" + mode: "program" + variable: "CMAKE_CXX_COMPILER" + description: "CXX compiler" + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: true + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "c++" + - "CC" + - "g++" + - "aCC" + - "cl" + - "bcc" + - "xlC" + - "icpx" + - "icx" + - "clang++" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + searched_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/c++" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/CC" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/g++" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/aCC" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/cl" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/bcc" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/xlC" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/icpx" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/icx" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/clang++" + found: false + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompiler.cmake:73 (find_program)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:69 (_cmake_find_compiler)" + - "CMakeLists.txt:2 (project)" + mode: "program" + variable: "CMAKE_CXX_COMPILER" + description: "CXX compiler" + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: true + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "c++" + - "CC" + - "g++" + - "aCC" + - "cl" + - "bcc" + - "xlC" + - "icpx" + - "icx" + - "clang++" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/sbin/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/.npm-global/bin/" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/" + - "/home/richard/.local/bin/" + - "/home/richard/miniconda3/condabin/" + - "/home/richard/.cargo/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/usr/lib/wsl/lib/" + - "/usr/local/go/bin/" + - "/home/richard/go/bin/" + searched_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/c++" + - "/home/richard/miniconda3/envs/bilateral-cuda124/sbin/c++" + - "/home/richard/miniconda3/envs/bilateral-cuda124/c++" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/c++" + - "/home/richard/.npm-global/bin/c++" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/c++" + - "/home/richard/.local/bin/c++" + - "/home/richard/miniconda3/condabin/c++" + - "/home/richard/.cargo/bin/c++" + - "/usr/local/sbin/c++" + - "/usr/local/bin/c++" + - "/usr/sbin/c++" + found: "/usr/bin/c++" + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake:462 (find_file)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake:500 (CMAKE_DETERMINE_COMPILER_ID_WRITE)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake:8 (CMAKE_DETERMINE_COMPILER_ID_BUILD)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake:64 (__determine_compiler_id_test)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:125 (CMAKE_DETERMINE_COMPILER_ID)" + - "CMakeLists.txt:2 (project)" + mode: "file" + variable: "src_in" + description: "Path to a file." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: true + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "CMakeCXXCompilerId.cpp.in" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/" + found: "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCXXCompilerId.cpp.in" + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "message-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake:17 (message)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake:64 (__determine_compiler_id_test)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:125 (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/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/4.2.3/CompilerIdCXX/a.out + + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/GNU-FindBinUtils.cmake:18 (find_program)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:207 (include)" + - "CMakeLists.txt:2 (project)" + mode: "program" + variable: "CMAKE_CXX_COMPILER_AR" + description: "A wrapper around 'ar' adding the appropriate '--plugin' option for the GCC compiler" + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "gcc-ar-11.4" + - "gcc-ar-11" + - "gcc-ar11" + - "gcc-ar" + candidate_directories: + - "/usr/bin/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/.npm-global/bin/" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/" + - "/home/richard/.local/bin/" + - "/home/richard/miniconda3/condabin/" + - "/home/richard/.cargo/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/usr/lib/wsl/lib/" + - "/usr/local/go/bin/" + - "/home/richard/go/bin/" + searched_directories: + - "/usr/bin/gcc-ar-11.4" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/gcc-ar-11.4" + - "/home/richard/.npm-global/bin/gcc-ar-11.4" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/gcc-ar-11.4" + - "/home/richard/.local/bin/gcc-ar-11.4" + - "/home/richard/miniconda3/condabin/gcc-ar-11.4" + - "/home/richard/.cargo/bin/gcc-ar-11.4" + - "/usr/local/sbin/gcc-ar-11.4" + - "/usr/local/bin/gcc-ar-11.4" + - "/usr/sbin/gcc-ar-11.4" + - "/sbin/gcc-ar-11.4" + - "/bin/gcc-ar-11.4" + - "/usr/games/gcc-ar-11.4" + - "/usr/local/games/gcc-ar-11.4" + - "/usr/lib/wsl/lib/gcc-ar-11.4" + - "/usr/local/go/bin/gcc-ar-11.4" + - "/home/richard/go/bin/gcc-ar-11.4" + found: "/usr/bin/gcc-ar-11" + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/GNU-FindBinUtils.cmake:30 (find_program)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:207 (include)" + - "CMakeLists.txt:2 (project)" + mode: "program" + variable: "CMAKE_CXX_COMPILER_RANLIB" + description: "A wrapper around 'ranlib' adding the appropriate '--plugin' option for the GCC compiler" + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "gcc-ranlib-11.4" + - "gcc-ranlib-11" + - "gcc-ranlib11" + - "gcc-ranlib" + candidate_directories: + - "/usr/bin/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/.npm-global/bin/" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/" + - "/home/richard/.local/bin/" + - "/home/richard/miniconda3/condabin/" + - "/home/richard/.cargo/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/usr/lib/wsl/lib/" + - "/usr/local/go/bin/" + - "/home/richard/go/bin/" + searched_directories: + - "/usr/bin/gcc-ranlib-11.4" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/gcc-ranlib-11.4" + - "/home/richard/.npm-global/bin/gcc-ranlib-11.4" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/gcc-ranlib-11.4" + - "/home/richard/.local/bin/gcc-ranlib-11.4" + - "/home/richard/miniconda3/condabin/gcc-ranlib-11.4" + - "/home/richard/.cargo/bin/gcc-ranlib-11.4" + - "/usr/local/sbin/gcc-ranlib-11.4" + - "/usr/local/bin/gcc-ranlib-11.4" + - "/usr/sbin/gcc-ranlib-11.4" + - "/sbin/gcc-ranlib-11.4" + - "/bin/gcc-ranlib-11.4" + - "/usr/games/gcc-ranlib-11.4" + - "/usr/local/games/gcc-ranlib-11.4" + - "/usr/lib/wsl/lib/gcc-ranlib-11.4" + - "/usr/local/go/bin/gcc-ranlib-11.4" + - "/home/richard/go/bin/gcc-ranlib-11.4" + found: "/usr/bin/gcc-ranlib-11" + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - + kind: "try_compile-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerABI.cmake:83 (try_compile)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeTestCUDACompiler.cmake:19 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + checks: + - "Detecting CUDA compiler ABI info" + directories: + source: "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/CMakeScratch/TryCompile-I3HvwS" + binary: "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/CMakeScratch/TryCompile-I3HvwS" + 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/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/CMakeScratch/TryCompile-I3HvwS' + + Run Build Command(s): /home/richard/miniconda3/envs/bilateral-cuda124/bin/ninja -v cmTC_4d9f7 + [1/2] /home/richard/miniconda3/envs/bilateral-cuda124/bin/nvcc -forward-unknown-to-host-compiler "--generate-code=arch=compute_52,code=[compute_52,sm_52]" -Xcompiler=-v -MD -MT CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.o -MF CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.o.d -x cu -c /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCUDACompilerABI.cu -o CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.o + Using built-in specs. + COLLECT_GCC=gcc + OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa + OFFLOAD_TARGET_DEFAULT=1 + Target: x86_64-linux-gnu + Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.4.0-1ubuntu1~22.04.2' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2 + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04.2) + 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' '/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=4' '-D' '__CUDACC_VER_BUILD__=131' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=4' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00001541_00000000-7_CMakeCUDACompilerABI.cpp1.ii' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/' + /usr/lib/gcc/x86_64-linux-gnu/11/cc1plus -E -quiet -v -I /home/richard/miniconda3/envs/bilateral-cuda124/bin/../include -imultiarch x86_64-linux-gnu -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__=4 -D __CUDACC_VER_BUILD__=131 -D __CUDA_API_VER_MAJOR__=12 -D __CUDA_API_VER_MINOR__=4 -D __NVCC_DIAG_PRAGMA_SUPPORT__=1 -include cuda_runtime.h /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCUDACompilerABI.cu -o /tmp/tmpxft_00001541_00000000-7_CMakeCUDACompilerABI.cpp1.ii -m64 -mtune=generic -march=x86-64 -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -dumpdir /tmp/ -dumpbase tmpxft_00001541_00000000-7_CMakeCUDACompilerABI.cpp1.cu -dumpbase-ext .cu + ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/11" + ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu" + ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/include-fixed" + ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/include" + ignoring duplicate directory "/home/richard/miniconda3/envs/bilateral-cuda124/include" + ignoring duplicate directory "/home/richard/miniconda3/envs/bilateral-cuda124/include" + #include "..." search starts here: + #include <...> search starts here: + /home/richard/miniconda3/envs/bilateral-cuda124/bin/../include + /usr/include/c++/11 + /usr/include/x86_64-linux-gnu/c++/11 + /usr/include/c++/11/backward + /usr/lib/gcc/x86_64-linux-gnu/11/include + /usr/local/include + /usr/include/x86_64-linux-gnu + /usr/include + End of search list. + COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/ + LIBRARY_PATH=/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/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' '/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=4' '-D' '__CUDACC_VER_BUILD__=131' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=4' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00001541_00000000-7_CMakeCUDACompilerABI.cpp1.ii' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/tmpxft_00001541_00000000-7_CMakeCUDACompilerABI.cpp1.' + Using built-in specs. + COLLECT_GCC=gcc + OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa + OFFLOAD_TARGET_DEFAULT=1 + Target: x86_64-linux-gnu + Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.4.0-1ubuntu1~22.04.2' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2 + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04.2) + COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-E' '-D' '__CUDACC__' '-D' '__NVCC__' '-v' '-I' '/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=4' '-D' '__CUDACC_VER_BUILD__=131' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=4' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00001541_00000000-5_CMakeCUDACompilerABI.cpp4.ii' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/' + /usr/lib/gcc/x86_64-linux-gnu/11/cc1plus -E -quiet -v -I /home/richard/miniconda3/envs/bilateral-cuda124/bin/../include -imultiarch x86_64-linux-gnu -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__=4 -D __CUDACC_VER_BUILD__=131 -D __CUDA_API_VER_MAJOR__=12 -D __CUDA_API_VER_MINOR__=4 -D __NVCC_DIAG_PRAGMA_SUPPORT__=1 -include cuda_runtime.h /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCUDACompilerABI.cu -o /tmp/tmpxft_00001541_00000000-5_CMakeCUDACompilerABI.cpp4.ii -m64 -mtune=generic -march=x86-64 -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -dumpdir /tmp/ -dumpbase tmpxft_00001541_00000000-5_CMakeCUDACompilerABI.cpp4.cu -dumpbase-ext .cu + ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/11" + ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu" + ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/include-fixed" + ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/include" + ignoring duplicate directory "/home/richard/miniconda3/envs/bilateral-cuda124/include" + ignoring duplicate directory "/home/richard/miniconda3/envs/bilateral-cuda124/include" + #include "..." search starts here: + #include <...> search starts here: + /home/richard/miniconda3/envs/bilateral-cuda124/bin/../include + /usr/include/c++/11 + /usr/include/x86_64-linux-gnu/c++/11 + /usr/include/c++/11/backward + /usr/lib/gcc/x86_64-linux-gnu/11/include + /usr/local/include + /usr/include/x86_64-linux-gnu + /usr/include + End of search list. + COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/ + LIBRARY_PATH=/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-E' '-D' '__CUDACC__' '-D' '__NVCC__' '-v' '-I' '/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=4' '-D' '__CUDACC_VER_BUILD__=131' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=4' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00001541_00000000-5_CMakeCUDACompilerABI.cpp4.ii' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/tmpxft_00001541_00000000-5_CMakeCUDACompilerABI.cpp4.' + Using built-in specs. + COLLECT_GCC=gcc + OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa + OFFLOAD_TARGET_DEFAULT=1 + Target: x86_64-linux-gnu + Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.4.0-1ubuntu1~22.04.2' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2 + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04.2) + 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' '/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include' '-m64' '-o' 'CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.o' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_4d9f7.dir/' + /usr/lib/gcc/x86_64-linux-gnu/11/cc1plus -quiet -v -I /home/richard/miniconda3/envs/bilateral-cuda124/bin/../include -imultiarch x86_64-linux-gnu -D_GNU_SOURCE -D __CUDA_ARCH__=520 -D __CUDA_ARCH_LIST__=520 -D __NV_LEGACY_LAUNCH -D CUDA_DOUBLE_MATH_FUNCTIONS /tmp/tmpxft_00001541_00000000-6_CMakeCUDACompilerABI.cudafe1.cpp -quiet -dumpdir CMakeFiles/cmTC_4d9f7.dir/ -dumpbase CMakeCUDACompilerABI.cu.cpp -dumpbase-ext .cpp -m64 -mtune=generic -march=x86-64 -Wno-psabi -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccZnm46M.s + GNU C++17 (Ubuntu 11.4.0-1ubuntu1~22.04.2) version 11.4.0 (x86_64-linux-gnu) + compiled by GNU C version 11.4.0, GMP version 6.2.1, MPFR version 4.1.0, MPC version 1.2.1, isl version isl-0.24-GMP + + warning: GMP header version 6.2.1 differs from library version 6.3.0. + GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072 + ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/11" + ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu" + ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/include-fixed" + ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/include" + ignoring duplicate directory "/home/richard/miniconda3/envs/bilateral-cuda124/include" + ignoring duplicate directory "/home/richard/miniconda3/envs/bilateral-cuda124/include" + #include "..." search starts here: + #include <...> search starts here: + /home/richard/miniconda3/envs/bilateral-cuda124/bin/../include + /usr/include/c++/11 + /usr/include/x86_64-linux-gnu/c++/11 + /usr/include/c++/11/backward + /usr/lib/gcc/x86_64-linux-gnu/11/include + /usr/local/include + /usr/include/x86_64-linux-gnu + /usr/include + End of search list. + GNU C++17 (Ubuntu 11.4.0-1ubuntu1~22.04.2) version 11.4.0 (x86_64-linux-gnu) + compiled by GNU C version 11.4.0, GMP version 6.2.1, MPFR version 4.1.0, MPC version 1.2.1, isl version isl-0.24-GMP + + warning: GMP header version 6.2.1 differs from library version 6.3.0. + GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072 + Compiler executable checksum: 6c87588fc345655b93b8c25f48f88886 + 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' '/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include' '-m64' '-o' 'CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.o' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_4d9f7.dir/' + as -v -I /home/richard/miniconda3/envs/bilateral-cuda124/bin/../include --64 -o CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.o /tmp/ccZnm46M.s + GNU assembler version 2.38 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.38 + COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/ + LIBRARY_PATH=/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/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' '/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include' '-m64' '-o' 'CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.o' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.' + [2/2] : && /usr/bin/g++ -v -Wl,-v CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.o -o cmTC_4d9f7 -lcudadevrt -lcudart_static -lrt -lpthread -ldl -L"/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs" -L"/home/richard/miniconda3/envs/bilateral-cuda124/lib" && : + Using built-in specs. + COLLECT_GCC=/usr/bin/g++ + COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper + OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa + OFFLOAD_TARGET_DEFAULT=1 + Target: x86_64-linux-gnu + Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.4.0-1ubuntu1~22.04.2' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2 + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04.2) + COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/ + LIBRARY_PATH=/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_4d9f7' '-L/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs' '-L/home/richard/miniconda3/envs/bilateral-cuda124/lib' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_4d9f7.' + /usr/lib/gcc/x86_64-linux-gnu/11/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/11/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper -plugin-opt=-fresolution=/tmp/cc8t4emG.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 -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_4d9f7 /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs -L/home/richard/miniconda3/envs/bilateral-cuda124/lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/11 -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib -L/usr/lib/gcc/x86_64-linux-gnu/11/../../.. -v CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.o -lcudadevrt -lcudart_static -lrt -lpthread -ldl -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o + collect2 version 11.4.0 + /usr/bin/ld -plugin /usr/lib/gcc/x86_64-linux-gnu/11/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper -plugin-opt=-fresolution=/tmp/cc8t4emG.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 -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_4d9f7 /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs -L/home/richard/miniconda3/envs/bilateral-cuda124/lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/11 -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib -L/usr/lib/gcc/x86_64-linux-gnu/11/../../.. -v CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.o -lcudadevrt -lcudart_static -lrt -lpthread -ldl -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o + GNU ld (GNU Binutils for Ubuntu) 2.38 + COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_4d9f7' '-L/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs' '-L/home/richard/miniconda3/envs/bilateral-cuda124/lib' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_4d9f7.' + + exitCode: 0 + - + kind: "message-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerABI.cmake:217 (message)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/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: [/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include] + add: [/usr/include/c++/11] + add: [/usr/include/x86_64-linux-gnu/c++/11] + add: [/usr/include/c++/11/backward] + add: [/usr/lib/gcc/x86_64-linux-gnu/11/include] + add: [/usr/local/include] + add: [/usr/include/x86_64-linux-gnu] + add: [/usr/include] + end of search list found + collapse include dir [/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include] ==> [/home/richard/miniconda3/envs/bilateral-cuda124/include] + collapse include dir [/usr/include/c++/11] ==> [/usr/include/c++/11] + collapse include dir [/usr/include/x86_64-linux-gnu/c++/11] ==> [/usr/include/x86_64-linux-gnu/c++/11] + collapse include dir [/usr/include/c++/11/backward] ==> [/usr/include/c++/11/backward] + collapse include dir [/usr/lib/gcc/x86_64-linux-gnu/11/include] ==> [/usr/lib/gcc/x86_64-linux-gnu/11/include] + collapse include dir [/usr/local/include] ==> [/usr/local/include] + collapse include dir [/usr/include/x86_64-linux-gnu] ==> [/usr/include/x86_64-linux-gnu] + collapse include dir [/usr/include] ==> [/usr/include] + implicit include dirs: [/home/richard/miniconda3/envs/bilateral-cuda124/include;/usr/include/c++/11;/usr/include/x86_64-linux-gnu/c++/11;/usr/include/c++/11/backward;/usr/lib/gcc/x86_64-linux-gnu/11/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include] + + + - + kind: "message-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerABI.cmake:253 (message)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/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: [^[ ]*(->|"|[0-9]+>[ -]*Build:[ 0-9]+ ms[ ]*)?[ ]*(([^"]*[/\\])?(ld[0-9]*(|\\.[a-rt-z][a-z]*|\\.s[a-np-z][a-z]*|\\.so[a-z]+)))("|,| |$)] + ignore line: [Change Dir: '/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/CMakeScratch/TryCompile-I3HvwS'] + ignore line: [] + ignore line: [Run Build Command(s): /home/richard/miniconda3/envs/bilateral-cuda124/bin/ninja -v cmTC_4d9f7] + ignore line: [[1/2] /home/richard/miniconda3/envs/bilateral-cuda124/bin/nvcc -forward-unknown-to-host-compiler "--generate-code=arch=compute_52 code=[compute_52 sm_52]" -Xcompiler=-v -MD -MT CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.o -MF CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.o.d -x cu -c /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCUDACompilerABI.cu -o CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.o] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=gcc] + ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa] + ignore line: [OFFLOAD_TARGET_DEFAULT=1] + ignore line: [Target: x86_64-linux-gnu] + ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.4.0-1ubuntu1~22.04.2' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c ada c++ go brig d fortran objc obj-c++ m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-nvptx/usr amdgcn-amdhsa=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04.2) ] + 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' '/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=4' '-D' '__CUDACC_VER_BUILD__=131' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=4' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00001541_00000000-7_CMakeCUDACompilerABI.cpp1.ii' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/'] + ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/11/cc1plus -E -quiet -v -I /home/richard/miniconda3/envs/bilateral-cuda124/bin/../include -imultiarch x86_64-linux-gnu -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__=4 -D __CUDACC_VER_BUILD__=131 -D __CUDA_API_VER_MAJOR__=12 -D __CUDA_API_VER_MINOR__=4 -D __NVCC_DIAG_PRAGMA_SUPPORT__=1 -include cuda_runtime.h /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCUDACompilerABI.cu -o /tmp/tmpxft_00001541_00000000-7_CMakeCUDACompilerABI.cpp1.ii -m64 -mtune=generic -march=x86-64 -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -dumpdir /tmp/ -dumpbase tmpxft_00001541_00000000-7_CMakeCUDACompilerABI.cpp1.cu -dumpbase-ext .cu] + ignore line: [ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/11"] + ignore line: [ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/include-fixed"] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/include"] + ignore line: [ignoring duplicate directory "/home/richard/miniconda3/envs/bilateral-cuda124/include"] + ignore line: [ignoring duplicate directory "/home/richard/miniconda3/envs/bilateral-cuda124/include"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /home/richard/miniconda3/envs/bilateral-cuda124/bin/../include] + ignore line: [ /usr/include/c++/11] + ignore line: [ /usr/include/x86_64-linux-gnu/c++/11] + ignore line: [ /usr/include/c++/11/backward] + ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/11/include] + ignore line: [ /usr/local/include] + ignore line: [ /usr/include/x86_64-linux-gnu] + ignore line: [ /usr/include] + ignore line: [End of search list.] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/] + ignore line: [LIBRARY_PATH=/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/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' '/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=4' '-D' '__CUDACC_VER_BUILD__=131' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=4' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00001541_00000000-7_CMakeCUDACompilerABI.cpp1.ii' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/tmpxft_00001541_00000000-7_CMakeCUDACompilerABI.cpp1.'] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=gcc] + ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa] + ignore line: [OFFLOAD_TARGET_DEFAULT=1] + ignore line: [Target: x86_64-linux-gnu] + ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.4.0-1ubuntu1~22.04.2' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c ada c++ go brig d fortran objc obj-c++ m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-nvptx/usr amdgcn-amdhsa=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04.2) ] + ignore line: [COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-E' '-D' '__CUDACC__' '-D' '__NVCC__' '-v' '-I' '/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=4' '-D' '__CUDACC_VER_BUILD__=131' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=4' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00001541_00000000-5_CMakeCUDACompilerABI.cpp4.ii' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/'] + ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/11/cc1plus -E -quiet -v -I /home/richard/miniconda3/envs/bilateral-cuda124/bin/../include -imultiarch x86_64-linux-gnu -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__=4 -D __CUDACC_VER_BUILD__=131 -D __CUDA_API_VER_MAJOR__=12 -D __CUDA_API_VER_MINOR__=4 -D __NVCC_DIAG_PRAGMA_SUPPORT__=1 -include cuda_runtime.h /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCUDACompilerABI.cu -o /tmp/tmpxft_00001541_00000000-5_CMakeCUDACompilerABI.cpp4.ii -m64 -mtune=generic -march=x86-64 -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -dumpdir /tmp/ -dumpbase tmpxft_00001541_00000000-5_CMakeCUDACompilerABI.cpp4.cu -dumpbase-ext .cu] + ignore line: [ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/11"] + ignore line: [ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/include-fixed"] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/include"] + ignore line: [ignoring duplicate directory "/home/richard/miniconda3/envs/bilateral-cuda124/include"] + ignore line: [ignoring duplicate directory "/home/richard/miniconda3/envs/bilateral-cuda124/include"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /home/richard/miniconda3/envs/bilateral-cuda124/bin/../include] + ignore line: [ /usr/include/c++/11] + ignore line: [ /usr/include/x86_64-linux-gnu/c++/11] + ignore line: [ /usr/include/c++/11/backward] + ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/11/include] + ignore line: [ /usr/local/include] + ignore line: [ /usr/include/x86_64-linux-gnu] + ignore line: [ /usr/include] + ignore line: [End of search list.] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/] + ignore line: [LIBRARY_PATH=/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-D' '__CUDA_ARCH_LIST__=520' '-D' '__NV_LEGACY_LAUNCH' '-E' '-D' '__CUDACC__' '-D' '__NVCC__' '-v' '-I' '/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include' '-D' '__CUDACC_VER_MAJOR__=12' '-D' '__CUDACC_VER_MINOR__=4' '-D' '__CUDACC_VER_BUILD__=131' '-D' '__CUDA_API_VER_MAJOR__=12' '-D' '__CUDA_API_VER_MINOR__=4' '-D' '__NVCC_DIAG_PRAGMA_SUPPORT__=1' '-include' 'cuda_runtime.h' '-m64' '-o' '/tmp/tmpxft_00001541_00000000-5_CMakeCUDACompilerABI.cpp4.ii' '-mtune=generic' '-march=x86-64' '-dumpdir' '/tmp/tmpxft_00001541_00000000-5_CMakeCUDACompilerABI.cpp4.'] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=gcc] + ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa] + ignore line: [OFFLOAD_TARGET_DEFAULT=1] + ignore line: [Target: x86_64-linux-gnu] + ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.4.0-1ubuntu1~22.04.2' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c ada c++ go brig d fortran objc obj-c++ m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-nvptx/usr amdgcn-amdhsa=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04.2) ] + 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' '/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include' '-m64' '-o' 'CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.o' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_4d9f7.dir/'] + ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/11/cc1plus -quiet -v -I /home/richard/miniconda3/envs/bilateral-cuda124/bin/../include -imultiarch x86_64-linux-gnu -D_GNU_SOURCE -D __CUDA_ARCH__=520 -D __CUDA_ARCH_LIST__=520 -D __NV_LEGACY_LAUNCH -D CUDA_DOUBLE_MATH_FUNCTIONS /tmp/tmpxft_00001541_00000000-6_CMakeCUDACompilerABI.cudafe1.cpp -quiet -dumpdir CMakeFiles/cmTC_4d9f7.dir/ -dumpbase CMakeCUDACompilerABI.cu.cpp -dumpbase-ext .cpp -m64 -mtune=generic -march=x86-64 -Wno-psabi -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccZnm46M.s] + ignore line: [GNU C++17 (Ubuntu 11.4.0-1ubuntu1~22.04.2) version 11.4.0 (x86_64-linux-gnu)] + ignore line: [ compiled by GNU C version 11.4.0 GMP version 6.2.1 MPFR version 4.1.0 MPC version 1.2.1 isl version isl-0.24-GMP] + ignore line: [] + ignore line: [warning: GMP header version 6.2.1 differs from library version 6.3.0.] + ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072] + ignore line: [ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/11"] + ignore line: [ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/include-fixed"] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/include"] + ignore line: [ignoring duplicate directory "/home/richard/miniconda3/envs/bilateral-cuda124/include"] + ignore line: [ignoring duplicate directory "/home/richard/miniconda3/envs/bilateral-cuda124/include"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /home/richard/miniconda3/envs/bilateral-cuda124/bin/../include] + ignore line: [ /usr/include/c++/11] + ignore line: [ /usr/include/x86_64-linux-gnu/c++/11] + ignore line: [ /usr/include/c++/11/backward] + ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/11/include] + ignore line: [ /usr/local/include] + ignore line: [ /usr/include/x86_64-linux-gnu] + ignore line: [ /usr/include] + ignore line: [End of search list.] + ignore line: [GNU C++17 (Ubuntu 11.4.0-1ubuntu1~22.04.2) version 11.4.0 (x86_64-linux-gnu)] + ignore line: [ compiled by GNU C version 11.4.0 GMP version 6.2.1 MPFR version 4.1.0 MPC version 1.2.1 isl version isl-0.24-GMP] + ignore line: [] + ignore line: [warning: GMP header version 6.2.1 differs from library version 6.3.0.] + ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072] + ignore line: [Compiler executable checksum: 6c87588fc345655b93b8c25f48f88886] + 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' '/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include' '-m64' '-o' 'CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.o' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_4d9f7.dir/'] + ignore line: [ as -v -I /home/richard/miniconda3/envs/bilateral-cuda124/bin/../include --64 -o CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.o /tmp/ccZnm46M.s] + ignore line: [GNU assembler version 2.38 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.38] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/] + ignore line: [LIBRARY_PATH=/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/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' '/home/richard/miniconda3/envs/bilateral-cuda124/bin/../include' '-m64' '-o' 'CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.o' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.'] + ignore line: [[2/2] : && /usr/bin/g++ -v -Wl,-v CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.o -o cmTC_4d9f7 -lcudadevrt -lcudart_static -lrt -lpthread -ldl -L"/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs" -L"/home/richard/miniconda3/envs/bilateral-cuda124/lib" && :] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/g++] + ignore line: [COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper] + ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa] + ignore line: [OFFLOAD_TARGET_DEFAULT=1] + ignore line: [Target: x86_64-linux-gnu] + ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.4.0-1ubuntu1~22.04.2' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c ada c++ go brig d fortran objc obj-c++ m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-nvptx/usr amdgcn-amdhsa=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04.2) ] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/] + ignore line: [LIBRARY_PATH=/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_4d9f7' '-L/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs' '-L/home/richard/miniconda3/envs/bilateral-cuda124/lib' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_4d9f7.'] + link line: [ /usr/lib/gcc/x86_64-linux-gnu/11/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/11/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper -plugin-opt=-fresolution=/tmp/cc8t4emG.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 -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_4d9f7 /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs -L/home/richard/miniconda3/envs/bilateral-cuda124/lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/11 -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib -L/usr/lib/gcc/x86_64-linux-gnu/11/../../.. -v CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.o -lcudadevrt -lcudart_static -lrt -lpthread -ldl -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/11/collect2] ==> ignore + arg [-plugin] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/11/liblto_plugin.so] ==> ignore + arg [-plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper] ==> ignore + arg [-plugin-opt=-fresolution=/tmp/cc8t4emG.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 [-m] ==> ignore + arg [elf_x86_64] ==> ignore + arg [--hash-style=gnu] ==> ignore + arg [--as-needed] ==> ignore + arg [-dynamic-linker] ==> ignore + arg [/lib64/ld-linux-x86-64.so.2] ==> ignore + arg [-pie] ==> ignore + arg [-znow] ==> ignore + arg [-zrelro] ==> ignore + arg [-o] ==> ignore + arg [cmTC_4d9f7] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o] + arg [-L/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs] ==> dir [/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs] + arg [-L/home/richard/miniconda3/envs/bilateral-cuda124/lib] ==> dir [/home/richard/miniconda3/envs/bilateral-cuda124/lib] + arg [-L/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib] ==> dir [/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib] + arg [-L/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib] ==> dir [/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/11] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/11] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib] + arg [-L/lib/x86_64-linux-gnu] ==> dir [/lib/x86_64-linux-gnu] + arg [-L/lib/../lib] ==> dir [/lib/../lib] + arg [-L/usr/lib/x86_64-linux-gnu] ==> dir [/usr/lib/x86_64-linux-gnu] + arg [-L/usr/lib/../lib] ==> dir [/usr/lib/../lib] + arg [-L/home/richard/miniconda3/envs/bilateral-cuda124/lib] ==> dir [/home/richard/miniconda3/envs/bilateral-cuda124/lib] + arg [-L/home/richard/miniconda3/envs/bilateral-cuda124/lib] ==> dir [/home/richard/miniconda3/envs/bilateral-cuda124/lib] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/11/../../..] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../..] + arg [-v] ==> ignore + arg [CMakeFiles/cmTC_4d9f7.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-linux-gnu/11/crtendS.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o] + ignore line: [collect2 version 11.4.0] + ignore line: [/usr/bin/ld -plugin /usr/lib/gcc/x86_64-linux-gnu/11/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper -plugin-opt=-fresolution=/tmp/cc8t4emG.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 -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_4d9f7 /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs -L/home/richard/miniconda3/envs/bilateral-cuda124/lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/11 -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib -L/usr/lib/gcc/x86_64-linux-gnu/11/../../.. -v CMakeFiles/cmTC_4d9f7.dir/CMakeCUDACompilerABI.cu.o -lcudadevrt -lcudart_static -lrt -lpthread -ldl -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o] + linker tool for 'CUDA': /usr/bin/ld + collapse obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o] ==> [/usr/lib/x86_64-linux-gnu/Scrt1.o] + collapse obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o] ==> [/usr/lib/x86_64-linux-gnu/crti.o] + collapse obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o] ==> [/usr/lib/x86_64-linux-gnu/crtn.o] + collapse library dir [/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs] ==> [/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs] + collapse library dir [/home/richard/miniconda3/envs/bilateral-cuda124/lib] ==> [/home/richard/miniconda3/envs/bilateral-cuda124/lib] + collapse library dir [/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib] ==> [/home/richard/miniconda3/envs/bilateral-cuda124/lib] + collapse library dir [/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib] ==> [/home/richard/miniconda3/envs/bilateral-cuda124/lib] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/11] ==> [/usr/lib/gcc/x86_64-linux-gnu/11] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib] ==> [/usr/lib] + collapse library dir [/lib/x86_64-linux-gnu] ==> [/lib/x86_64-linux-gnu] + collapse library dir [/lib/../lib] ==> [/lib] + collapse library dir [/usr/lib/x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu] + collapse library dir [/usr/lib/../lib] ==> [/usr/lib] + collapse library dir [/home/richard/miniconda3/envs/bilateral-cuda124/lib] ==> [/home/richard/miniconda3/envs/bilateral-cuda124/lib] + collapse library dir [/home/richard/miniconda3/envs/bilateral-cuda124/lib] ==> [/home/richard/miniconda3/envs/bilateral-cuda124/lib] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../..] ==> [/usr/lib] + implicit libs: [cudadevrt;cudart_static;rt;pthread;dl;stdc++;m;gcc_s;gcc;c;gcc_s;gcc] + implicit objs: [/usr/lib/x86_64-linux-gnu/Scrt1.o;/usr/lib/x86_64-linux-gnu/crti.o;/usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o;/usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o;/usr/lib/x86_64-linux-gnu/crtn.o] + implicit dirs: [/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs;/home/richard/miniconda3/envs/bilateral-cuda124/lib;/usr/lib/gcc/x86_64-linux-gnu/11;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib] + implicit fwks: [] + + + - + kind: "message-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeDetermineLinkerId.cmake:38 (message)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerABI.cmake:299 (cmake_determine_linker_id)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/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 for Ubuntu) 2.38 + - + kind: "try_compile-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerABI.cmake:83 (try_compile)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + checks: + - "Detecting CXX compiler ABI info" + directories: + source: "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/CMakeScratch/TryCompile-vdPXwe" + binary: "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/CMakeScratch/TryCompile-vdPXwe" + cmakeVariables: + CMAKE_CUDA_ARCHITECTURES: "52" + 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/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/CMakeScratch/TryCompile-vdPXwe' + + Run Build Command(s): /home/richard/miniconda3/envs/bilateral-cuda124/bin/ninja -v cmTC_13360 + [1/2] /usr/bin/c++ -v -o CMakeFiles/cmTC_13360.dir/CMakeCXXCompilerABI.cpp.o -c /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCXXCompilerABI.cpp + Using built-in specs. + COLLECT_GCC=/usr/bin/c++ + OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa + OFFLOAD_TARGET_DEFAULT=1 + Target: x86_64-linux-gnu + Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.4.0-1ubuntu1~22.04.2' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2 + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04.2) + COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_13360.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_13360.dir/' + /usr/lib/gcc/x86_64-linux-gnu/11/cc1plus -quiet -v -imultiarch x86_64-linux-gnu -D_GNU_SOURCE /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpdir CMakeFiles/cmTC_13360.dir/ -dumpbase CMakeCXXCompilerABI.cpp.cpp -dumpbase-ext .cpp -mtune=generic -march=x86-64 -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccS5o3Ac.s + GNU C++17 (Ubuntu 11.4.0-1ubuntu1~22.04.2) version 11.4.0 (x86_64-linux-gnu) + compiled by GNU C version 11.4.0, GMP version 6.2.1, MPFR version 4.1.0, MPC version 1.2.1, isl version isl-0.24-GMP + + warning: GMP header version 6.2.1 differs from library version 6.3.0. + GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072 + ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/11" + ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu" + ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/include-fixed" + ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/include" + ignoring duplicate directory "/home/richard/miniconda3/envs/bilateral-cuda124/include" + #include "..." search starts here: + #include <...> search starts here: + /home/richard/miniconda3/envs/bilateral-cuda124/include + /usr/include/c++/11 + /usr/include/x86_64-linux-gnu/c++/11 + /usr/include/c++/11/backward + /usr/lib/gcc/x86_64-linux-gnu/11/include + /usr/local/include + /usr/include/x86_64-linux-gnu + /usr/include + End of search list. + GNU C++17 (Ubuntu 11.4.0-1ubuntu1~22.04.2) version 11.4.0 (x86_64-linux-gnu) + compiled by GNU C version 11.4.0, GMP version 6.2.1, MPFR version 4.1.0, MPC version 1.2.1, isl version isl-0.24-GMP + + warning: GMP header version 6.2.1 differs from library version 6.3.0. + GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072 + Compiler executable checksum: 6c87588fc345655b93b8c25f48f88886 + COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_13360.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_13360.dir/' + as -v --64 -o CMakeFiles/cmTC_13360.dir/CMakeCXXCompilerABI.cpp.o /tmp/ccS5o3Ac.s + GNU assembler version 2.38 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.38 + COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/ + LIBRARY_PATH=/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_13360.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_13360.dir/CMakeCXXCompilerABI.cpp.' + [2/2] : && /usr/bin/c++ -v -Wl,-v CMakeFiles/cmTC_13360.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_13360 && : + Using built-in specs. + COLLECT_GCC=/usr/bin/c++ + COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper + OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa + OFFLOAD_TARGET_DEFAULT=1 + Target: x86_64-linux-gnu + Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.4.0-1ubuntu1~22.04.2' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2 + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04.2) + COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/ + LIBRARY_PATH=/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_13360' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_13360.' + /usr/lib/gcc/x86_64-linux-gnu/11/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/11/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper -plugin-opt=-fresolution=/tmp/ccr9pG8K.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 -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_13360 /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/11 -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib -L/usr/lib/gcc/x86_64-linux-gnu/11/../../.. -v CMakeFiles/cmTC_13360.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o + collect2 version 11.4.0 + /usr/bin/ld -plugin /usr/lib/gcc/x86_64-linux-gnu/11/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper -plugin-opt=-fresolution=/tmp/ccr9pG8K.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 -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_13360 /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/11 -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib -L/usr/lib/gcc/x86_64-linux-gnu/11/../../.. -v CMakeFiles/cmTC_13360.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o + GNU ld (GNU Binutils for Ubuntu) 2.38 + COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_13360' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_13360.' + + exitCode: 0 + - + kind: "message-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerABI.cmake:217 (message)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/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: [/home/richard/miniconda3/envs/bilateral-cuda124/include] + add: [/usr/include/c++/11] + add: [/usr/include/x86_64-linux-gnu/c++/11] + add: [/usr/include/c++/11/backward] + add: [/usr/lib/gcc/x86_64-linux-gnu/11/include] + add: [/usr/local/include] + add: [/usr/include/x86_64-linux-gnu] + add: [/usr/include] + end of search list found + collapse include dir [/home/richard/miniconda3/envs/bilateral-cuda124/include] ==> [/home/richard/miniconda3/envs/bilateral-cuda124/include] + collapse include dir [/usr/include/c++/11] ==> [/usr/include/c++/11] + collapse include dir [/usr/include/x86_64-linux-gnu/c++/11] ==> [/usr/include/x86_64-linux-gnu/c++/11] + collapse include dir [/usr/include/c++/11/backward] ==> [/usr/include/c++/11/backward] + collapse include dir [/usr/lib/gcc/x86_64-linux-gnu/11/include] ==> [/usr/lib/gcc/x86_64-linux-gnu/11/include] + collapse include dir [/usr/local/include] ==> [/usr/local/include] + collapse include dir [/usr/include/x86_64-linux-gnu] ==> [/usr/include/x86_64-linux-gnu] + collapse include dir [/usr/include] ==> [/usr/include] + implicit include dirs: [/home/richard/miniconda3/envs/bilateral-cuda124/include;/usr/include/c++/11;/usr/include/x86_64-linux-gnu/c++/11;/usr/include/c++/11/backward;/usr/lib/gcc/x86_64-linux-gnu/11/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include] + + + - + kind: "message-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerABI.cmake:253 (message)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/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: [^[ ]*(->|"|[0-9]+>[ -]*Build:[ 0-9]+ ms[ ]*)?[ ]*(([^"]*[/\\])?(ld[0-9]*(|\\.[a-rt-z][a-z]*|\\.s[a-np-z][a-z]*|\\.so[a-z]+)))("|,| |$)] + ignore line: [Change Dir: '/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/CMakeScratch/TryCompile-vdPXwe'] + ignore line: [] + ignore line: [Run Build Command(s): /home/richard/miniconda3/envs/bilateral-cuda124/bin/ninja -v cmTC_13360] + ignore line: [[1/2] /usr/bin/c++ -v -o CMakeFiles/cmTC_13360.dir/CMakeCXXCompilerABI.cpp.o -c /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCXXCompilerABI.cpp] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/c++] + ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa] + ignore line: [OFFLOAD_TARGET_DEFAULT=1] + ignore line: [Target: x86_64-linux-gnu] + ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.4.0-1ubuntu1~22.04.2' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c ada c++ go brig d fortran objc obj-c++ m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-nvptx/usr amdgcn-amdhsa=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04.2) ] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_13360.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_13360.dir/'] + ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/11/cc1plus -quiet -v -imultiarch x86_64-linux-gnu -D_GNU_SOURCE /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpdir CMakeFiles/cmTC_13360.dir/ -dumpbase CMakeCXXCompilerABI.cpp.cpp -dumpbase-ext .cpp -mtune=generic -march=x86-64 -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccS5o3Ac.s] + ignore line: [GNU C++17 (Ubuntu 11.4.0-1ubuntu1~22.04.2) version 11.4.0 (x86_64-linux-gnu)] + ignore line: [ compiled by GNU C version 11.4.0 GMP version 6.2.1 MPFR version 4.1.0 MPC version 1.2.1 isl version isl-0.24-GMP] + ignore line: [] + ignore line: [warning: GMP header version 6.2.1 differs from library version 6.3.0.] + ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072] + ignore line: [ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/11"] + ignore line: [ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/include-fixed"] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/include"] + ignore line: [ignoring duplicate directory "/home/richard/miniconda3/envs/bilateral-cuda124/include"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /home/richard/miniconda3/envs/bilateral-cuda124/include] + ignore line: [ /usr/include/c++/11] + ignore line: [ /usr/include/x86_64-linux-gnu/c++/11] + ignore line: [ /usr/include/c++/11/backward] + ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/11/include] + ignore line: [ /usr/local/include] + ignore line: [ /usr/include/x86_64-linux-gnu] + ignore line: [ /usr/include] + ignore line: [End of search list.] + ignore line: [GNU C++17 (Ubuntu 11.4.0-1ubuntu1~22.04.2) version 11.4.0 (x86_64-linux-gnu)] + ignore line: [ compiled by GNU C version 11.4.0 GMP version 6.2.1 MPFR version 4.1.0 MPC version 1.2.1 isl version isl-0.24-GMP] + ignore line: [] + ignore line: [warning: GMP header version 6.2.1 differs from library version 6.3.0.] + ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072] + ignore line: [Compiler executable checksum: 6c87588fc345655b93b8c25f48f88886] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_13360.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_13360.dir/'] + ignore line: [ as -v --64 -o CMakeFiles/cmTC_13360.dir/CMakeCXXCompilerABI.cpp.o /tmp/ccS5o3Ac.s] + ignore line: [GNU assembler version 2.38 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.38] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/] + ignore line: [LIBRARY_PATH=/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_13360.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_13360.dir/CMakeCXXCompilerABI.cpp.'] + ignore line: [[2/2] : && /usr/bin/c++ -v -Wl -v CMakeFiles/cmTC_13360.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_13360 && :] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/c++] + ignore line: [COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper] + ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa] + ignore line: [OFFLOAD_TARGET_DEFAULT=1] + ignore line: [Target: x86_64-linux-gnu] + ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.4.0-1ubuntu1~22.04.2' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c ada c++ go brig d fortran objc obj-c++ m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-nvptx/usr amdgcn-amdhsa=/build/gcc-11-2Y5pKs/gcc-11-11.4.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04.2) ] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/] + ignore line: [LIBRARY_PATH=/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/home/richard/miniconda3/envs/bilateral-cuda124/lib/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_13360' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_13360.'] + link line: [ /usr/lib/gcc/x86_64-linux-gnu/11/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/11/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper -plugin-opt=-fresolution=/tmp/ccr9pG8K.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 -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_13360 /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/11 -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib -L/usr/lib/gcc/x86_64-linux-gnu/11/../../.. -v CMakeFiles/cmTC_13360.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/11/collect2] ==> ignore + arg [-plugin] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/11/liblto_plugin.so] ==> ignore + arg [-plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper] ==> ignore + arg [-plugin-opt=-fresolution=/tmp/ccr9pG8K.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 [-m] ==> ignore + arg [elf_x86_64] ==> ignore + arg [--hash-style=gnu] ==> ignore + arg [--as-needed] ==> ignore + arg [-dynamic-linker] ==> ignore + arg [/lib64/ld-linux-x86-64.so.2] ==> ignore + arg [-pie] ==> ignore + arg [-znow] ==> ignore + arg [-zrelro] ==> ignore + arg [-o] ==> ignore + arg [cmTC_13360] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o] + arg [-L/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib] ==> dir [/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib] + arg [-L/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib] ==> dir [/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/11] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/11] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib] + arg [-L/lib/x86_64-linux-gnu] ==> dir [/lib/x86_64-linux-gnu] + arg [-L/lib/../lib] ==> dir [/lib/../lib] + arg [-L/usr/lib/x86_64-linux-gnu] ==> dir [/usr/lib/x86_64-linux-gnu] + arg [-L/usr/lib/../lib] ==> dir [/usr/lib/../lib] + arg [-L/home/richard/miniconda3/envs/bilateral-cuda124/lib] ==> dir [/home/richard/miniconda3/envs/bilateral-cuda124/lib] + arg [-L/home/richard/miniconda3/envs/bilateral-cuda124/lib] ==> dir [/home/richard/miniconda3/envs/bilateral-cuda124/lib] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/11/../../..] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../..] + arg [-v] ==> ignore + arg [CMakeFiles/cmTC_13360.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/lib/gcc/x86_64-linux-gnu/11/crtendS.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o] + ignore line: [collect2 version 11.4.0] + ignore line: [/usr/bin/ld -plugin /usr/lib/gcc/x86_64-linux-gnu/11/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper -plugin-opt=-fresolution=/tmp/ccr9pG8K.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 -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_13360 /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/11 -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib -L/home/richard/miniconda3/envs/bilateral-cuda124/lib -L/usr/lib/gcc/x86_64-linux-gnu/11/../../.. -v CMakeFiles/cmTC_13360.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o] + linker tool for 'CXX': /usr/bin/ld + collapse obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o] ==> [/usr/lib/x86_64-linux-gnu/Scrt1.o] + collapse obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o] ==> [/usr/lib/x86_64-linux-gnu/crti.o] + collapse obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o] ==> [/usr/lib/x86_64-linux-gnu/crtn.o] + collapse library dir [/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib] ==> [/home/richard/miniconda3/envs/bilateral-cuda124/lib] + collapse library dir [/home/richard/miniconda3/envs/bilateral-cuda124/lib/../lib] ==> [/home/richard/miniconda3/envs/bilateral-cuda124/lib] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/11] ==> [/usr/lib/gcc/x86_64-linux-gnu/11] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib] ==> [/usr/lib] + collapse library dir [/lib/x86_64-linux-gnu] ==> [/lib/x86_64-linux-gnu] + collapse library dir [/lib/../lib] ==> [/lib] + collapse library dir [/usr/lib/x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu] + collapse library dir [/usr/lib/../lib] ==> [/usr/lib] + collapse library dir [/home/richard/miniconda3/envs/bilateral-cuda124/lib] ==> [/home/richard/miniconda3/envs/bilateral-cuda124/lib] + collapse library dir [/home/richard/miniconda3/envs/bilateral-cuda124/lib] ==> [/home/richard/miniconda3/envs/bilateral-cuda124/lib] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../..] ==> [/usr/lib] + implicit libs: [stdc++;m;gcc_s;gcc;c;gcc_s;gcc] + implicit objs: [/usr/lib/x86_64-linux-gnu/Scrt1.o;/usr/lib/x86_64-linux-gnu/crti.o;/usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o;/usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o;/usr/lib/x86_64-linux-gnu/crtn.o] + implicit dirs: [/home/richard/miniconda3/envs/bilateral-cuda124/lib;/usr/lib/gcc/x86_64-linux-gnu/11;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib] + implicit fwks: [] + + + - + kind: "message-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeDetermineLinkerId.cmake:38 (message)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerABI.cmake:299 (cmake_determine_linker_id)" + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/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 for Ubuntu) 2.38 + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CTest.cmake:188 (find_program)" + - "CMakeLists.txt:10 (include)" + mode: "program" + variable: "MEMORYCHECK_COMMAND" + description: "Path to the memory checking command, used for memory error detection." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: true + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "purify" + - "valgrind" + - "boundscheck" + - "drmemory" + - "cuda-memcheck" + - "compute-sanitizer" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/sbin/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/.npm-global/bin/" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/" + - "/home/richard/.local/bin/" + - "/home/richard/miniconda3/condabin/" + - "/home/richard/.cargo/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/usr/lib/wsl/lib/" + - "/usr/local/go/bin/" + - "/home/richard/go/bin/" + - "/usr/local/bin/" + - "/usr/local/sbin/" + - "/usr/local/" + - "/usr/bin/" + - "/usr/sbin/" + - "/usr/" + - "/bin/" + - "/sbin/" + - "/usr/X11R6/bin/" + - "/usr/X11R6/sbin/" + - "/usr/X11R6/" + - "/usr/pkg/bin/" + - "/usr/pkg/sbin/" + - "/usr/pkg/" + - "/opt/bin/" + - "/opt/sbin/" + - "/opt/" + searched_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/purify" + - "/home/richard/miniconda3/envs/bilateral-cuda124/sbin/purify" + - "/home/richard/miniconda3/envs/bilateral-cuda124/purify" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/purify" + - "/home/richard/.npm-global/bin/purify" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/purify" + - "/home/richard/.local/bin/purify" + - "/home/richard/miniconda3/condabin/purify" + - "/home/richard/.cargo/bin/purify" + - "/usr/local/sbin/purify" + - "/usr/local/bin/purify" + - "/usr/sbin/purify" + - "/usr/bin/purify" + - "/sbin/purify" + - "/bin/purify" + - "/usr/games/purify" + - "/usr/local/games/purify" + - "/usr/lib/wsl/lib/purify" + - "/usr/local/go/bin/purify" + - "/home/richard/go/bin/purify" + - "/usr/local/bin/purify" + - "/usr/local/sbin/purify" + - "/usr/local/purify" + - "/usr/bin/purify" + - "/usr/sbin/purify" + - "/usr/purify" + - "/bin/purify" + - "/sbin/purify" + - "/usr/X11R6/bin/purify" + - "/usr/X11R6/sbin/purify" + - "/usr/X11R6/purify" + - "/usr/pkg/bin/purify" + - "/usr/pkg/sbin/purify" + - "/usr/pkg/purify" + - "/opt/bin/purify" + - "/opt/sbin/purify" + - "/opt/purify" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/valgrind" + - "/home/richard/miniconda3/envs/bilateral-cuda124/sbin/valgrind" + - "/home/richard/miniconda3/envs/bilateral-cuda124/valgrind" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/valgrind" + - "/home/richard/.npm-global/bin/valgrind" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/valgrind" + - "/home/richard/.local/bin/valgrind" + - "/home/richard/miniconda3/condabin/valgrind" + - "/home/richard/.cargo/bin/valgrind" + - "/usr/local/sbin/valgrind" + - "/usr/local/bin/valgrind" + - "/usr/sbin/valgrind" + - "/usr/bin/valgrind" + - "/sbin/valgrind" + - "/bin/valgrind" + - "/usr/games/valgrind" + - "/usr/local/games/valgrind" + - "/usr/lib/wsl/lib/valgrind" + - "/usr/local/go/bin/valgrind" + - "/home/richard/go/bin/valgrind" + - "/usr/local/bin/valgrind" + - "/usr/local/sbin/valgrind" + - "/usr/local/valgrind" + - "/usr/bin/valgrind" + - "/usr/sbin/valgrind" + - "/usr/valgrind" + - "/bin/valgrind" + - "/sbin/valgrind" + - "/usr/X11R6/bin/valgrind" + - "/usr/X11R6/sbin/valgrind" + - "/usr/X11R6/valgrind" + - "/usr/pkg/bin/valgrind" + - "/usr/pkg/sbin/valgrind" + - "/usr/pkg/valgrind" + - "/opt/bin/valgrind" + - "/opt/sbin/valgrind" + - "/opt/valgrind" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/boundscheck" + - "/home/richard/miniconda3/envs/bilateral-cuda124/sbin/boundscheck" + - "/home/richard/miniconda3/envs/bilateral-cuda124/boundscheck" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/boundscheck" + - "/home/richard/.npm-global/bin/boundscheck" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/boundscheck" + - "/home/richard/.local/bin/boundscheck" + - "/home/richard/miniconda3/condabin/boundscheck" + - "/home/richard/.cargo/bin/boundscheck" + - "/usr/local/sbin/boundscheck" + - "/usr/local/bin/boundscheck" + - "/usr/sbin/boundscheck" + - "/usr/bin/boundscheck" + - "/sbin/boundscheck" + - "/bin/boundscheck" + - "/usr/games/boundscheck" + - "/usr/local/games/boundscheck" + - "/usr/lib/wsl/lib/boundscheck" + - "/usr/local/go/bin/boundscheck" + - "/home/richard/go/bin/boundscheck" + - "/usr/local/bin/boundscheck" + - "/usr/local/sbin/boundscheck" + - "/usr/local/boundscheck" + - "/usr/bin/boundscheck" + - "/usr/sbin/boundscheck" + - "/usr/boundscheck" + - "/bin/boundscheck" + - "/sbin/boundscheck" + - "/usr/X11R6/bin/boundscheck" + - "/usr/X11R6/sbin/boundscheck" + - "/usr/X11R6/boundscheck" + - "/usr/pkg/bin/boundscheck" + - "/usr/pkg/sbin/boundscheck" + - "/usr/pkg/boundscheck" + - "/opt/bin/boundscheck" + - "/opt/sbin/boundscheck" + - "/opt/boundscheck" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/drmemory" + - "/home/richard/miniconda3/envs/bilateral-cuda124/sbin/drmemory" + - "/home/richard/miniconda3/envs/bilateral-cuda124/drmemory" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/drmemory" + - "/home/richard/.npm-global/bin/drmemory" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/drmemory" + - "/home/richard/.local/bin/drmemory" + - "/home/richard/miniconda3/condabin/drmemory" + - "/home/richard/.cargo/bin/drmemory" + - "/usr/local/sbin/drmemory" + - "/usr/local/bin/drmemory" + - "/usr/sbin/drmemory" + - "/usr/bin/drmemory" + - "/sbin/drmemory" + - "/bin/drmemory" + - "/usr/games/drmemory" + - "/usr/local/games/drmemory" + - "/usr/lib/wsl/lib/drmemory" + - "/usr/local/go/bin/drmemory" + - "/home/richard/go/bin/drmemory" + - "/usr/local/bin/drmemory" + - "/usr/local/sbin/drmemory" + - "/usr/local/drmemory" + - "/usr/bin/drmemory" + - "/usr/sbin/drmemory" + - "/usr/drmemory" + - "/bin/drmemory" + - "/sbin/drmemory" + - "/usr/X11R6/bin/drmemory" + - "/usr/X11R6/sbin/drmemory" + - "/usr/X11R6/drmemory" + - "/usr/pkg/bin/drmemory" + - "/usr/pkg/sbin/drmemory" + - "/usr/pkg/drmemory" + - "/opt/bin/drmemory" + - "/opt/sbin/drmemory" + - "/opt/drmemory" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/cuda-memcheck" + - "/home/richard/miniconda3/envs/bilateral-cuda124/sbin/cuda-memcheck" + - "/home/richard/miniconda3/envs/bilateral-cuda124/cuda-memcheck" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/cuda-memcheck" + - "/home/richard/.npm-global/bin/cuda-memcheck" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/cuda-memcheck" + - "/home/richard/.local/bin/cuda-memcheck" + - "/home/richard/miniconda3/condabin/cuda-memcheck" + - "/home/richard/.cargo/bin/cuda-memcheck" + - "/usr/local/sbin/cuda-memcheck" + - "/usr/local/bin/cuda-memcheck" + - "/usr/sbin/cuda-memcheck" + - "/usr/bin/cuda-memcheck" + - "/sbin/cuda-memcheck" + - "/bin/cuda-memcheck" + - "/usr/games/cuda-memcheck" + - "/usr/local/games/cuda-memcheck" + - "/usr/lib/wsl/lib/cuda-memcheck" + - "/usr/local/go/bin/cuda-memcheck" + - "/home/richard/go/bin/cuda-memcheck" + - "/usr/local/bin/cuda-memcheck" + - "/usr/local/sbin/cuda-memcheck" + - "/usr/local/cuda-memcheck" + - "/usr/bin/cuda-memcheck" + - "/usr/sbin/cuda-memcheck" + - "/usr/cuda-memcheck" + - "/bin/cuda-memcheck" + - "/sbin/cuda-memcheck" + - "/usr/X11R6/bin/cuda-memcheck" + - "/usr/X11R6/sbin/cuda-memcheck" + - "/usr/X11R6/cuda-memcheck" + - "/usr/pkg/bin/cuda-memcheck" + - "/usr/pkg/sbin/cuda-memcheck" + - "/usr/pkg/cuda-memcheck" + - "/opt/bin/cuda-memcheck" + - "/opt/sbin/cuda-memcheck" + - "/opt/cuda-memcheck" + found: "/home/richard/miniconda3/envs/bilateral-cuda124/bin/compute-sanitizer" + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + CMAKE_INSTALL_PREFIX: "/usr/local" + CMAKE_SYSTEM_PREFIX_PATH: + - "/usr/local" + - "/usr" + - "/" + - "/home/richard/miniconda3/envs/bilateral-cuda124" + - "/usr/local" + - "/usr/X11R6" + - "/usr/pkg" + - "/opt" + - + kind: "find-v1" + backtrace: + - "/home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CTest.cmake:196 (find_program)" + - "CMakeLists.txt:10 (include)" + mode: "program" + variable: "COVERAGE_COMMAND" + description: "Path to the coverage program that CTest uses for performing coverage inspection" + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: true + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "gcov" + candidate_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/sbin/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/" + - "/home/richard/.npm-global/bin/" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/" + - "/home/richard/.local/bin/" + - "/home/richard/miniconda3/condabin/" + - "/home/richard/.cargo/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/usr/lib/wsl/lib/" + - "/usr/local/go/bin/" + - "/home/richard/go/bin/" + - "/usr/local/bin/" + - "/usr/local/sbin/" + - "/usr/local/" + - "/usr/bin/" + - "/usr/sbin/" + - "/usr/" + - "/bin/" + - "/sbin/" + - "/usr/X11R6/bin/" + - "/usr/X11R6/sbin/" + - "/usr/X11R6/" + - "/usr/pkg/bin/" + - "/usr/pkg/sbin/" + - "/usr/pkg/" + - "/opt/bin/" + - "/opt/sbin/" + - "/opt/" + searched_directories: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/gcov" + - "/home/richard/miniconda3/envs/bilateral-cuda124/sbin/gcov" + - "/home/richard/miniconda3/envs/bilateral-cuda124/gcov" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin/gcov" + - "/home/richard/.npm-global/bin/gcov" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli/gcov" + - "/home/richard/.local/bin/gcov" + - "/home/richard/miniconda3/condabin/gcov" + - "/home/richard/.cargo/bin/gcov" + - "/usr/local/sbin/gcov" + - "/usr/local/bin/gcov" + - "/usr/sbin/gcov" + found: "/usr/bin/gcov" + search_context: + CMAKE_PREFIX_PATH: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{CMAKE_PREFIX_PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124" + ENV{PATH}: + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.vscode-server/bin/ce099c1ed25d9eb3076c11e4a280f3eb52b4fbeb/bin/remote-cli" + - "/home/richard/.npm-global/bin" + - "/home/richard/.local/bin" + - "/home/richard/miniconda3/envs/bilateral-cuda124/bin" + - "/home/richard/miniconda3/condabin" + - "/home/richard/.cargo/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/usr/lib/wsl/lib" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + - "/usr/local/go/bin" + - "/home/richard/go/bin" + CMAKE_INSTALL_PREFIX: "/usr/local" + CMAKE_SYSTEM_PREFIX_PATH: + - "/usr/local" + - "/usr" + - "/" + - "/home/richard/miniconda3/envs/bilateral-cuda124" + - "/usr/local" + - "/usr/X11R6" + - "/usr/pkg" + - "/opt" +... diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/CTestScript.cmake b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/CTestScript.cmake new file mode 100644 index 0000000..034e966 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/CTestScript.cmake @@ -0,0 +1,167 @@ +# This file is configured by CMake automatically as CTestScript.cmake +# If you choose not to use CMake, this file may be hand configured, by +# filling in the required variables. + +cmake_minimum_required(VERSION 4.2.3) + +# CTest Start Step +set(CTEST_SOURCE_DIRECTORY "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard") +set(CTEST_BINARY_DIRECTORY "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release") + +# CTest Update Step +set(CTEST_UPDATE_COMMAND "") +set(CTEST_UPDATE_OPTIONS "") +set(CTEST_UPDATE_VERSION_ONLY "") +set(CTEST_NIGHTLY_START_TIME "00:00:00 EDT") + +# CVS options +set(CTEST_CVS_COMMAND "") +set(CTEST_CVS_UPDATE_OPTIONS "") + +# Subversion options +set(CTEST_SVN_COMMAND "") +set(CTEST_SVN_OPTIONS "") +set(CTEST_SVN_UPDATE_OPTIONS "") + +# Git options +set(CTEST_GIT_COMMAND "") +set(CTEST_GIT_INIT_SUBMODULES "") +set(CTEST_GIT_UPDATE_CUSTOM "") +set(CTEST_GIT_UPDATE_OPTIONS "") + +# Perforce options +set(CTEST_P4_COMMAND "") +set(CTEST_P4_CLIENT "") +set(CTEST_P4_OPTIONS "") +set(CTEST_P4_UPDATE_CUSTOM "") +set(CTEST_P4_UPDATE_OPTIONS "") + +# CTest Configure Step +set(CTEST_CMAKE_GENERATOR "Ninja") +set(CTEST_LABELS_FOR_SUBPROJECTS "") + +# CTest Build Step +set(CTEST_CONFIGURATION_TYPE "Release") +set(CTEST_USE_LAUNCHERS "") + +# CTest Test Step +set(CTEST_RESOURCE_SPEC_FILE "") +set(CTEST_TEST_LOAD "") +set(CTEST_TEST_TIMEOUT "1500") + +# CTest Coverage Step +set(CTEST_COVERAGE_COMMAND "/usr/bin/gcov") +set(CTEST_COVERAGE_EXTRA_FLAGS "-l") + +# CTest MemCheck Step +set(CTEST_MEMORYCHECK_COMMAND "/home/richard/miniconda3/envs/bilateral-cuda124/bin/compute-sanitizer") +set(CTEST_MEMORYCHECK_COMMAND_OPTIONS "") +set(CTEST_MEMORYCHECK_TYPE "") +set(CTEST_MEMORYCHECK_SANITIZER_OPTIONS "") +set(CTEST_MEMORYCHECK_SUPPRESSIONS_FILE "") + +# CTest Submit Step +set(CTEST_SITE "Desktop") +set(CTEST_BUILD_NAME "Linux-c++") +set(CTEST_SUBMIT_URL "http://") +set(CTEST_SUBMIT_INACTIVITY_TIMEOUT "") +set(CTEST_TLS_VERIFY "") +set(CTEST_TLS_VERSION "") + +################################################################################ + +if(NOT MODEL) + set(MODEL "Experimental") +endif() + +if(MODEL STREQUAL "NightlyMemoryCheck") + set(MODEL "Nightly") + set(ACTIONS "Start;Update;Configure;Build;MemCheck;Coverage;Submit") +endif() + +if(NOT ACTIONS) + if(MODEL STREQUAL "Experimental") + set(ACTIONS "Start;Configure;Build;Test;Coverage;Submit") + else() + set(ACTIONS "Start;Update;Configure;Build;Test;Coverage;Submit") + endif() +endif() + +################################################################################ + +set(_exit_code 0) + +if("Start" IN_LIST ACTIONS OR NOT EXISTS "${CTEST_BINARY_DIRECTORY}/Testing/TAG") + ctest_start("${MODEL}") +else() + ctest_start("${MODEL}" APPEND) +endif() + +if("Update" IN_LIST ACTIONS) + ctest_update(RETURN_VALUE update_count) + if(update_count LESS 0) + math(EXPR _exit_code "${_exit_code} | 0x01") + endif() + if(MODEL STREQUAL "Continuous" AND update_count EQUAL 0) + return() + endif() +endif() + +if("Configure" IN_LIST ACTIONS) + ctest_configure(RETURN_VALUE success) + if(success LESS 0) + math(EXPR _exit_code "${_exit_code} | 0x02") + endif() +endif() + +if("Build" IN_LIST ACTIONS) + ctest_read_custom_files("${CTEST_BINARY_DIRECTORY}") + ctest_build(RETURN_VALUE success) + if(NOT success EQUAL 0) + math(EXPR _exit_code "${_exit_code} | 0x04") + endif() +endif() + +if("Test" IN_LIST ACTIONS) + ctest_read_custom_files("${CTEST_BINARY_DIRECTORY}") + ctest_test(RETURN_VALUE success) + if(NOT success EQUAL 0) + math(EXPR _exit_code "${_exit_code} | 0x08") + endif() +endif() + +if("Coverage" IN_LIST ACTIONS) + ctest_read_custom_files("${CTEST_BINARY_DIRECTORY}") + ctest_coverage(RETURN_VALUE success) + if(NOT success EQUAL 0) + math(EXPR _exit_code "${_exit_code} | 0x20") + endif() +endif() + +if("MemCheck" IN_LIST ACTIONS) + ctest_read_custom_files("${CTEST_BINARY_DIRECTORY}") + ctest_memcheck(RETURN_VALUE success) + if(NOT success EQUAL 0) + math(EXPR _exit_code "${_exit_code} | 0x10") + endif() +endif() + +file(GLOB notes_files LIST_DIRECTORIES OFF + "${CTEST_BINARY_DIRECTORY}/Testing/Notes/*") +if(notes_files) + list(APPEND CTEST_NOTES_FILES "${notes_files}") +endif() + +if("Submit" IN_LIST ACTIONS) + ctest_read_custom_files("${CTEST_BINARY_DIRECTORY}") + ctest_submit( + RETRY_COUNT "3" + RETRY_DELAY "5" + RETURN_VALUE success + ) + if(NOT success EQUAL 0) + math(EXPR _exit_code "${_exit_code} | 0x40") + endif() +endif() + +cmake_language(EXIT "${_exit_code}") diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/InstallScripts.json b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/InstallScripts.json new file mode 100644 index 0000000..e7d0d58 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/InstallScripts.json @@ -0,0 +1,7 @@ +{ + "InstallScripts" : + [ + "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/cmake_install.cmake" + ], + "Parallel" : false +} diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/TargetDirectories.txt b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/TargetDirectories.txt new file mode 100644 index 0000000..f8db9eb --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/TargetDirectories.txt @@ -0,0 +1,34 @@ +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/Experimental.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/Nightly.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/Continuous.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/NightlyMemoryCheck.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/NightlyStart.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/NightlyUpdate.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/NightlyConfigure.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/NightlyBuild.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/NightlyTest.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/NightlyCoverage.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/NightlyMemCheck.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/NightlySubmit.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/ExperimentalStart.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/ExperimentalUpdate.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/ExperimentalConfigure.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/ExperimentalBuild.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/ExperimentalTest.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/ExperimentalCoverage.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/ExperimentalMemCheck.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/ExperimentalSubmit.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/ContinuousStart.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/ContinuousUpdate.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/ContinuousConfigure.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/ContinuousBuild.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/ContinuousTest.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/ContinuousCoverage.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/ContinuousMemCheck.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/ContinuousSubmit.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/bilateral_filter.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_correctness.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/edit_cache.dir +/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/rebuild_cache.dir diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/bilateral_filter.dir/cmake_device_link.o b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/bilateral_filter.dir/cmake_device_link.o new file mode 100644 index 0000000000000000000000000000000000000000..32e41e0ddd69868b3c2c4e66726683f217cb686f GIT binary patch literal 332568 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 i&m*zO-ard0+J5)YQU!EoT$azr! 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

Sog+=&EaH%kBc2|BUlWwb6M>9yh!8z!rE8j60 z?M^U++aZp>U%a1a8(9FPBAGu72S~JZmY*cLE>Q!CIB)aWAe1yRfTMVnp4o+w7H@?4 zIaqY>Oi?@gY4HSMhyC;Xc@PPN5VUdj#s6|Ek&DCCjD=P_v#1t|(oe>*s62N(VY6igvHnUrw!>%q|x9F1Kk9_h0A?Kmm#77@3`3GoOo4zqte zdZS2jXPE&YUiO%{M8e;)8r_N+0ASegk?+On%AA4gyS&okK`HQF{_+QLEzVb-LI)6{ z?Jp$6+a_*YMU|TnvJr(-#Pzb=y>ZdH5M0#zWcnDmVhGO=yHpuLL4>IH!)U0%Zj`ce z1cwF7Z6Ve3ujF?gR`>$mT<(s+pO0_B9aQ*Am&B?wj*4WvZZdHMchP?}6X!1(w)J9AOA(|f7yCx{gqe$ zzx%<{Ec|xwe(?PJ-G?7Nv-|vGk6yCvf4SlNTPoe8yg=hpMzQHv7ScFFd^d=ox$V26BQud+O1L z&pl?>?b-Du`~N@7|Gjfd_4@rQ^A!2>f1U0B-l|h`=Qk79{p19# zo^)oaG?cDZ103NhSp_V173P9P9gEa_71)o!Whg9Q@1@1iROlx|vyYyC@YJJ!!A4G= zL|W*{(`VfC7oB^nHJShE#+h^YsD-*c_MWCmiQC}1aczEj%)M!TVQ-x1<8)^1>`k?W zC5$kIxO#Zwrs~`Rup@s!8>eroJ9}3`q0sx!e{l8#_hH7eXK8IE^yumTMtqc>*f?EX znz8R4kXdo=Um?JVu23vnT_N@y&@=0MP{i6E9G(xh=7Oz-U<)UJ8;7k7PVoN#Fe;qG z*Wj>OWbq#gi>ST_KX~!f?8Wo5=N>)3e(KR*X0e%n14lUqqt$FWy|fZSn_^H#Vq}dDE0QY)<_RwR3P;5d98`v!vog?VYQh-&mMi30*jI(VabaW|ZdLIx1nPJ`}+G9iY?m z^DCkA8=n?{%(F~yg*lXSf^TmNICb|nRA~b_J82Di~pNq z7t^%lE&{^m7QAiodt_C=N8=xO^m{?6{(bHp-NNJ+TcZfeq90-oz4O(Fj0VMK2vAY+mGj{D4 zf;LC6_!lVjXOyo0B0zk;L_7hot1p2!)_|I4VE;S~<8WyX_m&YH;iL02H*xdx1n^q$ zHNXnb{lvqk&r@;Z^ba_wrY^COYR#hqb ztJevDyE7=-3nKeE@f9k%)oWtD`p4pmvl5DnrRw4?A%e+7mmj7)+HSn&{6`>{-6rO$ z?-GB%21){9%zogphZB^ZFS5nj+#Z9C)s{Xcl&j140RjF#gy`${vsmpnkPtC{KUAdBps|e)tSfGQ0)rU!QCQ2 zDg*L52T28hh@YV$79#=ip);&}x;6nYvU^E=jl~y>oG;R1t%_nz)mMfn1JupvysHUO zO?XN|K4<`*Sh#vE`2u05;J@V~hc2 z=rN+wV(sI!I$gitCYG4{1eK@jKGhck>@D1#tN9e0Pf-pB#}{V)PoPFF4l$O*qB6bY z6PJeBbg+Tf-MArSv)B?0{Y9HCE>&?u0edVJELss`gya!cuGT(9^`!t?2yX}#aYK=1 z@e_ZG2_U(pqau6m20Z5lpn)%5;N|MV9LhNZb!>NiT}(W-E{@fmUBrJ^DA%3e6*7xl zCz+4))kZZC{3SHD5}KM3{Z8hRt{%{tFfad{5- zrM2fs#ny8)jGyr|CF);5t$hLgZvG1tKF#XO3-8>L!wJm$3>fV%kf#0*e$!lS&y-oI z)t|QF#l`#2bMbd+YH8+C3hfFCU!v*y@+kvY*$X$Tf=p58A=8=Nc`KlzMD}!=gm7+D7iT_zLKcG^rR$V$FuGSXr ze=kvT@e+mK8x-ZG7(tPJFY#zpyo=(?cM<)j82Ts1zN|}+1km2;b4l~C33dvs&?hN9_aqf-sEb1FN#gvCD9w@i6yibkr$9r&#{5%c%Ft4O ziAhfp{{f)Ea0G}jtgsNAUVI8&y7tr9TKZ|g9@n0x%<|L3e}wCno(9ja)~-@^`MkP& zu3F;Sw*x>rPvgmXAUW^Xa`TIVcFnBJ?>Vcn;bpEC7SC#&-ySs^f(DL&%6N_Q%Yukt z*|G=oY0hZ@pVw&!G&bklsEc&9Af51lPs;GoeB=luwfendYX1E&P1sF2$wCe9- zx3nwNwzN-E=4x|upQ3{ExWGr}>hR3$jsRMX{)tJDP#+cm(TTPAxKNy%2f*lG zn`C^3k_(?9AQv)lmCulYjoU5hGsJ%$SL1*nJOkmh^jV-1|CUs$%>zSyV3q32d6GlYp%H2oN&OiMc$>!W$yOHUZ_&h&`T3Ki zN4PMl31D;kp`wuTXFPI;Ia*!*GhV3v8AprMUg3r1S2zz18RcsAn|y3x=7%Zsn;fW) z@u9_iI{T+Iz7+=;dmz7jc7E~az(T*tC4i29ldEhkAAIO{@~da(aTLQZaLqy$A3AsA znmVrGpJTx_pJS5?ILM}Q!H0g63+(%usj~|Rue9UXl_wUKw~^jP+6t>I2G33}jvzb} zpIX3!`6nnl|4j}p3g4L5`LAaRi&P3nU*ZA$*Ai1p^~a&!8nw?y zmK`9%SA#OW6ss&P;|jo&v;D;T-1w-Z{g6-3?RhjiTC1HJ=Kmba)qY9RUQx4E0A_xH zNoPpEGQ{EGeVysMbL{2_5OhM=_*o4MujbaE6ok%U`Yto{6EOfxUk#Aq?*IU4HnFm? zGzaw*gC;=(cLR4eRvqU~ zT=LbN@E*j~iEbnHy#oJ6jst-59)OYlFa_xl!Zi2w`vny;ZvMZ&14XJGV$4aHrvzDO z#Ke6NMd0A`rvu>7Z1s!)T{TakGlFm#)iHlo5Mxz8j+ZSyBnXlXr1?h#`3@nokP*ge z^`GI|UmEPRC=OGk64)Tne=7nI;-MhIF8+9+Afg%;EB_B$ZvrM)QT2_Vs=7<>x7X?J z>7MCjdiJev?>&=bI+KJ12&4&+KuAbuVG_2anIt%b0FAP*!=eTaNsFQ&AcKk^pf-vT z#TP~p7epN}uYjVAiW&u-|L;!X`~SZ8`Q~}%c6HtAyPP^zb+$S`VO?lzDGZ9H{B@u~ zrXM%|jyqg%F#c%`xHg7a*{zqo&G;YD^>o^JKRuHXCbxc}7YnExYnFDOj|1}f_{tf{ z4+Du+FANJa`?Uq&+wOu&=KFju-EYD=sVxMK>Z9(Wo=ReYyi~?_l^vFhg)ue1Fybi| z;io6b$|&(XGrNU*{0RkEro|D+A_gkwh!CH_5FP=L>n#WJyHQhfw3n8x+ZVhaff0ynuwbfcEX(;0{l=?Z4O`8GMUp~Ef} zL_lYnKc>0$%bnl}Tu|blbr$t>0YvE1@LgqpXaN!U8CtXcJ?Ds?F|Lmpbe;%Z8RP0H zQ$bJXM+7^?WMHVGaJ>`Yq-hX>LA#%rzw9wW;AFS)PCh(=Wno)K24WwG!vY*uJqNC3 zjCarhTcGDT0eG9D85J$KYg5)B1AeHoDc8dBVs<|R;~b~LtF9qElm7!|MB@dsxP=)+ zl|Y17U3h5Ja{e{6$?6~iE{Zm|teM~7I?gQSzkmq8{~scFT+O<>-Kp@v27uv!cMYS~8t@ zC!jpJnnLMAHj@&B?7fb>sSi5sHIc|BLnNOKq3_r6K>94|(}zmr)oUGY$l($Fx_(jv z4s0nLQ2ki5FBsqmomMU!Fuxx`SfywqF-lZH2pM(c`v!>pkoS)3%Q|@+nDtP4bBFra zH42|0^N%IA#-jYa&+;<|9t&2IVEQGfoNr0g$*k`pBAuJ=?3K@jOB~FzjF@sa8^{cu z(hQBKmn^3=^PRGEN^?YqxGQdLxjvnOEd;oqKjQpFg~dtyfSZup0U3wrG^Wio8%pjm zNY^wtSdXRCtAgrRgX~rk?*s>+dr%^yKW2zx(1%n1KdP&=q8ST1Ov=9WMrsADE09!= zqq^E~CS#nzA`5w|0u#w`TvusFOLrz`;JRl1gX`+p0ecigt%tbfwnSGZvya=yn#E=y zy8>*xHRFBK2RbTGvI1cyP->?4w zYV^&_l2RZ({FA;|7_y9?w;P)M6*mJavFJ&^)Xob^N3emny`lUin&!?U#@RtfFrjj~LWgB5BOBY@$*dzMg1){~W)`XPH^Cq#( z|6vj<0?+oiNvw#H_EG_~@oK{`@u3-uz;fo+epE0fC!8M4ZTMut7D*e2%qI&@KJAmQ zE+`wUV3k%1WRldB`eZ@*vE)myNm+IzyOL>a8(EJtf9u0XQ+B)Yttlt+=0nh$n)r3h z@rxXTz?2-Y9CW}eGe(dKhTCH&>KpaqQA?!oYYX=l5o9p&w>+5TG~SmS{%Y$2ePjNE zSXSSddO=R;8?VvT2Ergju>TiO)3cAKkkZbVyBtaRbqm1VgVdECe%RszoFYFfqlRFB z==%%{=*=X)WR;sq@iN#*>P$vpL1E}}=F5G**pmN8aTw3A*~GMfbQZB)Uh}gy=+o^) zKjiJ_@5obU4og~d_DYxu0_{oY#=X`2YFm3Mbx{vp!ECM2Gw!73{J)9qB-4wmS%1OK zYyr6oV_6hAYp3SqSrjhJ5FhhPWmpSl@bLN!u}<<H}Q8_pl~i?#fJ{th+ql*J~_^? z4C=YVHi<`sbgFE=vOBS3%fqs?uY*1qa7b2hDd4C-Ew$_UIg7<912T^u9krYUwdxNJ zY)x$2wfmh>=?Y7mu3ur%K1bL^+Ud%#vTGy6q(OTmzZgKSg~d>z76Y@%Wj8*BuZUeb zdTNwp=`S`*rKde#IFU7HVDU6e6OKRI+I7Pyu|w|BlV@}D?IN81vyH2wNr$*#QCji~ zx&a}`jVW^&bk7v-Ew1FH%|x>%kQ3 zkuehz)OyTgi%gw*aVLyIriJ0u?P@rEyBfm3WgBC;m|8|>zM(W{e+6)85X26z9!zxn zVgih*=>ak~MLzxLs_yecJ;*LlV#OSjwT>kcJ3Xg$E@4_LS(;!tQ@WS5rwgwGC~~A{ z-gb5Zvta-6Uy$2w2@kcJ(xk3n7;bUkuEW640#j;GmsxMB_+uFuLE0)SV|RJ^iDXSQ z@l95>2Ry%o%$Hf)GwA?9`qds_R?BOn^jY)Lwq~My5}bZD^F;Lcud>dP0e;O(j8ZH)g~X-+LOL6LvlPNua|bNX#7k8)Ub zd(*k^3HH-wDFLc~PspDqcEvFNCE*ILqK~>V#XZKtj*J`Q6T|9F(Bb=bQEyHkkl3$` zA8B8<5`Wq1&OF1_&+x%q@kB`l4VdNUcJ_8!UB>y9Je>PdtN__3$-6UP0(NOOl#3Pc)xp^? zSjfYbCcBt+Ey0YLyq3%#CDXp1V8O~_#Z)tyt?2f2fA3&1bsm;g3)9Rno)%$7fvxm9 zf1!W~kQ`;AA0~cX=PA^gVVB`c&g~~o<64@o{KpUpIXL{y7jt#>w@fZ7pP7oZx?FY-d6n zO$c_UO#8^ZowM_0^&35`Rj}Wzk@0p{O3Ljce2AnWCcW2fz6_8eHdzJggx)Z5$?v$# zOjmY6R3VcaQtk&P>&Ftz(E)+paj%Rg2c_?oi+V13P>vMh62;OH2QUg=sXYA#O@=?s;n11oq z47CT$gtZ!`IvaHPP%kbgi;>>$l)kw)l1CGEVz1*G@)eI;>wv+H+ndlA@^!Et?lFE~ zVJmypt-QaOO>onX=eg?yb9*|4nKlje>_u-^CTSIe`cSW#1~StS%`b=&>cCi zclGJH*Gyf7)B*v^AZM{mYCRh%q&B=&QXIpOActVXdkjGgKj#BmbB|zde}qXt?~9}# z0d#5ZLDrgityjwfyEbbwo7*zk-(nm>K+ohJC2hOF?!#6wXvFM9^vTmi zdrp7dMSmshm$X*>PtMLv?t1D^rPtdael>e6=PLZ0g`RX_mm1Zybv<+z zEN1#2cw8^8B-^_@kbTVDr58`coS6F*%xvlWJ!TWn%eY7v!LP2}ZDvyIV$)f$Ps-XI zW&xAkBwFD8PNR56|J?}xZ{jy__OuHoD#uM`&A-^HU2le$BKI5O8PT1|EPzk;YFOnm z1z2?Rix!*rnb`y{j%89@W+yUOn=H@t$20K$Y0vb_?b+nE#quI^b9%{Q>uz&AtA9fD zW;cAD#A-8P@GT{_Vzqshzz?qGwqNoA*b;`d=eh8vpXaS`Jb3UA?`ECkNUCo5xa-9D zkL{2o>SVi?yySZ|38E9*KrhMMb))**EsZQSDiP24}O+ z3KP4#ziUi?)Tm+XJxlZ0he>+Na_oH3I4@gansgUmFPWYd+%-CoOFkPH0)WDAoc^dqMJiiI+NY=J{J=y=-Hls`KtKW(xI0M(?{p}z~< z`n?6-+;>~7=Yp@*=2m@to&9?)m_@SDup~dUTKqj^{+%RrK?}*!1^Za>9Bk{+H->WR zy&-HJ(`7m@i<#y=wX+tiaDhAh6z4<`+K-s`xEVo~Pi z{V??vZamvGf8^cz#^2gnvRjw4e_Qz3Lc95F(hguNQE_XmyO4+U5tF4D*|)~n)3UT) zNPPslAa^r_rX*<(uH#~YM>4*&f{R1b-7iVYL?Da3OX**v-0WjT_IK8jd!O-}Oz3Rw zeWteMH|#BH^Lj02BiWWw1j*i1vuuUAH}wK*#=q$%FJAE%DZBK=v(DJHbMtu@Ef~~( zcA;X%$bR)gZGfDPmyHi|BsG9U1Zf=HnQbY{dl!WDXetMHk3FSDQ);Y`kEWDgCLz$# zy>jH760;9%7%pJmDv+jqi0G4iE>Bt{l_yLMC~1E)>Ix_gW;R@*Tf4HU6VyQ7kG)S2 zRFb4y0@S3Rpj&Q`yoj9;e>*u?SZ{{u_-<@wDx|j=;T27p({%Ik;0mz|_Tx;i&Y4Vo z`CJ&{=vH|kpSO*X43GPnUD4FWb0zCuvnO*NnZN61pN)2n=RZH(z3sgBJEc!8*VbMj zX&^K|=u_Y|Gc4%A>U9ym7N+z3y^zlky+rIIigpH^ zvf1>Ryj9ODY`3X@yl}1Dl|mRtYew#0nc4`uzsH~2lfryvIw`?cn$1zgvnPtJl_pd< zRzWRHmVwPQw2$#^{qFoLR^>Ja>#x|JY*RnJ89nOQ-(O5^EdD`F6pH7P<$9~+?crbO zv|I;yEzE|fCH)c7PD)7hdsX{)9}T58<_=jC`Q)V(Zy(QWmA^>z^%ygAdXUU*2q|dg zyaOVAk=U=97Yt>7)!LNV37$(MnUXhq(-I3lUn1qO6v-+qtSsP>p&R;HJg47iD(3YK z?>ReCeXle6i4!&l_|k_B`EVi8J0!VXk@Ny+kl6(gH#hutHGI5_R%;7D#QXy4)>8{f znj*fGtfyLFet<1_Bjf#f{mnLUrUkxYN2j%2M_ff~@*e~KRD1sdyh=N&GS+?p^I9e^ zFru=za>bv!mA9fG?_A;-B7fmlxIk|M%iWC^$o)KL%`!Tl$#-*q?p@6P%&OR*hlx5k zxHbP>#-$&^=rcjABcHkhDqLz*YSZ%_%=$14K08?u|NcS)TU%l9~aHldBc|8P}8l;B(<+t;Kn zJ$Vjh(sY88_&J2Hb{6b&S5Pvo=1 zWPM6v7AC#!K~hH8^m~X_*@vYjs3%XcNahJjJY|^RK5vFvnf?mX9)L7bNd8(<_y;XeZXYy52l<^)C}k7M#Q+_Khj2tDJl{yV_O zzl0h3DCk_s-psqQ8*b)&VBk2N4|5?sBk^a#_Jsp*8bMV$PE^ZLNkj&`h4uk(F|`-< z1!Oxabre%u2AYfaGWhHNhtk=j5~OIn_))1nHP6J`TaX4!y@J7CfcyR<%;1Jg{xj@Y zW{_~dLG1l7VeZGX=JBkKg-ABNpL_C<$`5h2!pjHA`i$A1JH#!TBa(8-O>M>0E3kBL zm}VsX6sC}Qn&<8$%EA+1JPFK}Pk@UjSTp`jk1C+IAHmdmDYN}tiWGh>DNs)y9BN5phwr;Wj^w}83o@@O^z7N}>2Avx zHf0U2PV4KqjE0V3`&Z1J>GWzNZgVwuT7$S99%MKutW2rb8EkVGl~(#SJLT zq-ZmYDQWFN4x=cHaJJVa_J&1TPVA?t|IpF;d(Mtnl;xxiXoB5m5+$cyUP{tjx^ zAC_R#m}l8YYN8#106^mG%;;}h;l6<3XLE!>$9ab=FG`)6Gz^cK7bQ4A{EMthctBr* zafm5Gewabwd{IIOpuV14G68;@g>S|~Qe=1$GSwiW(T1OW(xSkmcAJE84w2e29N;IL z49ZHN>?(t@_7{&c?P4H=8cb_h91uHLYhiJK=lGyr#3yWU#%%oE4!V+=Zf5rFZQ@`D z^5$x{Kma=(s#oUoTnS`956SQI7-TsNvey1Zn3g|}X*t2PM=&if!?ZlY=shMs!cBb` z(xP=zcw&(%e+@GSxPDT0N|a@%oA&ogl$t;+MO zo9?6VA$k{Pmp z(b17h?;@5TvXAm(>)R;Sw^6KbcC2p?;mKYF?`E>+aLc&?{+fE6qW5q~`nY7<6p$Ae zeYtNJ4eA*c=LO_XpQqeV)Os|8qv{~%`2lI3oZVUdA$E*)j}bKc>aoR5dliW`4SHhi z9^>0zZzPo=TQfo?BE{7pXfAWV!MOK>aqq`Wko)hXv9jgyJ-4}EY0oFWl(a5F2<^jI z8?NG-sHl!tnYb`8SjfH1nEZ3BYx88y-3_l~>P%z!IQ}U0W|Nn(9^+uTRY_(GLoHp_ z*S1TDU3y^o@CyJR^*-P!zamx&7o z#MLOmXm7b~pf6ka2&~E5rLr@e{q+T0HaKB4IhH|8wfxM0>3lMMdmHQ3t>?qQ`A24% zA@&wmmO_YINdDXxBKC#UnTO`smCOA!&$e`HK*q4o-J-(gs|nl^76s*2g1yi27SZPt z%6C*Greg2Ma2G%g_2l*Q$?U#0p36KTq!##qajBNf7%tbh7V}fvtt)n2GLB$FPyVa7 zX!j?X_;@Oi&j|2GN7C-e{-%HRrmdT*yI;9MKRvneoqmVufCin>F_hE_(AuDbB^;+3 zWltoHawKCMvc@5YLsK4l+E{^tk%CcGd}9lmy|E?QntoRIXYM^9O&#dY9Cu7+al#%* zGd+>ZEL9y*>C+dZLB=Shj1o@3 z*Kd?^MhPc^0r;W#Hg246juifDE7OeA#kFZ0t{ElSm-^8X?ZSJtNcOfgZ_nmB)6fAU z`PW7mb^3CCjC5J%j2iN+>x-ty>gw#WS+uWAvJ3)x9 zYIimB9S2RjwC^|sTVl~-2UR%F51KVBn})Eh99<`!d5`wgdXm!TS)W`VPOsb#Gx`@L z_G_o?CvW}+V8xP}Iv9YZP8o!N?nlQXV;Yv~rt#0DMGNCMhmG+1V&5MnYqY5?iOmAR zG=hJREK<7=cz`W6>ET|NH|0kRF4+g#~A*IWLb?MQE&a1xZ=7Z-OHvlu?ljq$B1 z{4ksgii8e3Z7}&;;VnMBjV+>)s-F7R7-x?-U<5IBvv9hbK~L;~wh8a7`8^ItREX^N z8}a&poV@@Sd2|~)*)C3@VE#u4K=`~2gDMR-qe(b)(mEIH)FT4!^I$|-mGbt z5Dymqxm&v%pT&=ks-GaoA{UN)*d;$Vg79?6y7vBBUveG{v;9hho&A9<47hR_PBz=R4LkKR` z?-uma`2h2qxpWP0N&dtq{RWcGPkgLNhsAz*4jQX4H4FPseBzMeGyJ!Y$}Pp~SBjr1 zA^mlgJ=LYmP=9e)NZ4I-S61pM^nJ=op9;y{nOlnwX2oIB;NVIWk`G~sKZL2Ypg%;`OPHuPxeGf)w{fDQkX~5V z9wHgxd5EPc4&7-JFJ(JZh#no(hnM@wQ@EIm8@TNOWLjOXe$m%n$bF%%{7qqh@o86| zD)?g^+DA{7xu=2}w||)Cmq7J%RC0G4_iStUq4K9*h`U7=jyip9;p^ za7f*ADzeZEEJJ%vl~zQ%bbTdf+gk->=I;WfZHVi+{#Iww-)&1F4=dq}6c!nZ5P|%yNkY-h6 z_TC}>nh{8Jtr5C^Eh)je;g1xbTFJ%^*{(N6^!22@B};5kU0e^pAkv3DW0#B*`u4hp zZ~WUUM^bufJ0W5PhkuwY4?*8}h*%W+JnF*V_l^3X4o|2MzhB8Z>gt2MKUM7KmLuHp zg@|&|Fao|W8s_8>rVxS*hQ4NoCna~1iDx~IubKI8?b<1@GG$Vy4N3GnCZ7Ta&NU1& z@X-S%h?4urdJdUUnSL7aM1SDg(F4TNW@t0M+_$>yPcrG~fdRenhhc3ATtw+x%~tuv zy7u7#;D{#?o_!T|j-Kw4pMdT6<+`@%025aUgxTst0?x;p8Jv?!%^k47esGW+pAc-X zPdZ4@zu&EE2Z@PK2<+tr7fu#%^9&~I$!5dbk$K`Kt=+=-?cD?E?045|aSIgDLJa5Et2obozrHJ- zPny_}3Vlgiia_nfD*McOS2b*T3(Tg@Om-oe-&*h6{K!{f zvoaMd5G0Lw-kgPvbPSH?Cd@MH=wix2MTYCA@HRp;4w_t^mM!NZMCiWt%6coi!T5n= zomKwF{e5|TI}$p0rL(QAsk5yjEe)sg8%j+4-OQhdr^sy4HVW*bdQLaVe3@e{hm=KI3gdG-I$tIUJKw?r6!qbVW~k<5SJ-G?zFfs3{0J-!Fpsd&zY3 zITi)Gssuax9A%Ff%%{d=gkPt}WD_^J5o+vBSI=<_aqe+<=Q9X2&ds0C8|NQ);k-Nl z`f}3_m==p)UasxHqZg7tTyAvKT9-B^D;rJ?+Fq9(?!psG&9BQ4aGFVb9r~c*P_Znv@_i=xb-4vi0LIyw-0%i=pC!W{ zrgPbb2r2zKgkOK!T^KJUuV&)9Wd!!UPSEvk2p<072rPYQU>wZ!p-VO>^5zo9b%MR_ zVh`_9;eWyD!D9Y8Vd^Xv{sZir za}w^gTM(dH_sbAb(;Mz>+FV}KJyyIOq2H3hy0;7QDLKe)Dof0cocq_8sBu?<}&`A^y}!%JQ)Ou*$!& z90DW{!3&iSaS0aGFoz6^kXQswG#n%2ge)YqE07Z+qjLNSMgo^i&_*o%> z$0qL4*uSb45Y(oLV-L!kG?vTbNs+PlSQVnTHHIg}Q*dr}%zc_wvoZ)8=KYyWCj#y| zVU)WrtAx1+;X*+W1`5G3g1R)s7-tNE?sTvlcd8#_*p_l#)_(G5rMIZ57>0o#& z_L_L7%Et)^mGkaY!x&|~i`W1Y2l}vEXMc*hGYhv!-+UYnRq>6--I-?#*rWtO;(t7< za;7N)KPnc!jabw-5-%yn#!UEB#b15s{m*?>^){5b*MGP4-%XR3f`@gChal)zp z#0hJ6tb|oizhfn*o!qn!o41DUScxcMXhf~WeF9O!++jwPuz6mFv3e4L6rzL?FMB*n z*gP5x6sNKJ{C7dIJi)~GA0NnK;}vX0^8vw%H~Sca-xM-3+@{!Bggwf~1A<{S`_4*3 z3jPl6{RcArlRVkCvSrH^$ihg(iLn*)YmQaTAOClrg4&7f|2Ru@ z-&M<2o`79Kh?rrtlhHR3>4O%r#jxA`)xHKn@g*wY7bS`t^+*@6Yxnr>O`B=JM4gvi zY@$E)ZQQke$JPlN*m3E=`8&pT(!g%y78uyLam${qn>OycI6biuao`)rcWm6T6MF$S zj-^u@cU`peBh^j2w`b|&^H~fw?bw}Of~^ zv9YsA>m$$3W2p-U$UQQC-bL4we-%D9Jx z(nDC9_tMq#F6i>fW4lQ`5gYi)tgK{Of+Vxg_)xW5$!Q*7S|<#FCtx~{5IaPeYP!!K z`w3}SGL)YaPO9eDjSq`<4|&XQ5^kW{dRctOra_J=p>^zOhPJZfo6G@o-?PT$WTUC$ zd&aZyFK<0>^PX)R$Hq5ZeBK7Kxu|)Q8=Xnxn=ZO&+xVucEDm84mL=jN`S^Zf6`5VU3E z|0IMUBl81&LAbQtT-F|fH2o%-k=Dh0Z3-RFDU6N>^!!<8;hR9*1~P(N6CiA6N8wo% zV0WVEA%+sn2z2K(*u;KyfGQiUDashi-J! zNf0|EgfBP&-Ik(Zk)*z;aq6cy1z0?sYF`3z2m=1+!jvdgIYEzU_s zt0oy&x1n@RN+xQl`LTgBCTS{c4NC%8Itf#+b5(%)OK3B82HLot&ojMNFs|~E0IA!V zYq{~flL1l+ELK~f;>*MMV#1eUl`f?@{Phtcr;*1Fx!a|Ech_oNwySX<)7;gyE)%xb zntT*BecVUp0@-1EQGY>v8Reu&wv{>(_^nh$cpQbHy9=1^40;L4#+=gm)FCAMvd7RiO?KYLMKgrl@1PI698^m%VW?X zf2qqdOKZcpU$_pC?K(xgbr|?ub@IAwb=p}v0nc;74Wzp4H_%$F48g<-7K*N5h?~|P zpy4@&`&o&~VDxeku{*;LqpkB{THA%TT@tsv&$MS~18rrWFYCA#X2PkVXGqFOF8@;E zQSA0bt?&earPGWeqtd^@6DIQf3;!RQNN?m&=^5&yo_fYfJ*6}bGdd3Cq?2M(W~8B{ zkEu@I3f1bQP!<0rygng|BMl+C9$7dgC+T&hr6CWJ*LtR=32_v(Lh?-GTipZ~W`KGo zv8lo{g{#(3K#GE%WEvG^R76oQDyDT*%%Y-!f>BXQqN0L|BnqhLm|BLeg19p6q>ehu zCN!E^ibjM&0|hkdomx^sJ|XIzJoedBA4P+PabpyW%T6vv#S|*4C}0G3m%ss@NmP_e z$1YJFNzPxQeEhSz==k^JpVfuOzE_TYb~KhH1wAZ!W|x*kPh$zLG&PDteK8)RRsz9B z@V^LHX$zf{ogG2|78N9qbETLcyq*&7#8j zfasY)!KkPhgnUx;l#dbAliV(xC+)Veqbf%hq*@X)$OUpwbO4`Ulm|=wn4kuoI7-dE zsH)q0sy%^YNv(Ps-6(m{fgvXfMn0mE=`MPJ_{dDB@i92n`2dNYsdmh*FIcc46RnI% zsHd6$l0~LL&29LEo{J4DQrOlr8OPTyRLAfG#Fhhr5D#G=tVg#qJjDF55;4k+R^wQi zKh|1|a(Vvf41vTE+(#Om#jGkKGboOfgQ($=63X*W`r#b7ZlTaHKlIE5@K8rl5t%ZY z&iDyV@yN7sg@(Td!$aLD*8KZXtQf_lAGeF(h0(Z)3jb+bZz`aAa=!6=(YV`41)Bo} zkCf+s=$jPBemFSmeE`LVQCs&mP^=lniuY$I9&78J{hziT6XGVOjRsSmD2ns-tX}&yvj2g!X)+K3VR>cP&oKcOl6~#D~=a0z5h&EBQi8yf>oR*Dqjrn8UI7X62 z^^9axPh-UsgEa|*kG*488b9pGq@d`jA=GB*<}tTr`6CTpnPli zo&hmuian>JaIf_Lfx zmYpfmq}AID@oPJjib<<6IW&wxG=uw29UnxM94cz4D5GEuA~Hr*6cw|_rzLD?JvJFs zj!jF>*=|zHyl2{Yk*e_`&MXc!%#xnnUcZNLCuBXu&Lo~iiZK*!QT%v6dVzI()%f~? zsbi(_*-QSV_&AwEVa3StoLDs$_@0Y6+*o)^WU{4>pfRLAWO#rE-unOwSn)6@Z$V8N zZSaU4h7cS|Bq=_FLdP?hHaZM3r{`gm;#HLVXC#4Xje@cC|3ClE(t{IXf8Xa|0VV9; zre&Ai(i*K{&O|+?bEg!Yhuw2e2ytWI=v?DAEPP!Syu@NB7Wi1SZD!6%?J5$!*Pa6) zzy#61W`d`cW(7U(Bo`WgW@(k^HH{J|<&CzXYjkYYmkr4SaN#)-mZ|B6W)~jn* z(YOC3=m?T^%lO@2%A|)U@Z9lgwoHlT<|D1VL~pt$<{%%=T_rtVQ|Yw|4bFnaDEjhW zE965d@$z4)hM06MuJjX)mfv$mi$|{D9V)b9u5pbzNvZK=f1adsgIEQnNgA4Kd=$I; z+A#%>6Iix{O!8`!0X=ngl1A|bujxYjo&+zkGQUBgMxZ06(F}{W-Ee7YNp0gCT4eVF zU=9l{OYT>c&-O?ScApER!K&Ywd$LShmSLYkMNCrVw^%&K)ffbhxi@B6Ubb94%i2u4 zmZqq?trB-2rN6m>+;7CHyzHD1@>Tl=qi@eukbF5&Wz{)}-=@;x3T1>)CUHMX?zWn8 zy{t2G&GUdK9JiaS)##?@H58@ilRk7y%xWG%?pMl~?AFs6b5fhxyd{FZ%^=l(nLa-?&R~T2^`6 z>h~+OS_XGsg`81umdRC1l2Yff)qgHYdSYCiX+L$A6T|nkL zJvJ`M(p8MtiP;Hx2jb<+z8AlQXhzWQkQC4b5`W@jf*KkH5X?pz#u>m{*fni&jgrPT zeP_qNx;8nGT201jud!Z7IIr|Ox1;o5!bKMjuioqcaBeSi$w`jQW;RS#8ykRY74E&j z??XR32crZ`Z)}#Xj?K!&Q_PTx*CuwWbJDcD&26(LfQUy?K z@V+_ek{@aS?NyY!yI;Ad)kgO@keWy$+B8eZVcVAMuYw-RnsFD+f%=Q(2{)dTa=?cX zc|JFXabevH`EkoX5;Uz|y^7Sml0=(R#7Z(aK*mHSSxVw8j7CXDZ^1j&H%n_SHO*0_ zLT!9vO&nwEjKps19IKImY8q3}C2pRiGu#s<6GEW0DWdb7d(8mfm{KMr=U$7IHacku z&^XR@0<1JiolT~sF@jkg6OJ1iVba`D?=7({&T+3ahwd~k?f;X6UUL7qA$L^OSz7D| z66s^4?aka!hPlo(qT24Fy0sj$wdsIcg` zLzko^(n?_3v@_hLp}K-qlBd<>;|_-(n$faxjXpmV^G1{6Y6IN&-u+Jx*V$c%HHz-_ zX|(mvS=L~Lji>vTLCZ>uxVG|929*QNL>c-sjvncDTi71QOyqG(X8+NPL zIpOfKC}T;{WKRm`5j;9l>nBkm6MRbsqa*ejyUsv~8xI5mRodeO|Jo$r%50Mo;~|@El1gakn*u;H*seyw=2>yZ zvhe_+vGd3@>kRs)*;;Dbtu@zZ8!a1erBIz#ME3>)W&9Mm;b&PUXhtXcH8cP~uh%O% z*^0K^kwC?007wU(2!c*s;ns?QdfTGasXZ8}fZ?6g6APCq+R}`iZY`5Qp8X(LnyEha9T}y<$k1))f5Cy%e zA~{HHGYnwSG|85Y2ZPNRSgWGM4#~bil!ok%mMJ5BJBFq3d|0)#{;na|q{ZKc?wvrS zC9i`pCZs`+nxM#39db!^BgOe@|9H@1udA$r%+9zf%)8_|g6}0;Qy{7UAV-P={SVrC z&6MNgp^BML+nQ}vD%z|#x@=gp%I4%=Td;1@ZTz;XJeJto0!+)gGPe9dq6Tt48=yu_ za}|d+iBR__t-Z8$j?Tj8-U!jzQ7rMzph6SaWxB??r_`hzGj7oRXEAB-ot;er(8pK= z+;0#=_GKHjM%fvB94RcE^a-p>?Gug`Os#BL`-B(suk+1WOM9zh*0T2j2d3bN7n7QS z#f~#?Lnv#*cjudRXFApzc@HAx;Z?AWIufQ5ozUt{n95c?HXe;ham-r`Xtizewi4|> zayzaRb0qLoE5csmLytz=e#tp{sZO2+QF6u0FoU&DLO%q=6#kX6G3@$c=<1LcNy+gq zh2E@@=Q*S!57a1ve?W|&fd6nPiUR(_p#%!}4~M!?z<)T@hXVeCC$~Bh$r)}So|r?i zn(-i*0Weas8Vbb54XpPBP_UamU5+wb5f++75tjN%0&Q(T@AK6G23#*@O3f}5w*w(6R4!0K!Qkjh{vI>kd+RYGXm z(+aj~ikCU7v!=GF${O6+UYFE53&k2d7@bssp%MhbN>6)xUCp;fTFV?yDyFryvGLaS z))HG78;@5d`W7h_WTKaxtDF>Qtud-e%}(f^v3Lz(piZKwyR-7|s)QUYrm|mDCE)k5 zHO_Hc3xe>SfP3;w(`=b@+yRNpc{u6?n*5B}3$)Jcr49!!1T2}V)a09CQHUfmHt;8r z^d9d`n7PAAA)=O!Npz$!g`yi+l|mBKFei-}h%DyjI`V?^4s!@k^roW*vm4lrhnhoE zVkr-Ui)l0D9(h;zj770OMW<{9fV4O@`;=DX6W&S9+|bypv&l9I)F5Y<-Bxm(;h%7X z=Vq+Y!x22MJ?e;i!E7ZLR{B-e_?)v2Xf>C2Zko|F4ei$KPDjRW_fOi(M>P8ApaWJwmaoY$e0?w^dc9;DzlBVoMtlLS~7Qlr0IOaJ~wRKK= zW|+NdLz;OTrsJk*67}Z6DQC&Xc(vJHvJtGZ5VmcG;5A`;0T0MaESK0FD*2nB7I;Dp z_wd!1MUj%fwTwObGm2E>(Joe#lv(Ba%?#rQ$U#-t+TcVR&~h|f#4$;pM42xJN3}&+ zG=3E1uK8kZptAG*Bv8gCg*TL>#S_$K!od5d(*b;NRBq}Klo*XySepx-urvxv>S&evu^ftOJs;mQfV{>($h@nG-ll-PBo=c=WCA4^imrzDh;)c!eYaDSu$P=}HLmFNU4 zE&y7(;B!Pg9%*3fJr4b&krIPwmWa@#DHHYDYMjdM*hH+%+oHS#%y!o#ddfYC)w(1% z#p)6@M3X0p-jupGN2($Rn6Dal-`AjsyFnz^L~NWeGokKqgM6(Ga^614eBnu61Q5cM zoH;@?DcT}5-Gn_n;VEdlk~GEfd`@aerUrHL(F&AykAHQAIiH{55cD!JpQBFt5nw|J zz<)MH8Y~uP4dPCLcNKU|%zl9wM9a-!5ePKiqdgy{ltW6ixUhnLE~y z5O*p06O%lGfAS?t!jGla7imaJjfZU|;l>ojO46C=?+PZ-Bi_ zaY&`vxG!FleXGjCAD?C+l!NhUvQ}k(ssTvbNjc%6ikt(EPems1NED1hPJYsAm*J6M zyH1emT*B=jx&n+=@@NIUY4M%|={M{$XSa z)gTz*2eP$Bwz?YGTvu&9qwc!8D(<4zX-<9&AX5~{M=+Qo@hQ~=_ANMkj!D%$iu+=E zU6FE;1F^bsca+qs#eEc_!)jbDX|f|DNnH^&vLpde8|8t>B=^UYGL@`rPb4b+b=K~k zsJPwl&)U~O2&>Ao7O4z$U`xn8W8o!>54la6Vo8hZfoV&#W5&|dS_d}jw519Ep2H2Z zY1XnFYf8MNNM);n@tmld&cpOG5yFbg%G4B@lA{Sx7Vc14u!c1#mE>sLgVA0^e2FkS z)!1fm4h<5RfaSSzO)$B+sgo#ePI2ia%U_ISJ@X>}Lt zp773?DXP##GV_{gO6uaSX_=J(kt27c432V2RzUOc895xEk$K&M*+H1=mb??>v8YkA zH(Z5dPPD%{h%k{VkcPoeCX&v^1hm>UgQiv@v5I@BwJcGSi%bbDI-E*!Gw8ew8fYBf zAmlhDybb!l>F~78YnxSiFbCLrHoF?Ou2JJT%0^$ij}S9QC0ktzr=k+Cs^}jXkX}`F z6?ajB(B+95q(Tl+#1T~hS1W~sIIyT76Eg!dlutrmd(GuT9dV^U=hqZ&Vmh7ib+(Bp$l=YDqy&U@cMpLG&^d@ z`3<%P%t{Rt5COUb08U0bbB%hq8`PR?;?@575fK`#Q7f;3(`q!t6BrRdEv}IOlJ+Ex zE$=3Z{%g`i)h2&+7Gu}vmy%>A0hk*O@SRdqE-|4wO`UIQ5GlSbbrTBp`6mh_hhe;v2{Oc1H z1#CV8pI&qx2WKtJxL3m{AAJ*y0x&!w*M$d<;l+dmfz$QR*#V^?@tP?eF5o#`A5K#- z5r?6xGhrBgX3@(?L+6j9T(|YO-Ee}TqL%~sJF*($TQb$`n`vWPIc8^3Q+>^4LVEn> zNq*914=ieOM?i|UZ3Sd#Ai(O<88GoKHBSvV8%`6OZR@JM?o3#w22R53%Vin_EHv4> z=*MNU)Cafly#a#xhmZs(5nvUf>Hh8;G0{O?pn!q+TEo)@cdM=*qjR zoV6rV>n?dxB*M~^;N>P?xGvzrb?*KaC2J$FqFgW?p#<=~ly0|F;_sjq)3Lox zvje>5@oP>`;(am2yvZrdVU+iiM0`v8rA}fSsS6_LbKI*1n0pc*uKpo0)Wk`u~Gtr1w*33_@F@D$;JssUf6g1tZb2HtZE|)i*+kk7gmS2c6UCv2j1iv$7I(+b4y;H3}1?vC?{-PL8n| zb&I40YhdI^O)OSxO62*f!rDocxrR{I2o6#4`VcO%jdk3N{suuMpyqTo z4rj%pL`|*aI+6%9it&#Q5IRAWuqOocYqO5;ZJ6^oi|mmZXhl!qp*vxnEAwvNn^T(jqFy<3f6a(LMK|BY)(c^s)m>+ zIOnE`YVA=j&kXbEB1(!CTvp@?^eI_Z-&$XWSvhK2RfyFF%cRwZ0R6-Pay_)#vtiPP zPdT!_He}|dg(!18*qM7d64F&|m%^e8P`V8@+jb0n!LhI`!DP373a$EBN!P1Q)iNPW z%j_igc%RJbgz?n7TdsJPV98rI3uDX_@0wlOprF(s*jwB*SLIY8WYm?)daRl%DRNZC zi@O0K(lM!)X^V5Oq|muDwE0bFXA{x^?#5Doc4FK#HwS~KTpx}@;F(`mrD?l?aDC^v z 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 I&d&dT0I;cQcK`qY literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/bilateral_filter.dir/src/metrics.cpp.o b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/bilateral_filter.dir/src/metrics.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..7563d3fe99d712949ccc77298879b17d69d63afd GIT binary patch literal 2264 zcmbVL-ERz06u(>5EvmDGkPuyo2%^`{DnWvcQk!T*(4?)8+OFBQVLviEE3F7k>Lc+W zeGu>d0lbUY;-T#mUQ|3tJrR;d`zDe)znOD%I_Akq?woUe_x#Q|bMC#jjlqK=NzDnP z33X~wr`D}QMJPiTtgRme=8}+`v(gQ8r?-f* z+V!G~FgWX6r0yTw>piN1&24rgqwfFtNn6QT?dwPW83zEo#KG==lifiJGx|sJmSYcO z%Q{;sDc#;`;`^`4rkO3~OBKiJ$!DxnCvs;JJp+J~0+-4KTkxyJK9dLU zz7;A;=jfi{Z@NH`r`!l|oUh<7eK@8n_>>RF^aP(~966Tz@NbMGKTbj7<31dFA}wqH z!;<+aT^`CinO@S4?dg88Z0l-9JJz71^yQ3`QM$KWR@yGY(b=+N?)7^#%7v|cO4H!- zR)M&MqGM^g>&;~+lfA-zU!kH)cClpH&JYn%$?EUP*_phYv~>P|I!-j)_25lR5eBKl zrcZ)*X9MkF<|$tc%wc}0qm1KyAeG!}yh#Y|FK~I+z#wgbx*qDqiVeM!7IOYC-y|+d zdGC}AmQ!3m_`l+dK1}gp{7cNoZ2Tg==yuu+n zwt8s^<_~=m28P7igyCJ`t@z~`^W%PyZ0TFz`(z+A$bZZHv;?va^6wBHcK>2LV3`Z< z-wIm7m$`=3Myd7OP(An2$lM@*8R5aZ2Y#Hvb8vjZ>HZ?C$O_}9xc`TLBRwO?{{s>O B82A7H literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/bilateral_filter.dir/src/reference.cpp.o b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/bilateral_filter.dir/src/reference.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..ad46951c990b53dd789ae5829e69fa5cf15144a9 GIT binary patch literal 5392 zcmb_fZ){W76~F!y;-sms(}p%H)ku-sWfUHMX<8){o8rU{k6|FnpCLin2*3BM394gi`1Rvyt;=#LNZ-1uL{}!S9N%_! zB}jelQ*_%RJ@tJTgt4s#wdvF;m?+bO{zD6HXIUwf97^Xx9z1;Mq9P4D35 zSLo&oE3`564k>0Fohx+aO;A&!pI7wSWsolvGfq@l??(Acc5)Y!dr4v+|{rjhL_#?_p6NI2e37crf_gpgK=Cz5p8`v~_lcZdqid zc)Gz^sl;1!GW2D+%&KuR3tXidi^u%Fuw0Ute#VN-SXiwyQBqhz9rkrqsbyokpM`m2 z8(5_qyD9~Y#e2uFFt%!)Rj`fKW4u~#>|@5*evB(}3GLEzO%BW%)--u-7-`-0$^p{b~bj1^oP_Y$tbNR&2<{vbI*>BJ0+IfVjxoDDeI2H0k4h1-VF_ zU{^;4IHw6`djxD69)~F&+z-+Z+3&sV*Zi{&Cij{4g=dHK20V{A@y%Z$5%JGqiuc4y zzXZSzzfuL?2!Yw@OI7gas^CAaV*gAP{nxADKdFK*Rlz?-+~zvmtfEh{v3M*SOGRT+ zG?O9f{;ci6k&;G?VY!74M5D5{dp@@{`>{-lt`?@thP*Cr607BeJ(U z7*W++epub9{ttG*_kbShP}M{_kxJ-9iuA}Nv`>NnB~=}rm{2pZY%ZPBk_r8&dL#h) zd)lH$p4hGFJ#rXgyBj#dr}C4l`{`xd3HR^XGoZ?{x-*r@>%nYRJIbLpb#Go@#S$YU zW|JW~EKGJpkLW$=WIFp_n@XU^CxXe*bT*-njVpadoJweN(az(yemp6b25y#wJvbuic+39EM6m5|kuTv{E| zQX@$)sYWL>6;5{o63l3@GO!+oRS0h!MlW(4uTs4Uzrbc`7 zs1e7y68P0Bc!4$3ik(K2{&E$(j`sx=-)GWa&vA?&Wy0?x7Mz=9I-tfzbDRwb0->H6 z7yTV^E902pvazHl!JUPkFrw)ik%n_Q0)2s_Qa+VT9F8TA5@|FVRbvy;SVmXD23&ZP z78F}n&u2Js`o}vV>O_1`JO&u5i0?XJ8RgBFO@J_R zbF0V};Lv8Z^;UiB{3&kJx_{wc#3>wF*JFLy?f)!Kyuuga{?UhZ|6#z;Cg#RWMZW({ zW)OI*|ED=-jsI=FUVMiMGol}fIeu^1#ebQ{Kfx6-e*EgQ#-9cZ-v`$GU*rCTKBzDf zb1^;xsGa{l{%I)kkN)vWiFE>h4lv9Kz5~p3o%=`IW)gET7D0&XU6up5^&jFFHctb? z;SNXm!G&U-(7gl<_G3%1)jgN9LMv=cb8Z%&fm^AE@|d3nG6r? o0l@6;58i3(-Np5%`CptbED5trS?{%5@593e`l2$d{#w`n3z$yhH~;_u literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/cmake.check_cache b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/cmake.check_cache new file mode 100644 index 0000000..3dccd73 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/cmake.check_cache @@ -0,0 +1 @@ +# This file is generated by cmake for dependency checking of the CMakeCache.txt file diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/rules.ninja b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/rules.ninja new file mode 100644 index 0000000..d95192e --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/rules.ninja @@ -0,0 +1,159 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Ninja" Generator, CMake Version 4.2 + +# 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: bilateral_filter +# Configurations: Release +# ============================================================================= +# ============================================================================= + +############################################# +# Rule for compiling CUDA files. + +rule CUDA_COMPILER__bilateral_filter_unscanned_Release + depfile = $DEP_FILE + deps = gcc + command = ${LAUNCHER}${CODE_CHECK}/home/richard/miniconda3/envs/bilateral-cuda124/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 compiling CXX files. + +rule CXX_COMPILER__bilateral_filter_unscanned_Release + depfile = $DEP_FILE + deps = gcc + command = ${LAUNCHER}${CODE_CHECK}/usr/bin/c++ $DEFINES $INCLUDES $FLAGS -MD -MT $out -MF $DEP_FILE -o $out -c $in + description = Building CXX object $out + + +############################################# +# Rule for linking CXX executable. + +rule CXX_EXECUTABLE_DEVICE_LINKER__bilateral_filter_Release + command = /home/richard/miniconda3/envs/bilateral-cuda124/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 CXX executable $TARGET_FILE + restat = $RESTAT + + +############################################# +# Rule for linking CXX executable. + +rule CXX_EXECUTABLE_LINKER__bilateral_filter_Release + command = $PRE_LINK && /usr/bin/c++ $FLAGS $LINK_FLAGS $in -o $TARGET_FILE $LINK_PATH $LINK_LIBRARIES && $POST_BUILD + description = Linking CXX executable $TARGET_FILE + restat = $RESTAT + + +############################################# +# Rule for compiling CUDA files. + +rule CUDA_COMPILER__test_correctness_unscanned_Release + depfile = $DEP_FILE + deps = gcc + command = ${LAUNCHER}${CODE_CHECK}/home/richard/miniconda3/envs/bilateral-cuda124/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 compiling CXX files. + +rule CXX_COMPILER__test_correctness_unscanned_Release + depfile = $DEP_FILE + deps = gcc + command = ${LAUNCHER}${CODE_CHECK}/usr/bin/c++ $DEFINES $INCLUDES $FLAGS -MD -MT $out -MF $DEP_FILE -o $out -c $in + description = Building CXX object $out + + +############################################# +# Rule for linking CXX executable. + +rule CXX_EXECUTABLE_DEVICE_LINKER__test_correctness_Release + command = /home/richard/miniconda3/envs/bilateral-cuda124/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 CXX executable $TARGET_FILE + restat = $RESTAT + + +############################################# +# Rule for linking CXX executable. + +rule CXX_EXECUTABLE_LINKER__test_correctness_Release + command = $PRE_LINK && /usr/bin/c++ $FLAGS $LINK_FLAGS $in -o $TARGET_FILE $LINK_PATH $LINK_LIBRARIES && $POST_BUILD + description = Linking CXX executable $TARGET_FILE + restat = $RESTAT + + +############################################# +# Rule for compiling CUDA files. + +rule CUDA_COMPILER__test_performance_unscanned_Release + depfile = $DEP_FILE + deps = gcc + command = ${LAUNCHER}${CODE_CHECK}/home/richard/miniconda3/envs/bilateral-cuda124/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 compiling CXX files. + +rule CXX_COMPILER__test_performance_unscanned_Release + depfile = $DEP_FILE + deps = gcc + command = ${LAUNCHER}${CODE_CHECK}/usr/bin/c++ $DEFINES $INCLUDES $FLAGS -MD -MT $out -MF $DEP_FILE -o $out -c $in + description = Building CXX object $out + + +############################################# +# Rule for linking CXX executable. + +rule CXX_EXECUTABLE_DEVICE_LINKER__test_performance_Release + command = /home/richard/miniconda3/envs/bilateral-cuda124/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 CXX executable $TARGET_FILE + restat = $RESTAT + + +############################################# +# Rule for linking CXX executable. + +rule CXX_EXECUTABLE_LINKER__test_performance_Release + command = $PRE_LINK && /usr/bin/c++ $FLAGS $LINK_FLAGS $in -o $TARGET_FILE $LINK_PATH $LINK_LIBRARIES && $POST_BUILD + description = Linking CXX 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 = /home/richard/miniconda3/envs/bilateral-cuda124/bin/cmake --regenerate-during-build -S/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard -B/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release + description = Re-running CMake... + generator = 1 + + +############################################# +# Rule for cleaning all built files. + +rule CLEAN + command = /home/richard/miniconda3/envs/bilateral-cuda124/bin/ninja $FILE_ARG -t clean $TARGETS + description = Cleaning all built files... + + +############################################# +# Rule for printing all primary targets available. + +rule HELP + command = /home/richard/miniconda3/envs/bilateral-cuda124/bin/ninja -t targets + description = All primary targets available: + diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_correctness.dir/cmake_device_link.o b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_correctness.dir/cmake_device_link.o new file mode 100644 index 0000000000000000000000000000000000000000..9022fc41740e417edb7b74dbcee375e980897d70 GIT binary patch literal 331472 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

3qw&{VHH^>D9`ECS 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 literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_correctness.dir/src/bilateral_filter.cu.o b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_correctness.dir/src/bilateral_filter.cu.o new file mode 100644 index 0000000000000000000000000000000000000000..24525d852e6a27e06819f815ce75679d2adc8445 GIT binary patch literal 177248 zcmc$`37izw^*?&o$SM595Y{vvUY-~uj*Yc%eX#Ggylh%qWr6W;e$52(L<-v9sJ`@GM4@R_Px zcdL89_ndRjIrmgwG`Z&(&KMo}$7lk5`*b9i=)f=e(T5Hv)j>5>?bI#7bLm*=XKLA3 zkM{RBtI_pNj(DElJ(?#TCTmZ2-g_AT&YSS7FnvB(UTK<1qd(XEcxldLx;LNzsV3>n5=9#lGAT~ByXYhNzonGgCBvWQ?vrg}Q zbhE&t`{IwDz+@M7kI2<^4g~9C_u{VY=^mXFi+rYrC&fbj-RcVG8F;LXMY>1V#%z)I zoTwvr4-du4yGMs&-TmtFM@0TBBHuHd8&m5i#Rf#qW8I_EVs$8gbhrmCMtfojwSIkU z9o}@b^MFVl5KTjqhS46iADe{g0a0`FcWdT~n(udyD9EJ!lVTl$N>KfAq^F8>H`?3c z(v1o9#BxOsJCW~Tv|-O`?eI`6(LFjIS>z-~dSWvtjZBKo>mI>8MyAE4_Ka?dtwZq` ztlc9STo!dVW`J7l>Av_e0o|ic4K><9V|WVqzK7>6$jIPX?%?SRKZCEp4tNUeFr_CP zJcp+VgfejL#r!>EaE(FfH1vq-4*UVJB!FKm3E&sVIe@LhOGPE8y0e1Ls^khpL*2s} zJjNgt>v9CfZ=pK^<`MXvdHz2JPk``!@B~grz!RfAf}eQL_waiK8QLB!z(J=HC^FIw zkTB_KF&py@q395bj*wOd@^S@~bw>e62$bpsN)FHtav)}h3Wj1ck09sy52BPs7a4kX zXmJcGhsursbM!6Wp!=k@) zWo(BiUK{g_Aw8ry2|-U{jz`f`Hyn>g$VdUjoZim4oxPo>clJH1M#1NyX)#adh+E8I zP0#T1*ivN8jRpGEm5XAb;kmJC-DA>Mt$PZjFc-y+tnVJZ+u5ByQ)fPf%F8j^%qGx1 z`d~~f6*9roJ;RG)1CzkrQ$JH@J*Cz?hgZxL&#;*QLuB2X$=ZXP$ofn@{du+S zX|?|6u>;QIOr&pfB#&BucTChlpHHLOUcdmp!gW$?5#Eb!NU&uHHO8P(H~i_}&@k?f ztwT>oxO41jWK--3p^5Y9nGBm!FA}zNquYVNuU8I(Xg7PLSS1= z{sw2nQ@-ln+Bte!8Cd#~y{bCp`5yHSaOsLK!I}<_@BK<1%lhhD#s(XIDcJbSDSHp_ z%wR^hL_nUM!;rok%8?RcJ(-5;@@G+L z-{cK@)D7QY>X?i(;O>zPw_u9hqoWC@-IhA%wtJ~_duS$Z!#9ZcsC9qAN{KO{$(?9| zwg1bc;oZ(qhMgf|M7g4Tc=Dbx&c{0aMXjF>;T$Rzt3PS@Au+B=!#6pj9Nr-M-@joV zu4DZD23{iGy??{NSf*Nk!cMh*@|^-=(Y*r?G@bO}-Oi9lMn(Oe(Gxb0E#{;Vr|se0 zb;t*Ci+7A{5$|xC&YXQ@wH@l*uxCg`C5QBf_m34#e&VR8TzzWy=;BxA91)Sdk9P0h zAS#RLASq~SEGfDZ$q%0V#sSG8w@eLa_K;^zyAO7u)On4gkq$rlfoStxc`cGGXW8V#$|ZT!@^bo!>&X6e@Kb3u0t7{X><*C`)*hP8@8fq z_a*Ng>fYZWMnm28|J*O`bn)JAgb>)j?htO`pSEZ32hwNVyTq1qg6I2Oeh{m$`xsKYE1y?$69)-*?$?((t?8 zqmKCc4!jU`-3!0y-uvztcVsq}NyC30e%0aB{SIXc8Uiz7wt~Ebm?_)8K~RAxz-Bsn zY8m#;3}1@f6FiCi^$1%c=da&m$;bQEmyht?g=3^Ky5$v2DZ`dx!5yv>m%oDgZ$kz+ zP;iIH0^cwHy-2)(#3K&teTabo7Kb!OM?DxC>Jx5YiA?L=f=~g#RNRJd5M5z9;+<$F zmL4p0D3j@s@2DdO!E&3&SZ=?=Q)0qsCpy7Rbh+PQD+h@B(E((Dr`9>d0$!SNIK#&y zyG4thQK!P#qKs@240L$67$royGrZy59e4tx3Dz6l(k+UH9SMRR%*K<`@vPGY39Xh# zMkC0|fDJJm617JjD#vZa;nB$>XF(oi=*nrBf%l-8=IEBYaT6fE4}itYGk_ukiodgS zpw5G1`3I17uSl!QKg8dkMcr4N1}NBr0@M{7EXo``?kQ0w1ga4Es3N32%AOb5j6dfZQ1jpW=S%t;xAQm4IOoRKF z1~oWgO1o|p2WjZ!V;bQPr?$Ea+I({rx0oLa06k9&WE=M@&aK^6?vJ> z!s#4J*I7qiB&6t+;m0yk^jmilwj9TQBFw07&C8?SkeRT9N`!`M!}@`Z-xKR_%o@i4 z$3$SK;|lZsJJNN%qZDTBgt{a4x1bbk(UW53M~%u1Nll8CfOfDl>tpLMhNJZ&B9*cB zQU0hX-~8Qj#~T1T#t2aUm?+=*-EzlfIO1MG4d_qsq#QLo??m0P1#lcG9b;S!M@q;4 zHN*1>^ziNOCmbmP!!a}KTY$&m`tb|z4TZ4d9rQJd0nc?eWJ4yy9^@Vo_$kJ_q7 z9VJH)jT|v31!9iHm3tI*SgQYL_NjpFKVf%Zb7042_#gh2BdZ`_%($k$i(%qh3=;yw z|GhIxOzis@3Y?A@@9U6;z;ozR)coJ#_dU?IqQ(FFpb1a}9gYcr?_&7>7ARui-v>oZ z{=4=&OeBH3@E?IEuW_s_kPb*{j6dOfgv-&PBtcK`R(=nfSI~HjKfmSqqnrmf(@~ew z5grvZ=D3T*gpY9WfAFm1404DkgnIwUvqxM@8BZ6gJSJX>4GWIa?=tWsj>JLvfBKUg zSJwYu{v^OgQ$L=LeJMl(gBkxlBgU2@zoSEx5>4p9!r(5GhmIE+WBaWQep zPihqH*C;!h!qZchuikgQuX*{(h4Yuc#47sw@@Qw@qQwI%hZ1u%-Nm0CT)YI6N}1)= zr%qKVwPG$S=(3VlX{i^iFW32i=~ z@2r*QG_RgZ#qlettIfB3(Feq<=%T?znjJ5nbCA@QL~k2WG~Gtog<2c2hp8oLwql5S zE3%U!Wr$Qtq)4xNH?ZvZ z&zM?HO1553i|jTZ)-;c*jChJyCfbhWoY<`xOZAGOWs92E6wul<9u^MGkI=MK0?B4N zd;TJT)V!*YVp=>!{8XwROf8{UN?SsO=N3?&zJz=cqT5MsCJzeqOsz)-Q%0L_)#9On z<|T`(C^=vPgc7raV#)X zd3GroD;6)=PV7f`t@SU;9x5Pvz>1g9ad?~cE`_vrsb=-^cg3har1E6yGM2L@LiMTS zaS)qaDx^Gg=`SQ+M1V#Mval5@S!6M1zyK91^=<|JOF#ck3C(rw+02gTFh zr9d`Uo4DfnAx*CvSS9?HVkMguS&+p zarH)G1*yv@+W?wBShi>-RSqutjDu=Sg;i+!I+|pH){mF!jMj3hwBj}7`8&~1+;TCM z>VGF*&!YC!2hMM)T?w%W|n8S;;KjXbrMz-5!w|wDeq7lAO!xbhDRb>%X8nJ=x1r zMj~EJfs?plq%gazUY0a048VU9r=Mm9V0=pThW#l`HqvdrGl*@Yt^p$*|AQPcZlIcU zdNDO>=~-x}p@W8Gs!moX$|P4a-oR-K6{R;ay3gf09|xxiExv-4=xfP@bj#wbk%EUg zNUD~i=JiynR1d_9- z$n0S*p=cGaHmp^=K}#7JXWUIyP38hQcf|s^+Dw!Zze{Q`6L(1wi%XSuYdggjpWRM8 zDl6luP#aG@hTewVC$+NXicC&*;# zX1tDk)2TKcpN@t3l(Fp8r!1NdaxOj0{oA-{+u(MAPRhsmeZ0lCeVmjq&rUC5QGF2$ z<`^Qeov13Ec!1Q8B&jN`Jw$;IB{Qvq8_~8f@i0}UjeLsg50eL}hp7yI!Htw_-UQTc z0^cQXBL5<0rc;?FMJV9sv6gh|Ch~ed;o}UwwO(z}&5fa)N~?Dzm+zu_JHDKJrDE_g zYBbaHgDEYM8t;)@6izHv6U~DwCK0bAy6>vP(O)I7DM89#&v4U6G0{5uV)zy`@(~|~?UCflzh<{0y3F9}EST%pBj+8iM zr^=`(IgjWnxuf6gGS4IbwGev6q#M@6Yl)pt%1@b{NXOB3I;&4u|6r^&z#B1sb^;GXnqCD$d^3N1Qc`6%m7i=c+a9Ex}Iq4Zhzm$D{ zW9;sLas~tK7o?|!sg9&^lnr%7y%&tCYxk1;yy9JlB*bZRqxnNBFn&mtIH1|ZUelO=I zht&?r3yA2-`Mjl?|Gq9r;csx}f176n>|)NCZ~VO53(5PVs_yIBZg zNWPn)Hs+<>jdq%L7asKmENZp0VASsPx((ehuBK?>Y>8JHW|VkSmjBm8e`5-Es0*bQ z!^B-aTdFjYyGeahrQr3Hm%5(R%OnP=ay^0b)RnO>#E)X(sG*oS`U zWMXr&+WSonn1;<+O1){!f|9pT)JZKsow>4nGKEtviX@{RHeO;iq|Wt9>@c(YP5W%< zhKX5TPfb#L2it@Tdq#RZ$YYwPxvwPHplQ$Y>Qwym zeDzt*`58GSR%d|ytpIaH24kler~8xEH4vfCa-}7ec$RxuSFxDrtHtg8N#rs%fI2A+ z6E&PVChG9*Ow`%V>QcyL^+jT$&vJ=<8maG36+;ov!K14-m41h~i@a^D#S(oNSQU&P z%&AYIV}1n{CZFZdqA|<%%pp~A^_zT!C4se+l z=hj=vn?S7xFk#C+fXVF4#bo&7P9EdCa_g-0EEr$8=s;?*by4NKTnL~F+gTuV`_tSO z+dv2W=ehN^c{bF0RI0J9cPQJ=OxG4Y*VA6QyiIz7B51?v^TeVa;1%ga1Uw|h z^i+0>okk4~MPVZG13Wmact7WjM(gszDqWvn#=p!i(to0OpYarG?*`dTOj%5UwI#fO z*xy;8sfdlwlG@3K#HbenPan{s6!?||=+CO}2ibMDaVfRv#&pTW3Uk{AZ3F6QPA&rt zOqUq_IR{~8o+93oPEMB;Y+=(S4}T>`EO2WklkxdE^=S(vkVcJmEs;14RqiX2P9-Qx z)I*+`5`U+vc(c~)nf83mZb9lN3vg%v$f4Rc$u|Sl9Y1Fv(J!R)1^o%B30|=<=p#nkS&ts zGRkTZHVE|J7OC1%5MdW@5(*+Xg2mN^~OA|Yueb(8MWFZSBqx1NnZB0&xI;B=5}LV zSS#>gpH#<7GQT4`t?3DDkmo3PcC&r5*cf$ZW5g&Xpy_dntBbhByxCIr;61Lirls4V zivRJxxCUap*|S%AoZL&Db%5TVK+d)VtOx8v$gX>pb2y+^Ph#%nqdQk zIu*}u_Hijd;M3G1ZGWg;Ge!T9pbiLirs!Sw*qULrOY8&>b6{YXhS~?y27q9&?$WV<@~7Zq-cdV@O0X!6aVc1*kGWcqxoQBbW2vpiWW)2X5cIgTbb_>vIwc^eGJD77goC8W5-mr?n*dmLDK5sKCll0sB%+AAl(A zi}?4ZkEx3FXK4w2m72Af)4f~@=NB700v=Z(bnn@etAAaawN8p96UC&=g3|YPWyF|C zajmt3al_yO|%L1w4l)THx%Clv9OihM#*RD-%Jjh0?&=}zvQg><&`T|u3j;?a{2Pgdl*TzB~c@n3%#_G z)VrBGCw&);@fYAAG17OD;(np7#?ZIR7*JD__7u$M5$4lfP#?acU)rs{!No(c>@OHe zE0oSLo~`C~+Vxy@7NymCQi8a_2Fu(6|HIjKBscY}ofFlbwaeqC@vNQFEd4>7KWk6X z6B=A)eejeS_Oo_YRJ+C|>QvNx9*R0HG4nevv9vAxT#idDjgXV~ORD$Bb|7kqi}_p!+#e~|Nx({$g8L|wx0 z`&@HT@2;Xt$=$j?0=4yg zs&CSK{yeLY>WsGAe0g?+_)ODX3Hwr7JD1C_0twHrO zSjySNKVlL4bk?G`?h6pX6Z#|tr}v}#tqG^Z3Z+3y z%;MfFr4r-s0q&OaHTaW!u2O4Uy;Lj}TPs}hV^NDzfU7eYY?Z_e z)?oGyL1eB)%YAZON1|Cb)^a{O1f}~ysYTZj6OnD~X40n-45y9-bB#K98(xF~^R*f^ zcX6r8(0_?tR683kg|kUL4W1qSG)(3+lKI2D&?w-()oy-3hFFiL8^_5tR`O9-gJy1{ zNMbH|Zz__XbnywUQhP3lVy=tkLW7zMIX1yltEE@MDdZVnqF?DQF|KqMRT{> zuzA(FD;9nx`LY=Qox+y+n$qb~*vvO{)}`&|BkWa)M`^-L*qk_8a7nv^O}uvtyVq=3$?OT)7i@ahb;;cQ*sORg%914u(>=QVTVO zHR|anYIM#jeZc5t5q84gYs4{w&EQ<5p{ z9$eGrz8p4ud=)jOv}T#TB^s&!4wW+^p5GL9yL=~hiBg!|2p_&a7%TEqN91Rnc_j35D z8r;JawsN6waH*TBZ5%eV*cOh`lrU2_5ZsuF4dneHdDb=*+J07%){DsN$FdtujV)K93tx} z&YEnyi1@IxzyA$F*1`tgFBMt+l6Ma;G5;3eU%B$lpG!sd1S+-n`D1!o2lu%7&!X~I zG~2OAD=kwevR<wU#`u?vt&FK%F^OHR&|2~?)0+8z&=3xel*>B2gwD#EW9R)o|4XV9OUbqB})uZ>-m~1&vV)RoIlq;CjkSk9q5;#l-79 zSPNw%yoakr10U;YbT8sf>12$1{@_s8G2UuJhom)No;{OWXD0koi`LrcrDikvygO<( zdL`+)EZB~m@2rb!snm_z()ZnYx42r4odPbr;A5Gfv%wJ$8wN z6OVeKE@yr1iJA6RQZJAgoNZevxK^r5Cbq&9FN&*MiKO$T!sM0QH<-ucp_0@$Wl~EB zycE?opDb0Uv^T=^Ir)F3mT8}cYR%N8)TA4815m$;a(t(|_;2k7!(Qc5o(Tm$Z_U=O zKEXd1HVZa0?PFf4rF$sw5sxJA^44kTDUgY&pTNy#Sl4+y+)~g<9pPMEy~fMrvQE!T z_$L+hDz5~W-DcFl{7$AyQ~PT>|8L@#arQtME~?<=UbUdpuU_iKDMjip#7(K*G{@mg z_F{PDOdB3uYeJ`Yt(UFg>3&n^3Y)^+jsT9yiCc1okrEL3l!cDqGDzW!Ul_{vY>erScm2^c?d!?du zvdfj=W$D@$ezr^9rLsCBzDq6D&P3JpySz;|dO4F+rk5xv9xI1IA1b_(v2*v1lJ z*>#fI0Uk3tD63y$UzZ|J?x0|UTx}&gpd(@HdKA`YvI`pi&60FS7F{EGu^InX@}9&v zPDjjyjvcb?cn@2pDpk;6HN@mLC+*Gc^gMIF#fr_pmEu6RF!+Ec-~Ni?2(b?}d+=S=10 zT3>O>eM2!n?o@s{vE}5wgYh3oh_Y=k+MtWCD!?HPdm=Y@5h>$Xdot1bevcAQr-vkd zOo{q_kDEP|N4t64&{nr7yHa`D*^=j3ydT!>9x7|YVYi;KZVQYTPk<}t=@!lol;!rf z<@@dei5#(Oh3R_4uALQtCt}Qc6?Uy_rzNafxjYa}iEQhLQEMMDYFDfENgGCOI<0W; zR=E1?;aMK%%ImehcLSx#MaQy#`}izL9hpVyHVIO0QANFNLHnps@oN<+{7Vw#s$an+Yg%bb}I| z)4{Tud)sWtEt^#J8$_R2DT~yoZV^NSQtB5X&qk`n?7cwq*Cq91+!3oF;VOWlk|50& zp?vKa&3Boci`WV2i{lIJxn8)AuSxJ~+gKvPEAq{gHSbt(g|rI(W3y4?Orf}yDuFt> zNNKjLKtCxsai3mSuJ@fT`_J>{n2X8#csBc4dEKCOb6fqA#s8?4e{!rk;|y5^(0qHI z3#VqngI+kWG0JDab#9#xR!Ve2h)_s=QNSL={xp5tPy$LlS3<*Y7uv5*H@!INMXCZ zA^03{mfj}x!}0j!faL6O)EEZ~GC2|De5?YXpN(KO&?G4ox~@R|3n|$ z5AX%|G2Ucpf3A|I`*2nqto2uGh^r_|{Ij`0uWlNLsZ=A&^fyUxubGwvj!KSlS3zo& zmm#67oEU7S0(%rkpjUw8uE7LSucrJ-M$4FT4KGN21o_YWuB<2EqAqM%WIfKf{5v>( z))1?)^s8XP>0NS_X4NqNZE*OkWQF)Eu=fCt*8MWZoVtoh=LFOzWgH|v2|eGs3(l0e zN>F}Gf)^qv9;*lwoL`$9c?3wvqpSnfaLfMvi)+ z48J_U^dSe41YO`M0eE^GW!*0qSR>PYgSGT4VScLf7;maq0L#S5C z+vI$hC-<|cc@Gn(xGgqLIRU77wE(nQc+i5k$&GrVk2Q#k2lm``r?{s>wZg|V*yRSIMnR$!pNDNX0116-x#M{zSl~&BJjR ze2N?g{86pG4Ts_SL7(@KT&tNwus#fg4?4%P{y```gYfeGT;i*e;A8>eRsr@_xG=Y3tQPjC z;CPDITX~KJt$YV(-MPGl{118yQaiX$4Mz2_l3$h9UxcT-_c=!LAK?mdFi%}gl*CDZ z7zx~#_kfDmup<0l6l~3!h_BjI?7D=6Niy)M`4=Bcn?jByye&>sEcc*KIB z&_1RT*Dt^-uLJ0`HJumYkKGpF^N7Ewshc^IcgXydcGq|q!G7p>*y)gDT0)ut6KVn? zo#Jq3KUD%HhC52kpX53#-in}1_h3>EZB}3OLY)8VJH{fuzb+XPK z!Y$#uFz*OEimd3tH9zYI>djoeFeH2sL2&+ZDa-H;Fe1vzmaQ_m+} zW7*dTs*XBT{g~WnBxW)1J>a7LDD^YXOWqbeF~gy1zH?|wqSoyYt>>`7t8&zS zRd&HVxwW;_I8TJgC{gQIjevQ!-LQH=PJNYS&rb@fHniDXLB(KO)~~&_hH;9B+dPHC zwSGsV{}lMUPvPoERO)&FRa?&l!ETr9)4fO>&}jjjDTaD0hf@?zxWF4S`;$*Tme?Ql zBRKj$sV5oRf*l`kvho#mJH_nTKBtJ9nYS+LI{lXTe1|Cqp7!Kn0O##X+HPu z^}459QGL1vW40{MCLf{>G)Y|7b5~w6G(KwwVnkp~;%M=)k{YQ3+N(FY#a2#=UA z!Ww#0E~wN}cf-_5^uoMS?gf!xcdfA#4!TtWUG+^F5eG9ty)&6-HBQZ}c{!}nG|$I^ z+$PHq3bzTGJx~Lh?F7y4kz6~|4Tg0U6=}E0@M$0Ksn*oq_v82ij-Lfl z1{>!C@;xKhng$$?<})%5Knf=KC-R6k5qt;{q1?t`a6Tg=1W=pHeP)DT;o}Q1NQ$;i zAQ&CM7R`R_bHSx{g$zE2O6_Zl@Z&uKSsBQlB#_N|W{hY%BUC1c*4G)4RmKB3ATe3?lnMA#A|>qVx#2H+f!bqC}n0_2t^t)d#{ zQbjeVd&u(`OxD&5ap-fQL&DN6=c>Q=^2Vh0OooChlxV6#ami=NS-Ed(^H{{ZBKe;q8kL9)Xs;EcS@anKIgTRk`1A7kr zd5EtFHqcp2eG{8p(!K;M@t`cRWp(OsvB@P-aFw&im5Src z1XpTt-p{48@_cRNGF!8L8LUYetB6^xSzSD{zja}M>%#t)h5c<8M)neD*G$ggzSAT8 zHTM{z*Kt|iA_wM2l+JWs>XEcSPh>2PDAzA`U6xiGRD`2yfOAPs@Y1fJmC4BfunM{XvCB!o;v)29H?lzEdN+?znSH$f7l{yQOdHVeDM zEAgv@e*!{iZ^Pbj5m%*o?%+#IIy2H@r(R%8c@_Jb18eFUoJ#7`1^Wd5CO0M%=duQI z@r=3>NxQYQ&i~p{8L>-Gx8UeTd9$)9X_O-xHeDEm)+`6RE$oMKn ziBWyhdUvvPMzeG=l5pDlu4s-Y?H|CKyi}eVDoMV523G_nbS3&t#8fK}HhY$l=aD6> zQS&c@gY$39cYxS?+%*YG+;}QT{UVw*o@y;vj&-TjA1$`9Ud?Beb$F8-K3`SBE8$Ua zjS~EQ!S{%M9&K(@stFeb5y2Y*S$~23r%V z4XX_{SS)y=NasWiq@$*|B*i6#OTGm=t>31?s4cS6e_DuYe_B{xX6)4p%p11JcW$dU z#||cwD9DN!OpB$=@tx5*UsAsMfd*yF?m~MUyF(p7WMW|<4vv`0qRCESHFm=2(>hVX z6e(S#P=K?3kxGda3JN1QhvG}PC@+fIzhA^uQJkJ(1kh(WDS7(y6V)?sP@~B!3|^f~ z)f%t?qt+FMm!(7qK09lr8#A$;()1F7KLY?|iltwSchYWf@D&EG+7(7#wsG$!^$aGv zUf%A#1tImzC@1l?Kk%TR*HxAn_xstT0vz%~zu7m>mqH-*tuyla>r4iEx|4gqSWsog zkCCLhf%*aS(I7n+Rv!&YY@$!C*zU&R`F5|0ZBr=Qu0yls>DQ_E&n4Md?7w$ziP5ta zZuDQu?Cp?JK)Kdsj0(uDZ;!xJ=W2n1UVw$yBk=6_@&|uvNTrOAl!);9bo_6!zdXMx zfsX|W4FvzbGr?Vlz=IBPPTCmG)e8`VOM#a{d5B;yG@%dfgRX~zCqkTgCCnJ}N5nTR zbRP@*=%elGvCw5LS4qCsX|LlRZBtK7Jwstf1M3=H#ZXWTlCpEeRW|FZKO9S!49A2@#ClXF6-sNwCjj z{d|#*h9#*&DW<_sTbOuP%1uA8giWCK0Zo6npR?P8aDsU1S&324U?(=f+QjLs_Y;nT zsA9^xNyO_{k^c;Ia>o*Oe3o$H|+YDC4S3SkCC zbwpLqCSGWNHKbmHd-{i6?rSMHA&e_;3oDPcBRn0t?hV8~U86##SEr0?h0R=rWi#*V z@?0xE!Ke@c)V?^tNFjbY84L3~Jr+iF?urYm@yDdNnw$Xlbl6ptYGz70?Ac24LrmI% z;9~6>iT>yWn2&IIJugkXoG1SUn$F94EMJ4i{@4^OR>@N&Wxbpy?QrFZ^V>U=()6W0 z(jQ&L+8b_mf1T?9HKp4m8DH1@C@I(2@t^qVCnZ_87}9j`hc#uQt0j@Vc^d+U%`chM zZ0Wad^Ol3ZZ`;Ow`?4D>J%_8W>|jz3my4iXCfhA_Ig@hj z$!ubQIB;ps@ql(4cdGlyTb8~xDeWT_2V5~bu?sA|3!>E4c9H*VChg46wpU2?qM*h$ z#_v>jk%I6%#L}c&uMSAhCTn#>kG5!S#}-hIeHNE4AYpltIj8B;CgIAz9&53qEc$tlgZbPaZxQOtm_!Yf5O=7$N2xy!)}d=PZ$b& zhfW0H_U>@6K9QzM61Jh$C(7OBb(+@0+0rrzI`q<$B+vLAo|B<9oOzOmzg?{Sj`0KA zncos|ZvQA$&pt_!?%ytT5n?$%B2~wuTFCcpSANUczU{7fVM7|nj`?63uI*Iv8Cw-_ zxrIH+|L6;r_*lfq1bD~o_;cPuJvShiTL?K&b6sMihgog*pU-miQ_oj7$~>kgdU$iX zcMeHQs!R2sbADRAbm5c=6J8Dey6XOXM|e&>#e3VHVA5XZRd*I7%R-r`Zk!B7Q$R4+ znn$YNrLa$S@Yh5j(FPH^zkytZJH>gV^phUezawy|;OI+9eNU0ugq_l*I2XK>*n?TJ zDA1PfRPn?g>1o$BeJLSg1($z%eY;?9>>^fu%&1@VV=wrDsBm81`QSj|rNt-MK3 zH*w!PJot;KYk3<2zL&Rg3QC@01R1pc#*34b)Nvl3%nAO+%iqmXPk@)n)K6}e>90&V z0S7qi8Fb)7+dNPu*OGq@d68*6fOw*hxq4_DVy3*XX7W-G*Ja(ybs~<4 zj8U&&d1j~j%{CbjB0T#diP))OSx%?;i%^MzJg6ApG}*Xq`C z%37#pTQfXa%Un6yi(&ulUynEX?5|m_jZ=C=QU57RT9B)1_@ZM$GADJK#FsI4MF<~s z`I~%fQ;7Z7kc;Dl$Y}84gvhM-dD!t@aoS3 z*@tuM3@hPbt!~&$>Ldhece>e6=eo`&S}UuaURRB2yn~f`^9Hx@<&E=tYR%+$^1e4W zZ^7+%!)N8OeNZGtJa5X!+G|<{Q)|2mtEpqI?JfmJKlb|w(b(<@=aeoy9U($D&UMZ8 zv&%$-;B3G0&zs_wwp8IfSDxiB(`Wf5LvGWp-VP>x>E%!0q{!=2`y_lt^_Ud3=ShLw z^gM+9&68+{Dqm5c&corL5w5fJIgH+k$oqSJ^CVUoVSn20eVX`9IniWX3i3O1s*(sv zD>!TK9B6CmAz0k0#Bb*yA>k9if;rx6@%a!WIe&}CQ(6_d?<0OCD@;9xlgChD@-dv9 zIWxrbBas%%e2mMnl=by-u4Rl@Nm3D*rJUnnvYZD?Q_o(|VD#Nz#7+)NClsnKgq&}c z3auN+Gcw2L!dF!in>EL^T57TMeg)yzM!(|Wo@|5~=NbcZf~}nAWY=3J0*zBnxh2YX zhf$twy>YB(1zd~i|2kG(fuY-p-yJI!YDQS?S6nr={tnKvwUdt#DR|wGMxmIa|??%r0!>r*Hs0%!1r>-8vLN(Y{{|(-4B#AtsNO%kExt_S)T3wiv z_-9F((R#A9)#Hvsw7sDOv+a8(dEZc=;1rSi2JAs`pyHe4=W9L68%imv$XUVKMDL&Q z^;x1MhiP01AVNypi16#{v+Y4UaWRuNP9~7=Mu{%XhT>7s7KNt|6~x6$--H!`$e$+$ zH%jb{FuQG)8|N=5Zb@4kB~NYI{?{t?lT~mSrr+vBzQli3%>LQw8YKSvVthrR@Lv>5 z?`49nixN0q+k^nsodpV1RHOHX`~_1_tM5-=iO_FZknWX|^pgS{R%}MdZvOH7mmRJ! zz7)vw&c4Ba6M5b|JI@ANzry)uc(;amqt>>ISBr1Z;C#E4yQIr6wt$N4%{hQz~;!AFio6p(r%V&4(Y{=o$QPN+XSNlx+- z?KU@m=vXL_ycnlYRxy|1K`r6XK@ky*pou-f_CY&Ug4p{hLBveMN@cw=?7P7EH!7F3 zF%7wEA5{0-|Yj|X;u02)xG%s_d*%2F0a%5wvmEJSas3?s!TIQIq*U(W`T3IHwPO{Q6k zfV)~aV^edsj%FD>>dnN=8uw|nz~^}Kt&P@csXJ0=LZWqf{c{9@(o-EC&F_XAyCxtncc zf%81P*3AcrPGZh+s&Gb$VBuyaZHwb;ovk{{HpefNf4dt8s?tNdv(3FWK2m}rar8u0 zG4rE1N5#h1hfTeYc!x`Tm?7mabT| zhMHHL)4Xg&|4M2e!fy*S_w_AYy=Z>ls?CUr5zE#Ut{s2Ez zurx_qoL@1RzhcOkh)*vlk1wNxf!SJe>~{woS3~Bf2jFeMuMaS)?eCvSYMgRbW`4S$ znX=ml7cak*3Qodp{%$Igi&-?GQMPXl!)HZ(!ksaWWvybq#Y}A=m%IyG^Lcc!a|Dgw zG#DcH6nwx>URMuOVhU-;Aq1$sW zsWs$_&cBXwyniOV!5wI1l`H1AaL9zR{s$N;E5YBgApCuMMSqHls=@tYF#Nw3EncvC zNnbyHOJQ*@1;SJ`KbvSa4bES_e97Sa0Y%z@uPBFB4xKx&_#L@i{i$3e=C1mb!|99q zoZn!eKgoIMHJCNZ)RQTo-XweF3mGQl4h~7Gt{gsm@!_2R`O6Tru#zW!t5yA)UNbE%dz9%Z*!H|M0 zfv$cIq>^=Ugy!}6buvZSAK7NAE)&)9L0JVI>L$d3BYz4`@e$>R{LkS+Da2P2QeNR2 z*tb+(A|)tZE{gt$q9TL~NqI%xR2dWPn2f>-QTQMVi=Dz^6xNBXcTpybTKNik4k9A@XN9b~;cuAe%mU&!bW((xI#8#78tP<+o?zNKTlDgS2)UQC@UddNnZamzE2M-?F+;k4%H<}K|3DMJx4k~bHuf1m7y1Kx{xRB@Y#p~)k_{7$eN9CR^ zdE~Vz00Lg;dY$-WO37QnrkNIgK4 zvGD+)Rn#(*4p4gw9eaS}lh%ic2B@QM-M9gSDGbm_zYB_t&S)D-^S2F0B^D6_e1S+89tGhK9zhP0-Q9DnIsjOBo_qgXtkFTLth4w@}|PsC~>P@`tlF(G2Vpg|TU@xO^J( zO=9Y8)OMKR7e@RTGN^uY8oiFY6Lmv((u_LPt;^*;oB-~jURus>o~ofQ$i-0G9+G?H zaKR+vHopDEiJ+8I7^0jaBpG#xp91qx&cE>Yjfb?U7BX{M&fLIR7?u+u;W`fAvWgvby-0FyHn8RbZbjLivT+=+~JNFbwzj=@4fcPS51 z&B4hD@}N>V?l~P85*AT3IxrETGlYOSYS@D$SgoiFH4dPgok)o1PCV}s-6DY|>46Tk z%@I?Y+L6hb*Di9_A*Z7~)9us=$QVFI0txY+j`7HtCo+%_g9{y#kmxq4Au+i_YB)F% zCC_!?a%U$l>pE~5XvbyVgb+1O9Ur11K*gRUP*lTa3qY2q2qo)Gcz(9>&~YF6!AnI= zD1EM0v@OMDPZ6dm@R*0SES`!+2k`?ZRD3{G$VOrwaM>J~Du;6KWJSJmj1BA6P!1|h zA8@0lvt-30u}4Amb*SFaHjm>w4Kb6N1k!*sebC12wGaYh04E}m#B|qLnC?#TA|ymc zD20p!=5T_~oyi%%H#824^NH z-g@=}-PLb28bDP)0W=<600EF7D4__FB4s&Y36d z7x|KfHrzz?y@Ns}Jg(fpRcknk7Htd)1WUc%58v+=JZMA0cUpGgQ^?{?v1JzC&BSDw z(+WqJz~&>kpp8MEj^IT_KXVsji*DT~JK16)52| zR}NF>Ahp9(H^UM}n1p3pffN=P9;AaX)%)SIUihpVUaweyh6w$~*e&Qj8bm^bp#h>- z%_G=N{A0N7g^=t6w7bZJplybz3d;+G;{bIXASg;Ty<3QC);>xjGe-z-^jDEsK$^g2 z8f7jIv&IhznMGT zkbh}D30IzQSry_YHHsl%-(mE{_9WeR2{I9-G>!0p49bWG)lOac z%W=aKG_ukiL0BSZ-~YHmd(dyH=+AMjBMVn1tHXVb>IyK9_j;1z9g_d?jpE%_Aka09 zQb2aUbkZeyBT2Ov=v#BvK7Cwq>Cw|40c*fKvcH?8Sm$%&&wJ0&AAVm5D^CMarG9AB z;&=y5s<i1C9 zHhay!zeC6AcH z?@=!)B%dXhDhaA}#2zi~i`)f~)jE>&+`nm+zrAlTLu*5e&?6VEs9shTSVul=ym(Eg zYCEQ=FOGX?PqnRxG2my7meq)IW0Hdu;d(6+Q4LxaV-ZWQUq?I-W(cKgn!tLrtOybs zi7s{sdq#M`4f>}(TX6!x;{`rsi@1+>H!;h+*=Gi28F7qzX<(4{?Hgsm;N^7ZndOw% zqx3gjD)dZRs$)|(D(NdVdB5N2xErj%!r+~?)3 zA6VjIt*!KUMTwe(db@my_HXw2@mQPaEH?+=7fjJALIr2=%D(LLjA9d0CRGyfwn3F* z`>z=rilseG1Z-D2@@pLD3xHRpBm5cH#2zDv3K~`98v}N4x-AGaWbSnUZAXythJZ1% z(rr;V&no*j2UIzI#S%n^MLd=Tm`{7pnFsK5Jk=H@o62AKxG5ONuRKL~nM@k<9D>-s z;fZG)Qgj=WfsPkU1MK*f57MT;PuZ>z?@^}QBlfb6DPSWcVF}t-exZK%P@wPX7Nr6v z{M?5G@&Rx=?8&7{lDbT^NNfC2<9q@!*d$_<4e94|m=T(u)!vQ#ypW>5KDxCHAlmsT zrKB#yzO*<{*EvHVm#24pmcsOEErZ$uVPCa-(UI1EB0@fR)63$%Xi1OOb}~ed1nhSK zP4#EQ4CF%UiSHdGA-sy>2K|>OuqpP_2{a2Tf%D*jO-ahkW7&IBrJaUb3lNjkd5UQS zzS9(zIRaQy7a$wkA(0;aM1?Hn`Lm?#K&7y~M64H1I6$-#jrRCEu?(XzQ+x+d#$Ya> z#X=h+1FvNa>N8^PnX!FxT)J25j6~T0%sZ7Y7ym3A_#=rZI#%xF!+%Ha-gIYdOaPn@ z$cRVxS!Um$$F!YFksOPD2E&ufkb^1dO#X%-b;Y>G9@ln8i*(Myx-1x!gL?5yGAiIN z4wptoJgV}}XTd152Wsu{M50G0ibZ+^^YJ1`Vvmw_~nVev7rXUMRSf{>DIRXiATT2xoE_0?-U6K=6BSS8Tp4Qfxq(Zv;@C+303ljO#Yj z_K00D=odfrAJ@BBY@H8K?b#C=Eyifmt}E4Fz4L0Qo20PhNMP^{Zi{-Zb zEh(pWqsxW}_(;7zj5b8T>P4!xRaG_V4vlvjj-c(j?66F-Enue0h5>qknwU+iRSBSY zLBzaC(SgLA*kMr=eSWWeNhQ@mILHC3EAoJS`0F~!m&(vyP`P^f99!CGlmp?Eu@k|+ zeE50`535wQu^4!H$};JlYW1>#p+@MKC>hbimkq-r8uFYHaAv_Mi_7Wo9;zspdsKcM z_(3wlHW{^uO_`caZ>wHb%0sHxtAO9VmPuq$t;S5MSC!r^AdS>568dq;6Lvsk%9k6} zJ~gY=fSOa0fQ$xe&NTv>nx3)%LF%Ol)f_5sCs0?9Dh+1PoyE@7ltX4`x^7c$+7XQD zx=HxjiA~E5YS^TG+7?QRElev&?pH5O)AW!QjkfVE#!X-y6vkp6A)B3Q^J>F@8l)$T zVK$CVO-=hkZVL3gCsw_iMs)JK1A(k)V_4P5taYTnjT}cbh>r(+wbnKQC3V$QrlfsC z*ebNkqtZ|XHh5HNm&+k%gT9wLVh~Fk4(bro6-%tVDR>aQU3HbW8~sRX&xOX$h2&pE zni4^jdXal}us!7wE2;s>-%%BTXw=&2Uw`s8iPYM}zLrRK;rMRQ{m)G8(>rnAfwcXA z0d#?Z)h0mOzV5M^zG6w`dfcU%9|+b+JqQA=(HB7j@cdh7+dwKz8LZ0NeOVYv7wa7v z|Ag&d^^TfDPoKXu{a-n^V>_Qo0Nu{08l3fvwJC>s32oY@=3;ogEQc6A zME}hdT%W;?EO2(sr7*uBQx^HDFh7q#QOM7Q`B^#Ccr=?~9-5G4oQ}$L45(}!x3ul< z$f4Hs%&Q|NT|H}JZ0`QUA#lWu~ z{<0v3PfvR$JEnM#jm`}zjyF~g?jBmQi2JN$ z`fL<>fzmNM?6=F#U>uI1ovSM0UzevA04(H7C);!LbKu)v2mL$-;6yXlnzKz4C8nUq zOJCC{+XQ9o$B)+Qfti-OSmAiOesmp3*QCRZhUTg0+w=_DSH5=Eq2hFxR%$JPs`jcz zGgHW{EG~k6UrDlZyH;B?5H6z6%xg(NZgB-yhq~Z6XsuQ|WYGHB+7aAdLpu&1UIqA1 ziPn%(e?OE6P~by9NM>8zA4(_p_x91+!ny%6oNGA$;K*1QSRXTo$Y zOsA(K2C<%?AU{9906JTno;MD-@_JvXy6@0NV}35_Dy`B~j|1Y+>X{xdHC?4Ni}M`L z^F5wlaFz5neCzikl0Aay6b%p~Cb*g~5F;S4Lz&rZtvS=wxZ+5O0ec*?I5#zCisXt} z&F7`v9y@$B$z4(C@x!$_=w-=IO*#MMiijLDMg_qY3zpB`0diaghSXFqRS*a4l-8DW zfcmRmRuhMjtTJFno{=%Qi_c$DH%Rso3unkupY~ITb%rKH)QHWNYqiLL1S8t$Qa{90 z1#S^@sRTTPk-qplSocDGAd<-&Lc`>(-GoOm>a#PvUT+N8NnWef4Lbj|BuSTQuc|fr zzKt*-cJeOb9eJ3}N1SAQn0gT`V4)+`_WhW)H%t|4LCi|E6{#gv_BDqhTG|F7dg1-{ zNY1xLL@iyB%V>a=tVF;WB(?NW?LvQqdnK_ya=+0AUGqk)a+}wECV>?H`ZsUWJvW}u zPGDz)Y4h-RFoEm$|wd5 z!nc$b9B@6-hbsbJI#L5IUaWQ00ERg}q^7F6R6mA9d$&*dqn^Z2*Qy(y3bT%cwyw?8 zfUvp4QZpb6V7Qp0Ew^fDoc47O;;!hCv0XNJs%3Daa-+|Vi{Q7uubOVtx7_ZsjdIc|YGm(CTi; zXQpo8xM}fI#m>Tl4;bVtog+sqPF~7v&)1(TRu%!Vi?z)(Mgc434y{&6Y4jpQNxl>z z+$EbDTbcnaF*Pt$Qlc(14*y84dS>= zW^QUzG}t?Iv@mRp#qQb?DP@ytg8`_BJt7CFf2qENs<9F`)3oFe5!?l^9o#`+P>Cu^`G?@;8m(JqULVcVUOl+k_**8rAeILhbaM74US+sA? zLHqFx=MwsT(7{s0qtk6VvTuphqcL=i^&vj;<*E8q7c;=XvgW63j_|ph1NJ%QDz?0v zREH$_{LGR@Q$C;DLM+YcBR4Ifu#E~V;mEQ2F(}k5F?-CRGg~RbDg3AAHijYWOYue^ zqM2|rIqFdwPqIf*a5F_XmC(ksTN)k3@TeYfgQtJ=|K_*y5;yVIGKJ>V>$DYbA&0PzH@}d$cas@t!W* zBI)u#ly3DAU6M?mM5W7W9lc2J4oB1>u!J~@H7s~aLG`6b7a)rf8QpcG0LN$`=C2RA z47%N{H@kHCED%AhrWuj^RgGtw01b=hn*lwpa;!m=c>MI8xc7I#$jJ_@T@*{d5kwoV z6hsrlsICm7V7?JxQpLs8Fd8p4htY|-VHC(FDh{K-La7Cv%RX#+8qi2QNEXatl)!&S zY6Gl~Xnk&OCTN-g!$lU;oa>L`?X{ICH zu=q4kkC@T}RzUQ!Sza;WGVXJg%;*eHdz=Ccg~9Ix2&sLJA!6X%=LVF&+9TPD#$8E8 zjF(qkStMnO^FS7Qe00jANx*+rbePf?B#&BLG!eiGNomWB7Bp4wJVIIQvQo&eN2v#I&`q5vr-_L`Gqi$FN()rI;3X0az` zaXJGGkJEIxjv0Wm$J1|lRNC}N=Y4VH$V`0(lg!aHoX=t*&-7&~AkU$lvW4hSN?+>| zaMU=;D7KQnX3CPO6qXzX4W8zxc4U~uD0vj`OZui3Q}fq)QU(hfBxTg}`1B_DVQ4?b z8&*ymenL!kC0Uoc63-tSs7?WK%FhPrhYAH8G?5-pOC>#t{hy+BJ3`$1)Gc zZxWC4(-=4ak%->90+ zSZe$q5uG)cy4eedROt!S7fNYjI>sVis1Otu>1G-fYKDW8pXHlfK{ZnPbub#E2&I#I z6`C%J6gK@BbvX!6gnLrMh#FP0z`R4jBy`Pb_b;gywHMxo&K4{<5g?iNzKMNpX6qu~ zfknpggnL2ON5NdcZR%3SMYW&*EQ3-=TGi#hZQ9K6)VSIcL`?pw8go(#LPt|0fkVm zNTt%=FnR$>YoSy6r5R>w(7;OeqF_;-U%KmVi>Q%smJEseCRi<2skVQbGJuNd(;o@U zyFq8$l8Lsa>gkznI}A+^8HX?y~)$b9#xNDImd({BNIV+1ubycI25V? z|MU-ht-O;TE>y;Nmt>E%-V}VsR(YoY$}?b91FK*Ac3(P?&(lNN)cCHeOeTA*aas1+ z-Fv$D@+IY76MGlIg0UV;?{--h$`l6F1IS^rcCp8rKxHf?_=j|yd8yT7y53`k@H;+j(|WP%q9JAJg|BsS;B}5m5l^$&0;M{(S&gw zNkMOE!m(7#X8N0&5RtlJ_ofIkD6&bHtt`lb%b=~P>5U;*apw*lH=+y#KkfsF+Em)_ z=}e0s85AXP~G_8}#h+4I@XYjZaDw@)Hi0|^phl$F|mtF-? z;pOi!j~6tfdfQK2pl~b^{Pwo!rRGCY1?>5M+Y3?jb0Y8q- zZHgTSt}qPMK3eu#HX3|1ksPuZ8vYYW@8~-+4?A(3CH*1qXe6&XYh)zu*^!BG9q*-? z6+Z=n`;ZmCBx*Z~N)KzK?RwIQahcxLBf>iBio6FJH3Gl26K)>T1r>3m+fOFMJ^>F+ z+o$?8#``3|Q)1sQTJas?fmwBzD1N5RY2T_*Ps;-yE^0fXN{{%o^g>5`7UUA_xrHwm zu*EO#NWJw6sRo?_W)iz2=b=XbxwiQIV?Vv&e>_RMJs4cNLPG<+h}%@wI=%p!w$#Pa zr}DSvi91G+$>WMU){LveY%_r*uemkm)e31i!9lXh z8V9Gmc5oVn&jzHfv7X6rnsg6NhIMeNXa}cS(89AqW7tZwVRIC!o$zh2B@J*F-K6=DN*Ou^48M zGyp|CjSK^wyF0Y#HA5E*I43~40QU>wr=JM#LGwe+N|@Bbq=9658p#PU)W~h;%cm$4iM@ho1EKdUKm;Ff2ijLRhLid&A&-$TmdyeK7I)-B-b&##O_D z2bv~D0`}-G%*E{ylc%0DvlZS(%#}b`+eHWY6T1+S+7airq`~#P2r+bTD2+#rq7IAD zSZSoo@`)~_aG`Y522WwLaD{L6rGzPz;!r!pRLy2*M&hB`bpkhv*pImmZ*!aF;-FST zIZHh?{XJhwi#^K53`Vo3M1z56x-;raIhEwpb%Q1VgqcTNy>x9LaR;0VJMn3Nxgr1b z#&ADLU+WT_h_b-75l_rK2liET8G{Gk^|M3p+xy07!Sa+xYtJbA^oXJ4_v}r~b|^H~ zxiX;l?RHpVSQ$MKLpVkz-b(o*s%Q(#@Olz|2E90@?IxDZH%geHbyvBBf$+L%5vP{;F0P$^WyVLLeh1__-qg}ITDu37{r zY$Qe!U3Kg%Pr#(8iYN*u;_b3gigZunA_4|m(PO3(8e8Pih*@g1Bbo)h3^uDkLqnb_ zL0xqX(z318uOsZ`VoXkG>=d*^5r?I(+DgOQ?+J1LPI468ag->xC!ogT%uDF1tBmB3 z2o8gThr`6ut_v*gDG5hWx~#O@RWO^xKDrzqsye2a>EIKNm*TFXkGM)apK%0m-X#r3 z7RRWgl*VxwIBGbiam?W`aV$GZ1h37z%G*_RvMaUXVHKr}t0W!eqigZ_EG8lqpARR( zRVtM2)QXbi~+ z??)%E4=|ldat)>_Pf4kcoQrx2`|LDs3Sh9aSYV|+sH3h9lvD&yG=@=OlVA4~LX!scuo5M-q^+o>>$akQ*H#u2egfC~b3ZvUqR~PAKkJ&U%q7i{ z5j^<7?IRkX2)S3n+v7<;aV}~KINcUrFT^M>qp_xvPWBTIZ)g#%pNLMR`w758jJtC< z-9Mhjlz0y!`v>_POl(jkYdEqvMomlr4g*IG$25*P943xsQ;A?vwJhZ)^|YmomvUH9 z=E2C%W8~BE)~zM5^<&7dZlp)BuU@WO3h6W@UMp z8;hV4d8jsJ84xYYJ(RVT)c1U9MdG&7Y{qfF84HsHl6U>l4Bx)M2Q2O|>a!^RT6umM z4^;<7R`ExbZgUDoRed(eAAy|u?jf|YZoZcpN^8JJkq7voZ&Jcqieux|@kO(j76Vkw3d27EGJ8V$tK7>-FCSaPKbjv9^zj%gfC z9HEtA0f!09;U|tnBHAt5034!fQixPysB07m<<+%V3~K5V`Is5bh@YsGVn8T(`p*aj z9J~v48W!wN#_}N}fF?bFK`w3NV}_sjF;Xeve?(1=8IpwmG=&kGL%BIU4+NtRTqT#k z=1V&Is1_AqIUK@Q@5leM5GM;=STqL-)tVraZRC~wAR%M)Q`~t^a*()RFANg5kMtRe zmvWKr`S3OU-#W@jVvs=ozoATyJ50vozjG9ExS;x(TaUgvRsc3H4ib{=K7wL#6n_%u zM5_=7jY4zuA393B1^*1?o^h1Lvk!&~7jOLcCxVVA3sED_TTJdt;Jwz_AW;$wYRLkc z3M#|@G(=~5=7)f$J44F+rL=x7NtrxC5EMqLTJ!{;x9*OP2PKwWtY-nDs%rN+cO2i_AVYguuud}#3KEi?2;boNB8(>p zkcES@OuKV(m+k}r>2M=b6V_?C8_w4w6x>mPFU6_CIr|h1KA3-G@WI7Tbii*_HdOo6 zDn68HoNjF=tUGzbi4rdtuk1uQ{>46BSIIj~-hG=0aV)uaXmL9ZQyIZQNE`KIKmU3Q z&S*vGi0w@J8*XemfL1LZ@24%ue<{1Nb&kA!LnE_xIeBzU!S}YW)p!fWZ%BbX>)?>yC(o~@Ko~7YS1=V2@s^R;JFF^T-NmV|B4oXL#(kQ7g6_k+`{*ICOXgkA?gaNu%b!!3kI9eC{V z?%fY)5Ezr%mDNr*We^Q%Ih`hN1XFrAx4-YOPzlF9THzzWOW=Ld0OiyV2G*j|<|c`* ztkukWG7njIrgzOz)w%B!%4@?+(jzE0+T-tHk^Ylv_dL0FAwDRM3^M0_od86GjB=mW zsplXEI=Wcf8OsMOmoq=OJe7m=0x9fNXC@an!v>{9lQQ*CDe5vT5^hj>Du7+DwgXa< znIUe~pMgdu0o(fnxKqbsr1!yi^Zca=Y~Zc`DjDIvN*YWd_P5y0Hp^q(?48vym;zGl zvm_7Sn>XwS7^qUkIylv|hjEo^K$L^nBe+?_o)qEDfNx4-me0)b(1#;6o8Yod`I42Y zyj%C$(DKuCOZM8Q(U)wW-3Os@e7u)s9-FRbd+Y(Nlgnv7t54wqJPQ^ST8e`21^m2n ziN>s_&z~WpZy$%TK}Y@1<6H(FWN1sis?kM`QuRrIg-Nq@092`>(O6BR*{KFDrg4DL z7@NZl4qmxb!U4`L+tR4K%e3)^f75{K^?uNr%o{^t6dy9cx)vl2EFz0^xAIqQAy)z_ z!~PjKETO}1gRPW%ndVrSK!Kep7#=5^rzV~|VBmC=EW`i5DtdfW@pw^mL|~12B|9K6 z1F(K&@;OH|u0re9RAh%Ym9a3H3=;!MWx{8(6?C?Qj!He=*kk7X$sj9k@QyGP!Q8O= zHNDSrLO&y%y+^{pg$&;ql#7#~d=t_Tax_qpgEx~t{|_H9RVHzU<$SGoUtP)e?n@6$UK8Q4UOH~YxdpAg zMVVc!E010L{Ye=8C66_~ov<+%?4&>nM9A{q^WD)}_wPYl`VT*sNH->Z~5}|WLB8z68iS?szgT8AN3XnvXBm@4JJ5h&({zoNuU9#w8XEC-v z40Vs?XEi%kQFuS5Y39cihfHHf?*DAcdn?X@XgwASqNs6kM}uKB%N=Z!GNMusRuRSw zIuTD`<64wi=eU>1VIeIi6X6nk-Ip3bQE}+q6A9erZfrFcqODWuPAb*Iqn|n1$!co% zXG(khxBz#nu3$!|Qu_lg4$svEg6Cf}fV}zh&C?(0g6mI2?M{Bo?l7ZsxTH!($E;q? z{ghyA4n%tiGTz{2M$eD!@+@h`7GjABzgqr%+yKF zb?g=@Uv0VAQBw6;BtP!6($zkL*^AZ2t^O6g)MfD$l4=QbuG~Q`ha)}y@jsDax(PcOnw^j0^KDtQ;hKsH}^R{TYsMpc^;&d)I;HPRkrBWcKzh+*<_eCx7(8xXwrKC#;^UxVDsU*f-g2rfqvOb5a z@gx-IBi#?rn2Ig5CgZ(C93$CFDEGd2r7}+6FR_58;m8|b?81legUqp+2`|bC6B@yU z2bC5480PE)f4uy>Nk9GW1ig4=0XJJ%G@mgL#1;8N$bTF88RVPDhnRE<`Gx_t< zXjwFI);n;=nqRO;aT)7=_^@dn>VEjxi&v(xmRqJp>~BTD4_=h%`L(M_2FBkao}a~& z?uS>+sfI;G2%acVTEa2!;ai=(=M;~PH&MgVA>5ns*jm{rdki`9G@)hiJ?wX^+ed#RDxJ2G^Z2LlYZM0m?xHMM%ZkzgsMwZI8Wm| zgEJMp4GW)B!>uYNPEb7|B{)>9V%#0+Vg*}u+jUQ1!)I2;v4sY1 zLKaEZhah@LnEKrwUz=)75l4Mf2G7s9A7l1Z(=dXUS7)2ED8bP^oY&^(=KZkLdG!w#pUH~c;85Nw*305T?XQj z-gQ{1Y{C*IH}_x-f<9R>IIBE z`otV|MtgP~>fn&1#c)X!Io+vDh(_f8V#k14{)M-_cxAleuzI-E!MX`+`Z5C`5i{wXRriM5IG2`7;sw^G{GfKn5v1%Gd{6MTZB8A9*9Q$f1VVs305KL2)X z9iNRH7F$8miZQNT9-6a7`S)6gpHQtP8?UKYMt`9&$;`H%)vIX_igPa z#TT!9R;bcD9r1Vv+rc4&{>Xc}R#yEF0>9*ICZ)Gc%HAAY25t-S#EZY0Aii0lJemR> z>{g{;C(mqbSG+3u>_pp`F#dLeJhoWd$`}M#9=vxsPliow@ZQlhNKY4DCC>YaSYxT; z7~~%K41_*VE47K52PRl9Rv?Sl-~fvyGr{7MtEgGhnGaMzyUz zRx=X^B-!|2dY4uz6O}H}fbrl+x?)pN18`Gvej8nZ`br!;54?2;`VW?Fem4nbvd8mZ z8xSN;;eNgiRslA$aHlZA9c(i{WYoXh+=4jT*v5aN<>8;e03yLtVb7;R#-mnk3o5qa z=77O@WeG^H&x+}Q#XTPJ89dhu+kG%x&_ou{fGLiyl=eJ6dDY`10lp*vV;I(B1tvYz zfR{!*p@3eculX!uAySVq5V$m8Gh6vSiwE%B-Odb!C;|z0IWt~P1cK!9IPum+7>Tra zz>4_+dysEsU@MhI8#bF<>O&HcBE;*zobZ{1E^KuvK47K1CmhKThO4;+C&E}DCb}Gh ziRNU{j&LpasJWZ$MpIXZ@^o2*c54&fRtFS$2@YgCTL4a+=&gJ2!`7d%3AF|dicO@g~MUSAmG|c34svRA_ z>PULaku>f>3oMBao8ns@rcP9$x5R$CX`kEDMA?RCS9Z15soD}GV^Oli&{$Hc;y=rd z#Oz-HJxW)xB@V+fTfway9x*@Jtl?F~V$9%Ua6!UQ+Y+#?EeS9Pp;f8?#Mgy$r4%2+ zrHTXCeU2$@ZRv13DCwpuS@2A<`1BS!jFJ(bht7s2;B|e|<`L?BG-7jfcxE&0ayiH) z5h0DE9G>$o!%${iIPPo>o}pyUi{kDNJg{COlax8p}=gv_J-~GjU4s#<^y7;HE*AEZePHKb%m1G)7P_766{=~_g_s~;yYu5W8_fkn#VZ3qHo(TNvp!xz9%h-wRS+zpc=nNn1XS^IN9)J z_%7Hlv24#EBEj4lFAk@&1ct8vyNcDI?s@_G6ljSP&P&tar{tvbl2+6A(NIUo>HQCe z{nf#-D9%fjJQ0BOB__E7P6DXkOU1PFl0NCY^xJ7Y5cI%)0eA|;&4a^$Hg3+#-jCgQ zrg*1&3@>p*)2#O+LZ>E;KQg28BLU(wvuSll#^rbCe^cl4!zw_fk^OeigPPL8}eEka;LL z5+5#U*MbSynIBXu`v&%$!{q@A{xii+sWjABuq2XKx^CQ_-s>JONYD*fFDJd16c!Lp zDubHW;ecWNdp?|L0LwagFZD%hliXPhu_}5bcqi|J*Nmolca-+vg99Wud~YiydoQ(; z-iLN)pNY~^viIdt>alxvC`#x0M*0m+oHk9Y(cEA$1;c<<_!KlC=77k5 zrL-2TR(3?!l7K$t?pKt|uJcmnTp&+=t@q`{>W*ap0n64}*L3eUWnJ+QIQ*LXn{hx< zUh4fO>wk%V^-)IPs_1x|ODaOx(O@w?T!o&TL546vVi`y*6MFKD0nA)l^w`MoOH%<^ zR%xw&uhAB}CwX50`6#{aGJVfspAhy*7}BQF789RVYM$7i8ymur5j*{5eUI2Uc4hWi zAs4`o$3H+uMzT}Mz93F{lF73l`O@DD*cKK@H4#K2KW3ykMI#=+A8J1lkU(87S%*h= z11a?*OiZn#Ks94^FJhCpED9Ep@!O;L-V)5Y$A84>b(_+PO_>`uEh9>0_w(GPvaDum$aJ94RH)bD|dmL5|u&ei9Dt zS9@PAN;b#F3R^&sqeB}?S>xtqMX`8p61qBscjK%-Q&$uNdl$IbiNI?g_?;VJrV?TO zC^=sli&(s+L~H>lONIsDP`;EwEfg3adP@Z!)A7j)uaBVYPxfD7+rGu)n+UKl(8 z1lE{GUKl<&n#G*XYHr~>+C!tz+@)s>&H4Hifn*&biweCX_PDlK9 z;XCyC(K%Fj%zY^R9Xh#PZm(2pRD(qNnh-oBL87bTKa5Y4NrzS{^eurIhnAO@4_j2( zd)4qom#{T?sa{#Jzofn1!>8YjhqK=qenHW`%8b|Q%K)}=h4ry(agF)-!T@C4+m5aq zucZ&U56j^F-G|YQ^wHiW7{St!-X*5NSmsjUwm!k;H}4(+a$cLAgXXzesq|Kq;7j0B zqQjN?)U>^ve%&C+SPeJ$MeWr_z0q3+80&S@$JX3v9RkWCbELzDp_$S9%I#{cYE$;C zc9h$pLL^_ceRu@;<-J!;1oU@&In+255BEqzP;m}b2OP2hUDkuGO2v3hEpp<_p!N0j zqZ%u&BNsUqF{lvf)BNeRz^|3XE(pYQJn*BwI1>2mpZDuwqTwv}-0wo$RB8^y^z88w zseiC14|{m-M0R{(Ao5gF8X~A8o-hB>FJM$kE66qiUv|K`is@S5<7P7=Bbfpls|-Zu ze`UE^HEa&h;wi%^%YD94F5d`zK^Qn|Gc!$}Z_HF?{IAF<^szVxt-?b8D-2%}nVGSU zG4D3T<0!U-Sy^6Qf$Dr_#(b^R=nKupjB`wj_+M7=DAGVT*QTeS9GR{}wAZBWv@)!t zo3KgWRjT)RXf1C}$;gBz^BKr#Fq@~h;rVv6pM}k(AR1gEmfkWV*gROR0=ls4xF?S_ zjIW->b;D)K;|%*RtJ9`PnpD&@2`!7FAJ~monVzu-|8{?^EkY?53oSv}e!6@;>3uyb z4r1k}s4J>LH9>cuM5NkBdVfN6;jmmVdZsw|iINhW198eeZ+%W0vU)gte9&rTnf6)~ zta4I&O_<7JvKfS905gi>NnQ`c@PwhgwfPQGp>-6h7-%Re6+j8IkHYL%A$;wDcSL6- zqq}!Do;_h7tyd}t#X}?H{At>Gt_bT8)Xn0%Mp7FxF$a5xYbUL{B+D6@mGRmbj+7jH zy($Bblso0Y*K@Kng59`f?evPG$Udd?o}AqW+Y7I&G`@TY0IRnK87Hnb+p-lu+g2&> z`>`oCZkZ!mT>oR=kDt68*+*CMdp>A|BJ_cH{hwg_g4Bhgw4=)~I$X8x$%}4O4l0t@ zWaw;nF5=XT8-fEh=~kK2hO}DSE<5AoHPV|fhe7vqPql3*#<|iWT|e9ZV%D%|3Zr67 z-w*~fIir6#pMo>)H~a;W<|`=}8L2-9$6>On?TYd&XO|%~d@XO70whME`-MWK`&rdn z6nnpwsd$W8OtjP~NR#E%O)WAD`JOd5%RQRiLZTR~e(h}Uiv^?mA9TaPH!}^QK+4JR zin~4(LEQ~#Yc@Ws;&UguIh%f?-;DU!FQxm`+Jr|qytHZX+tKdqD&J1oOt3$v0AqBy zw%g}*!|3zT>uyu(g{xcXLF3i~7dQv_vKI7IFiQaJm6}rX3CuurFiU+3rRh7jQ-o8o zW^>tYrf%45wzk=YkPWeYyG!t}9N)Crm}ax$mIF@|&ccdkYj{>dIep7uD)~ZjOJmF- z2v^`rxvnBwt`PhIlrRw4jm61peGVaAM{UjRR3OA@ZDCUj<$b8@{sO{`tY7Q#3E1V! zv0k{#1@T^EzqK6+ z5Wp&8NlSXdk|?~5E*CH~kXc(%C%p^`4$aE01t&|Xs6v$7HKe#D>EHBOSuxrA^;gN^ zco3c2#s3%S;E~U3s%TNTQ7hv6t;^+MG_50%^~f+fl8boL9J^Zv?rh~p8c>IX$Tw2b z7h>Fx#KG|Rk%;3f+Cj!Y1T|;Q=r8X1IYZEexr}?zw&+x4V_3DVidM(F7}Q# zxuyy8Td6M8CH~kK?f0Wn9Wtw`!2VZ?47uQ{rMFyF9P%+4Ce|e+{JAijQh%ue&po)y ze>LLe^*#HmgnePx(gPBczR!gr$-c_Hg;jh)*%w)W0EvAP{%R=q31V9=hbzptX!#LD z+B06u2*zuo!)BH=ljNb8d22{Y@3qQa@;zSxpH~T<=}t+$3O5ap@d2fGy3*{X+?8VX ze`+q_3~dPXe<_b8K+^m_p1j(tz71^Zq`AI4iQp_k=9@j19Qcu=_&%Bir!FLo!Jh#k zbMJdqNTI4|&+FUPvVeU%*@}O34f_VV&*4i}e{J+Sq8uXhmG&^jdDT58csgf0!LRJ_SfbcEFr-;&Am}gnHac>+ho1 z5M%2fW5(K%(NQtfimfMe84IGkLXqw|(-b(Ag&R~xM@=p1t@9&!62qM-1p-SVIbX%S z&_5d|b!t@Y3kh#M*%J~8ljD}3$vd=)ttLjKzMF&$-F^RqkfHN=Z(YwgTvqz8=ml^6 zMFf7G&$2JE7$g3Cd5lknS^3w_>_1r;hgH+ZQ`9CL=cLyo6WljFpArwbzu=9%HZm_N3kTU(vuc7Ej(!k z+Gp@#vc1y@i}cs=uVU`k`QNN^TuoR+tv>_XC@g$C<&i##YxaNq5hjrMec~NNA49`* z9hZ857c(Ej%=W`uM)=~N3wSYgOsui*J|f{}88_3{h>!Rza}y=cpkx7ucm^StM+%XE ziwGEZ=GR32H%pi+uS0VMO&*!2R zJ7{I=3~mdlSN^;yeoVeqlm08Hu=z&4D5AwcX6W+o`77jx)FYKEBr%>Y1zj! z83hAwzps_1{~MYXY65PE{#4U0{8eczoQr$kw{Ra33?!K6gE9WKus5l1|B87SUsFK+ z;gGgI5{_T>!fnuAi;PM*t;>Db(=REjm3$Pz;bw|NV!Kv3KJVw-0`|<9r4=5q7VC zT`pxDJpPyD_rLKk*@H}2R>Ltr|LD{2ai4hdvH7Q;dh&{496UsFEZTy%S}+-1c;>P8 zr6-<#$~dyH99_74zWw-PmyJvBId{a2E}Xw`q5asUOXn^h`s$- z`zZr~y3e;CyMQQ1VQ}XMA6}2XgZA~up1Rz=Vw`)|;?j@fYd>}VR&Z@Z*2eGR#p&q6 zK}>05;eD&iu;Hi9P0_|Vb8eBw3yb)Q@}VW{9@3Fa=!e2&8A*O+5#RJeyls6ISJw|m zXQJ$sMomyQs>i5{tsJ~q!%{BOi zx_fM8_4Z7-f*-42Jhrq7Q;W8pp(onM77wlBn_xer_Jw21=I!gzX!Jc#KeO<@hp067 zDs8SupS%_i_uc9p`E1whKqrqnOiN_{}Ip7ckdPbD+gvM_cMoU4G)iLZ?8_uHoX*%jZYw-c=LX1$yuK z3mBw@OU3YermMv7f%;+k?53izn>9QG5HjbDNvy zxn;EX!*Go_L;PvtUnc%n>_bbdD|3c<5vsPx8NYhjgf6IwvcTi%q9q!9RvYlg0U460t6FG0%3E4 zNQfaDC=dt`LIm+8BtRmWaylM}t zU4v}hN+mHM-&bRqFObIcEoW@lOAJuw1>-*y+#Vxy&;T^Uad?{XHu=@Jsd2~Vx2;ya zOQ}NfN){T9Q**I!9MnRNz~BgO=}sVa0eNXss*eQ>EMRV;dZYE%!rvC7`Yr1NGQc_J z0rg@I1k8c)R>D zyk2cJNgXV8En>j4z}`QFC&-mHm>Mr-A$1?gcaiP)#4h6PMPoB782Ca|rM`jyaf~+P zeUZbKuscvZfha6m!mszc}+JRHWz)N(&To}$H4g?fVYum(;7W3=zsvMCHC!#ZYYdZ&*yXy!E{tCm&+ z*>^Pq0?-;3)b2*&fWjJ9)N??d@GRlFUc}pZ*RXKW8at-q7v`W@6*DxCpjmC~uWPQ?wfgz&K(sZ=s6PE{2)Fc0SEl zb871rxT!CoJVrM!5NLp?%fV6>(ADi!#eyWRaIiC2cD>dFkeOBFc!!0II?fF;G!@Ni z&UaN|X?hg}3WH7&aEi-h%E%TdR&q@Zv5;9qb?TZHD{(TAw30-2q5(O*Zd)}do{Pdp zcMX!LTU|8B7~mte5U`WAYpJ^>za~Y%BER0kA|Iu^VPUG^>Ix0oRUt|hsBA2@egkM= zMim1bc@;X3IZ9lvVJ%hxkDIx`m103N#VU*xGfWj1B(cY$)~4UDZFK!)R50r6Ms-- z^SK8F%q61E!uCj?aZWe!q$JM2Gtb)D)O2Rn!7$F zrjqFMWHtR{aQn$%bF7ZdYx&j;xt3Y@TFdZZK42_Z`~ZkJKF-CH+`WhAO%uJ{qD~Pg zP>=Br({yoU9N@vydY07IGhaxz3VR8_gSjUx&|*5S^{(ZZE`Fj}#4lTdS zAF4CfY~|8})NHnHCRer9_%yZTOKW{aHCLSN5HXlDr#H8km@Z+Ofag>HjT9^T+3q8-Z*(hj zZ3AX={uXyYeUxFOQeKcHbY*bP3vxiSG3iBF+2J5fQ_Yj5Zmqax1yRH}kK8M)ru;HU zjl@!Feq(34ovkyXCQ65D{)zn8x`mO97K@r0# zFyJnwn0_g+;6aO|b}7uu9|cG! z#%1Wz+T|#jmjljH+ePuxF5;iyJaZSud{w&wIp?-I+H^I|ov&CxLnBTe0XCkP=d36g z!g)yPD0B`uSxt#MlE#3O^OFL|1MI|z0Ajqu`A#7r*rPN8O+(N119vf37Sy2UW@r&p z%Yfd_J;LgB6-01(T@N8v5IMabVmKS`1$Y^ZY3hU6)z$&?xEt$X%(+gxuIc(s2-rJE z@OnLuSdTU@Aam&NOvVg#kpT1>ex-9non8QN+#eP4-3~C_+X;wN45P~JkzkECK zTW~figt!uuleq_IllRGKtpIG?DStX&LfGsFL3)GSjsBYa{y~KYPU|J`5|{onR-{HDu@~KxPjB&rce3I!<%2?Ot<0 zFI505Pd&>i12OMR7X68WNJO{F2?o_7(=sSloP1rDJlz>8}o$PeP3bm}Zpy5Kb*U5kC z&*Y60o$N8hF_3Gqldnv47=`1UQf;BoM; zXwLyQ`8m#ARlcmMKF=G9tsh5~=Q+^2LRH3G5Bqxz?}`e>POB^p6pWiOgg(z@fXP13 z9jvF)deK)ay9WxWMKBA_DXMr;ede4z&f$BRba`>ilQ&2R($op7_6KL_GHPHHrb!|<^kd0o@GbCZeh%W7H1 z#M8vH6vs8JIbwa(NnTrm;~=S8ZTe-f!z|$p4nbia!Q$w??=k?(CBj`prVjBm6lUOoW$-Y(6@o+DQNcS(g=Ip<6t+w__$wjn19u*&WPEL? zxnzI^N;soi&E-zPDUVf%uMh+!T1<`=g8#UJ16XV&K;}My1gWzj~19M#A{UZ=_ z&IOF+!pd3!>e>Hc$>_Y})2?3fNmJR~>w?hE=7Xl*m;%hAd5o9nrgnPE9+UyWfV;5+U zZ^OfX7OXOTjNh(^B%&1r3#z^03jBAgs;*n_r{?p*5me6#V*(9g&Qk7-a6nleojH?6 z7ZCPTvr9PHpIkPaV!~{8XC$D;9GEAS*+SwE1WT%x!vuM*jD0&hBv})qHZw7z6?1Uu zak8z4xWSx35gdBN28_B=H)IhDZLM2~Z=nl!1EBBPAX}1Bx&@aYnk*zww@8@XB2wrE zz$0oK?U*!hIza~_&QRJz3# zP`8jp1zgEfR+~%jLn~Fg@q#+;?-Zw#fFN*n5J>f?<#l=<;)C9gQE%p)BF>>h0Xv9* zkLmoH5>(GeXqI(DiGSN)QgstV$SByiv-hh(1b(top+4j9R`b^VF@nwzA(OZ6t~pFq zH@XEo!C_(Jp>TyCpmRD1!Jyq^eHm_hgb+B`Y`s$iEpW}QZ_GpN194cK!@TFiy{!HY zI$+u73?~3bO;n(w8c&TDEHdCiJ3A1VJya^}W?-D7RCp=SspgIMF(O(oSimEkAgTl+ zyc9sAQOo&{a85x55pYwSgWEd!m4Tzo;`|Uqc=vyZ5DHYN!3Mv&`v?uLZMA(&5F%Vl z8HQV2m?^5DKy9F;7I1Ir337r9j3ZpYKDAyS1d-V%t^e2S<5jKi&q@OKs?Imzoq*C2 zh*s+RJPsQ`p>r#d6!G&Wgsi3uxk{2xh0yn>y12fATGh@n;I-lBgB+ezceRl{?u)7E zc6$tS_L=RRJDj$&+MORIk;@d(%c6&wOb z8V?})PN?8pW$6UqxiUv|{hKOR?a)0aomU^UL^0^Y+W&{vCoQVLgbpilMDL>-!1Vzk59*eM z*5|>IymbVVEaa_zm`IM|^+{W*oAX5ruP^^4UY~CZ>`@T4?&GfO)0uq!0`48C5bJ>0 z2N2bod_b~aOYF}cAojUtWKXxr<0T;W!SX}4Rpjm@=8+^oBo-%V+GcdZ9yYXg!`W+7 zbz8RX*fO+r^X9ro;Qei?O6p;5$)z(ee)dr5K`7%dz(Asx0OV(XA@e1SUt62{OQ_M; zFqdY7`0#J~p4sUdI%7LD`wOor$y5sI&o^+hWSeO4Qb|EBEFXTLgB|(t{6EIFFKdg> zo1vuoyqRjv>(84-)zA)_{CV?OEvLd%)(1a1dKuJDDb8X3Ga=P1PTa6>1wBjdP*l6uVi^6d3gVq$~yO{3}MFxQ> z*Y4WugIQ*PAQf~q)E=w$sin_cN%K!gi&%|i>nnR zzVDVR$QEX>k&H2Uf?CYZ^MR`Ti&C}muTmG;#(#-z1ui|SP=DoRp12H{YpluO ztbrd55`FG){QmEL7N zy@6VDxl_HEVSsx3QJ|vq8KZlB%7@UD;b?x3#m& zq!VT5Ma}6gr|*}g3mWP3cAw-H=K^N*cBw%%rd=+-4Co_zpvQF_)T;M=OpVuX+y2)c z=|We%s$S?)z5|yGYYG@kyh=AQsl%Hz=8}k*bD=`b1;|FgYyFByX|AO!^^h!m=yCOD z8w~SUR*{Fr(=tu?{^zvVw0Zs zD;IG`#C*^1x`?ymB zdllY)nlq>tuWdn>D&${w&`XNg!5Fl`D=|mk=4w-Oz6iUan!n)l~OaY z%k1_GVo(nXvuw4cB9oQIc@q0dQE8gTlp1nHVK}oj&uh@l*MSVyot?3rEnu#+gMH|? zh3E0g8i!8yMGW1o4tTmSFjT{onownUjZ43iSw5mHaWnSyFh7>ua4N2K+q2;LdE`9L z4cPNILHbqhVQ$xJJ@jqoF}VRVhXhBA#`k}uc4kgSV%%Qa1qc3)zMcmbF9|Lr6pZ2-L zE^p%(a(je$3vV?_7xD%zcRk~OvQ=pFfl!`%*h`M(QicAGo2NLex-EL~8Nq&EA*Dg} zXN3G+Vi$JtKO*NV1xgXh&8el>LX)@{^MRNE!?hINth12^#(+`;@o zZvPhVD3*>zT3&4)bG_}+w2&zOeAU0fL_!EZ2N$HB5Z z7%*Xal?)J&95ilh#V=p9amtqXZ@QYn1)E+Ps=4zPgJkaGU zTW~vBbhk8X>bjPsfm7JAExyYD{(RJ02UJx&-hpo+?}GJkhjoFAEpD-|=WV3|f>M4r z!(9uU4LVjOavkc~bKy)r=N27mXN!~C^M&8qllc~>5Vv`uJ0ct?)2bFG1?Sc4J5ptbo<3BO8y1C6JKj-&++!<7FI>EgfItwN<^?hEamKKxeJsvMS z=*+04V=*QczX>y&ZrtW{a6`sTG6cW6aDUPo^rhl1;k0A~Nv39_1Z9hcoOO$JM^mmN#izGvzu$hMzM%qChve?pI4&}K_?`?ATGqb|QpI5t217F)KYSf{X z-e;;YiWE{+l6>D%@oA;=Z<0_2%_dg{_Oa5cUY=6>DvS0zD*16=;inPXOwI=w|El2c zP*(4PEWRxUCk=Zx?7NucS**K|>wIUi+*&Ga7kojL^3GyA`*DOG=B>KAqeH&07*Wp= zj_2`wXt(1u14OSK(Qae| zYU#DMF~iborIaUGw5p9Sm0DmNAkqs*b|}pS6H0BVBy;C(nEK4CPIb&|d9&L0wx_zV zej)p>i=Qf#YfdF)57wEK*4H+h2BeQ#S*j)P`dapcEUgw&D}gRpTmqpfN6Nh`xftfj zd_=e5=FoI^OVWH1FCe*<{s%3{zE)zNvg+bTj9=}*$5uXK_IhK@&JytHq1R$Gl0A7F z(rkvc3fT>Ful6gf#{Cs@Tph+M{z3Cf-&=9=45<374&{}zY)&KbY z+L3xg$0nHHpt=5WW|f-Kig5RMH6^9lYfU4i+5QN~Mxs09aZpC|@A@ z#3&l1BsGIDG@zt>V%3=_b>!DvsJb%+ZGk;*#B#P61QjfPa>XgCE>K-pN?}A;h)<4B zn5&&I9p9Ye4W_=q3a^OfPg0#ngDb=~*pKrqDrYja8pSGzqwD2%!|)7{43GP=OiJrJ zO>*yahVo~S^XEbK?NnyS_-N!pcdwOsYUC&fbk7&LE}ZY?Rp<; z>-RibZ@*<7zNl|^TS@CHy>CyOrPIiDgeTv*``l?GcP`a64CU9$-y?dgmN_}yOU``yEVhH}2-j^?+5=X8@( zxN!A67k-h;@Q{=&*jSZq7Eg9w*~aRM>Q#=Cp|1Idzfo&_ozcsF*c{+X@3Q2>*;s`` zQZSIzXF-E3%!0VN=Iy2M@y=PQ%mNXOS=6j*vq?HY{1|ed=z{qHw%|U-+YI%sda=v} zU$L*r-Jl|_q9*sR_L$btHVd!PfU3N^O~AaCHw1cA;W}=M6|dtpD9Bsq`8p|PUI!QG z^z6CLY~pEEA~8b%+Wr8XMcjZopV9;se6 z8ku`P3_e>~0{<~{9OUSHMnap5H!^XqNBIRJdyBt-oNqh`W6EmTCp|4-h49Va9MrBT zIDRFC^TU=k&h-qZZ>N=R_#ZA#i!z)`lIm$r;#CM=4Lq(l@TBoERmnHO zQ>Z;I@p?n=<{5nr7EIrUz*NZSr0nE8Z4|o5{kVkm=+f&US`Ue}q|H z+zu07P7pMIlSR-5$rAbZOD$Tik7ccm1Nz);OYO@bS}hXqXeqF&GKVmub`eSvVDgfBU(-7vq9lKC$zZq{aX=v_C;Uh#K$=k!V>z1MC? z*}lN5Xh-2(qrj#*S7s1DOB9J94VsEsD4CBudS1j3I`STIJR-ii)-uZGkM?2?he1@@W)Gry^ z1~Wq~qL8GFHpACqhOZ-9b*H-qMz>v9fiERXKb4~FK@WQv*`7_<3wMV_lM3VU0-U&Z7$_7tv}G> zUJ85nQm(v5)wU;aYUf#C*u7G7X$=aK8m)sdMOW_SFp9zm=XqUXZ@MG|bN^oZl8)|o zIXmpKEhME~5$sNfD3kjQ37zwE&28(PvFs^ZtO29+h9rDaviODs6%TAI)^gWVPWv(= zsVy_0%+^Fqav|zK71s7LZi^KBv%UKeBLZzIRNzdx25rvwHoK}B{ncT+hR5?SLL2%c zR#d3PhoEZZ)@$;NBI?u>)Q+qd&x2^7-@eLH0`$ z28I0=&rUXiXXk=v$At~6@pR)xs!;b!uxZS&Y*HI;Kp=pJQ&V1j#|`%d3_t6V3_8wV z$@QGnl-FT+%s(f=0TP?zp2y?rJoG~h5%PWph4VQHA%N;??#jpc^)9{+jihAP9D>pT z+TyZrxNI<~T`!@ZL!@?f#rg3Li?R|ZyTqcb_qn4?J2y@>7Sp=s#>Ey^W6q89BJWU3 z_=OG58jXM6NEb23HO#xQUhHi|_`Gs01hB6_^~!&j+v0`qLh}1AI$05&tfp-ahUM>K zSWYwLehka=F)Vj8`UjKm=Z;o%=@aVhzL%LeAzLNOnWOa?R|tn z;%A5uu*)#v>f5;Mk~lXVM<}fT06DD}KxwG~PTb7h>*wnG-2;p!4t z_}aMqIKjf@y8bAoXPDU3?efg5=d;VON?LT@eeqE`e|tz^p<5~J0);-Dnhri^kBj;h0=8oNp3Sxj=L#bFG@Bv-(J8)xRY zYRjFO<8l-H{alRA`eFtLMD=>r66cAf0xC$cY$&5!bnj3UpZ@L zGq7J=*Jf)la^KIn=OBc3Kjwyuxgz@QzL%IdE8bxiUtmmr74zB*S&KKrE2%BBx{vSg zQcEFs9?M!A$91+`!R)NgxL?~SA$I9k9dO;qf2?aO=qW_QmJ&V~4$jI+zi=rq#yNi! z&J^?(#<$6Gnwks7+w;Yl?cx#?VYGK$-`-jz-S69qGBC!58Q^2jN^8>hD z>vD`w_17)hcFquj4MWC5*D81An7BoY8+if#Xv}#-g+I3~UAunm;Pw}A;@m{87hb0SCNsovG@kLf$HARtX2->$gfptAqoIIQ&q213=oWYs}xQXNq;Wv|RV#o+*+e+HdD6 zXWgMB3)kzsp-^nnp#vt3>vbn9S|RxC?5%dZi8*t$w1HsH0D+Di7I)8{DcjM5uh+3v zuh%0%{n2ZcGnr(2d9U*xgw$`MQ0{ZL=b)Qs>ZfEcqpPd*#k*lf|DMGD_3x596|K)_!y#^k?F{Mys)3!xvqw^vyRS=K;(yIL%5=m6L(S>s6q%wO7zdn8NqxDzmX7c8}V z?}jBstZ0lBJnjnJeFr>K{OXe&-yuGG9s;Z&+4@(7i#M?9+_yIb^c`2Y{#$6&`-c4l zW%s$cO{D_5&(i~Zy@m^`iV2ZcVW&;x-WK7~6C2nZ>K;_JCkHsY-v=XzqnTCd%?x^C z7TPAfv(A5TIHD@adzTfjUr+8cagzr&u;abr1mqg{Ekb#7_d^@ELieT?n)^^Hz z+dn8~tW#SH+8glp3-4}(aOh`pS`~4;5e@3zcIDbVoQA-ACz1O`EU`nWB_7M~>#^@p*gx!eGwChGcHb!- zh2k{|mMR1o1l4O428FlL)N{6*ayQ3#`K1w zeygQ3*W}vz*bRg zXL2dv*iF)p8Pbh68|ux1em@gnehrr{AW0aQ56>Zg+*wr!cif-FGs{a zTg39;J|I_@u2?L7Z>v;ax3kAHwn=I$bqNWpYrbBP8qL;ky6Kx$-g|Vh4E@76cAl*x zSNQH81P9WvmD4UrGo0~Dr-$_zU z@xUJU)9A}T+#|7hG0Wl79&&(pTgH?_a)j``$$H39%5-qoi};J^Mxi2(W4z|*TNWu%(J<;l6&qMlVYpw--|Su z#kp(B6rf#iJcx{1=n!sT_3mE?PHX;CVps*5?>SR)`qZ(JfAv-depg4A%<5(ocN zrTlBgC-*Y9Va2(9lu*uDB8$iOiXK8N=X<1R*i{nz&|di`oE_S0YfWTJa63lPX}CHj zM;Y7ZvDqzslKp| z%Pr>Zr8TQaY-p&~zQg$`&EleCYxA&b@INT_kM{*uHB;-Fu4kEeiaC|BSOLjvXQH~{ z8A=vG!LZR!irXf$f9&J0S%E~CTcP`xlPxi3`6I#eFZ6hktH@~Ok4rK z;1$FUdL`?Cx^Yaw9{=g$Zop=5Bt)!W^Dn3CKIj|w5ldm6$C!w<{&=iIg(p;qcNeq9 zG5fu|O)Ir=*J19vJ89e8g@EtPU7UQvQHdaf&L279Nhu!Z;DwOyM^65>S2+Pzro47i zr$m2a@(FO@T*e>+f40W~QSt(EuOcTZ^(PQd^gdTU+e1uuLYs*cpUik4WzuJR+Ew%Y zE@d8EMEZ43xBT3g^2HtrBt&@j#aKo9m4N&RY`-szDQovIaj`&{t=cKzd>nCtb2M#w zj|=vLz2v)9u$>WUFG2r)Z%o-sOx!B4s^@O*`p#F8AIN+Nb zY|@O)3xQ*IliKx>4qU20GPUqn+v&y40l^YsyS~>g3PDQ{;3heFCefo)$^7 zUwFc$euVw?3)-hh*T;|qf^$8PF|<{T4#%Zu*0}lwtBbQY_d0(?{H{>4&?dA7|Udc)bu6=qxD?$7G88s*BHGnAQ6puV5zy#0d$-hLH2! zB4OM?j%!xAY*q}X;Z89P4hV|=) z>~{j4_WKCX$;P(fdI=cg}A`eX7Q#We5kBx4BX+|L&B=F1PN!%Ta$!`h^bumAVNyrh4Aa!gXWN#yM&2d^MNw&-X-XYAOw$CR}z*!oM3I7^hH3nDDu`k z-!8#k53v2)?C`(fa7W45B^*s9^FP~^e{6%nu=K`U)C>OoO7^e0wjtubsl+M@ncrP0 z{&FPfx*`Yn+O-H!9gE2jQS~)z&o(XZkyYS(?d!CHd`9Q>Cw{*lX3q<-4)UQOspLM6^ASbDh=&=2U$YQVK+1`TeMdO^U+1{TApVSzRNz(W zemnp1LI{vZKH01qm0W@awTeRqMMN-yCdPf;LuRoGvG>RN5Hk%em93GW-+9izQ~p|4 zM8%PJwmF)YvsxsCt%Cbyrlm#|xASlMD$!E3y^1_lyiO}rk@x$p>^#|ORTak=X1sHb z3(xq&(HhPk30UnsQ&*@|7R zLd=VP?ONPc@UOY$=6UwpOek31OWXOdPt07@u4%KDvnr&3!d1VH3sAI#+t~RP@ygO| zBwjI-Xg2YX!u~Vp0zo|%{)E*~9#vS;KueJh_DB_?w-tt#q7|GwebcwI!Ga8eR`Irc zz6k+$O)$#sD%h%c2;o8r5C#gt5rPI3#2Du-f^PM(tG3#|#;`19SHXMyx23;Ov{VHH zKgi9ZmQ+@izcI+72wLU*#-Q^!lXN70b7nQ;ufcF`Je^ekGaz^^+(`2ln|hzVoY055 zA-@ka)Toc{5WAb5)rXq%xfPA}Q<^}ZbFGNTqBXmWk#VmC|mL+Xv!*b8o05qlQ% zkbd1Rh}lcf5eS*UuKB3cm2!7e$3_BQQzz{r{Z*{!i)e)j3oPacLtRs8tjVE!o+i| zzKj!AZd?qjpnBtCPFuO-0xaI@ym2w2grO1Dlr9j666QW9qJ*6@GK@Qvj%$b#M!f9N zC}C$$B3_!n?DM}&o9huKe(`X70Sm8SE1C%iwuK81GWbm)Bg1Wql|@*itZRFZT6TW6 z*ph;OhG)M|j(=0A@Rvfb>q3`{h&VB}2*3Wd*!&;AcH}*Y z?!0*Z;ssbGgoqhNTN(WXkv=%1b{_0@AA5V{UMiD`E6P-7)gxWNw(UdP*RG>>2Q{5{ zwu3%s?c26-%lctz-*RsIrY!?oseL%)DB1MeH!(zj(R)&lko z=vv>l&0D`ZxOV%-0^Kr`#bE80?fN_{y`Tu+L{pxXYT;7pS2HDg;dFsIhBI0VTNTzeU>?67V~ant}~dDC7W~~ zrskb=$&3rS_xOSBWIq-Q_{nKo%#<`q&WQD6SFR(!vz;kTFa$2ZaGoT#k1*6UZyIs2(nT?(A^@SZ0E9aAH?am$cgkW&dW7?c}`XM@&Eu{u>yMnfg4Bza#MAaiPtl+GdlqWq{!;N$;78G#V$n$pUk%rtilA2M%=E>0Ck*p6OOX;50*aGuW~(xOoKW1TVpc9MhMK zWE@ys>xcmP_?8GcP4dF@V*dm2`Baof*?MYB<63DD(Q#A-)m^}HXHiQ?9_E)eQKOVT zn`$5R#*qS(7Q{G+vyD1Vrb#L%7fzD2WF%na$0=tJxr^|GK?*s3%yH`MWEYO+uk_(w zs?_25yP&`EI;no9olO$(F>5;@==Ax-)(Vg-UyErsa=0lY$xk@{JlL?Ta8%#%hJ+DQ#lNHte-5b{<6 zr4XrEkTEZfEdU^}g#!l3TB-nJNISTdGi9n4wTzI)k}(>eswGi5jj7O2qYu&EcB}%x z6Gx2KNtr_45!VzgufpT1kl#5zM#=CPEPR16K%{xbXzR!VqOk>6l0D$Pl9pp?NTe6B z%G4r;z-i?k>Y8SFo*P;1b=cW3X4CBbIM=_QmP3_HWF+qTh$#nY4O`D{RgugUBjI@G zK~Pr;#Ev1J!fIc6n`q{wmZ^FD6guV=s>Cmbg6w1uj#CD=MPcSSbB{jf01D`U z&1GC^wKY3hK5~l#-8tksqL$I4zX#?V-9P$!VD^#yu_M2Yv;a8>_ls<9ei=)aj=`O# zda#+Ci+hY)P3y-09Dw!AMs0Z($d>9PY{yM(v;77(69qp~B0kIg$Ndh#oK(?n9k$S+ zvt?KfvLhBq)*uT03hPaAaBKz`c+{#29jR)ZK)yMD*a_S=O5yVWx-#nricbfwmw2*3S|(p zW6CI472^d|Orqid3aBWJU{q$JkI6Y1yD$m0&}cuGjkxd<8OpT*r^yn}JHuADs!d#FYD`Hbd&&?jdpc&de z;SceR6hqgdC+r1eAVc9jDTYafe#jdivUYE`H7>?)l=b--cHb4yU%|qmV+XAXKf9U3 ztCa&vrYA>@35&PCU`L+cxCaGrK6=TuN17PJK-y@@#DGYqx=9oo4}zH*Eukm7AEmlM zlwv0%(K%9v&4>b)IPm}bTcIX~#qQScz#vLk&Q0^rlbTW^82?a@fy6JRXz;K?LGavF ztv%D@*W=YQ4!p!%WC$0R)YMN-`>DZ>k!Iv+g*?M#`_E+Jr1F%YXMqlglfQM$Akk|I zr7xwwww9;qdiw~SzVIqSAkZlF{!JnG@Do*+j9g4V{Xo!RByYwb75K21)T&{$yKb=1 zOX-EqW2$+X-U<#+Lt31^SbBEEPOtS-$CT7hlzQRgeu|)!e&NGGOKiFvcX}CcnzvnB z9Rh>+acI%>_+|D{(uU^$bCga?U{aJusdIY#QY`js7$>+sq#Tuz3D}-u>fpMmQR=}C z2F(D@&!%}989J{d8lTl(tI#A%)n9q8mKy1UG*YJd^}A&>8h||H-@U(08fSL~KpO}F z0xPv)M<(Lqpkj7S-$w%j@oyo{Ve4l8YA3}#_62x4m%#xeR1ltXOmPvv}NBy)^26tYJ6jE>XQeXsWGRJuB z(tnmE;Hue2d7T|#NVxAH*J%2SoHW-xM8K}gO?)77yqth}EywGoaZSkHOKiH@F=bty zqPoP;y9^n#D-V+dK30cq)6-xTS_dw*4}-tyLnfdJ_^HnJ*#tW|I3xr* zijjWcNtfKXU@=D|?aHx39K5!~6&1Nh4RjuZ_E!piBv0YKZF;6!Vd zr?=aur3qPkY-jrBT+lTrP6v7iAsIFw2YWS~i=MF(t~fuP^J|4JInQSMsOiPqYCLqO z4|$3tqP0^bCgl2D+aRq)zbI@E^oqJ^FilDxzP=U>qd{6Y#HXi6so!no-9Np#o+j*< zEFt?&NuqTcv9b&fz<^&TxyoV%dZQ#yNHiuzTc>~_Ii#dOW)3o+E2Ync0Ny`Hz<9Jv zY|w_!T)VyEKI>DM4hgSVJB$$(>B_DL;#d&i9b!_j3G&{9>PD$VqMwQ(@LMcA{6Ps-e6dS5`pmPCJ zv!a4dE0h0ejEgmu2Z)Wy4awvrxB^%JRAzO9!4XcA&c>KdvPsJ~$@~?Z4fC)>6) zQB#imclvo_8u#n#04LXvb32W=3fmjg{X`R<+;BbCw$;@`#GjwqnQB0@p6=(FNaF}C zuHT+Xl?hyvu4l*t+t@TpXDq=z8X}|UQPfbE!P#&1@_aqj_i}$7-0Ydge(MI5YDi-| zY8a#AYPUDl^-?s^OL*bjFp`H;x&fa!)r5Noo6uh*+%bVqoMO$1M2h8xQ#g`tVwjjl zkUI8&V}AW`L*ppjiqSSTR3ERWLFqW~P^6a{ta_I6H%IEwJ$KgE`+=a<&oLfcmh+Kg zTbdgDL{ls{G{G47_}LDs-x>dEwyqvLa%yTQ5=o7UKxCRn;wj+HCDJLFNe+nmG_9T` zjY{<+UjT~hZy4bYxSA&F$3$v4{G=1fOC|y9Hk2B-2M_rLGT;mU;R6n}P6>a2NoQO> z-9A)T2lFoxI{I*=-xGuoL^&zw%Sm+~iGC;l2{CN@sUp%(rHHi+L@0XZ{+@ zhA;H9<^#wiUR&?!r{;f(QE$uCR4%|VZQ$seQ*<&P3RB~ljE`VMsQG|gZWxX>byFxj zMe`em;~2F3Zvi8>F*@bid5;exa&z2I^IGC*2}j;Ru`O=Ff%r3JnwN>D{U~CJn3s*G zp^*CD8u#nXjm?TzqeDv|im-FVEo6~SV9x4O-B$`HLp{)_ts9FV#6!na`0fCWD zx1fPH93W{FIZpdYO*g0C=TbklHpk19XiL!|JUBl>jV+meT!~(vh-0PbBvpj_sj7K| zs>9=CPhrJcyq|pWsxsNfsB~Dtmk+%)h7|V)*plXWx@v?x$&|H8k5E-*W`wMQCy9b5 z*@~)AE=So$#ky(~*;J=^G&f?+2le$+V?m&^QQ+xO>W-()QApYccs3L5<#-aCqL$_; z!u0lud-8n73dL6p<46xAhBlfRz&Q#0ZD!NSc*MCxBWwDYeA0R}mhO^6>wZ#TugBFQ})m)y>Yic z3doNo*=+Ox5_@A|rza)5Y-4u3QDp{@O3hrL%r2F^F)=8`%Hxc3zL4~! z6W^d1ZfY3e%N&?htxoh@DvW`C(ix6Tu)?{~sGk_{661qXG%?9ikZ$DWN|s~xUa1xc z5<&(|CI&f1v;)@25##tAgI@xF3>-j5bk&ba;07gI=W=PNi~+YeZq=ek@iG=aiFU!_oBgnA?ANEMTN*x>xiDhGJ3o2n+gq zJ!L)|rAgS*l>-cuK_uMoyZcZFU3z{jMl@db`J)|N>yFk=iuv{1qtO)f&OkOEC0|1{ zI_kwvDju2i*2giK=P*2vd*R=QkmT4Fq4=oRzkbvkh@OMq?Om1{O2j~puO-nfIIwG= zI`n&*CPKiE?Dv$?L+Mmx6(2&(aW33^z@Or^aZi~nj5b7_4^k9Tyk|rPz*O{IUtJmy zvBmWE`f?1aMqNE0jdopf9#}q>IUogTQj!Mw6?Kdf!_8^l&x)6v*Dxrh)2jKTiw4!%4W2rr7@wVdm=ejAE0px)_sJjyKEoZp5CH4YExinu@@Tf#@wM;#Z?4`1%8lzh z6aDY49Vk>4_O02dMx!@$vr#~!H@3tEo4X{N5KT$eO0dO6l4Y^fq@5;1TV+KN<=C;x zeo3AaI}YNB6Hk^IBzBy5Y>zOK!Z3;=BN``Td$J(?`uJ#)Oa_)^N2AfaeqT{e&U>#( z)V|!h_rL#s@5f=2rLvP>zR9K+drAtxG{?8`+*+FwsWu&5i%|--6x`XS%zB${H7NiL z&8@ZZEEavE!A9N?n!*7*1k`42_teyQTfDa<&67wMl@(83+;a zxI-sKH^#DK9{tP~#?^1o^bRO?T5R!iA_ua{m>(EO2_S`lbfd8r#l~DZWR+_0EJAmx zr%P&^pS^|$uO&KkcDq9SI5-4()=UxWsUulq+67FsV$>np|0}d zF`8-7;zur}+8i_Y@x)A*#*273YOh=yYq9Y)ELaOT)y=>l6?+V>ITtVB>;TJedwgVz z`jmLn=44}7Z4^8P$R=ZsKq+koa=D}2F}g9H9rwh`Cd1d3K_`=CvB`lzVMjnCDbNTIC2I{SkBd^{ z4$GBWTx|ei6ObHI`goUEQ>c$-M>~|d-T_o-hpk2lOG=M=Bn=q!>#&D5@?ahC5QwO8 z<7h`+%wz`rF`&|wN>&fnm6A+#=+0y4c(FksH;;i(Q()!^ECQU&e6dYKYc`vo%uc$L ze6}Yhus%}5%&ABKF2-y~fDpqls-CQ&so_%@LUVIpk=ks$7Q-ugJbTy&42R11qQaJYAL1^5S1|g##DkS?M4qSLGJ=G7PN1Odn2)e~&38c#Uq3ldQ zw2<9IGH!Is$ub{tKHg0}*XrHmsroh{rVM2k96cu2@HiYP# zm^HN}og0q>gLK*o1jgbt#kydUwdoEMJW9O@%EJfrK`~)_D*IV6G2KN9i!J4gwlrP? zS+l-?WNGyLGEZC5?qa$tCC2oFtShCkIsHZ6m1I9Gp(Akof(`)ynEV=WVR&1@g8&7w z2?Zj%IXT$?!tL>BAh_hrc%L8Rz!YwZ#M;c>s@QyDa>wT4KupEjEIAo;OH$!phBoYQ zy&0mW3{cmmeBJ^)63q-$O3yS&YH@1t0{29Hs7B&aIa?;NT#Px9V>}AiE65paRcT9x zEeBUcmQvXinhvmqzz(t^3TgqV%K$wwJW02K`U;M`g(-U8wB*>fC1+JjUQK7ymW)_n zTgnDZ2(=Qs<}t$uE|;t+zEs|N*0u`Q+EPG3Qh6=zL~h!kOe1Oaqk;t3nuIUuFfnmu zI^kN=W7v{OEKV{6!aPZez38#@+a8lWNp49A(GfIPNmLzslsS?SlmpZ1@l2pgc zZ#$;ob0{h3?#R%Jks20!VOOdxnZCdPNG@1QiR_rA;%GYI3wS$tTEe638@`~lP0)?m z!##7f-duzN1_WDo88kK#H}}@!>ErG^x-|cwALb^O?xDCB-N+0hhcEo z|Jzr|O-;JoO=XjAN`nXe)d6Q}$E?G;#pqF&3C&dWM}51BuHQ`7-Qw$@QU`K`LnBD2 zeg5#PkO8r@%{1UaZ@UVMrW`2&+cg&J$>~&6F&i=XUYPaO&6aF2%~vNrZ}joZuD0-z zqX%eQ`&-nb7^*GQvq;XrcMo+_o zYTK+Wo`7HYfYzC{x{k`7O6IQyqoL01E%@X}lPVD`B9onOH7V4tz*5T)wZKdV)lvp* zpL)BeJ_=rnu1}erjzoR+@J4nAw&c+m+#}s-xK61xDR}Z^3x%<=t0eitiG!CEYS_e` z8Ca|{R<9#W=Cht~mwG`U-kyWGk;}c^ru}fe%l~+c`WeN~;r4P~>rCkk9ON^lyB^PU&3sZ z*)KDx%OE@XK(Gc58xnhY5Djb29Tn9JQU`s4L9MHnE~h%P^I86hE*rO@Q83#8m~P&B z(H65}L(+X#efknP<;$h4g$ZN@A6eWiDfL<9TEPc)sv5u?POS!~jO-g&^mzWw7Ml>%7K1#-xuV(SuRu^GbO$QOP-$q#EwFxgF$)YT znOwWn|DSysLtgixg`1@MArqifd*&}nR%q(7=!xXdNFCkkdEx>1H1D(LsYh9>2c760 zq@$px{hbV6AXvi|L=}nPf))=f8Quy_W>qJo+Ptvs3DqIV6AJi+D}-gbVA^m~zq|)4 zPCnSB61PC04I{lXP(-kXwh38kS>m9iSv@mB8ui|(*W8@&cz4hNwURiMURY8H!v_*b01k8t_>M{IRfimn3qZ>tBuPFQ<;$q|llNtRjyc27xh*&^FkD@#SM(!xvkM9da{ z!u0kWkKga>SWAWbygeFk+>C8yzezb<{L~74{{?Z3T>oQpS{T3DB3zs{5~A0@ z_e5w}KD+%2?I3Msj}?YTmR|||s(iaiDs8uJ1jxv>?z}9E^gs(JDHlbDS=W5FUzX{; zK7(Zp8Q-PAfgIBNIkP_|s%}j0kKOW-OIf**Ea!krSPsk9?jsqwq+^wq14q($N_KXW zn>><~OK>_JNyw!ktm1OX#wsR5qoX6HT$;qnkV`XIMdXrW(IH(f)%(ff$VNj!CJm$M zaZzqo&JZljT=vbAyg!qY+qIt{_*z1tfyEyj*$C&txRAW^flW=b+Dd-ghpJBdGYInI z5&n!gSO%Q~53tdySl6t{c*>p>Y&yE3>?qAjJlUM&9cll_Mk4u1NkCEJ3A6}`8IJ`k zGZv(~95GC|ap`Eph+wr8(Xot*gJ_A!F7FpHiVRR;Th9(4`vwWLXF{}?=YjVvFIhPJ!n|mu(}@Q#*p#;v zr6 zAy4kS9MRl21JO=Xf(Q%P|sNlj%qkIki~ z0#8{!-xe7yrZPC;jF!V;SJ|)U(dy*DHgAdC5)npK+YI=XxKPR%fE{!dI%XOsxr$bf znGK~JkF}I?A`T@rnP@BJRI)8a(@h7Qahaz%Nn=^w1P5D;@uHcv(Q7`3wpV;w<0;^~F#KV2n__LM>%E!Xp-FA!1l^-U#+1F-zVBZ90o1 zE0IV73b<*L0F9}`un*G9<}4_ok)Q^{EhP+rZw}N*%Jf-m-4^iBXsD${Y)QgLAoRs& zB9V@o1<7fSV0Kh%l^a+|s8|M{ordy%w|{_8?bC|flPpkE0c|b=!xRGzu|P~vm0ZeS zZ=-7{)=SMqEDQ!I8x}hPSCs`({NTY-lW=)!1$=#WdOyO3ob z1QCb3#5`p>9EL;k@g^jz*uGtL71d?TR@e?n9XeuN4u#uh#0O{9(p!Bkw&q&|FAW4^ zcE{2RJ6)(8TYY0+KJ5zmtSjiAg4mlB5RK+3;1Eh0(cYNZ74k!EC2#vmzT_(z6zRxN zdWZrt@)c0x%up89=%7_n^_Frc_+mZ<2NNGqX2~PL-VX)(5WM|(NCk|=r2Tp_pe86S zre#LVwz8{Wv=zM)H+&_`dq-plt*n0pw2;D+t?RwL(QI!-?wE^1Svc9vzEQ}V9!CN5 zaga#T<1tv#L7B6jqJlzDHx{mnESp0n{GhhQ92s{gDZ^u+VP=CKFuiP-Ws^--HVn)+ zZWvk5lF-?34FF6jJ=B${DW#OYf+xjr^KPtntwth4o^ne83vdq=hf2t<$Lb&yZSbl5 z^$wY+6>cd>%~vLe6gN1_DmL0tE5ux7Z?@MrKpPQP8Q+xqcL#p|fDErS6}|9sQ`x8Y z4D?x{kZvkhmb2MdQ-O<2S8!331+LYA0;A>5#qT_hJtYOJ202EfDXl69O z7C09MCSEvE()5mqjUv>;l%CHv1k>9U$)iMh13&bYG@c)@5D^dQA6+)hR6`lUFJ}&t zN@thQP_kJ|Mtvd#1LhSip(enpY=%Sm(@iD59Z;T4W4Y`=h`&fI3x8%g7q+FTT*M;a z#wVCBW(F-GJYZT&xd}d|b_yF9JH3=Z&VqvO$by+)7fy*O$ zJ9r;DmJv75fPKkycM17K+sGPiLvwZwb7vQXkBL&4c%8+K_O8V^N)VE~8!efKoXLkF zYkH+fMOE8|p2OpCl&jrk3OHO{eU zAW~X^>mz|K3-vE`t&92!x&ks7WS8yk9dnhD`HMTZNPU@{+w(hJqtaA-@S%*a+zO$B zlO_;+l|YumR{}kCCco8%Me8ZLFes^w^IAs&>k|u}2couO`8-602@g+}B(teAbN~hU z>Ny05;tzENt!pf2B4|WqV2peoJ~H9o{G8;-V=|ta%LLN-&ggBMnH*#jzh;I{Mx)o{odXH&sWeB4~a>tx_`ML>U$Lr6w z1JVx|8td|Oq^B6pu+~#Xwt;4kUA{Q7k!iq!QVPBg4g#T&&-q-pLU{xJ`H0Wc=!C^( zGXv3Y^o?xJ3%aMrl%6qt-RvpD_@SoE#+VuMgZHa#xK@pn?m$^kZdR?`&`8bJ%*{ca z&K7#Uk}OcKXf5{o^Ta0mqu60x{4$> zPKH1c2~-ja_3`CIIsxxPJB^*W!VhqHWe4hsfI7jEf{7tvg*2J5|JSJk9yJ?krg(+P zaPJb3kD+t3icFrOt$ySZwUko)2Q5WJn}34X=*ULvF`>z*PienTRrx2gL8RlO5AxC}i7vi^!0B>@d>9gdSfQ-M}~(23v^w)p3#8 zl%Sh_acIlim#omfLe|?izM3P^+ox)MG9fOH@e4FGp!`Z+z=}FDCTFw>8SLpicK`h? z@&FpyO$D4|vs~D;42L0C4!|Q1#Ux+#$&;|8~_RrxSSK6cjM_Z=71vAk&XEJ8mtPTdpI$0DEg1M zJ%#zgnJd;QpBw#96y2gEr7UQC6pNn+l#xwyVphOZgNQeYtu@nTY9VE_6VB*n{8^-_ z$6>9+zSpA!z9o9iVTH6KK`e%X#hnnz!Xz<-Q*)S6D2WYlOm+g6L@wXp2qNsy=Y!!-WDC15N)BT? zNg$oF0;DTdGBEY>!RCRH(ajyD(#XR}HYNx`p$-){#OOiRe~2NcAs&a)Yd?P2oV!N~oKTGs7m*^yUJGO@EXO~;P4Su3%o`t&0dYZ*mRPR=Hy3U2Ipn# zNFwY%IWbThAELq2qD80v9+MDnhCd^XN_-F-*|6GF&C@5^5vf^DtT!&zqiVSQe(F*2 zO1Sm3!#`md0nr=k*ihS@uPWNeE zS9IqwD1q#64Pop(#^2=(I;k9hC#e8_#j z+FY-~)#FA*Hyi22PySn?rqGKkcg$Z*!Lm=Z;Ap;VCg7WmTld(8=^DwDYm|qLzImu< zltiZpt2rHOpbP(0DK0{-8^p$tWoVrmN9^-*1P*36DGq+*l5JSl<+JeYeo)8T$1=!= zvR-SQ8iO7|pPm$8z3kG1+@wPzI=o7>@0kmf?mlK6aroJTc+hYR>d7%=&Zr$?-9XQy z^7VqnMz+i*C5lZdzV;D|Nj8fP+mtNX@I`<{CD5*Cw_v|tMy6x@n$1LFRf6b!&F60=Dpsk@|W;)D%sNhe_ z9`1^#hCNn%r~6Q8~gmQ!;|Rzi^(M1hLE^n+>TIj?jt0`uEBSc zap356S&(27BADTnzz{7)x6jApmdnC@eBM55XuSKj6$LL#i1>)__Js@^L{q>o8rv## zm}mKzL2`+@;H)%#4fW8(CBqvfEqD%#WqwuE3kZL~0kf2QDwPg0Mp_ zZSityWWdVVOrPbm12&yS&8LeFT$N9l{e-wUe=*`n1Sz09lCA5A7)Cl`-e}|7+pPH7 za8J~HRvy-yXxc7AdS=K@X5%eM>Jkm&97d!G*HhU{1&d6Rjhn+3vv^mL`-ya+`?F?$ zR9N7f&_}>*3fBX5t<{>k92>xan@_;pw66Pi*5fhm-x+TA=l?eFLuiVz12 z#;1Dh?5AgutOM<2_iF|`tIr4+!)npU_D^}4lK;;ZGnx;88%U5afuG1$ladWo&{W|^ z{Rfn}U6`H?>F}M6Aul-^m0!aRUr$>x-&EBA*N-g1Sf1+{Z#5?Um%cqq|;E}>V}B+p8H*9YfGFExL>=1Y3W)ahS-n4Y3bctEC@9y|F{Y%FC|@fHDp#l11|T_&vRkJPAxu~knrDC{Yv3*~=tVfP#V`?+VX4O=%Tvbim2xzyQO-*iG8r5*> zoz1xB#*nd-5mvRPbvuSrT;bgjix&~XXt22U0s;nG4pUoqk;QJ%O$P&c zI`BDB(ckRGz+gm2fr3CTh(Q-R?CjS}rXSzCRFS-?GDHN9%~`ARrIg>RC&hA;i$D zPhN?92DuH0{ch+TS#*wC3h49|3;|Z!0<#K5cg=!_(9EC@%dU<5lLqMxv-Z>_^H&6r z!)As2%}8Y6%7-yl#8K6n|?}7I>kp0r2vkw{c)FsP-EW){{ zP1YA-_QGM1f`t#T^f}XvomXiflK1YSPM_qw52^*n*lMqiz&rZkWxTmZw~uVZV)1VX z;3ZJX;#SllB#*UWg3#`5)1d{tqX|Zwnup!#QtsIv2x3HTQ2tsUuVHy8t3%La$8@tr zg~EVnIg!97+PNN$S`D(VS1g)HM0<2M^oR%sO)FjEHcdoPcC8yc!;1Dv2_Dm?DJ$AW z+83-ko2yWGgh6L0oJY*k*X_#%80F3(#&oC;_#SenbxXbfhj&C5}Jz;&cZ`L{}KaaX(} z!0^SVm{warrR_d#v<29#Q4)e?fJH9kU+fbyOnp{)P4PKT+CFF9(o`60!8!rKJMv51wI)FCdKA$kq;?z-M5jz@HU7q`B^Stf`N`L-sODTw!B8`t5 zEke$!igH)-hRb$ET$Zp}3_X@*A??f2sI5!}3(e)sgUO58rmi1rBHN`q0k%&b$ir%( zPWq8dyZOvMgkBOh8+$zr(ar2oEv%tF<7PWjN`M`}C>RT&Cy|>tuxW)wK*$Wv)y)v^ zh9|ZwEm0h(tOAD~D~C;zm&2j3gXs2z46WXYOe8oQTP+IR=r@-T$bCwSfYSD8h6$Hw z;PLiYoDc4Rs&Sa>dZZ;T&tDANkrVcY4(YDPwgxfPGWCxBpnX|~EJpQoACF!=s`ad4wJ(M44 zY_0ToD+K1@haW6$>Kdc=s?e7uKTM83zZnS)K)iC@&}op^U7Yn%j~j^{?~$|Hrg(#4 zMArw8!s#Kme_|w}g8biVDTiRgySp0?0?De*?@L*%fjHM2L8 zuo?`>S}QkF8q+nOqM)KAD2fg2c|?8Nv5!ik`QK7cP5XmiMF@taHQ$RSs(Cyt1vwR8}j;6K(sbi4yY zge455q876VgnAz=*We2r4?bBS7V7PpAVXdmN(hZhkyVi6(`5OdfEgDEAoB ziPqbcKHeswgPbcCO0V~r;8Ip?{d6kR7VgLpmcwTFdWWE| zPu7qiehWS}(-qR|T|u!$u|tso3tPCW*by}9vTU}^?&X-xG|><<36FF~l)A$38{jET zQamyTjEIDUjwAs}&x!efsgxql`L`aKki$+g? zZ-N)Dq2BVx5m_pBg{iePak;~X-|&@@b?DI=l>c>GFu}qSZ@>YCxGYM@!)*z9;yuAk zBO0ysVSR`wF>1foA*ChDK81UN>SGcSDGON;)OG9{tP7V4Yrdo+PY3yI=?>Ggu#x0} zCUl>eI1c;no@1yHtSf6evV#(OLzyaOS}f29dOU{=uDcE|gVK9f$qEgNZdCI_YP(~4 zAy#teZWF zqz?ST5+=`T%4$PM9`mJi%$KyDoCg=lt)t}zqKQ_>4!|vYqCkE~YYG?+7A_<_i9}b> z8j^`H<1{jPM022NN{8hU%1>B6yc0cfs)hjuG6~$_S{L3gYDqy_W}!F`^(@XCtxDHea=gvNV343W$&0RZ3{%k7Tq(kRCb?3mg&>=ew_GV>bp^4z zp)?a#cLak}rL@_UkUk}4-$wW?+LXYoRftN~7NCFhnO!mlycFFD>_lnWFk4b7DmFzv z_)09=f@23PK+5B2EE?n%9JvKd&+MA1NE7VD%td^0dJWs$S<6Q{N*aw_&|M+W_3_X* zvDJg#>=6UeMtaDHj5I8si1c{K2T`FiTY_K{gSGocOCXoZpc&LvlNX9ju2KIftt%KE zHQbS)-qw!45pD`$T(Ab}3iMPi^+3id5+6avXal5bV5G-hYA3TTO9(JK{U^o^b-)p+wq7Ox6+1y<5ndot{k@Vpx85p3suXa*5KXoYt?$$)(Dw>@tyxb+q6`}F;NbJkhBgDX$ zLg7#s%*IND96G`?guPp1>0njy33FC(PvCxjx)g&x2X0;fz3TZN?@S`Wmm=Mw)*35( z+rBD{_x`#ACRgOm(W$W1932aXq3d2p=lpJqgz?6ATF3>uj6@jlQ|e8|Hve?F;;y?_ z!ur>2K*@f3c~}y?s}t4^+~@Yw=nxFvdN#Xlw&2u!3Vz3{pPRDYN%xaH zS!l7acNL~8P8ZF0()~i-)zYq=hJ(0G6_>}8sRksA3_s!Jyel(nkI?;^)D^Ak-mlw3 zL+g8rJGN6jg7MKq?I4jp9&bh)NEx%*Vlm1)T9D=UeHjl@83@3EWp))peNOeRX0k3K zf5I#h`>y_WCWV-jhq-~gt4ao=)9~p^i$gB({wFI@*}IA)x1ZjLnf{!a4f}Jtb5{5E z>b>Wv9Y*S1WYTdUt~HNJ7LCkQ=2dy$|uu+=M1H=}zm4 zDCiCZR%Aj#IUhnIoJ9Ba*rcL#X4kMM+GM?9(|g5FZK|SQKY@yncKS~Td2YY9VOXWH zRSr3VtBMy{w|+p}p;PWCIkad-A`TrdeOTI2d$4avZq)48k&sb)@=D0RP3Trf^i4fG@>1rQT{*Y}^~&c8_PI&gxy(l@P&>pk8CVv%9tbD9RFY7sU2nf)Am|$KBoF zD1IGG_rMj6Lf+GeO;oQSaR{0i#a~9`N^6kXsSDkw6X6C4PD%B?L9K?=QH4%c^OlO2 zLw%0eThGbKftp*tnrt1jPu68gwGN8P?NX#GU?Q%xJ}_4QdZYUHS1Scjk5# z+$GJM7Z7fNea5KC5^$cu^CjYbz(KSymtyCL(2Hr#orkZ4G^4>m+@ZoY5)L5m+2brk zQlE~)WfZ|XYdXE$Kvbi_1b=tFkJy1}v9XcUgp@(8Mfrlu3l*1tBq=qQM3<)|bUM&w z+O{z)bTbUlwgxgyLr}OqgrE3$mwAwKb`nDDxQL2}Y7u?QCit-<2o{`0BDNj^^-u$* z3%bLq)H-l`>Mc&&F!~}*jH7{O37bmn>_3RRVRWQlbnfGqXmC5&fDP4I6dGTW9bPdLO+k$`#oWV9@nmVkvY?J91tgGIO)*rC zgpr004-drIk2mr-Qov6y1V@K7V#@|nU|1ga?MmPrwyj_%8SG%KM}r;w{$;%agW{c2 z*`cGjJq!~HiUULtta%Jtu~qEb!E=LyNvwGvu8RRB@x!DA<%r=(IFo-66{utC z0{AdAICNrviIF1xw|Wui64Z-~Q^`UTUJi$v;rH?@7KL4Hax-d4n6O~f8*NbLwT>wD zwV^2HDrk%%M{00i^vy2Qx_gJW2B*Od;cH-?MT6zL{seLbR-4$ptFkr#%fciD$*|Rx zSohY{dnrP#PsespHcKG-S^`EBLm&VHYQlw=`_FUs5gXner!00bna9z>clytVsjsBP z0sI>WiN3V{kJGB`2wuL~#Gy0NGSTQ?TS_|gklgfe=IV-P|j zF=(3k>kYBIWuhfqi#H#eTkU^;uuvC8%d@z5z*>D)tgdc9F%Sb+(cpfi1Ik&LAIhWf zxnq_fG(+M3^QDB?zA-9U>py?sia|(zVy?MplG2b*jBV;k(Fs#moZmDQixBeeh@?ZT zcg4NoF3fFlvb>FB%zZeObw!MF#kP#|@aV`lGOTCPL!BTuh#}ccM7C9~OZjYDT+Ji9 zM+`%;Lb3AcuDFuHIA@-)+tBF8!HRj}%>fr0b^$3IA>?Zfb&(_=crNDCImrIpvkjQS z(0c#W1Qj7x{;9Cb(Pqe10#TsCU6IgQFnlv_yCNKumE!}LPzkHYhPV3%a5`K$hC#yN z-56OT?!w0>r8Wrz6Z5saOHFY5mYC_%e(MT8JIwt(2R^Jv;r8HzcP9xY00}_i9~-(=%chjrO;a>2?aDcjR)q zvnQEuM#>Q^l%^5e^1_Kgh41V^#-@S1RAbsmw_~_IHvF=WU{o(~{}FXpV*Jnlv*`1n z_gV?qNiCgs^pWQ;JSSq(6-M{K0F3=*gT@C|`_7XeM~=GQ%yKZ?%x4`v_HCT#hdhEj zh`rX75+&<5N9Yq?`dsO<5v2$GKNk9Mru`AKj-_>&PCsLMJPq~LTNqHIz?Uh1|rrJwl+Y#q&WWph6A;PQs!;n!N9$0A?40M#+^F6t|R&;H%2#xk|4^{GHd%+ohdPV~vl{yT@obyIgWV#W?rH9@YBrhc zj)~1bg+V38EMFG8;@B3szn{+bDE&r%8k*`yi%6VYPZ91+#X$khM^d^gkNi8ULmIq~ z>phx24*f4`_yRbWcsDO?W{3KGYCUev(BSt{Mhg)E>x)twF2M(oiNu`eVe)dBzIf;@ zfnI4l@stbGc|H+$@L6WxiN`!}VU|#PEPAbRwwTNr;y$96o^>e${)NFwS)Zr2?B9>) znne8$7?U^=_;%pYQGEQb%8pPsli*Wh!T9IVA>P1PdzTUjwBEWNgAV+awAmt~A*Lb? zapd#xL`i5dzg%9=bx=oGOs`>4&m}YNIp%~h>wq}6O@kLD7)EPNw#1Le1H(lG`N3Mt zU&HB(>E^Q3p<{46#XSLDIkA+bZhSF2#61~4U(Mpe1+8|7qa9i~x-4~cCYoz0}6 zsjYWKp|_BaxnfptgB>Jqlh{Sn$T9azsR)UoHlJLN<7QVtI$+>h)_gJkQd<`-@sZCH z@#A?*EU#fPy^aOGKhu7Q(Kiqq4ayF~-|Uj)a||9tI+HYxd@ErOUpIYxFc#BmSj^>< zNYmmSuJpsq|0)s_rPSwJQaX>%#GMT(k$33`Xd&;@_~sBvm2bfipQgbdnD7$hhZ+*| zNcL~Wm3T;IsLe%WCN%|QS~ZnSyu-(j>rFu*BQbF2Ca#;dR(vDelIjWA^_&J{$iuRD zT5n0YOiL;ZwIn846}9n|)L;4pXGAb0I39q3@B_0{fNVrcnA)>MvU)c_3U2rNy-i>13K10~1SoB=$nflY=)K zViG&N^^jzTZ#hcjSSuw_B(B(D*axxiT48PQyx7Go?dr^BO#Eh9t* zO$Z!VP{>u2SW6ZgGVlGF>0gJFOiChboqE-uPoz51_&WTZxSw-~2)NkbwJ4+!x@MLv z^um%Cibfn3N8Zbx5?YrBt;@&P(HctQfpMLCp+puB*?QKySMWlFOr2~O3Z(#_p(A9n z9gNX{JVo=uKe}c%*jzR_1P@C`Di7%cebUqiY?iN~ZJ}Il_uv?a8dt&gOX?0nj-ug5v8T3a~SWDL*8E}qC{G1vd|U_@s=v55){UCSqO7T`E4X! zZXuCW_f&+U6d9K`AWLN)Lu(c=;*!#F2-jZZ5NoJ`0|bq+drj}DLC3`yQClsTUW6&O znl^1!>#Bi=M1}Wh3%{3;Eq2`zg|=i_4$r202+`R1wE2>_+Fa4Q7S3q&!t}*RTgvNg zNpa)lm&~>Sl~C^pif=IJhz9(R2TN!rHyE`50g`wd@sg&BsSm?uSK2kf*PKvl8{I74 zrx||SLFhps3`0T_TFy%5;Bo^3Cu75i9Xl4DN(82xTQ&!qw%h(M&CsHltmxv{Jb@n_prIr1H}U=iING7hoL=!c>(K1W zgwHXV3scAA4RB`Ux4H}(Rirn17@E3el`PS&rI}SS8!N0}TQ8_u%i$!m zR!Q!xQ0us0(fnWm%;M~W1H!8 zcNXel2!c50o8lm9-L{kfJi+-tp%KiFTvfQC%ks$g7VmUf_hwO%ll&Y!T> z7`8IJhk)b@F|jF3^H}feg1aKpe3=*N8ElUA<%h|ynB8jG

Sog+=&EaH%kBc2|BUlWwb6M>9yh!8z!rE8j60 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 z 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 B82A7H literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_correctness.dir/src/reference.cpp.o b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_correctness.dir/src/reference.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..ad46951c990b53dd789ae5829e69fa5cf15144a9 GIT binary patch literal 5392 zcmb_fZ){W76~F!y;-sms(}p%H)ku-sWfUHMX<8){o8rU{k6|FnpCLin2*3BM394gi`1Rvyt;=#LNZ-1uL{}!S9N%_! zB}jelQ*_%RJ@tJTgt4s#wdvF;m?+bO{zD6HXIUwf97^Xx9z1;Mq9P4D35 zSLo&oE3`564k>0Fohx+aO;A&!pI7wSWsolvGfq@l??(Acc5)Y!dr4v+|{rjhL_#?_p6NI2e37crf_gpgK=Cz5p8`v~_lcZdqid zc)Gz^sl;1!GW2D+%&KuR3tXidi^u%Fuw0Ute#VN-SXiwyQBqhz9rkrqsbyokpM`m2 z8(5_qyD9~Y#e2uFFt%!)Rj`fKW4u~#>|@5*evB(}3GLEzO%BW%)--u-7-`-0$^p{b~bj1^oP_Y$tbNR&2<{vbI*>BJ0+IfVjxoDDeI2H0k4h1-VF_ zU{^;4IHw6`djxD69)~F&+z-+Z+3&sV*Zi{&Cij{4g=dHK20V{A@y%Z$5%JGqiuc4y zzXZSzzfuL?2!Yw@OI7gas^CAaV*gAP{nxADKdFK*Rlz?-+~zvmtfEh{v3M*SOGRT+ zG?O9f{;ci6k&;G?VY!74M5D5{dp@@{`>{-lt`?@thP*Cr607BeJ(U z7*W++epub9{ttG*_kbShP}M{_kxJ-9iuA}Nv`>NnB~=}rm{2pZY%ZPBk_r8&dL#h) zd)lH$p4hGFJ#rXgyBj#dr}C4l`{`xd3HR^XGoZ?{x-*r@>%nYRJIbLpb#Go@#S$YU zW|JW~EKGJpkLW$=WIFp_n@XU^CxXe*bT*-njVpadoJweN(az(yemp6b25y#wJvbuic+39EM6m5|kuTv{E| zQX@$)sYWL>6;5{o63l3@GO!+oRS0h!MlW(4uTs4Uzrbc`7 zs1e7y68P0Bc!4$3ik(K2{&E$(j`sx=-)GWa&vA?&Wy0?x7Mz=9I-tfzbDRwb0->H6 z7yTV^E902pvazHl!JUPkFrw)ik%n_Q0)2s_Qa+VT9F8TA5@|FVRbvy;SVmXD23&ZP z78F}n&u2Js`o}vV>O_1`JO&u5i0?XJ8RgBFO@J_R zbF0V};Lv8Z^;UiB{3&kJx_{wc#3>wF*JFLy?f)!Kyuuga{?UhZ|6#z;Cg#RWMZW({ zW)OI*|ED=-jsI=FUVMiMGol}fIeu^1#ebQ{Kfx6-e*EgQ#-9cZ-v`$GU*rCTKBzDf zb1^;xsGa{l{%I)kkN)vWiFE>h4lv9Kz5~p3o%=`IW)gET7D0&XU6up5^&jFFHctb? z;SNXm!G&U-(7gl<_G3%1)jgN9LMv=cb8Z%&fm^AE@|d3nG6r? o0l@6;58i3(-Np5%`CptbED5trS?{%5@593e`l2$d{#w`n3z$yhH~;_u literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_correctness.dir/test/test_correctness.cpp.o b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_correctness.dir/test/test_correctness.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..4967de5ba130a229ee777b122346dafa60008d50 GIT binary patch literal 11120 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 literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/cmake_device_link.o b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/cmake_device_link.o new file mode 100644 index 0000000000000000000000000000000000000000..9022fc41740e417edb7b74dbcee375e980897d70 GIT binary patch literal 331472 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

3qw&{VHH^>D9`ECS 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 literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/src/bilateral_filter.cu.o b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/src/bilateral_filter.cu.o new file mode 100644 index 0000000000000000000000000000000000000000..4b8f6aee6796d179c49baefe4faa27f607831ede GIT binary patch literal 177248 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

Sog+=&EaH%kBc2|BUlWwb6M>9yh!8z!rE8j60 z?M^U++aZp>U%a1a8(9FPBAGu72S~JZmY*cLE>Q!CIB)aWAe1yRfTMVnp4o+w7H@?4 zIaqY>Oi?@gY4HSMhyC;Xc@PPN5VUdj#s6|Ek&DCCjD=P_v#1t|(oe>*s62N(VY6igvHnUrw!>%q|x9F1Kk9_h0A?Kmm#77@3`3GoOo4zqte zdZS2jXPE&YUiO%{M8e;)8r_N+0ASegk?+On%AA4gyS&okK`HQF{_+QLEzVb-LI)6{ z?Jp$6+a_*YMU|TnvJr(-#Pzb=y>ZdH5M0#zWcnDmVhGO=yHpuLL4>IH!)U0%Zj`ce z1cwF7Z6Ve3ujF?gR`>$mT<(s+pO0_B9aQ*Am&B?wj*4WvZZdHMchP?}6X!1(w)J9AOA(|f7yCx{gqe$ zzx%<{Ec|xwe(?PJ-G?7Nv-|vGk6yCvf4SlNTPoe8yg=hpMzQHv7ScFFd^d=ox$V26BQud+O1L z&pl?>?b-Du`~N@7|Gjfd_4@rQ^A!2>f1U0B-l|h`=Qk79{p19# zo^)oaG?cDZ103NhSp_V173P9P9gEa_71)o!Whg9Q@1@1iROlx|vyYyC@YJJ!!A4G= zL|W*{(`VfC7oB^nHJShE#+h^YsD-*c_MWCmiQC}1aczEj%)M!TVQ-x1<8)^1>`k?W zC5$kIxO#Zwrs~`Rup@s!8>eroJ9}3`q0sx!e{l8#_hH7eXK8IE^yumTMtqc>*f?EX znz8R4kXdo=Um?JVu23vnT_N@y&@=0MP{i6E9G(xh=7Oz-U<)UJ8;7k7PVoN#Fe;qG z*Wj>OWbq#gi>ST_KX~!f?8Wo5=N>)3e(KR*X0e%n14lUqqt$FWy|fZSn_^H#Vq}dDE0QY)<_RwR3P;5d98`v!vog?VYQh-&mMi30*jI(VabaW|ZdLIx1nPJ`}+G9iY?m z^DCkA8=n?{%(F~yg*lXSf^TmNICb|nRA~b_J82Di~pNq z7t^%lE&{^m7QAiodt_C=N8=xO^m{?6{(bHp-NNJ+TcZfeq90-oz4O(Fj0VMK2vAY+mGj{D4 zf;LC6_!lVjXOyo0B0zk;L_7hot1p2!)_|I4VE;S~<8WyX_m&YH;iL02H*xdx1n^q$ zHNXnb{lvqk&r@;Z^ba_wrY^COYR#hqb ztJevDyE7=-3nKeE@f9k%)oWtD`p4pmvl5DnrRw4?A%e+7mmj7)+HSn&{6`>{-6rO$ z?-GB%21){9%zogphZB^ZFS5nj+#Z9C)s{Xcl&j140RjF#gy`${vsmpnkPtC{KUAdBps|e)tSfGQ0)rU!QCQ2 zDg*L52T28hh@YV$79#=ip);&}x;6nYvU^E=jl~y>oG;R1t%_nz)mMfn1JupvysHUO zO?XN|K4<`*Sh#vE`2u05;J@V~hc2 z=rN+wV(sI!I$gitCYG4{1eK@jKGhck>@D1#tN9e0Pf-pB#}{V)PoPFF4l$O*qB6bY z6PJeBbg+Tf-MArSv)B?0{Y9HCE>&?u0edVJELss`gya!cuGT(9^`!t?2yX}#aYK=1 z@e_ZG2_U(pqau6m20Z5lpn)%5;N|MV9LhNZb!>NiT}(W-E{@fmUBrJ^DA%3e6*7xl zCz+4))kZZC{3SHD5}KM3{Z8hRt{%{tFfad{5- zrM2fs#ny8)jGyr|CF);5t$hLgZvG1tKF#XO3-8>L!wJm$3>fV%kf#0*e$!lS&y-oI z)t|QF#l`#2bMbd+YH8+C3hfFCU!v*y@+kvY*$X$Tf=p58A=8=Nc`KlzMD}!=gm7+D7iT_zLKcG^rR$V$FuGSXr ze=kvT@e+mK8x-ZG7(tPJFY#zpyo=(?cM<)j82Ts1zN|}+1km2;b4l~C33dvs&?hN9_aqf-sEb1FN#gvCD9w@i6yibkr$9r&#{5%c%Ft4O ziAhfp{{f)Ea0G}jtgsNAUVI8&y7tr9TKZ|g9@n0x%<|L3e}wCno(9ja)~-@^`MkP& zu3F;Sw*x>rPvgmXAUW^Xa`TIVcFnBJ?>Vcn;bpEC7SC#&-ySs^f(DL&%6N_Q%Yukt z*|G=oY0hZ@pVw&!G&bklsEc&9Af51lPs;GoeB=luwfendYX1E&P1sF2$wCe9- zx3nwNwzN-E=4x|upQ3{ExWGr}>hR3$jsRMX{)tJDP#+cm(TTPAxKNy%2f*lG zn`C^3k_(?9AQv)lmCulYjoU5hGsJ%$SL1*nJOkmh^jV-1|CUs$%>zSyV3q32d6GlYp%H2oN&OiMc$>!W$yOHUZ_&h&`T3Ki zN4PMl31D;kp`wuTXFPI;Ia*!*GhV3v8AprMUg3r1S2zz18RcsAn|y3x=7%Zsn;fW) z@u9_iI{T+Iz7+=;dmz7jc7E~az(T*tC4i29ldEhkAAIO{@~da(aTLQZaLqy$A3AsA znmVrGpJTx_pJS5?ILM}Q!H0g63+(%usj~|Rue9UXl_wUKw~^jP+6t>I2G33}jvzb} zpIX3!`6nnl|4j}p3g4L5`LAaRi&P3nU*ZA$*Ai1p^~a&!8nw?y zmK`9%SA#OW6ss&P;|jo&v;D;T-1w-Z{g6-3?RhjiTC1HJ=Kmba)qY9RUQx4E0A_xH zNoPpEGQ{EGeVysMbL{2_5OhM=_*o4MujbaE6ok%U`Yto{6EOfxUk#Aq?*IU4HnFm? zGzaw*gC;=(cLR4eRvqU~ zT=LbN@E*j~iEbnHy#oJ6jst-59)OYlFa_xl!Zi2w`vny;ZvMZ&14XJGV$4aHrvzDO z#Ke6NMd0A`rvu>7Z1s!)T{TakGlFm#)iHlo5Mxz8j+ZSyBnXlXr1?h#`3@nokP*ge z^`GI|UmEPRC=OGk64)Tne=7nI;-MhIF8+9+Afg%;EB_B$ZvrM)QT2_Vs=7<>x7X?J z>7MCjdiJev?>&=bI+KJ12&4&+KuAbuVG_2anIt%b0FAP*!=eTaNsFQ&AcKk^pf-vT z#TP~p7epN}uYjVAiW&u-|L;!X`~SZ8`Q~}%c6HtAyPP^zb+$S`VO?lzDGZ9H{B@u~ zrXM%|jyqg%F#c%`xHg7a*{zqo&G;YD^>o^JKRuHXCbxc}7YnExYnFDOj|1}f_{tf{ z4+Du+FANJa`?Uq&+wOu&=KFju-EYD=sVxMK>Z9(Wo=ReYyi~?_l^vFhg)ue1Fybi| z;io6b$|&(XGrNU*{0RkEro|D+A_gkwh!CH_5FP=L>n#WJyHQhfw3n8x+ZVhaff0ynuwbfcEX(;0{l=?Z4O`8GMUp~Ef} zL_lYnKc>0$%bnl}Tu|blbr$t>0YvE1@LgqpXaN!U8CtXcJ?Ds?F|Lmpbe;%Z8RP0H zQ$bJXM+7^?WMHVGaJ>`Yq-hX>LA#%rzw9wW;AFS)PCh(=Wno)K24WwG!vY*uJqNC3 zjCarhTcGDT0eG9D85J$KYg5)B1AeHoDc8dBVs<|R;~b~LtF9qElm7!|MB@dsxP=)+ zl|Y17U3h5Ja{e{6$?6~iE{Zm|teM~7I?gQSzkmq8{~scFT+O<>-Kp@v27uv!cMYS~8t@ zC!jpJnnLMAHj@&B?7fb>sSi5sHIc|BLnNOKq3_r6K>94|(}zmr)oUGY$l($Fx_(jv z4s0nLQ2ki5FBsqmomMU!Fuxx`SfywqF-lZH2pM(c`v!>pkoS)3%Q|@+nDtP4bBFra zH42|0^N%IA#-jYa&+;<|9t&2IVEQGfoNr0g$*k`pBAuJ=?3K@jOB~FzjF@sa8^{cu z(hQBKmn^3=^PRGEN^?YqxGQdLxjvnOEd;oqKjQpFg~dtyfSZup0U3wrG^Wio8%pjm zNY^wtSdXRCtAgrRgX~rk?*s>+dr%^yKW2zx(1%n1KdP&=q8ST1Ov=9WMrsADE09!= zqq^E~CS#nzA`5w|0u#w`TvusFOLrz`;JRl1gX`+p0ecigt%tbfwnSGZvya=yn#E=y zy8>*xHRFBK2RbTGvI1cyP->?4w zYV^&_l2RZ({FA;|7_y9?w;P)M6*mJavFJ&^)Xob^N3emny`lUin&!?U#@RtfFrjj~LWgB5BOBY@$*dzMg1){~W)`XPH^Cq#( z|6vj<0?+oiNvw#H_EG_~@oK{`@u3-uz;fo+epE0fC!8M4ZTMut7D*e2%qI&@KJAmQ zE+`wUV3k%1WRldB`eZ@*vE)myNm+IzyOL>a8(EJtf9u0XQ+B)Yttlt+=0nh$n)r3h z@rxXTz?2-Y9CW}eGe(dKhTCH&>KpaqQA?!oYYX=l5o9p&w>+5TG~SmS{%Y$2ePjNE zSXSSddO=R;8?VvT2Ergju>TiO)3cAKkkZbVyBtaRbqm1VgVdECe%RszoFYFfqlRFB z==%%{=*=X)WR;sq@iN#*>P$vpL1E}}=F5G**pmN8aTw3A*~GMfbQZB)Uh}gy=+o^) zKjiJ_@5obU4og~d_DYxu0_{oY#=X`2YFm3Mbx{vp!ECM2Gw!73{J)9qB-4wmS%1OK zYyr6oV_6hAYp3SqSrjhJ5FhhPWmpSl@bLN!u}<<H}Q8_pl~i?#fJ{th+ql*J~_^? z4C=YVHi<`sbgFE=vOBS3%fqs?uY*1qa7b2hDd4C-Ew$_UIg7<912T^u9krYUwdxNJ zY)x$2wfmh>=?Y7mu3ur%K1bL^+Ud%#vTGy6q(OTmzZgKSg~d>z76Y@%Wj8*BuZUeb zdTNwp=`S`*rKde#IFU7HVDU6e6OKRI+I7Pyu|w|BlV@}D?IN81vyH2wNr$*#QCji~ zx&a}`jVW^&bk7v-Ew1FH%|x>%kQ3 zkuehz)OyTgi%gw*aVLyIriJ0u?P@rEyBfm3WgBC;m|8|>zM(W{e+6)85X26z9!zxn zVgih*=>ak~MLzxLs_yecJ;*LlV#OSjwT>kcJ3Xg$E@4_LS(;!tQ@WS5rwgwGC~~A{ z-gb5Zvta-6Uy$2w2@kcJ(xk3n7;bUkuEW640#j;GmsxMB_+uFuLE0)SV|RJ^iDXSQ z@l95>2Ry%o%$Hf)GwA?9`qds_R?BOn^jY)Lwq~My5}bZD^F;Lcud>dP0e;O(j8ZH)g~X-+LOL6LvlPNua|bNX#7k8)Ub zd(*k^3HH-wDFLc~PspDqcEvFNCE*ILqK~>V#XZKtj*J`Q6T|9F(Bb=bQEyHkkl3$` zA8B8<5`Wq1&OF1_&+x%q@kB`l4VdNUcJ_8!UB>y9Je>PdtN__3$-6UP0(NOOl#3Pc)xp^? zSjfYbCcBt+Ey0YLyq3%#CDXp1V8O~_#Z)tyt?2f2fA3&1bsm;g3)9Rno)%$7fvxm9 zf1!W~kQ`;AA0~cX=PA^gVVB`c&g~~o<64@o{KpUpIXL{y7jt#>w@fZ7pP7oZx?FY-d6n zO$c_UO#8^ZowM_0^&35`Rj}Wzk@0p{O3Ljce2AnWCcW2fz6_8eHdzJggx)Z5$?v$# zOjmY6R3VcaQtk&P>&Ftz(E)+paj%Rg2c_?oi+V13P>vMh62;OH2QUg=sXYA#O@=?s;n11oq z47CT$gtZ!`IvaHPP%kbgi;>>$l)kw)l1CGEVz1*G@)eI;>wv+H+ndlA@^!Et?lFE~ zVJmypt-QaOO>onX=eg?yb9*|4nKlje>_u-^CTSIe`cSW#1~StS%`b=&>cCi zclGJH*Gyf7)B*v^AZM{mYCRh%q&B=&QXIpOActVXdkjGgKj#BmbB|zde}qXt?~9}# z0d#5ZLDrgityjwfyEbbwo7*zk-(nm>K+ohJC2hOF?!#6wXvFM9^vTmi zdrp7dMSmshm$X*>PtMLv?t1D^rPtdael>e6=PLZ0g`RX_mm1Zybv<+z zEN1#2cw8^8B-^_@kbTVDr58`coS6F*%xvlWJ!TWn%eY7v!LP2}ZDvyIV$)f$Ps-XI zW&xAkBwFD8PNR56|J?}xZ{jy__OuHoD#uM`&A-^HU2le$BKI5O8PT1|EPzk;YFOnm z1z2?Rix!*rnb`y{j%89@W+yUOn=H@t$20K$Y0vb_?b+nE#quI^b9%{Q>uz&AtA9fD zW;cAD#A-8P@GT{_Vzqshzz?qGwqNoA*b;`d=eh8vpXaS`Jb3UA?`ECkNUCo5xa-9D zkL{2o>SVi?yySZ|38E9*KrhMMb))**EsZQSDiP24}O+ z3KP4#ziUi?)Tm+XJxlZ0he>+Na_oH3I4@gansgUmFPWYd+%-CoOFkPH0)WDAoc^dqMJiiI+NY=J{J=y=-Hls`KtKW(xI0M(?{p}z~< z`n?6-+;>~7=Yp@*=2m@to&9?)m_@SDup~dUTKqj^{+%RrK?}*!1^Za>9Bk{+H->WR zy&-HJ(`7m@i<#y=wX+tiaDhAh6z4<`+K-s`xEVo~Pi z{V??vZamvGf8^cz#^2gnvRjw4e_Qz3Lc95F(hguNQE_XmyO4+U5tF4D*|)~n)3UT) zNPPslAa^r_rX*<(uH#~YM>4*&f{R1b-7iVYL?Da3OX**v-0WjT_IK8jd!O-}Oz3Rw zeWteMH|#BH^Lj02BiWWw1j*i1vuuUAH}wK*#=q$%FJAE%DZBK=v(DJHbMtu@Ef~~( zcA;X%$bR)gZGfDPmyHi|BsG9U1Zf=HnQbY{dl!WDXetMHk3FSDQ);Y`kEWDgCLz$# zy>jH760;9%7%pJmDv+jqi0G4iE>Bt{l_yLMC~1E)>Ix_gW;R@*Tf4HU6VyQ7kG)S2 zRFb4y0@S3Rpj&Q`yoj9;e>*u?SZ{{u_-<@wDx|j=;T27p({%Ik;0mz|_Tx;i&Y4Vo z`CJ&{=vH|kpSO*X43GPnUD4FWb0zCuvnO*NnZN61pN)2n=RZH(z3sgBJEc!8*VbMj zX&^K|=u_Y|Gc4%A>U9ym7N+z3y^zlky+rIIigpH^ zvf1>Ryj9ODY`3X@yl}1Dl|mRtYew#0nc4`uzsH~2lfryvIw`?cn$1zgvnPtJl_pd< zRzWRHmVwPQw2$#^{qFoLR^>Ja>#x|JY*RnJ89nOQ-(O5^EdD`F6pH7P<$9~+?crbO zv|I;yEzE|fCH)c7PD)7hdsX{)9}T58<_=jC`Q)V(Zy(QWmA^>z^%ygAdXUU*2q|dg zyaOVAk=U=97Yt>7)!LNV37$(MnUXhq(-I3lUn1qO6v-+qtSsP>p&R;HJg47iD(3YK z?>ReCeXle6i4!&l_|k_B`EVi8J0!VXk@Ny+kl6(gH#hutHGI5_R%;7D#QXy4)>8{f znj*fGtfyLFet<1_Bjf#f{mnLUrUkxYN2j%2M_ff~@*e~KRD1sdyh=N&GS+?p^I9e^ zFru=za>bv!mA9fG?_A;-B7fmlxIk|M%iWC^$o)KL%`!Tl$#-*q?p@6P%&OR*hlx5k zxHbP>#-$&^=rcjABcHkhDqLz*YSZ%_%=$14K08?u|NcS)TU%l9~aHldBc|8P}8l;B(<+t;Kn zJ$Vjh(sY88_&J2Hb{6b&S5Pvo=1 zWPM6v7AC#!K~hH8^m~X_*@vYjs3%XcNahJjJY|^RK5vFvnf?mX9)L7bNd8(<_y;XeZXYy52l<^)C}k7M#Q+_Khj2tDJl{yV_O zzl0h3DCk_s-psqQ8*b)&VBk2N4|5?sBk^a#_Jsp*8bMV$PE^ZLNkj&`h4uk(F|`-< z1!Oxabre%u2AYfaGWhHNhtk=j5~OIn_))1nHP6J`TaX4!y@J7CfcyR<%;1Jg{xj@Y zW{_~dLG1l7VeZGX=JBkKg-ABNpL_C<$`5h2!pjHA`i$A1JH#!TBa(8-O>M>0E3kBL zm}VsX6sC}Qn&<8$%EA+1JPFK}Pk@UjSTp`jk1C+IAHmdmDYN}tiWGh>DNs)y9BN5phwr;Wj^w}83o@@O^z7N}>2Avx zHf0U2PV4KqjE0V3`&Z1J>GWzNZgVwuT7$S99%MKutW2rb8EkVGl~(#SJLT zq-ZmYDQWFN4x=cHaJJVa_J&1TPVA?t|IpF;d(Mtnl;xxiXoB5m5+$cyUP{tjx^ zAC_R#m}l8YYN8#106^mG%;;}h;l6<3XLE!>$9ab=FG`)6Gz^cK7bQ4A{EMthctBr* zafm5Gewabwd{IIOpuV14G68;@g>S|~Qe=1$GSwiW(T1OW(xSkmcAJE84w2e29N;IL z49ZHN>?(t@_7{&c?P4H=8cb_h91uHLYhiJK=lGyr#3yWU#%%oE4!V+=Zf5rFZQ@`D z^5$x{Kma=(s#oUoTnS`956SQI7-TsNvey1Zn3g|}X*t2PM=&if!?ZlY=shMs!cBb` z(xP=zcw&(%e+@GSxPDT0N|a@%oA&ogl$t;+MO zo9?6VA$k{Pmp z(b17h?;@5TvXAm(>)R;Sw^6KbcC2p?;mKYF?`E>+aLc&?{+fE6qW5q~`nY7<6p$Ae zeYtNJ4eA*c=LO_XpQqeV)Os|8qv{~%`2lI3oZVUdA$E*)j}bKc>aoR5dliW`4SHhi z9^>0zZzPo=TQfo?BE{7pXfAWV!MOK>aqq`Wko)hXv9jgyJ-4}EY0oFWl(a5F2<^jI z8?NG-sHl!tnYb`8SjfH1nEZ3BYx88y-3_l~>P%z!IQ}U0W|Nn(9^+uTRY_(GLoHp_ z*S1TDU3y^o@CyJR^*-P!zamx&7o z#MLOmXm7b~pf6ka2&~E5rLr@e{q+T0HaKB4IhH|8wfxM0>3lMMdmHQ3t>?qQ`A24% zA@&wmmO_YINdDXxBKC#UnTO`smCOA!&$e`HK*q4o-J-(gs|nl^76s*2g1yi27SZPt z%6C*Greg2Ma2G%g_2l*Q$?U#0p36KTq!##qajBNf7%tbh7V}fvtt)n2GLB$FPyVa7 zX!j?X_;@Oi&j|2GN7C-e{-%HRrmdT*yI;9MKRvneoqmVufCin>F_hE_(AuDbB^;+3 zWltoHawKCMvc@5YLsK4l+E{^tk%CcGd}9lmy|E?QntoRIXYM^9O&#dY9Cu7+al#%* zGd+>ZEL9y*>C+dZLB=Shj1o@3 z*Kd?^MhPc^0r;W#Hg246juifDE7OeA#kFZ0t{ElSm-^8X?ZSJtNcOfgZ_nmB)6fAU z`PW7mb^3CCjC5J%j2iN+>x-ty>gw#WS+uWAvJ3)x9 zYIimB9S2RjwC^|sTVl~-2UR%F51KVBn})Eh99<`!d5`wgdXm!TS)W`VPOsb#Gx`@L z_G_o?CvW}+V8xP}Iv9YZP8o!N?nlQXV;Yv~rt#0DMGNCMhmG+1V&5MnYqY5?iOmAR zG=hJREK<7=cz`W6>ET|NH|0kRF4+g#~A*IWLb?MQE&a1xZ=7Z-OHvlu?ljq$B1 z{4ksgii8e3Z7}&;;VnMBjV+>)s-F7R7-x?-U<5IBvv9hbK~L;~wh8a7`8^ItREX^N z8}a&poV@@Sd2|~)*)C3@VE#u4K=`~2gDMR-qe(b)(mEIH)FT4!^I$|-mGbt z5Dymqxm&v%pT&=ks-GaoA{UN)*d;$Vg79?6y7vBBUveG{v;9hho&A9<47hR_PBz=R4LkKR` z?-uma`2h2qxpWP0N&dtq{RWcGPkgLNhsAz*4jQX4H4FPseBzMeGyJ!Y$}Pp~SBjr1 zA^mlgJ=LYmP=9e)NZ4I-S61pM^nJ=op9;y{nOlnwX2oIB;NVIWk`G~sKZL2Ypg%;`OPHuPxeGf)w{fDQkX~5V z9wHgxd5EPc4&7-JFJ(JZh#no(hnM@wQ@EIm8@TNOWLjOXe$m%n$bF%%{7qqh@o86| zD)?g^+DA{7xu=2}w||)Cmq7J%RC0G4_iStUq4K9*h`U7=jyip9;p^ za7f*ADzeZEEJJ%vl~zQ%bbTdf+gk->=I;WfZHVi+{#Iww-)&1F4=dq}6c!nZ5P|%yNkY-h6 z_TC}>nh{8Jtr5C^Eh)je;g1xbTFJ%^*{(N6^!22@B};5kU0e^pAkv3DW0#B*`u4hp zZ~WUUM^bufJ0W5PhkuwY4?*8}h*%W+JnF*V_l^3X4o|2MzhB8Z>gt2MKUM7KmLuHp zg@|&|Fao|W8s_8>rVxS*hQ4NoCna~1iDx~IubKI8?b<1@GG$Vy4N3GnCZ7Ta&NU1& z@X-S%h?4urdJdUUnSL7aM1SDg(F4TNW@t0M+_$>yPcrG~fdRenhhc3ATtw+x%~tuv zy7u7#;D{#?o_!T|j-Kw4pMdT6<+`@%025aUgxTst0?x;p8Jv?!%^k47esGW+pAc-X zPdZ4@zu&EE2Z@PK2<+tr7fu#%^9&~I$!5dbk$K`Kt=+=-?cD?E?045|aSIgDLJa5Et2obozrHJ- zPny_}3Vlgiia_nfD*McOS2b*T3(Tg@Om-oe-&*h6{K!{f zvoaMd5G0Lw-kgPvbPSH?Cd@MH=wix2MTYCA@HRp;4w_t^mM!NZMCiWt%6coi!T5n= zomKwF{e5|TI}$p0rL(QAsk5yjEe)sg8%j+4-OQhdr^sy4HVW*bdQLaVe3@e{hm=KI3gdG-I$tIUJKw?r6!qbVW~k<5SJ-G?zFfs3{0J-!Fpsd&zY3 zITi)Gssuax9A%Ff%%{d=gkPt}WD_^J5o+vBSI=<_aqe+<=Q9X2&ds0C8|NQ);k-Nl z`f}3_m==p)UasxHqZg7tTyAvKT9-B^D;rJ?+Fq9(?!psG&9BQ4aGFVb9r~c*P_Znv@_i=xb-4vi0LIyw-0%i=pC!W{ zrgPbb2r2zKgkOK!T^KJUuV&)9Wd!!UPSEvk2p<072rPYQU>wZ!p-VO>^5zo9b%MR_ zVh`_9;eWyD!D9Y8Vd^Xv{sZir za}w^gTM(dH_sbAb(;Mz>+FV}KJyyIOq2H3hy0;7QDLKe)Dof0cocq_8sBu?<}&`A^y}!%JQ)Ou*$!& z90DW{!3&iSaS0aGFoz6^kXQswG#n%2ge)YqE07Z+qjLNSMgo^i&_*o%> z$0qL4*uSb45Y(oLV-L!kG?vTbNs+PlSQVnTHHIg}Q*dr}%zc_wvoZ)8=KYyWCj#y| zVU)WrtAx1+;X*+W1`5G3g1R)s7-tNE?sTvlcd8#_*p_l#)_(G5rMIZ57>0o#& z_L_L7%Et)^mGkaY!x&|~i`W1Y2l}vEXMc*hGYhv!-+UYnRq>6--I-?#*rWtO;(t7< za;7N)KPnc!jabw-5-%yn#!UEB#b15s{m*?>^){5b*MGP4-%XR3f`@gChal)zp z#0hJ6tb|oizhfn*o!qn!o41DUScxcMXhf~WeF9O!++jwPuz6mFv3e4L6rzL?FMB*n z*gP5x6sNKJ{C7dIJi)~GA0NnK;}vX0^8vw%H~Sca-xM-3+@{!Bggwf~1A<{S`_4*3 z3jPl6{RcArlRVkCvSrH^$ihg(iLn*)YmQaTAOClrg4&7f|2Ru@ z-&M<2o`79Kh?rrtlhHR3>4O%r#jxA`)xHKn@g*wY7bS`t^+*@6Yxnr>O`B=JM4gvi zY@$E)ZQQke$JPlN*m3E=`8&pT(!g%y78uyLam${qn>OycI6biuao`)rcWm6T6MF$S zj-^u@cU`peBh^j2w`b|&^H~fw?bw}Of~^ zv9YsA>m$$3W2p-U$UQQC-bL4we-%D9Jx z(nDC9_tMq#F6i>fW4lQ`5gYi)tgK{Of+Vxg_)xW5$!Q*7S|<#FCtx~{5IaPeYP!!K z`w3}SGL)YaPO9eDjSq`<4|&XQ5^kW{dRctOra_J=p>^zOhPJZfo6G@o-?PT$WTUC$ zd&aZyFK<0>^PX)R$Hq5ZeBK7Kxu|)Q8=Xnxn=ZO&+xVucEDm84mL=jN`S^Zf6`5VU3E z|0IMUBl81&LAbQtT-F|fH2o%-k=Dh0Z3-RFDU6N>^!!<8;hR9*1~P(N6CiA6N8wo% zV0WVEA%+sn2z2K(*u;KyfGQiUDashi-J! zNf0|EgfBP&-Ik(Zk)*z;aq6cy1z0?sYF`3z2m=1+!jvdgIYEzU_s zt0oy&x1n@RN+xQl`LTgBCTS{c4NC%8Itf#+b5(%)OK3B82HLot&ojMNFs|~E0IA!V zYq{~flL1l+ELK~f;>*MMV#1eUl`f?@{Phtcr;*1Fx!a|Ech_oNwySX<)7;gyE)%xb zntT*BecVUp0@-1EQGY>v8Reu&wv{>(_^nh$cpQbHy9=1^40;L4#+=gm)FCAMvd7RiO?KYLMKgrl@1PI698^m%VW?X zf2qqdOKZcpU$_pC?K(xgbr|?ub@IAwb=p}v0nc;74Wzp4H_%$F48g<-7K*N5h?~|P zpy4@&`&o&~VDxeku{*;LqpkB{THA%TT@tsv&$MS~18rrWFYCA#X2PkVXGqFOF8@;E zQSA0bt?&earPGWeqtd^@6DIQf3;!RQNN?m&=^5&yo_fYfJ*6}bGdd3Cq?2M(W~8B{ zkEu@I3f1bQP!<0rygng|BMl+C9$7dgC+T&hr6CWJ*LtR=32_v(Lh?-GTipZ~W`KGo zv8lo{g{#(3K#GE%WEvG^R76oQDyDT*%%Y-!f>BXQqN0L|BnqhLm|BLeg19p6q>ehu zCN!E^ibjM&0|hkdomx^sJ|XIzJoedBA4P+PabpyW%T6vv#S|*4C}0G3m%ss@NmP_e z$1YJFNzPxQeEhSz==k^JpVfuOzE_TYb~KhH1wAZ!W|x*kPh$zLG&PDteK8)RRsz9B z@V^LHX$zf{ogG2|78N9qbETLcyq*&7#8j zfasY)!KkPhgnUx;l#dbAliV(xC+)Veqbf%hq*@X)$OUpwbO4`Ulm|=wn4kuoI7-dE zsH)q0sy%^YNv(Ps-6(m{fgvXfMn0mE=`MPJ_{dDB@i92n`2dNYsdmh*FIcc46RnI% zsHd6$l0~LL&29LEo{J4DQrOlr8OPTyRLAfG#Fhhr5D#G=tVg#qJjDF55;4k+R^wQi zKh|1|a(Vvf41vTE+(#Om#jGkKGboOfgQ($=63X*W`r#b7ZlTaHKlIE5@K8rl5t%ZY z&iDyV@yN7sg@(Td!$aLD*8KZXtQf_lAGeF(h0(Z)3jb+bZz`aAa=!6=(YV`41)Bo} zkCf+s=$jPBemFSmeE`LVQCs&mP^=lniuY$I9&78J{hziT6XGVOjRsSmD2ns-tX}&yvj2g!X)+K3VR>cP&oKcOl6~#D~=a0z5h&EBQi8yf>oR*Dqjrn8UI7X62 z^^9axPh-UsgEa|*kG*488b9pGq@d`jA=GB*<}tTr`6CTpnPli zo&hmuian>JaIf_Lfx zmYpfmq}AID@oPJjib<<6IW&wxG=uw29UnxM94cz4D5GEuA~Hr*6cw|_rzLD?JvJFs zj!jF>*=|zHyl2{Yk*e_`&MXc!%#xnnUcZNLCuBXu&Lo~iiZK*!QT%v6dVzI()%f~? zsbi(_*-QSV_&AwEVa3StoLDs$_@0Y6+*o)^WU{4>pfRLAWO#rE-unOwSn)6@Z$V8N zZSaU4h7cS|Bq=_FLdP?hHaZM3r{`gm;#HLVXC#4Xje@cC|3ClE(t{IXf8Xa|0VV9; zre&Ai(i*K{&O|+?bEg!Yhuw2e2ytWI=v?DAEPP!Syu@NB7Wi1SZD!6%?J5$!*Pa6) zzy#61W`d`cW(7U(Bo`WgW@(k^HH{J|<&CzXYjkYYmkr4SaN#)-mZ|B6W)~jn* z(YOC3=m?T^%lO@2%A|)U@Z9lgwoHlT<|D1VL~pt$<{%%=T_rtVQ|Yw|4bFnaDEjhW zE965d@$z4)hM06MuJjX)mfv$mi$|{D9V)b9u5pbzNvZK=f1adsgIEQnNgA4Kd=$I; z+A#%>6Iix{O!8`!0X=ngl1A|bujxYjo&+zkGQUBgMxZ06(F}{W-Ee7YNp0gCT4eVF zU=9l{OYT>c&-O?ScApER!K&Ywd$LShmSLYkMNCrVw^%&K)ffbhxi@B6Ubb94%i2u4 zmZqq?trB-2rN6m>+;7CHyzHD1@>Tl=qi@eukbF5&Wz{)}-=@;x3T1>)CUHMX?zWn8 zy{t2G&GUdK9JiaS)##?@H58@ilRk7y%xWG%?pMl~?AFs6b5fhxyd{FZ%^=l(nLa-?&R~T2^`6 z>h~+OS_XGsg`81umdRC1l2Yff)qgHYdSYCiX+L$A6T|nkL zJvJ`M(p8MtiP;Hx2jb<+z8AlQXhzWQkQC4b5`W@jf*KkH5X?pz#u>m{*fni&jgrPT zeP_qNx;8nGT201jud!Z7IIr|Ox1;o5!bKMjuioqcaBeSi$w`jQW;RS#8ykRY74E&j z??XR32crZ`Z)}#Xj?K!&Q_PTx*CuwWbJDcD&26(LfQUy?K z@V+_ek{@aS?NyY!yI;Ad)kgO@keWy$+B8eZVcVAMuYw-RnsFD+f%=Q(2{)dTa=?cX zc|JFXabevH`EkoX5;Uz|y^7Sml0=(R#7Z(aK*mHSSxVw8j7CXDZ^1j&H%n_SHO*0_ zLT!9vO&nwEjKps19IKImY8q3}C2pRiGu#s<6GEW0DWdb7d(8mfm{KMr=U$7IHacku z&^XR@0<1JiolT~sF@jkg6OJ1iVba`D?=7({&T+3ahwd~k?f;X6UUL7qA$L^OSz7D| z66s^4?aka!hPlo(qT24Fy0sj$wdsIcg` zLzko^(n?_3v@_hLp}K-qlBd<>;|_-(n$faxjXpmV^G1{6Y6IN&-u+Jx*V$c%HHz-_ zX|(mvS=L~Lji>vTLCZ>uxVG|929*QNL>c-sjvncDTi71QOyqG(X8+NPL zIpOfKC}T;{WKRm`5j;9l>nBkm6MRbsqa*ejyUsv~8xI5mRodeO|Jo$r%50Mo;~|@El1gakn*u;H*seyw=2>yZ zvhe_+vGd3@>kRs)*;;Dbtu@zZ8!a1erBIz#ME3>)W&9Mm;b&PUXhtXcH8cP~uh%O% z*^0K^kwC?007wU(2!c*s;ns?QdfTGasXZ8}fZ?6g6APCq+R}`iZY`5Qp8X(LnyEha9T}y<$k1))f5Cy%e zA~{HHGYnwSG|85Y2ZPNRSgWGM4#~bil!ok%mMJ5BJBFq3d|0)#{;na|q{ZKc?wvrS zC9i`pCZs`+nxM#39db!^BgOe@|9H@1udA$r%+9zf%)8_|g6}0;Qy{7UAV-P={SVrC z&6MNgp^BML+nQ}vD%z|#x@=gp%I4%=Td;1@ZTz;XJeJto0!+)gGPe9dq6Tt48=yu_ za}|d+iBR__t-Z8$j?Tj8-U!jzQ7rMzph6SaWxB??r_`hzGj7oRXEAB-ot;er(8pK= z+;0#=_GKHjM%fvB94RcE^a-p>?Gug`Os#BL`-B(suk+1WOM9zh*0T2j2d3bN7n7QS z#f~#?Lnv#*cjudRXFApzc@HAx;Z?AWIufQ5ozUt{n95c?HXe;ham-r`Xtizewi4|> zayzaRb0qLoE5csmLytz=e#tp{sZO2+QF6u0FoU&DLO%q=6#kX6G3@$c=<1LcNy+gq zh2E@@=Q*S!57a1ve?W|&fd6nPiUR(_p#%!}4~M!?z<)T@hXVeCC$~Bh$r)}So|r?i zn(-i*0Weas8Vbb54XpPBP_UamU5+wb5f++75tjN%0&Q(T@AK6G23#*@O3f}5w*w(6R4!0K!Qkjh{vI>kd+RYGXm z(+aj~ikCU7v!=GF${O6+UYFE53&k2d7@bssp%MhbN>6)xUCp;fTFV?yDyFryvGLaS z))HG78;@5d`W7h_WTKaxtDF>Qtud-e%}(f^v3Lz(piZKwyR-7|s)QUYrm|mDCE)k5 zHO_Hc3xe>SfP3;w(`=b@+yRNpc{u6?n*5B}3$)Jcr49!!1T2}V)a09CQHUfmHt;8r z^d9d`n7PAAA)=O!Npz$!g`yi+l|mBKFei-}h%DyjI`V?^4s!@k^roW*vm4lrhnhoE zVkr-Ui)l0D9(h;zj770OMW<{9fV4O@`;=DX6W&S9+|bypv&l9I)F5Y<-Bxm(;h%7X z=Vq+Y!x22MJ?e;i!E7ZLR{B-e_?)v2Xf>C2Zko|F4ei$KPDjRW_fOi(M>P8ApaWJwmaoY$e0?w^dc9;DzlBVoMtlLS~7Qlr0IOaJ~wRKK= zW|+NdLz;OTrsJk*67}Z6DQC&Xc(vJHvJtGZ5VmcG;5A`;0T0MaESK0FD*2nB7I;Dp z_wd!1MUj%fwTwObGm2E>(Joe#lv(Ba%?#rQ$U#-t+TcVR&~h|f#4$;pM42xJN3}&+ zG=3E1uK8kZptAG*Bv8gCg*TL>#S_$K!od5d(*b;NRBq}Klo*XySepx-urvxv>S&evu^ftOJs;mQfV{>($h@nG-ll-PBo=c=WCA4^imrzDh;)c!eYaDSu$P=}HLmFNU4 zE&y7(;B!Pg9%*3fJr4b&krIPwmWa@#DHHYDYMjdM*hH+%+oHS#%y!o#ddfYC)w(1% z#p)6@M3X0p-jupGN2($Rn6Dal-`AjsyFnz^L~NWeGokKqgM6(Ga^614eBnu61Q5cM zoH;@?DcT}5-Gn_n;VEdlk~GEfd`@aerUrHL(F&AykAHQAIiH{55cD!JpQBFt5nw|J zz<)MH8Y~uP4dPCLcNKU|%zl9wM9a-!5ePKiqdgy{ltW6ixUhnLE~y z5O*p06O%lGfAS?t!jGla7imaJjfZU|;l>ojO46C=?+PZ-Bi_ zaY&`vxG!FleXGjCAD?C+l!NhUvQ}k(ssTvbNjc%6ikt(EPems1NED1hPJYsAm*J6M zyH1emT*B=jx&n+=@@NIUY4M%|={M{$XSa z)gTz*2eP$Bwz?YGTvu&9qwc!8D(<4zX-<9&AX5~{M=+Qo@hQ~=_ANMkj!D%$iu+=E zU6FE;1F^bsca+qs#eEc_!)jbDX|f|DNnH^&vLpde8|8t>B=^UYGL@`rPb4b+b=K~k zsJPwl&)U~O2&>Ao7O4z$U`xn8W8o!>54la6Vo8hZfoV&#W5&|dS_d}jw519Ep2H2Z zY1XnFYf8MNNM);n@tmld&cpOG5yFbg%G4B@lA{Sx7Vc14u!c1#mE>sLgVA0^e2FkS z)!1fm4h<5RfaSSzO)$B+sgo#ePI2ia%U_ISJ@X>}Lt zp773?DXP##GV_{gO6uaSX_=J(kt27c432V2RzUOc895xEk$K&M*+H1=mb??>v8YkA zH(Z5dPPD%{h%k{VkcPoeCX&v^1hm>UgQiv@v5I@BwJcGSi%bbDI-E*!Gw8ew8fYBf zAmlhDybb!l>F~78YnxSiFbCLrHoF?Ou2JJT%0^$ij}S9QC0ktzr=k+Cs^}jXkX}`F z6?ajB(B+95q(Tl+#1T~hS1W~sIIyT76Eg!dlutrmd(GuT9dV^U=hqZ&Vmh7ib+(Bp$l=YDqy&U@cMpLG&^d@ z`3<%P%t{Rt5COUb08U0bbB%hq8`PR?;?@575fK`#Q7f;3(`q!t6BrRdEv}IOlJ+Ex zE$=3Z{%g`i)h2&+7Gu}vmy%>A0hk*O@SRdqE-|4wO`UIQ5GlSbbrTBp`6mh_hhe;v2{Oc1H z1#CV8pI&qx2WKtJxL3m{AAJ*y0x&!w*M$d<;l+dmfz$QR*#V^?@tP?eF5o#`A5K#- z5r?6xGhrBgX3@(?L+6j9T(|YO-Ee}TqL%~sJF*($TQb$`n`vWPIc8^3Q+>^4LVEn> zNq*914=ieOM?i|UZ3Sd#Ai(O<88GoKHBSvV8%`6OZR@JM?o3#w22R53%Vin_EHv4> z=*MNU)Cafly#a#xhmZs(5nvUf>Hh8;G0{O?pn!q+TEo)@cdM=*qjR zoV6rV>n?dxB*M~^;N>P?xGvzrb?*KaC2J$FqFgW?p#<=~ly0|F;_sjq)3Lox zvje>5@oP>`;(am2yvZrdVU+iiM0`v8rA}fSsS6_LbKI*1n0pc*uKpo0)Wk`u~Gtr1w*33_@F@D$;JssUf6g1tZb2HtZE|)i*+kk7gmS2c6UCv2j1iv$7I(+b4y;H3}1?vC?{-PL8n| zb&I40YhdI^O)OSxO62*f!rDocxrR{I2o6#4`VcO%jdk3N{suuMpyqTo z4rj%pL`|*aI+6%9it&#Q5IRAWuqOocYqO5;ZJ6^oi|mmZXhl!qp*vxnEAwvNn^T(jqFy<3f6a(LMK|BY)(c^s)m>+ zIOnE`YVA=j&kXbEB1(!CTvp@?^eI_Z-&$XWSvhK2RfyFF%cRwZ0R6-Pay_)#vtiPP zPdT!_He}|dg(!18*qM7d64F&|m%^e8P`V8@+jb0n!LhI`!DP373a$EBN!P1Q)iNPW z%j_igc%RJbgz?n7TdsJPV98rI3uDX_@0wlOprF(s*jwB*SLIY8WYm?)daRl%DRNZC zi@O0K(lM!)X^V5Oq|muDwE0bFXA{x^?#5Doc4FK#HwS~KTpx}@;F(`mrD?l?aDC^v z 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 literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/src/io.cpp.o b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/src/io.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..e2d03acf8855338de4dd8094e8198ceb9a631546 GIT binary patch literal 17920 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 B82A7H literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/src/reference.cpp.o b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/src/reference.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..ad46951c990b53dd789ae5829e69fa5cf15144a9 GIT binary patch literal 5392 zcmb_fZ){W76~F!y;-sms(}p%H)ku-sWfUHMX<8){o8rU{k6|FnpCLin2*3BM394gi`1Rvyt;=#LNZ-1uL{}!S9N%_! zB}jelQ*_%RJ@tJTgt4s#wdvF;m?+bO{zD6HXIUwf97^Xx9z1;Mq9P4D35 zSLo&oE3`564k>0Fohx+aO;A&!pI7wSWsolvGfq@l??(Acc5)Y!dr4v+|{rjhL_#?_p6NI2e37crf_gpgK=Cz5p8`v~_lcZdqid zc)Gz^sl;1!GW2D+%&KuR3tXidi^u%Fuw0Ute#VN-SXiwyQBqhz9rkrqsbyokpM`m2 z8(5_qyD9~Y#e2uFFt%!)Rj`fKW4u~#>|@5*evB(}3GLEzO%BW%)--u-7-`-0$^p{b~bj1^oP_Y$tbNR&2<{vbI*>BJ0+IfVjxoDDeI2H0k4h1-VF_ zU{^;4IHw6`djxD69)~F&+z-+Z+3&sV*Zi{&Cij{4g=dHK20V{A@y%Z$5%JGqiuc4y zzXZSzzfuL?2!Yw@OI7gas^CAaV*gAP{nxADKdFK*Rlz?-+~zvmtfEh{v3M*SOGRT+ zG?O9f{;ci6k&;G?VY!74M5D5{dp@@{`>{-lt`?@thP*Cr607BeJ(U z7*W++epub9{ttG*_kbShP}M{_kxJ-9iuA}Nv`>NnB~=}rm{2pZY%ZPBk_r8&dL#h) zd)lH$p4hGFJ#rXgyBj#dr}C4l`{`xd3HR^XGoZ?{x-*r@>%nYRJIbLpb#Go@#S$YU zW|JW~EKGJpkLW$=WIFp_n@XU^CxXe*bT*-njVpadoJweN(az(yemp6b25y#wJvbuic+39EM6m5|kuTv{E| zQX@$)sYWL>6;5{o63l3@GO!+oRS0h!MlW(4uTs4Uzrbc`7 zs1e7y68P0Bc!4$3ik(K2{&E$(j`sx=-)GWa&vA?&Wy0?x7Mz=9I-tfzbDRwb0->H6 z7yTV^E902pvazHl!JUPkFrw)ik%n_Q0)2s_Qa+VT9F8TA5@|FVRbvy;SVmXD23&ZP z78F}n&u2Js`o}vV>O_1`JO&u5i0?XJ8RgBFO@J_R zbF0V};Lv8Z^;UiB{3&kJx_{wc#3>wF*JFLy?f)!Kyuuga{?UhZ|6#z;Cg#RWMZW({ zW)OI*|ED=-jsI=FUVMiMGol}fIeu^1#ebQ{Kfx6-e*EgQ#-9cZ-v`$GU*rCTKBzDf zb1^;xsGa{l{%I)kkN)vWiFE>h4lv9Kz5~p3o%=`IW)gET7D0&XU6up5^&jFFHctb? z;SNXm!G&U-(7gl<_G3%1)jgN9LMv=cb8Z%&fm^AE@|d3nG6r? o0l@6;58i3(-Np5%`CptbED5trS?{%5@593e`l2$d{#w`n3z$yhH~;_u literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/test/test_performance.cpp.o b/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/test/test_performance.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..7b44f467ee56eb930e18a5b9f484a0d107ce10a3 GIT binary patch literal 9736 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 +Test time = 0.37 sec +---------------------------------------------------------- +Test Passed. +"correctness" end time: Mar 15 16:52 CST +"correctness" time elapsed: 00:00:00 +---------------------------------------------------------- + +2/2 Testing: performance +2/2 Test: performance +Command: "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/test_performance" +Directory: /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release +"performance" start time: Mar 15 16:52 CST +Output: +---------------------------------------------------------- +=== Bilateral Filter Benchmark === + +[naive_512_rgb ] 512x512 C=3 GPU=0.33ms Throughput=805.9MPix/s CPU=19.1ms Speedup=58.8x MAE=0.4780 PSNR=51.52dB +[shared_512_rgb ] 512x512 C=3 GPU=0.28ms Throughput=941.9MPix/s CPU=3.4ms Speedup=12.2x MAE=0.4922 PSNR=50.83dB +[adaptive_512_rgb ] 512x512 C=3 GPU=0.81ms Throughput=322.9MPix/s CPU=26.3ms Speedup=32.4x MAE=0.7032 PSNR=47.37dB +[naive_4K_rgb ] 3840x2160 C=3 GPU=7.54ms Throughput=1100.3MPix/s CPU=124.8ms Speedup=16.6x MAE=0.4735 PSNR=51.64dB +[shared_4K_rgb ] 3840x2160 C=3 GPU=5.98ms Throughput=1386.2MPix/s CPU=150.9ms Speedup=25.2x MAE=0.4762 PSNR=51.50dB +[adaptive_4K_rgb ] 3840x2160 C=3 GPU=5.99ms Throughput=1385.3MPix/s CPU=114.7ms Speedup=19.2x MAE=0.6957 PSNR=47.54dB + +Test time = 1.94 sec +---------------------------------------------------------- +Test Passed. +"performance" end time: Mar 15 16:52 CST +"performance" time elapsed: 00:00:01 +---------------------------------------------------------- + +End testing: Mar 15 16:52 CST + +benchmark = 1.94 sec*proc + +correctness = 0.37 sec*proc + +performance = 1.94 sec*proc + diff --git a/08_bilateral_filter/MLRichard/build/conda-release/Testing/Temporary/LastTestsFailed.log b/08_bilateral_filter/MLRichard/build/conda-release/Testing/Temporary/LastTestsFailed.log new file mode 100644 index 0000000..baef8a0 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/Testing/Temporary/LastTestsFailed.log @@ -0,0 +1,2 @@ +1:correctness +2:performance diff --git a/08_bilateral_filter/MLRichard/build/conda-release/bilateral_filter b/08_bilateral_filter/MLRichard/build/conda-release/bilateral_filter new file mode 100755 index 0000000000000000000000000000000000000000..68d6f086f6a97a6e6c75b5b568d74f4899b18f7f GIT binary patch literal 1523376 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%0DBTOSw@+ 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/b?AnLJZ!o(i|28J}^CDB)kpP8RV-AMS{U|P^1Vv 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ε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 literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/build.ninja b/08_bilateral_filter/MLRichard/build/conda-release/build.ninja new file mode 100644 index 0000000..860484a --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/build.ninja @@ -0,0 +1,822 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Ninja" Generator, CMake Version 4.2 + +# This file contains all the build statements describing the +# compilation DAG. + +# ============================================================================= +# Write statements declared in CMakeLists.txt: +# +# Which is the root file. +# ============================================================================= + +# ============================================================================= +# Project: bilateral_filter +# Configurations: Release +# ============================================================================= + +############################################# +# Minimal version of Ninja required by this file + +ninja_required_version = 1.5 + + +############################################# +# Set configuration variable for custom commands. + +CONFIGURATION = Release +# ============================================================================= +# Include auxiliary files. + + +############################################# +# Include rules file. + +include CMakeFiles/rules.ninja + +# ============================================================================= + +############################################# +# Logical path to working directory; prefix for absolute paths. + +cmake_ninja_workdir = /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/ + +############################################# +# Utility command for Experimental + +build Experimental: phony CMakeFiles/Experimental + + +############################################# +# Utility command for Nightly + +build Nightly: phony CMakeFiles/Nightly + + +############################################# +# Utility command for Continuous + +build Continuous: phony CMakeFiles/Continuous + + +############################################# +# Utility command for NightlyMemoryCheck + +build NightlyMemoryCheck: phony CMakeFiles/NightlyMemoryCheck + + +############################################# +# Utility command for NightlyStart + +build NightlyStart: phony CMakeFiles/NightlyStart + + +############################################# +# Utility command for NightlyUpdate + +build NightlyUpdate: phony CMakeFiles/NightlyUpdate + + +############################################# +# Utility command for NightlyConfigure + +build NightlyConfigure: phony CMakeFiles/NightlyConfigure + + +############################################# +# Utility command for NightlyBuild + +build NightlyBuild: phony CMakeFiles/NightlyBuild + + +############################################# +# Utility command for NightlyTest + +build NightlyTest: phony CMakeFiles/NightlyTest + + +############################################# +# Utility command for NightlyCoverage + +build NightlyCoverage: phony CMakeFiles/NightlyCoverage + + +############################################# +# Utility command for NightlyMemCheck + +build NightlyMemCheck: phony CMakeFiles/NightlyMemCheck + + +############################################# +# Utility command for NightlySubmit + +build NightlySubmit: phony CMakeFiles/NightlySubmit + + +############################################# +# Utility command for ExperimentalStart + +build ExperimentalStart: phony CMakeFiles/ExperimentalStart + + +############################################# +# Utility command for ExperimentalUpdate + +build ExperimentalUpdate: phony CMakeFiles/ExperimentalUpdate + + +############################################# +# Utility command for ExperimentalConfigure + +build ExperimentalConfigure: phony CMakeFiles/ExperimentalConfigure + + +############################################# +# Utility command for ExperimentalBuild + +build ExperimentalBuild: phony CMakeFiles/ExperimentalBuild + + +############################################# +# Utility command for ExperimentalTest + +build ExperimentalTest: phony CMakeFiles/ExperimentalTest + + +############################################# +# Utility command for ExperimentalCoverage + +build ExperimentalCoverage: phony CMakeFiles/ExperimentalCoverage + + +############################################# +# Utility command for ExperimentalMemCheck + +build ExperimentalMemCheck: phony CMakeFiles/ExperimentalMemCheck + + +############################################# +# Utility command for ExperimentalSubmit + +build ExperimentalSubmit: phony CMakeFiles/ExperimentalSubmit + + +############################################# +# Utility command for ContinuousStart + +build ContinuousStart: phony CMakeFiles/ContinuousStart + + +############################################# +# Utility command for ContinuousUpdate + +build ContinuousUpdate: phony CMakeFiles/ContinuousUpdate + + +############################################# +# Utility command for ContinuousConfigure + +build ContinuousConfigure: phony CMakeFiles/ContinuousConfigure + + +############################################# +# Utility command for ContinuousBuild + +build ContinuousBuild: phony CMakeFiles/ContinuousBuild + + +############################################# +# Utility command for ContinuousTest + +build ContinuousTest: phony CMakeFiles/ContinuousTest + + +############################################# +# Utility command for ContinuousCoverage + +build ContinuousCoverage: phony CMakeFiles/ContinuousCoverage + + +############################################# +# Utility command for ContinuousMemCheck + +build ContinuousMemCheck: phony CMakeFiles/ContinuousMemCheck + + +############################################# +# Utility command for ContinuousSubmit + +build ContinuousSubmit: phony CMakeFiles/ContinuousSubmit + +# ============================================================================= +# Object build statements for EXECUTABLE target bilateral_filter + + +############################################# +# Order-only phony target for bilateral_filter + +build cmake_object_order_depends_target_bilateral_filter: phony || . + +build CMakeFiles/bilateral_filter.dir/src/main.cu.o: CUDA_COMPILER__bilateral_filter_unscanned_Release /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/main.cu || cmake_object_order_depends_target_bilateral_filter + CONFIG = Release + DEP_FILE = CMakeFiles/bilateral_filter.dir/src/main.cu.o.d + FLAGS = -O3 -DNDEBUG -std=c++17 "--generate-code=arch=compute_75,code=[compute_75,sm_75]" "--generate-code=arch=compute_80,code=[compute_80,sm_80]" "--generate-code=arch=compute_86,code=[compute_86,sm_86]" "--generate-code=arch=compute_89,code=[compute_89,sm_89]" + INCLUDES = -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 + OBJECT_DIR = CMakeFiles/bilateral_filter.dir + OBJECT_FILE_DIR = CMakeFiles/bilateral_filter.dir/src + TARGET_COMPILE_PDB = CMakeFiles/bilateral_filter.dir/ + TARGET_PDB = bilateral_filter.pdb + TARGET_SUPPORT_DIR = CMakeFiles/bilateral_filter.dir + +build CMakeFiles/bilateral_filter.dir/src/bilateral_filter.cu.o: CUDA_COMPILER__bilateral_filter_unscanned_Release /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/bilateral_filter.cu || cmake_object_order_depends_target_bilateral_filter + CONFIG = Release + DEP_FILE = CMakeFiles/bilateral_filter.dir/src/bilateral_filter.cu.o.d + FLAGS = -O3 -DNDEBUG -std=c++17 "--generate-code=arch=compute_75,code=[compute_75,sm_75]" "--generate-code=arch=compute_80,code=[compute_80,sm_80]" "--generate-code=arch=compute_86,code=[compute_86,sm_86]" "--generate-code=arch=compute_89,code=[compute_89,sm_89]" + INCLUDES = -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 + OBJECT_DIR = CMakeFiles/bilateral_filter.dir + OBJECT_FILE_DIR = CMakeFiles/bilateral_filter.dir/src + TARGET_COMPILE_PDB = CMakeFiles/bilateral_filter.dir/ + TARGET_PDB = bilateral_filter.pdb + TARGET_SUPPORT_DIR = CMakeFiles/bilateral_filter.dir + +build CMakeFiles/bilateral_filter.dir/src/io.cpp.o: CXX_COMPILER__bilateral_filter_unscanned_Release /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/io.cpp || cmake_object_order_depends_target_bilateral_filter + CONFIG = Release + DEP_FILE = CMakeFiles/bilateral_filter.dir/src/io.cpp.o.d + FLAGS = -O3 -DNDEBUG -std=gnu++17 + INCLUDES = -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 + OBJECT_DIR = CMakeFiles/bilateral_filter.dir + OBJECT_FILE_DIR = CMakeFiles/bilateral_filter.dir/src + TARGET_COMPILE_PDB = CMakeFiles/bilateral_filter.dir/ + TARGET_PDB = bilateral_filter.pdb + TARGET_SUPPORT_DIR = CMakeFiles/bilateral_filter.dir + +build CMakeFiles/bilateral_filter.dir/src/reference.cpp.o: CXX_COMPILER__bilateral_filter_unscanned_Release /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/reference.cpp || cmake_object_order_depends_target_bilateral_filter + CONFIG = Release + DEP_FILE = CMakeFiles/bilateral_filter.dir/src/reference.cpp.o.d + FLAGS = -O3 -DNDEBUG -std=gnu++17 + INCLUDES = -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 + OBJECT_DIR = CMakeFiles/bilateral_filter.dir + OBJECT_FILE_DIR = CMakeFiles/bilateral_filter.dir/src + TARGET_COMPILE_PDB = CMakeFiles/bilateral_filter.dir/ + TARGET_PDB = bilateral_filter.pdb + TARGET_SUPPORT_DIR = CMakeFiles/bilateral_filter.dir + +build CMakeFiles/bilateral_filter.dir/src/metrics.cpp.o: CXX_COMPILER__bilateral_filter_unscanned_Release /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/metrics.cpp || cmake_object_order_depends_target_bilateral_filter + CONFIG = Release + DEP_FILE = CMakeFiles/bilateral_filter.dir/src/metrics.cpp.o.d + FLAGS = -O3 -DNDEBUG -std=gnu++17 + INCLUDES = -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 + OBJECT_DIR = CMakeFiles/bilateral_filter.dir + OBJECT_FILE_DIR = CMakeFiles/bilateral_filter.dir/src + TARGET_COMPILE_PDB = CMakeFiles/bilateral_filter.dir/ + TARGET_PDB = bilateral_filter.pdb + TARGET_SUPPORT_DIR = CMakeFiles/bilateral_filter.dir + + +# ============================================================================= +# Device Link build statements for EXECUTABLE target bilateral_filter + + +############################################# +# Link the executable CMakeFiles/bilateral_filter.dir/cmake_device_link.o + +build CMakeFiles/bilateral_filter.dir/cmake_device_link.o: CXX_EXECUTABLE_DEVICE_LINKER__bilateral_filter_Release CMakeFiles/bilateral_filter.dir/src/main.cu.o CMakeFiles/bilateral_filter.dir/src/bilateral_filter.cu.o CMakeFiles/bilateral_filter.dir/src/io.cpp.o CMakeFiles/bilateral_filter.dir/src/reference.cpp.o CMakeFiles/bilateral_filter.dir/src/metrics.cpp.o | /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_gapi.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_stitching.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_alphamat.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_aruco.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_bgsegm.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_bioinspired.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ccalib.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_cvv.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn_objdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn_superres.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dpm.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_face.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_freetype.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_fuzzy.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_hdf.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_hfs.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_img_hash.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_intensity_transform.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_line_descriptor.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_mcc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_quality.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_rapid.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_reg.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_rgbd.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_saliency.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_signal.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_stereo.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_structured_light.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_superres.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_surface_matching.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_tracking.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_videostab.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_wechat_qrcode.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xfeatures2d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xobjdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xphoto.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_shape.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_highgui.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_datasets.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_plot.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_text.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ml.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_phase_unwrapping.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_optflow.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ximgproc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_video.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_videoio.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_imgcodecs.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_objdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_calib3d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_features2d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_flann.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_photo.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_imgproc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_core.so.4.13.0 + LANGUAGE_COMPILE_FLAGS = -O3 -DNDEBUG "--generate-code=arch=compute_75,code=[compute_75,sm_75]" "--generate-code=arch=compute_80,code=[compute_80,sm_80]" "--generate-code=arch=compute_86,code=[compute_86,sm_86]" "--generate-code=arch=compute_89,code=[compute_89,sm_89]" + LINK_LIBRARIES = -lcudadevrt -lcudart_static -lrt -lpthread -ldl + LINK_PATH = -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs + OBJECT_DIR = CMakeFiles/bilateral_filter.dir + TARGET_COMPILE_PDB = CMakeFiles/bilateral_filter.dir/ + TARGET_FILE = CMakeFiles/bilateral_filter.dir/cmake_device_link.o + TARGET_PDB = bilateral_filter.pdb + TARGET_SUPPORT_DIR = CMakeFiles/bilateral_filter.dir + +# ============================================================================= +# Link build statements for EXECUTABLE target bilateral_filter + + +############################################# +# Link the executable bilateral_filter + +build bilateral_filter: CXX_EXECUTABLE_LINKER__bilateral_filter_Release CMakeFiles/bilateral_filter.dir/src/main.cu.o CMakeFiles/bilateral_filter.dir/src/bilateral_filter.cu.o CMakeFiles/bilateral_filter.dir/src/io.cpp.o CMakeFiles/bilateral_filter.dir/src/reference.cpp.o CMakeFiles/bilateral_filter.dir/src/metrics.cpp.o CMakeFiles/bilateral_filter.dir/cmake_device_link.o | /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_gapi.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_stitching.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_alphamat.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_aruco.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_bgsegm.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_bioinspired.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ccalib.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_cvv.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn_objdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn_superres.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dpm.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_face.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_freetype.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_fuzzy.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_hdf.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_hfs.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_img_hash.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_intensity_transform.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_line_descriptor.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_mcc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_quality.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_rapid.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_reg.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_rgbd.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_saliency.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_signal.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_stereo.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_structured_light.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_superres.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_surface_matching.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_tracking.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_videostab.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_wechat_qrcode.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xfeatures2d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xobjdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xphoto.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_shape.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_highgui.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_datasets.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_plot.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_text.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ml.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_phase_unwrapping.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_optflow.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ximgproc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_video.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_videoio.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_imgcodecs.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_objdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_calib3d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_features2d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_flann.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_photo.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_imgproc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_core.so.4.13.0 + CONFIG = Release + FLAGS = -O3 -DNDEBUG + LINK_LIBRARIES = /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_gapi.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_stitching.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_alphamat.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_aruco.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_bgsegm.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_bioinspired.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ccalib.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_cvv.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn_objdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn_superres.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dpm.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_face.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_freetype.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_fuzzy.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_hdf.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_hfs.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_img_hash.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_intensity_transform.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_line_descriptor.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_mcc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_quality.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_rapid.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_reg.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_rgbd.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_saliency.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_signal.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_stereo.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_structured_light.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_superres.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_surface_matching.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_tracking.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_videostab.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_wechat_qrcode.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xfeatures2d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xobjdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xphoto.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_shape.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_highgui.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_datasets.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_plot.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_text.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ml.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_phase_unwrapping.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_optflow.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ximgproc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_video.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_videoio.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_imgcodecs.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_objdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_calib3d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_features2d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_flann.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_photo.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_imgproc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_core.so.4.13.0 -lcudadevrt -lcudart_static -lrt -lpthread -ldl + LINK_PATH = -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs + OBJECT_DIR = CMakeFiles/bilateral_filter.dir + POST_BUILD = : + PRE_LINK = : + TARGET_COMPILE_PDB = CMakeFiles/bilateral_filter.dir/ + TARGET_FILE = bilateral_filter + TARGET_PDB = bilateral_filter.pdb + TARGET_SUPPORT_DIR = CMakeFiles/bilateral_filter.dir + +# ============================================================================= +# Object build statements for EXECUTABLE target test_correctness + + +############################################# +# Order-only phony target for test_correctness + +build cmake_object_order_depends_target_test_correctness: phony || . + +build CMakeFiles/test_correctness.dir/test/test_correctness.cpp.o: CXX_COMPILER__test_correctness_unscanned_Release /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/test/test_correctness.cpp || cmake_object_order_depends_target_test_correctness + CONFIG = Release + DEP_FILE = CMakeFiles/test_correctness.dir/test/test_correctness.cpp.o.d + FLAGS = -O3 -DNDEBUG -std=gnu++17 + INCLUDES = -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 + OBJECT_DIR = CMakeFiles/test_correctness.dir + OBJECT_FILE_DIR = CMakeFiles/test_correctness.dir/test + TARGET_COMPILE_PDB = CMakeFiles/test_correctness.dir/ + TARGET_PDB = test_correctness.pdb + TARGET_SUPPORT_DIR = CMakeFiles/test_correctness.dir + +build CMakeFiles/test_correctness.dir/src/bilateral_filter.cu.o: CUDA_COMPILER__test_correctness_unscanned_Release /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/bilateral_filter.cu || cmake_object_order_depends_target_test_correctness + CONFIG = Release + DEP_FILE = CMakeFiles/test_correctness.dir/src/bilateral_filter.cu.o.d + FLAGS = -O3 -DNDEBUG -std=c++17 "--generate-code=arch=compute_75,code=[compute_75,sm_75]" "--generate-code=arch=compute_80,code=[compute_80,sm_80]" "--generate-code=arch=compute_86,code=[compute_86,sm_86]" "--generate-code=arch=compute_89,code=[compute_89,sm_89]" + INCLUDES = -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 + OBJECT_DIR = CMakeFiles/test_correctness.dir + OBJECT_FILE_DIR = CMakeFiles/test_correctness.dir/src + TARGET_COMPILE_PDB = CMakeFiles/test_correctness.dir/ + TARGET_PDB = test_correctness.pdb + TARGET_SUPPORT_DIR = CMakeFiles/test_correctness.dir + +build CMakeFiles/test_correctness.dir/src/io.cpp.o: CXX_COMPILER__test_correctness_unscanned_Release /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/io.cpp || cmake_object_order_depends_target_test_correctness + CONFIG = Release + DEP_FILE = CMakeFiles/test_correctness.dir/src/io.cpp.o.d + FLAGS = -O3 -DNDEBUG -std=gnu++17 + INCLUDES = -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 + OBJECT_DIR = CMakeFiles/test_correctness.dir + OBJECT_FILE_DIR = CMakeFiles/test_correctness.dir/src + TARGET_COMPILE_PDB = CMakeFiles/test_correctness.dir/ + TARGET_PDB = test_correctness.pdb + TARGET_SUPPORT_DIR = CMakeFiles/test_correctness.dir + +build CMakeFiles/test_correctness.dir/src/reference.cpp.o: CXX_COMPILER__test_correctness_unscanned_Release /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/reference.cpp || cmake_object_order_depends_target_test_correctness + CONFIG = Release + DEP_FILE = CMakeFiles/test_correctness.dir/src/reference.cpp.o.d + FLAGS = -O3 -DNDEBUG -std=gnu++17 + INCLUDES = -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 + OBJECT_DIR = CMakeFiles/test_correctness.dir + OBJECT_FILE_DIR = CMakeFiles/test_correctness.dir/src + TARGET_COMPILE_PDB = CMakeFiles/test_correctness.dir/ + TARGET_PDB = test_correctness.pdb + TARGET_SUPPORT_DIR = CMakeFiles/test_correctness.dir + +build CMakeFiles/test_correctness.dir/src/metrics.cpp.o: CXX_COMPILER__test_correctness_unscanned_Release /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/metrics.cpp || cmake_object_order_depends_target_test_correctness + CONFIG = Release + DEP_FILE = CMakeFiles/test_correctness.dir/src/metrics.cpp.o.d + FLAGS = -O3 -DNDEBUG -std=gnu++17 + INCLUDES = -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 + OBJECT_DIR = CMakeFiles/test_correctness.dir + OBJECT_FILE_DIR = CMakeFiles/test_correctness.dir/src + TARGET_COMPILE_PDB = CMakeFiles/test_correctness.dir/ + TARGET_PDB = test_correctness.pdb + TARGET_SUPPORT_DIR = CMakeFiles/test_correctness.dir + + +# ============================================================================= +# Device Link build statements for EXECUTABLE target test_correctness + + +############################################# +# Link the executable CMakeFiles/test_correctness.dir/cmake_device_link.o + +build CMakeFiles/test_correctness.dir/cmake_device_link.o: CXX_EXECUTABLE_DEVICE_LINKER__test_correctness_Release CMakeFiles/test_correctness.dir/test/test_correctness.cpp.o CMakeFiles/test_correctness.dir/src/bilateral_filter.cu.o CMakeFiles/test_correctness.dir/src/io.cpp.o CMakeFiles/test_correctness.dir/src/reference.cpp.o CMakeFiles/test_correctness.dir/src/metrics.cpp.o | /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_gapi.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_stitching.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_alphamat.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_aruco.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_bgsegm.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_bioinspired.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ccalib.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_cvv.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn_objdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn_superres.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dpm.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_face.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_freetype.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_fuzzy.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_hdf.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_hfs.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_img_hash.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_intensity_transform.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_line_descriptor.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_mcc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_quality.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_rapid.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_reg.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_rgbd.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_saliency.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_signal.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_stereo.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_structured_light.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_superres.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_surface_matching.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_tracking.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_videostab.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_wechat_qrcode.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xfeatures2d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xobjdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xphoto.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_shape.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_highgui.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_datasets.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_plot.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_text.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ml.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_phase_unwrapping.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_optflow.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ximgproc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_video.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_videoio.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_imgcodecs.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_objdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_calib3d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_features2d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_flann.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_photo.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_imgproc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_core.so.4.13.0 + LANGUAGE_COMPILE_FLAGS = -O3 -DNDEBUG "--generate-code=arch=compute_75,code=[compute_75,sm_75]" "--generate-code=arch=compute_80,code=[compute_80,sm_80]" "--generate-code=arch=compute_86,code=[compute_86,sm_86]" "--generate-code=arch=compute_89,code=[compute_89,sm_89]" + LINK_LIBRARIES = -lcudadevrt -lcudart_static -lrt -lpthread -ldl + LINK_PATH = -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs + OBJECT_DIR = CMakeFiles/test_correctness.dir + TARGET_COMPILE_PDB = CMakeFiles/test_correctness.dir/ + TARGET_FILE = CMakeFiles/test_correctness.dir/cmake_device_link.o + TARGET_PDB = test_correctness.pdb + TARGET_SUPPORT_DIR = CMakeFiles/test_correctness.dir + +# ============================================================================= +# Link build statements for EXECUTABLE target test_correctness + + +############################################# +# Link the executable test_correctness + +build test_correctness: CXX_EXECUTABLE_LINKER__test_correctness_Release CMakeFiles/test_correctness.dir/test/test_correctness.cpp.o CMakeFiles/test_correctness.dir/src/bilateral_filter.cu.o CMakeFiles/test_correctness.dir/src/io.cpp.o CMakeFiles/test_correctness.dir/src/reference.cpp.o CMakeFiles/test_correctness.dir/src/metrics.cpp.o CMakeFiles/test_correctness.dir/cmake_device_link.o | /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_gapi.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_stitching.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_alphamat.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_aruco.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_bgsegm.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_bioinspired.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ccalib.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_cvv.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn_objdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn_superres.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dpm.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_face.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_freetype.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_fuzzy.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_hdf.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_hfs.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_img_hash.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_intensity_transform.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_line_descriptor.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_mcc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_quality.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_rapid.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_reg.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_rgbd.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_saliency.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_signal.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_stereo.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_structured_light.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_superres.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_surface_matching.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_tracking.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_videostab.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_wechat_qrcode.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xfeatures2d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xobjdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xphoto.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_shape.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_highgui.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_datasets.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_plot.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_text.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ml.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_phase_unwrapping.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_optflow.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ximgproc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_video.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_videoio.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_imgcodecs.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_objdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_calib3d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_features2d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_flann.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_photo.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_imgproc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_core.so.4.13.0 + CONFIG = Release + FLAGS = -O3 -DNDEBUG + LINK_LIBRARIES = /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_gapi.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_stitching.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_alphamat.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_aruco.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_bgsegm.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_bioinspired.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ccalib.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_cvv.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn_objdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn_superres.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dpm.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_face.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_freetype.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_fuzzy.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_hdf.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_hfs.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_img_hash.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_intensity_transform.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_line_descriptor.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_mcc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_quality.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_rapid.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_reg.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_rgbd.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_saliency.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_signal.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_stereo.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_structured_light.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_superres.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_surface_matching.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_tracking.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_videostab.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_wechat_qrcode.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xfeatures2d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xobjdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xphoto.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_shape.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_highgui.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_datasets.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_plot.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_text.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ml.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_phase_unwrapping.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_optflow.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ximgproc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_video.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_videoio.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_imgcodecs.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_objdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_calib3d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_features2d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_flann.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_photo.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_imgproc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_core.so.4.13.0 -lcudadevrt -lcudart_static -lrt -lpthread -ldl + LINK_PATH = -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs + OBJECT_DIR = CMakeFiles/test_correctness.dir + POST_BUILD = : + PRE_LINK = : + TARGET_COMPILE_PDB = CMakeFiles/test_correctness.dir/ + TARGET_FILE = test_correctness + TARGET_PDB = test_correctness.pdb + TARGET_SUPPORT_DIR = CMakeFiles/test_correctness.dir + +# ============================================================================= +# Object build statements for EXECUTABLE target test_performance + + +############################################# +# Order-only phony target for test_performance + +build cmake_object_order_depends_target_test_performance: phony || . + +build CMakeFiles/test_performance.dir/test/test_performance.cpp.o: CXX_COMPILER__test_performance_unscanned_Release /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/test/test_performance.cpp || cmake_object_order_depends_target_test_performance + CONFIG = Release + DEP_FILE = CMakeFiles/test_performance.dir/test/test_performance.cpp.o.d + FLAGS = -O3 -DNDEBUG -std=gnu++17 + INCLUDES = -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 + OBJECT_DIR = CMakeFiles/test_performance.dir + OBJECT_FILE_DIR = CMakeFiles/test_performance.dir/test + TARGET_COMPILE_PDB = CMakeFiles/test_performance.dir/ + TARGET_PDB = test_performance.pdb + TARGET_SUPPORT_DIR = CMakeFiles/test_performance.dir + +build CMakeFiles/test_performance.dir/src/bilateral_filter.cu.o: CUDA_COMPILER__test_performance_unscanned_Release /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/bilateral_filter.cu || cmake_object_order_depends_target_test_performance + CONFIG = Release + DEP_FILE = CMakeFiles/test_performance.dir/src/bilateral_filter.cu.o.d + FLAGS = -O3 -DNDEBUG -std=c++17 "--generate-code=arch=compute_75,code=[compute_75,sm_75]" "--generate-code=arch=compute_80,code=[compute_80,sm_80]" "--generate-code=arch=compute_86,code=[compute_86,sm_86]" "--generate-code=arch=compute_89,code=[compute_89,sm_89]" + INCLUDES = -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 + OBJECT_DIR = CMakeFiles/test_performance.dir + OBJECT_FILE_DIR = CMakeFiles/test_performance.dir/src + TARGET_COMPILE_PDB = CMakeFiles/test_performance.dir/ + TARGET_PDB = test_performance.pdb + TARGET_SUPPORT_DIR = CMakeFiles/test_performance.dir + +build CMakeFiles/test_performance.dir/src/io.cpp.o: CXX_COMPILER__test_performance_unscanned_Release /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/io.cpp || cmake_object_order_depends_target_test_performance + CONFIG = Release + DEP_FILE = CMakeFiles/test_performance.dir/src/io.cpp.o.d + FLAGS = -O3 -DNDEBUG -std=gnu++17 + INCLUDES = -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 + OBJECT_DIR = CMakeFiles/test_performance.dir + OBJECT_FILE_DIR = CMakeFiles/test_performance.dir/src + TARGET_COMPILE_PDB = CMakeFiles/test_performance.dir/ + TARGET_PDB = test_performance.pdb + TARGET_SUPPORT_DIR = CMakeFiles/test_performance.dir + +build CMakeFiles/test_performance.dir/src/reference.cpp.o: CXX_COMPILER__test_performance_unscanned_Release /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/reference.cpp || cmake_object_order_depends_target_test_performance + CONFIG = Release + DEP_FILE = CMakeFiles/test_performance.dir/src/reference.cpp.o.d + FLAGS = -O3 -DNDEBUG -std=gnu++17 + INCLUDES = -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 + OBJECT_DIR = CMakeFiles/test_performance.dir + OBJECT_FILE_DIR = CMakeFiles/test_performance.dir/src + TARGET_COMPILE_PDB = CMakeFiles/test_performance.dir/ + TARGET_PDB = test_performance.pdb + TARGET_SUPPORT_DIR = CMakeFiles/test_performance.dir + +build CMakeFiles/test_performance.dir/src/metrics.cpp.o: CXX_COMPILER__test_performance_unscanned_Release /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/metrics.cpp || cmake_object_order_depends_target_test_performance + CONFIG = Release + DEP_FILE = CMakeFiles/test_performance.dir/src/metrics.cpp.o.d + FLAGS = -O3 -DNDEBUG -std=gnu++17 + INCLUDES = -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 + OBJECT_DIR = CMakeFiles/test_performance.dir + OBJECT_FILE_DIR = CMakeFiles/test_performance.dir/src + TARGET_COMPILE_PDB = CMakeFiles/test_performance.dir/ + TARGET_PDB = test_performance.pdb + TARGET_SUPPORT_DIR = CMakeFiles/test_performance.dir + + +# ============================================================================= +# Device Link build statements for EXECUTABLE target test_performance + + +############################################# +# Link the executable CMakeFiles/test_performance.dir/cmake_device_link.o + +build CMakeFiles/test_performance.dir/cmake_device_link.o: CXX_EXECUTABLE_DEVICE_LINKER__test_performance_Release CMakeFiles/test_performance.dir/test/test_performance.cpp.o CMakeFiles/test_performance.dir/src/bilateral_filter.cu.o CMakeFiles/test_performance.dir/src/io.cpp.o CMakeFiles/test_performance.dir/src/reference.cpp.o CMakeFiles/test_performance.dir/src/metrics.cpp.o | /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_gapi.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_stitching.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_alphamat.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_aruco.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_bgsegm.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_bioinspired.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ccalib.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_cvv.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn_objdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn_superres.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dpm.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_face.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_freetype.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_fuzzy.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_hdf.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_hfs.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_img_hash.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_intensity_transform.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_line_descriptor.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_mcc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_quality.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_rapid.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_reg.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_rgbd.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_saliency.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_signal.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_stereo.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_structured_light.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_superres.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_surface_matching.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_tracking.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_videostab.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_wechat_qrcode.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xfeatures2d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xobjdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xphoto.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_shape.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_highgui.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_datasets.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_plot.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_text.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ml.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_phase_unwrapping.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_optflow.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ximgproc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_video.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_videoio.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_imgcodecs.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_objdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_calib3d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_features2d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_flann.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_photo.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_imgproc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_core.so.4.13.0 + LANGUAGE_COMPILE_FLAGS = -O3 -DNDEBUG "--generate-code=arch=compute_75,code=[compute_75,sm_75]" "--generate-code=arch=compute_80,code=[compute_80,sm_80]" "--generate-code=arch=compute_86,code=[compute_86,sm_86]" "--generate-code=arch=compute_89,code=[compute_89,sm_89]" + LINK_LIBRARIES = -lcudadevrt -lcudart_static -lrt -lpthread -ldl + LINK_PATH = -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs + OBJECT_DIR = CMakeFiles/test_performance.dir + TARGET_COMPILE_PDB = CMakeFiles/test_performance.dir/ + TARGET_FILE = CMakeFiles/test_performance.dir/cmake_device_link.o + TARGET_PDB = test_performance.pdb + TARGET_SUPPORT_DIR = CMakeFiles/test_performance.dir + +# ============================================================================= +# Link build statements for EXECUTABLE target test_performance + + +############################################# +# Link the executable test_performance + +build test_performance: CXX_EXECUTABLE_LINKER__test_performance_Release CMakeFiles/test_performance.dir/test/test_performance.cpp.o CMakeFiles/test_performance.dir/src/bilateral_filter.cu.o CMakeFiles/test_performance.dir/src/io.cpp.o CMakeFiles/test_performance.dir/src/reference.cpp.o CMakeFiles/test_performance.dir/src/metrics.cpp.o CMakeFiles/test_performance.dir/cmake_device_link.o | /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_gapi.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_stitching.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_alphamat.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_aruco.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_bgsegm.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_bioinspired.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ccalib.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_cvv.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn_objdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn_superres.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dpm.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_face.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_freetype.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_fuzzy.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_hdf.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_hfs.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_img_hash.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_intensity_transform.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_line_descriptor.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_mcc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_quality.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_rapid.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_reg.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_rgbd.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_saliency.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_signal.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_stereo.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_structured_light.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_superres.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_surface_matching.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_tracking.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_videostab.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_wechat_qrcode.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xfeatures2d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xobjdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xphoto.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_shape.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_highgui.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_datasets.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_plot.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_text.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ml.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_phase_unwrapping.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_optflow.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ximgproc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_video.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_videoio.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_imgcodecs.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_objdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_calib3d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_features2d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_flann.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_photo.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_imgproc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_core.so.4.13.0 + CONFIG = Release + FLAGS = -O3 -DNDEBUG + LINK_LIBRARIES = /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_gapi.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_stitching.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_alphamat.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_aruco.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_bgsegm.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_bioinspired.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ccalib.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_cvv.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn_objdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn_superres.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dpm.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_face.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_freetype.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_fuzzy.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_hdf.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_hfs.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_img_hash.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_intensity_transform.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_line_descriptor.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_mcc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_quality.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_rapid.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_reg.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_rgbd.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_saliency.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_signal.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_stereo.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_structured_light.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_superres.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_surface_matching.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_tracking.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_videostab.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_wechat_qrcode.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xfeatures2d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xobjdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_xphoto.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_shape.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_highgui.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_datasets.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_plot.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_text.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ml.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_phase_unwrapping.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_optflow.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_ximgproc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_video.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_videoio.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_imgcodecs.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_objdetect.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_calib3d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_dnn.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_features2d.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_flann.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_photo.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_imgproc.so.4.13.0 /home/richard/miniconda3/envs/bilateral-cuda124/lib/libopencv_core.so.4.13.0 -lcudadevrt -lcudart_static -lrt -lpthread -ldl + LINK_PATH = -L/home/richard/miniconda3/envs/bilateral-cuda124/lib/stubs + OBJECT_DIR = CMakeFiles/test_performance.dir + POST_BUILD = : + PRE_LINK = : + TARGET_COMPILE_PDB = CMakeFiles/test_performance.dir/ + TARGET_FILE = test_performance + TARGET_PDB = test_performance.pdb + TARGET_SUPPORT_DIR = CMakeFiles/test_performance.dir + + +############################################# +# Utility command for test + +build CMakeFiles/test.util: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest + DESC = Running tests... + pool = console + restat = 1 + +build test: phony CMakeFiles/test.util + + +############################################# +# Utility command for edit_cache + +build CMakeFiles/edit_cache.util: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ccmake -S/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard -B/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release + 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/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/cmake --regenerate-during-build -S/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard -B/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release + DESC = Running CMake to regenerate build system... + pool = console + restat = 1 + +build rebuild_cache: phony CMakeFiles/rebuild_cache.util + + +############################################# +# Custom command for CMakeFiles/Experimental + +build CMakeFiles/Experimental | ${cmake_ninja_workdir}CMakeFiles/Experimental: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Experimental -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/Nightly + +build CMakeFiles/Nightly | ${cmake_ninja_workdir}CMakeFiles/Nightly: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Nightly -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/Continuous + +build CMakeFiles/Continuous | ${cmake_ninja_workdir}CMakeFiles/Continuous: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Continuous -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/NightlyMemoryCheck + +build CMakeFiles/NightlyMemoryCheck | ${cmake_ninja_workdir}CMakeFiles/NightlyMemoryCheck: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=NightlyMemoryCheck -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/NightlyStart + +build CMakeFiles/NightlyStart | ${cmake_ninja_workdir}CMakeFiles/NightlyStart: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Nightly -DACTIONS=Start -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/NightlyUpdate + +build CMakeFiles/NightlyUpdate | ${cmake_ninja_workdir}CMakeFiles/NightlyUpdate: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Nightly -DACTIONS=Update -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/NightlyConfigure + +build CMakeFiles/NightlyConfigure | ${cmake_ninja_workdir}CMakeFiles/NightlyConfigure: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Nightly -DACTIONS=Configure -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/NightlyBuild + +build CMakeFiles/NightlyBuild | ${cmake_ninja_workdir}CMakeFiles/NightlyBuild: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Nightly -DACTIONS=Build -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/NightlyTest + +build CMakeFiles/NightlyTest | ${cmake_ninja_workdir}CMakeFiles/NightlyTest: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Nightly -DACTIONS=Test -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/NightlyCoverage + +build CMakeFiles/NightlyCoverage | ${cmake_ninja_workdir}CMakeFiles/NightlyCoverage: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Nightly -DACTIONS=Coverage -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/NightlyMemCheck + +build CMakeFiles/NightlyMemCheck | ${cmake_ninja_workdir}CMakeFiles/NightlyMemCheck: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Nightly -DACTIONS=MemCheck -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/NightlySubmit + +build CMakeFiles/NightlySubmit | ${cmake_ninja_workdir}CMakeFiles/NightlySubmit: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Nightly -DACTIONS=Submit -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/ExperimentalStart + +build CMakeFiles/ExperimentalStart | ${cmake_ninja_workdir}CMakeFiles/ExperimentalStart: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Experimental -DACTIONS=Start -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/ExperimentalUpdate + +build CMakeFiles/ExperimentalUpdate | ${cmake_ninja_workdir}CMakeFiles/ExperimentalUpdate: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Experimental -DACTIONS=Update -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/ExperimentalConfigure + +build CMakeFiles/ExperimentalConfigure | ${cmake_ninja_workdir}CMakeFiles/ExperimentalConfigure: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Experimental -DACTIONS=Configure -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/ExperimentalBuild + +build CMakeFiles/ExperimentalBuild | ${cmake_ninja_workdir}CMakeFiles/ExperimentalBuild: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Experimental -DACTIONS=Build -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/ExperimentalTest + +build CMakeFiles/ExperimentalTest | ${cmake_ninja_workdir}CMakeFiles/ExperimentalTest: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Experimental -DACTIONS=Test -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/ExperimentalCoverage + +build CMakeFiles/ExperimentalCoverage | ${cmake_ninja_workdir}CMakeFiles/ExperimentalCoverage: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Experimental -DACTIONS=Coverage -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/ExperimentalMemCheck + +build CMakeFiles/ExperimentalMemCheck | ${cmake_ninja_workdir}CMakeFiles/ExperimentalMemCheck: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Experimental -DACTIONS=MemCheck -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/ExperimentalSubmit + +build CMakeFiles/ExperimentalSubmit | ${cmake_ninja_workdir}CMakeFiles/ExperimentalSubmit: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Experimental -DACTIONS=Submit -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/ContinuousStart + +build CMakeFiles/ContinuousStart | ${cmake_ninja_workdir}CMakeFiles/ContinuousStart: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Continuous -DACTIONS=Start -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/ContinuousUpdate + +build CMakeFiles/ContinuousUpdate | ${cmake_ninja_workdir}CMakeFiles/ContinuousUpdate: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Continuous -DACTIONS=Update -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/ContinuousConfigure + +build CMakeFiles/ContinuousConfigure | ${cmake_ninja_workdir}CMakeFiles/ContinuousConfigure: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Continuous -DACTIONS=Configure -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/ContinuousBuild + +build CMakeFiles/ContinuousBuild | ${cmake_ninja_workdir}CMakeFiles/ContinuousBuild: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Continuous -DACTIONS=Build -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/ContinuousTest + +build CMakeFiles/ContinuousTest | ${cmake_ninja_workdir}CMakeFiles/ContinuousTest: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Continuous -DACTIONS=Test -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/ContinuousCoverage + +build CMakeFiles/ContinuousCoverage | ${cmake_ninja_workdir}CMakeFiles/ContinuousCoverage: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Continuous -DACTIONS=Coverage -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/ContinuousMemCheck + +build CMakeFiles/ContinuousMemCheck | ${cmake_ninja_workdir}CMakeFiles/ContinuousMemCheck: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Continuous -DACTIONS=MemCheck -S CMakeFiles/CTestScript.cmake -V + pool = console + + +############################################# +# Custom command for CMakeFiles/ContinuousSubmit + +build CMakeFiles/ContinuousSubmit | ${cmake_ninja_workdir}CMakeFiles/ContinuousSubmit: CUSTOM_COMMAND + COMMAND = cd /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release && /home/richard/miniconda3/envs/bilateral-cuda124/bin/ctest -DMODEL=Continuous -DACTIONS=Submit -S CMakeFiles/CTestScript.cmake -V + pool = console + +# ============================================================================= +# Target aliases. + +# ============================================================================= +# Folder targets. + +# ============================================================================= + +############################################# +# Folder: /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release + +build all: phony bilateral_filter test_correctness test_performance + +# ============================================================================= +# Built-in targets + + +############################################# +# Re-run CMake if any of its inputs changed. + +build build.ninja /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/cmake_install.cmake /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CTestTestfile.cmake: RERUN_CMAKE | /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/CMakeLists.txt /home/richard/miniconda3/envs/bilateral-cuda124/lib/cmake/opencv4/OpenCVConfig-version.cmake /home/richard/miniconda3/envs/bilateral-cuda124/lib/cmake/opencv4/OpenCVConfig.cmake /home/richard/miniconda3/envs/bilateral-cuda124/lib/cmake/opencv4/OpenCVModules-release.cmake /home/richard/miniconda3/envs/bilateral-cuda124/lib/cmake/opencv4/OpenCVModules.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCUDACompiler.cmake.in /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCUDACompilerABI.cu /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCUDAInformation.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCXXCompiler.cmake.in /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCXXCompilerABI.cpp /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCXXInformation.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCommonLanguageInclude.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCompilerIdDetection.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCUDACompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerABI.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerSupport.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineSystem.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeGenericSystem.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeInitializeConfigs.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeLanguageInformation.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeNinjaFindMake.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeParseImplicitIncludeInfo.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeParseImplicitLinkInfo.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeParseLibraryArchitecture.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeSystem.cmake.in /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeSystemSpecificInformation.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeSystemSpecificInitialize.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeTestCUDACompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeTestCXXCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeTestCompilerCommon.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CTest.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CTestTargets.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CTestUseLaunchers.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/ADSP-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/ARMCC-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/ARMClang-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/AppleClang-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Borland-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Bruce-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/CMakeCommonCompilerMacros.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Clang-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Clang-DetermineCompilerInternal.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Compaq-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Cray-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/CrayClang-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Diab-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Embarcadero-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Fujitsu-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/FujitsuClang-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/GHS-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/GNU-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/GNU-CXX-CXXImportStd.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/GNU-CXX.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/GNU-FindBinUtils.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/GNU.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/HP-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/HP-CXX-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/IAR-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/IBMCPP-C-DetermineVersionInternal.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/IBMClang-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/IBMClang-CXX-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Intel-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/IntelLLVM-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/LCC-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/LCC-CXX-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/MSVC-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/NVHPC-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/NVIDIA-CUDA.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/NVIDIA-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/NVIDIA.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/OrangeC-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/PGI-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/PathScale-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Renesas-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/SCO-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/SDCC-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/SunPro-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/SunPro-CXX-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/TI-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/TIClang-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Tasking-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/TinyCC-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/VisualAge-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/VisualAge-CXX-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Watcom-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/XL-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/XL-CXX-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/XLClang-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/XLClang-CXX-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/zOS-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/zOS-CXX-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/DartConfiguration.tcl.in /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/FindPackageHandleStandardArgs.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/FindPackageMessage.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeCUDAArchitecturesAll.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeCUDAArchitecturesNative.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeCUDAArchitecturesValidate.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeCUDAFilterImplicitLibs.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeCUDAFindToolkit.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeCUDALinkerInformation.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeCXXLinkerInformation.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeCommonLinkerInformation.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeDetermineLinkerId.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeInspectCUDALinker.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeInspectCXXLinker.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeNVCCFilterImplicitInfo.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeNVCCParseImplicitInfo.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/FeatureTesting.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Linker/GNU-CUDA.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Linker/GNU-CXX.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Linker/GNU.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/Linker/GNU.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/Linker/Linux-GNU-CUDA.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/Linker/Linux-GNU-CXX.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/Linker/Linux-GNU.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/Linux-Determine-CXX.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/Linux-GNU-CXX.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/Linux-GNU.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/Linux-Initialize.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/Linux-NVIDIA-CUDA.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/Linux.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/UnixPaths.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Templates/CTestScript.cmake.in CMakeCache.txt CMakeFiles/4.2.3/CMakeCUDACompiler.cmake CMakeFiles/4.2.3/CMakeCXXCompiler.cmake CMakeFiles/4.2.3/CMakeSystem.cmake + pool = console + + +############################################# +# A missing CMake input file is not an error. + +build /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/CMakeLists.txt /home/richard/miniconda3/envs/bilateral-cuda124/lib/cmake/opencv4/OpenCVConfig-version.cmake /home/richard/miniconda3/envs/bilateral-cuda124/lib/cmake/opencv4/OpenCVConfig.cmake /home/richard/miniconda3/envs/bilateral-cuda124/lib/cmake/opencv4/OpenCVModules-release.cmake /home/richard/miniconda3/envs/bilateral-cuda124/lib/cmake/opencv4/OpenCVModules.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCUDACompiler.cmake.in /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCUDACompilerABI.cu /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCUDAInformation.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCXXCompiler.cmake.in /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCXXCompilerABI.cpp /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCXXInformation.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCommonLanguageInclude.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeCompilerIdDetection.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCUDACompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerABI.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineCompilerSupport.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeDetermineSystem.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeGenericSystem.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeInitializeConfigs.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeLanguageInformation.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeNinjaFindMake.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeParseImplicitIncludeInfo.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeParseImplicitLinkInfo.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeParseLibraryArchitecture.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeSystem.cmake.in /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeSystemSpecificInformation.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeSystemSpecificInitialize.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeTestCUDACompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeTestCXXCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CMakeTestCompilerCommon.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CTest.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CTestTargets.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/CTestUseLaunchers.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/ADSP-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/ARMCC-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/ARMClang-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/AppleClang-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Borland-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Bruce-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/CMakeCommonCompilerMacros.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Clang-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Clang-DetermineCompilerInternal.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Compaq-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Cray-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/CrayClang-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Diab-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Embarcadero-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Fujitsu-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/FujitsuClang-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/GHS-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/GNU-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/GNU-CXX-CXXImportStd.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/GNU-CXX.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/GNU-FindBinUtils.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/GNU.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/HP-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/HP-CXX-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/IAR-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/IBMCPP-C-DetermineVersionInternal.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/IBMClang-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/IBMClang-CXX-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Intel-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/IntelLLVM-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/LCC-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/LCC-CXX-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/MSVC-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/NVHPC-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/NVIDIA-CUDA.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/NVIDIA-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/NVIDIA.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/OrangeC-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/PGI-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/PathScale-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Renesas-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/SCO-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/SDCC-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/SunPro-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/SunPro-CXX-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/TI-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/TIClang-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Tasking-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/TinyCC-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/VisualAge-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/VisualAge-CXX-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/Watcom-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/XL-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/XL-CXX-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/XLClang-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/XLClang-CXX-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/zOS-C-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Compiler/zOS-CXX-DetermineCompiler.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/DartConfiguration.tcl.in /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/FindPackageHandleStandardArgs.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/FindPackageMessage.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeCUDAArchitecturesAll.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeCUDAArchitecturesNative.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeCUDAArchitecturesValidate.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeCUDAFilterImplicitLibs.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeCUDAFindToolkit.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeCUDALinkerInformation.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeCXXLinkerInformation.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeCommonLinkerInformation.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeDetermineLinkerId.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeInspectCUDALinker.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeInspectCXXLinker.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeNVCCFilterImplicitInfo.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/CMakeNVCCParseImplicitInfo.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Internal/FeatureTesting.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Linker/GNU-CUDA.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Linker/GNU-CXX.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Linker/GNU.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/Linker/GNU.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/Linker/Linux-GNU-CUDA.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/Linker/Linux-GNU-CXX.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/Linker/Linux-GNU.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/Linux-Determine-CXX.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/Linux-GNU-CXX.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/Linux-GNU.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/Linux-Initialize.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/Linux-NVIDIA-CUDA.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/Linux.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Modules/Platform/UnixPaths.cmake /home/richard/miniconda3/envs/bilateral-cuda124/share/cmake-4.2/Templates/CTestScript.cmake.in CMakeCache.txt CMakeFiles/4.2.3/CMakeCUDACompiler.cmake CMakeFiles/4.2.3/CMakeCXXCompiler.cmake CMakeFiles/4.2.3/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/08_bilateral_filter/MLRichard/build/conda-release/cmake_install.cmake b/08_bilateral_filter/MLRichard/build/conda-release/cmake_install.cmake new file mode 100644 index 0000000..5ebdff5 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/cmake_install.cmake @@ -0,0 +1,66 @@ +# Install script for directory: /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard + +# 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 "Release") + 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 "1") +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/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/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/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/${CMAKE_INSTALL_MANIFEST}" + "${CMAKE_INSTALL_MANIFEST_CONTENT}") +endif() diff --git a/08_bilateral_filter/MLRichard/build/conda-release/compile_commands.json b/08_bilateral_filter/MLRichard/build/conda-release/compile_commands.json new file mode 100644 index 0000000..b5f6403 --- /dev/null +++ b/08_bilateral_filter/MLRichard/build/conda-release/compile_commands.json @@ -0,0 +1,92 @@ +[ +{ + "directory": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release", + "command": "/home/richard/miniconda3/envs/bilateral-cuda124/bin/nvcc -forward-unknown-to-host-compiler -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 -O3 -DNDEBUG -std=c++17 \"--generate-code=arch=compute_75,code=[compute_75,sm_75]\" \"--generate-code=arch=compute_80,code=[compute_80,sm_80]\" \"--generate-code=arch=compute_86,code=[compute_86,sm_86]\" \"--generate-code=arch=compute_89,code=[compute_89,sm_89]\" -x cu -rdc=true -c /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/main.cu -o CMakeFiles/bilateral_filter.dir/src/main.cu.o", + "file": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/main.cu", + "output": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/bilateral_filter.dir/src/main.cu.o" +}, +{ + "directory": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release", + "command": "/home/richard/miniconda3/envs/bilateral-cuda124/bin/nvcc -forward-unknown-to-host-compiler -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 -O3 -DNDEBUG -std=c++17 \"--generate-code=arch=compute_75,code=[compute_75,sm_75]\" \"--generate-code=arch=compute_80,code=[compute_80,sm_80]\" \"--generate-code=arch=compute_86,code=[compute_86,sm_86]\" \"--generate-code=arch=compute_89,code=[compute_89,sm_89]\" -x cu -rdc=true -c /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/bilateral_filter.cu -o CMakeFiles/bilateral_filter.dir/src/bilateral_filter.cu.o", + "file": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/bilateral_filter.cu", + "output": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/bilateral_filter.dir/src/bilateral_filter.cu.o" +}, +{ + "directory": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release", + "command": "/usr/bin/c++ -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 -O3 -DNDEBUG -std=gnu++17 -o CMakeFiles/bilateral_filter.dir/src/io.cpp.o -c /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/io.cpp", + "file": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/io.cpp", + "output": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/bilateral_filter.dir/src/io.cpp.o" +}, +{ + "directory": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release", + "command": "/usr/bin/c++ -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 -O3 -DNDEBUG -std=gnu++17 -o CMakeFiles/bilateral_filter.dir/src/reference.cpp.o -c /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/reference.cpp", + "file": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/reference.cpp", + "output": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/bilateral_filter.dir/src/reference.cpp.o" +}, +{ + "directory": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release", + "command": "/usr/bin/c++ -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 -O3 -DNDEBUG -std=gnu++17 -o CMakeFiles/bilateral_filter.dir/src/metrics.cpp.o -c /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/metrics.cpp", + "file": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/metrics.cpp", + "output": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/bilateral_filter.dir/src/metrics.cpp.o" +}, +{ + "directory": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release", + "command": "/usr/bin/c++ -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 -O3 -DNDEBUG -std=gnu++17 -o CMakeFiles/test_correctness.dir/test/test_correctness.cpp.o -c /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/test/test_correctness.cpp", + "file": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/test/test_correctness.cpp", + "output": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_correctness.dir/test/test_correctness.cpp.o" +}, +{ + "directory": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release", + "command": "/home/richard/miniconda3/envs/bilateral-cuda124/bin/nvcc -forward-unknown-to-host-compiler -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 -O3 -DNDEBUG -std=c++17 \"--generate-code=arch=compute_75,code=[compute_75,sm_75]\" \"--generate-code=arch=compute_80,code=[compute_80,sm_80]\" \"--generate-code=arch=compute_86,code=[compute_86,sm_86]\" \"--generate-code=arch=compute_89,code=[compute_89,sm_89]\" -x cu -rdc=true -c /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/bilateral_filter.cu -o CMakeFiles/test_correctness.dir/src/bilateral_filter.cu.o", + "file": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/bilateral_filter.cu", + "output": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_correctness.dir/src/bilateral_filter.cu.o" +}, +{ + "directory": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release", + "command": "/usr/bin/c++ -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 -O3 -DNDEBUG -std=gnu++17 -o CMakeFiles/test_correctness.dir/src/io.cpp.o -c /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/io.cpp", + "file": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/io.cpp", + "output": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_correctness.dir/src/io.cpp.o" +}, +{ + "directory": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release", + "command": "/usr/bin/c++ -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 -O3 -DNDEBUG -std=gnu++17 -o CMakeFiles/test_correctness.dir/src/reference.cpp.o -c /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/reference.cpp", + "file": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/reference.cpp", + "output": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_correctness.dir/src/reference.cpp.o" +}, +{ + "directory": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release", + "command": "/usr/bin/c++ -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 -O3 -DNDEBUG -std=gnu++17 -o CMakeFiles/test_correctness.dir/src/metrics.cpp.o -c /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/metrics.cpp", + "file": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/metrics.cpp", + "output": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_correctness.dir/src/metrics.cpp.o" +}, +{ + "directory": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release", + "command": "/usr/bin/c++ -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 -O3 -DNDEBUG -std=gnu++17 -o CMakeFiles/test_performance.dir/test/test_performance.cpp.o -c /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/test/test_performance.cpp", + "file": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/test/test_performance.cpp", + "output": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/test/test_performance.cpp.o" +}, +{ + "directory": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release", + "command": "/home/richard/miniconda3/envs/bilateral-cuda124/bin/nvcc -forward-unknown-to-host-compiler -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 -O3 -DNDEBUG -std=c++17 \"--generate-code=arch=compute_75,code=[compute_75,sm_75]\" \"--generate-code=arch=compute_80,code=[compute_80,sm_80]\" \"--generate-code=arch=compute_86,code=[compute_86,sm_86]\" \"--generate-code=arch=compute_89,code=[compute_89,sm_89]\" -x cu -rdc=true -c /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/bilateral_filter.cu -o CMakeFiles/test_performance.dir/src/bilateral_filter.cu.o", + "file": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/bilateral_filter.cu", + "output": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/src/bilateral_filter.cu.o" +}, +{ + "directory": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release", + "command": "/usr/bin/c++ -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 -O3 -DNDEBUG -std=gnu++17 -o CMakeFiles/test_performance.dir/src/io.cpp.o -c /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/io.cpp", + "file": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/io.cpp", + "output": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/src/io.cpp.o" +}, +{ + "directory": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release", + "command": "/usr/bin/c++ -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 -O3 -DNDEBUG -std=gnu++17 -o CMakeFiles/test_performance.dir/src/reference.cpp.o -c /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/reference.cpp", + "file": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/reference.cpp", + "output": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/src/reference.cpp.o" +}, +{ + "directory": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release", + "command": "/usr/bin/c++ -I/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src -isystem /home/richard/miniconda3/envs/bilateral-cuda124/include/opencv4 -O3 -DNDEBUG -std=gnu++17 -o CMakeFiles/test_performance.dir/src/metrics.cpp.o -c /home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/metrics.cpp", + "file": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/src/metrics.cpp", + "output": "/home/richard/2026/Learning-CUDA/08_bilateral_filter/MLRichard/build/conda-release/CMakeFiles/test_performance.dir/src/metrics.cpp.o" +} +] diff --git a/08_bilateral_filter/MLRichard/build/conda-release/test_correctness b/08_bilateral_filter/MLRichard/build/conda-release/test_correctness new file mode 100755 index 0000000000000000000000000000000000000000..de3d7134dd63a14a83e338e06cc6987ed203b73d GIT binary patch literal 1513464 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ⅅqBl&CzS2k4|J@94 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

fOC` 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

cKNBG~n(DnKNtBuYyz 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 literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/build/conda-release/test_performance b/08_bilateral_filter/MLRichard/build/conda-release/test_performance new file mode 100755 index 0000000000000000000000000000000000000000..9384b9da3a75c2a180f1155584936a9b40060158 GIT binary patch literal 1508960 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%0A7#_hJqAeJdRxl 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 (|TPn{B;M!*D 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

F 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

<=dgoD))Cy}HG%b1M71I_8nE}E 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 F{{Ybo?Dzlx literal 0 HcmV?d00001 diff --git a/08_bilateral_filter/MLRichard/docs/plans/2026-03-06-bilateral-filter-design.md b/08_bilateral_filter/MLRichard/docs/plans/2026-03-06-bilateral-filter-design.md new file mode 100644 index 0000000..9cb4b81 --- /dev/null +++ b/08_bilateral_filter/MLRichard/docs/plans/2026-03-06-bilateral-filter-design.md @@ -0,0 +1,200 @@ +# 实时图像双边滤波（CUDA）设计文档 + +## 文档信息 + +- 日期：2026-03-06 +- 项目：实时图像双边滤波（CUDA） +- 目标平台：NVIDIA RTX 4070（本地开发）、NVIDIA A100（性能测试） + +--- + +## 一、总体设计 + +### 架构总览 + +``` +输入 (raw / PNG / JPG) + │ + ▼ +[CPU] 读取图像 → 转换为浮点 → 传输到 GPU + │ + ▼ +[GPU] Phase 1: 朴素 Kernel（基线） +[GPU] Phase 2: Shared Memory + 预计算权重表 +[GPU] Phase 3: 自适应半径 + 查找表替代 exp() + │ + ▼ +[CPU] 结果回收 → 与 OpenCV 参考结果对比（MAE / PSNR） + │ + ▼ +输出 (raw) + 性能日志 +``` + +### 核心约束 + +- 输入/输出格式：二进制 raw（宽、高、通道数 + 行主序像素数据） +- 支持灰度图（1 通道）和 RGB 图（3 通道），像素值 0-255 +- 窗口半径 r 支持至少 5（11×11 窗口） +- 正确性：MAE < 1.0（对比 OpenCV cv::bilateralFilter） +- 性能目标：在 A100 上处理 4K RGB 图像达到实时水平（> 60fps） + +--- + +## 二、项目结构 + +``` +bilateral_filter/ +├── CMakeLists.txt +├── params.txt # 默认参数文件 +├── README.md +├── src/ +│ ├── main.cu # 程序入口，参数解析，流程控制 +│ ├── bilateral_filter.cu # CUDA kernel（三个阶段） +│ ├── bilateral_filter.cuh # kernel 声明和参数结构体 +│ ├── io.cpp # raw 文件读写，PNG/JPG 转 raw +│ ├── io.h +│ ├── reference.cpp # CPU 参考实现（调用 OpenCV） +│ ├── reference.h +│ ├── metrics.cpp # MAE / PSNR 计算 +│ └── metrics.h +├── test/ +│ ├── test_correctness.cpp # 自动生成测试图，验证 MAE < 1 +│ └── test_performance.cpp # benchmark，输出吞吐量 +└── docs/ + ├── plans/ + │ └── 2026-03-06-bilateral-filter-design.md + └── report.md # 总结报告（最终交付） +``` + +--- + +## 三、CUDA Kernel 设计 + +### Phase 1 — 朴素 Kernel（基线） + +- 1 线程 : 1 输出像素 +- block size：16×16（profile 后可调整为 32×32） +- 每次直接从 Global Memory 读取邻域像素 +- 用途：正确性基线，提供性能对比数据 + +``` +kernel_naive<<>>(input, output, width, height, channels, + radius, sigma_spatial, sigma_color) +``` + +### Phase 2 — Shared Memory Kernel + +- Tile size：`BLOCK_SIZE × BLOCK_SIZE` +- Halo 区域：tile 周围额外加载 r 圈像素（halo），大小为 `(BLOCK_SIZE + 2r)²` +- 所有线程协作将 halo 区域从 Global Memory 加载到 Shared Memory +- 空间高斯权重表：预计算 `(2r+1)²` 个值，存入 Constant Memory（最大 r=15） +- 颜色权重：运行时计算 `exp(-Δcolor² / (2σc²))` + +``` +__constant__ float c_spatial_weight[(2*MAX_RADIUS+1)*(2*MAX_RADIUS+1)]; + +kernel_shared<<>>(...) +``` + +### Phase 3 — 自适应半径 Kernel + +- 步骤 1：跑 Sobel kernel，计算每像素梯度幅值图 +- 步骤 2：按梯度阈值分配半径 + - 梯度 > T（边缘区域）→ 小半径（r=3），保边 + - 梯度 ≤ T（平坦区域）→ 大半径（r=7），强平滑 +- 步骤 3：颜色权重用 256 级查找表替代 `exp()` 计算 + - 查找表预计算 `lut[i] = exp(-i² / (2σc²))`，i ∈ [0, 255] + - 存入 Constant Memory 或 Texture Memory + +--- + +## 四、内存布局 + +- GPU 上图像以 **行主序 float 数组** 存储 +- RGB 图：交错存储 `[R0,G0,B0, R1,G1,B1, ...]` +- 灰度图：`[V0, V1, V2, ...]` +- 颜色距离：RGB 用三通道欧氏距离 `√(ΔR²+ΔG²+ΔB²)`，灰度用绝对差 +- 内存分配：初版用 `cudaMalloc + cudaMemcpy`，后期可升级为 `cudaMallocPitch` 做内存对齐优化 + +--- + +## 五、参数文件格式 + +```text +radius = 5 +sigma_spatial = 3.0 +sigma_color = 30.0 +``` + +--- + +## 六、输入/输出文件格式 + +### raw 文件格式 + +``` +[4字节] width (uint32_t, little-endian) +[4字节] height (uint32_t, little-endian) +[4字节] channels (uint32_t, little-endian) +[width × height × channels 字节] 像素数据 (uint8_t, 行主序) +``` + +--- + +## 七、正确性验证 + +- 自动生成随机噪声图（512×512 RGB 和灰度）用于快速 CI 测试 +- 调用 `cv::bilateralFilter` 作为参考，计算 MAE 和 PSNR +- 断言 MAE < 1.0 +- 支持 Set14 / BSDS100 真实图像批量验证 +- DIV2K 验证集（100 张）用于 4K 性能 benchmark + +--- + +## 八、性能日志格式 + +``` +Platform : NVIDIA A100 +Image : 3840x2160 RGB +Kernel : Phase2_SharedMemory +Radius : 5, sigma_s=3.0, sigma_c=30.0 +GPU Time : 12.34 ms +Throughput : 673.2 MPix/s +CPU Time : 1823.5 ms (OpenCV) +Speedup : 147.8x +MAE : 0.42 +PSNR : 51.3 dB +``` + +--- + +## 九、测试数据集 + +| 用途 | 数据集 | 规模 | +|------|--------|------| +| 快速 CI 验证 | 程序自动生成随机图 | 512×512 | +| 正确性对比 | Set14 / BSDS100 | < 50 MB | +| 性能 Benchmark | DIV2K 验证集 | ~400 MB | + +--- + +## 十、Profiling 计划 + +- 工具：ncu（Nsight Compute）+ nsys（Nsight Systems） +- 平台：RTX 4070（本地）和 A100（远程服务器）对比 +- 分析重点： + - Global Memory 带宽利用率 + - Shared Memory bank conflict + - Occupancy 和 warp 利用率 + - 各阶段 kernel 耗时对比 +- 报告中包含 ncu/nsys 截图和分析 + +--- + +## 十一、实现阶段规划 + +| 阶段 | 内容 | 完成标志 | +|------|------|---------| +| Phase 1 | 朴素 Kernel + IO + 参考实现 + MAE 验证 | MAE < 1.0，程序可跑通 | +| Phase 2 | Shared Memory + 预计算权重 + benchmark | 性能明显优于 Phase 1 | +| Phase 3 | 自适应半径 + 查找表 + ncu/nsys profiling | 完整性能报告 | diff --git a/08_bilateral_filter/MLRichard/docs/plans/2026-03-06-bilateral-filter-impl.md b/08_bilateral_filter/MLRichard/docs/plans/2026-03-06-bilateral-filter-impl.md new file mode 100644 index 0000000..c86aa77 --- /dev/null +++ b/08_bilateral_filter/MLRichard/docs/plans/2026-03-06-bilateral-filter-impl.md @@ -0,0 +1,1161 @@ +# 实时图像双边滤波（CUDA）实现计划 + +> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task. + +**Goal:** 实现一个基于 CUDA 的实时双边滤波器，分三阶段优化，支持灰度和 RGB 图像，MAE < 1.0，并在 A100 上达到 4K 60fps。 + +**Architecture:** 模块化 C++/CUDA 项目，分离 IO、参考实现、CUDA kernel 和测试。三阶段 kernel：朴素版（基线）→ Shared Memory 优化版 → 自适应半径 + 查找表版。CPU 端调用 OpenCV bilateralFilter 作为正确性参考。 + +**Tech Stack:** CUDA 12+, CMake 3.20+, OpenCV 4.x, C++17 + +--- + +## Task 1: 项目脚手架与构建系统 + +**Files:** +- Create: `CMakeLists.txt` +- Create: `params.txt` +- Create: `src/main.cu` +- Create: `src/io.h` +- Create: `src/io.cpp` +- Create: `src/metrics.h` +- Create: `src/metrics.cpp` +- Create: `src/reference.h` +- Create: `src/reference.cpp` +- Create: `src/bilateral_filter.cuh` +- Create: `src/bilateral_filter.cu` +- Create: `test/test_correctness.cpp` +- Create: `test/test_performance.cpp` + +**Step 1: 创建 CMakeLists.txt** + +```cmake +cmake_minimum_required(VERSION 3.20) +project(bilateral_filter CUDA CXX) + +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CUDA_STANDARD 17) +set(CMAKE_CUDA_ARCHITECTURES 75;80;86;89) + +find_package(OpenCV REQUIRED) +find_package(CUDA REQUIRED) + +include_directories(${OpenCV_INCLUDE_DIRS} src) + +# 主程序 +add_executable(bilateral_filter + src/main.cu + src/bilateral_filter.cu + src/io.cpp + src/reference.cpp + src/metrics.cpp +) +target_link_libraries(bilateral_filter ${OpenCV_LIBS}) +set_target_properties(bilateral_filter PROPERTIES CUDA_SEPARABLE_COMPILATION ON) + +# 正确性测试 +add_executable(test_correctness + test/test_correctness.cpp + src/bilateral_filter.cu + src/io.cpp + src/reference.cpp + src/metrics.cpp +) +target_link_libraries(test_correctness ${OpenCV_LIBS}) +set_target_properties(test_correctness PROPERTIES CUDA_SEPARABLE_COMPILATION ON) + +# 性能测试 +add_executable(test_performance + test/test_performance.cpp + src/bilateral_filter.cu + src/io.cpp + src/reference.cpp + src/metrics.cpp +) +target_link_libraries(test_performance ${OpenCV_LIBS}) +set_target_properties(test_performance PROPERTIES CUDA_SEPARABLE_COMPILATION ON) +``` + +**Step 2: 创建 params.txt** + +```text +radius = 5 +sigma_spatial = 3.0 +sigma_color = 30.0 +``` + +**Step 3: 创建目录结构并确认编译** + +```bash +mkdir -p build && cd build && cmake .. -DCMAKE_BUILD_TYPE=Release && make -j$(nproc) +``` + +Expected: 编译成功，生成 `bilateral_filter`、`test_correctness`、`test_performance` + +**Step 4: Commit** + +```bash +git add CMakeLists.txt params.txt +git commit -m "feat: add CMake build system" +``` + +--- + +## Task 2: IO 模块（raw 文件读写） + +**Files:** +- Modify: `src/io.h` +- Modify: `src/io.cpp` + +**Step 1: 编写 io.h** + +```cpp +#pragma once +#include +#include +#include + +struct Image { + uint32_t width; + uint32_t height; + uint32_t channels; // 1 (灰度) 或 3 (RGB) + std::vector data; // 行主序，交错存储 +}; + +// 读取 raw 格式文件 +Image read_raw(const std::string& path); + +// 写入 raw 格式文件 +void write_raw(const std::string& path, const Image& img); + +// 从 PNG/JPG 转换为 raw（借助 OpenCV） +Image load_image(const std::string& path); + +// 将 float 数组（0-255）转换回 uint8 Image +Image float_to_image(const float* data, uint32_t w, uint32_t h, uint32_t c); + +// 将 Image 转换为 float 数组（0-255） +std::vector image_to_float(const Image& img); +``` + +**Step 2: 编写 io.cpp** + +```cpp +#include "io.h" +#include +#include +#include + +Image read_raw(const std::string& path) { + std::ifstream f(path, std::ios::binary); + if (!f) throw std::runtime_error("Cannot open: " + path); + Image img; + f.read(reinterpret_cast(&img.width), 4); + f.read(reinterpret_cast(&img.height), 4); + f.read(reinterpret_cast(&img.channels), 4); + size_t n = (size_t)img.width * img.height * img.channels; + img.data.resize(n); + f.read(reinterpret_cast(img.data.data()), n); + return img; +} + +void write_raw(const std::string& path, const Image& img) { + std::ofstream f(path, std::ios::binary); + if (!f) throw std::runtime_error("Cannot write: " + path); + f.write(reinterpret_cast(&img.width), 4); + f.write(reinterpret_cast(&img.height), 4); + f.write(reinterpret_cast(&img.channels), 4); + f.write(reinterpret_cast(img.data.data()), img.data.size()); +} + +Image load_image(const std::string& path) { + cv::Mat mat = cv::imread(path, cv::IMREAD_UNCHANGED); + if (mat.empty()) throw std::runtime_error("Cannot load image: " + path); + Image img; + img.width = mat.cols; + img.height = mat.rows; + img.channels = mat.channels(); + if (img.channels == 3) cv::cvtColor(mat, mat, cv::COLOR_BGR2RGB); + img.data.assign(mat.data, mat.data + mat.total() * mat.elemSize()); + return img; +} + +Image float_to_image(const float* data, uint32_t w, uint32_t h, uint32_t c) { + Image img; + img.width = w; img.height = h; img.channels = c; + size_t n = (size_t)w * h * c; + img.data.resize(n); + for (size_t i = 0; i < n; i++) { + float v = data[i]; + if (v < 0.f) v = 0.f; + if (v > 255.f) v = 255.f; + img.data[i] = static_cast(v + 0.5f); + } + return img; +} + +std::vector image_to_float(const Image& img) { + size_t n = (size_t)img.width * img.height * img.channels; + std::vector f(n); + for (size_t i = 0; i < n; i++) f[i] = static_cast(img.data[i]); + return f; +} +``` + +**Step 3: 确认编译通过** + +```bash +cd build && make -j$(nproc) 2>&1 | grep -E "error|warning|Built" +``` + +**Step 4: Commit** + +```bash +git add src/io.h src/io.cpp +git commit -m "feat: add raw image IO module" +``` + +--- + +## Task 3: Metrics 模块（MAE / PSNR） + +**Files:** +- Modify: `src/metrics.h` +- Modify: `src/metrics.cpp` + +**Step 1: 编写 metrics.h** + +```cpp +#pragma once +#include + +// 计算平均绝对误差 MAE（输入为 float 数组，值域 0-255） +float compute_mae(const float* a, const float* b, int n); + +// 计算峰值信噪比 PSNR（最大值 255） +float compute_psnr(const float* a, const float* b, int n); +``` + +**Step 2: 编写 metrics.cpp** + +```cpp +#include "metrics.h" +#include +#include + +float compute_mae(const float* a, const float* b, int n) { + double sum = 0.0; + for (int i = 0; i < n; i++) sum += std::fabs(a[i] - b[i]); + return static_cast(sum / n); +} + +float compute_psnr(const float* a, const float* b, int n) { + double mse = 0.0; + for (int i = 0; i < n; i++) { + double d = a[i] - b[i]; + mse += d * d; + } + mse /= n; + if (mse < 1e-10) return 100.0f; + return static_cast(10.0 * std::log10(255.0 * 255.0 / mse)); +} +``` + +**Step 3: Commit** + +```bash +git add src/metrics.h src/metrics.cpp +git commit -m "feat: add MAE/PSNR metrics module" +``` + +--- + +## Task 4: CPU 参考实现（OpenCV bilateralFilter） + +**Files:** +- Modify: `src/reference.h` +- Modify: `src/reference.cpp` + +**Step 1: 编写 reference.h** + +```cpp +#pragma once +#include +#include + +struct BilateralParams { + int radius; + float sigma_spatial; + float sigma_color; +}; + +// CPU 参考实现，调用 OpenCV cv::bilateralFilter +// 输入/输出均为 float 数组（0-255），行主序，交错 RGB 或灰度 +void bilateral_filter_cpu( + const float* input, + float* output, + int width, int height, int channels, + const BilateralParams& params +); +``` + +**Step 2: 编写 reference.cpp** + +```cpp +#include "reference.h" +#include +#include + +void bilateral_filter_cpu( + const float* input, float* output, + int w, int h, int c, + const BilateralParams& p) +{ + // 转换为 OpenCV Mat（uint8） + cv::Mat src(h, w, c == 3 ? CV_8UC3 : CV_8UC1); + for (int i = 0; i < h * w * c; i++) + src.data[i] = static_cast(std::min(std::max(input[i], 0.f), 255.f)); + + // OpenCV bilateralFilter 要求 BGR，我们存的是 RGB，需要转换 + if (c == 3) cv::cvtColor(src, src, cv::COLOR_RGB2BGR); + + cv::Mat dst; + // d = 2*radius+1，sigma_color 和 sigma_space 与我们的参数对应 + cv::bilateralFilter(src, dst, 2 * p.radius + 1, p.sigma_color, p.sigma_spatial); + + if (c == 3) cv::cvtColor(dst, dst, cv::COLOR_BGR2RGB); + + for (int i = 0; i < h * w * c; i++) + output[i] = static_cast(dst.data[i]); +} +``` + +**Step 3: Commit** + +```bash +git add src/reference.h src/reference.cpp +git commit -m "feat: add OpenCV CPU reference implementation" +``` + +--- + +## Task 5: Phase 1 — 朴素 CUDA Kernel + +**Files:** +- Modify: `src/bilateral_filter.cuh` +- Modify: `src/bilateral_filter.cu` + +**Step 1: 编写 bilateral_filter.cuh** + +```cpp +#pragma once +#include "reference.h" // BilateralParams + +// Phase 1：朴素 kernel，每线程处理一个像素，直接读取 Global Memory +void launch_bilateral_naive( + const float* d_input, + float* d_output, + int width, int height, int channels, + const BilateralParams& params +); + +// Phase 2：Shared Memory 优化 kernel +void launch_bilateral_shared( + const float* d_input, + float* d_output, + int width, int height, int channels, + const BilateralParams& params +); + +// Phase 3：自适应半径 kernel +void launch_bilateral_adaptive( + const float* d_input, + float* d_output, + int width, int height, int channels, + const BilateralParams& params +); +``` + +**Step 2: 编写 Phase 1 kernel（bilateral_filter.cu 初始版本）** + +```cuda +#include "bilateral_filter.cuh" +#include +#include + +#define BLOCK_SIZE 16 + +__device__ inline float color_dist_sq( + const float* img, int idx_a, int idx_b, int channels) +{ + float sum = 0.f; + for (int c = 0; c < channels; c++) { + float d = img[idx_a * channels + c] - img[idx_b * channels + c]; + sum += d * d; + } + return sum; +} + +__global__ void kernel_naive( + const float* input, float* output, + int W, int H, int C, + int radius, float inv2_sigma_s2, float inv2_sigma_c2) +{ + int x = blockIdx.x * blockDim.x + threadIdx.x; + int y = blockIdx.y * blockDim.y + threadIdx.y; + if (x >= W || y >= H) return; + + int center = y * W + x; + float weight_sum = 0.f; + float val[3] = {0.f, 0.f, 0.f}; + + for (int dy = -radius; dy <= radius; dy++) { + int ny = y + dy; + if (ny < 0 || ny >= H) continue; + for (int dx = -radius; dx <= radius; dx++) { + int nx = x + dx; + if (nx < 0 || nx >= W) continue; + int nbr = ny * W + nx; + + float spatial = (dx*dx + dy*dy) * inv2_sigma_s2; + float color = color_dist_sq(input, center, nbr, C) * inv2_sigma_c2; + float w = expf(-(spatial + color)); + + weight_sum += w; + for (int c = 0; c < C; c++) + val[c] += w * input[nbr * C + c]; + } + } + + for (int c = 0; c < C; c++) + output[center * C + c] = val[c] / weight_sum; +} + +void launch_bilateral_naive( + const float* d_in, float* d_out, + int W, int H, int C, + const BilateralParams& p) +{ + dim3 block(BLOCK_SIZE, BLOCK_SIZE); + dim3 grid((W + BLOCK_SIZE - 1) / BLOCK_SIZE, + (H + BLOCK_SIZE - 1) / BLOCK_SIZE); + float inv2s2 = -1.f / (2.f * p.sigma_spatial * p.sigma_spatial); + float inv2c2 = -1.f / (2.f * p.sigma_color * p.sigma_color); + kernel_naive<<>>(d_in, d_out, W, H, C, + p.radius, inv2s2, inv2c2); + cudaDeviceSynchronize(); +} + +// Phase 2 和 Phase 3 占位（后续 Task 实现） +void launch_bilateral_shared( + const float* d_in, float* d_out, + int W, int H, int C, const BilateralParams& p) +{ + launch_bilateral_naive(d_in, d_out, W, H, C, p); // 临时占位 +} + +void launch_bilateral_adaptive( + const float* d_in, float* d_out, + int W, int H, int C, const BilateralParams& p) +{ + launch_bilateral_naive(d_in, d_out, W, H, C, p); // 临时占位 +} +``` + +**Step 3: Commit** + +```bash +git add src/bilateral_filter.cuh src/bilateral_filter.cu +git commit -m "feat: add Phase 1 naive CUDA bilateral filter kernel" +``` + +--- + +## Task 6: 正确性测试（test_correctness） + +**Files:** +- Modify: `test/test_correctness.cpp` + +**Step 1: 编写 test_correctness.cpp** + +```cpp +#include +#include +#include +#include +#include +#include "../src/bilateral_filter.cuh" +#include "../src/reference.h" +#include "../src/metrics.h" + +// 生成随机噪声图 +std::vector make_random_image(int w, int h, int c, unsigned seed = 42) { + std::srand(seed); + std::vector img(w * h * c); + for (auto& v : img) v = static_cast(std::rand() % 256); + return img; +} + +void run_test(const char* name, int W, int H, int C, + const BilateralParams& params, + void (*launcher)(const float*, float*, int, int, int, const BilateralParams&)) +{ + auto input = make_random_image(W, H, C); + int N = W * H * C; + + // CPU 参考 + std::vector ref(N); + bilateral_filter_cpu(input.data(), ref.data(), W, H, C, params); + + // GPU + float *d_in, *d_out; + cudaMalloc(&d_in, N * sizeof(float)); + cudaMalloc(&d_out, N * sizeof(float)); + cudaMemcpy(d_in, input.data(), N * sizeof(float), cudaMemcpyHostToDevice); + + launcher(d_in, d_out, W, H, C, params); + + std::vector gpu_out(N); + cudaMemcpy(gpu_out.data(), d_out, N * sizeof(float), cudaMemcpyDeviceToHost); + cudaFree(d_in); cudaFree(d_out); + + float mae = compute_mae(gpu_out.data(), ref.data(), N); + float psnr = compute_psnr(gpu_out.data(), ref.data(), N); + printf("[%s] W=%d H=%d C=%d MAE=%.4f PSNR=%.2f dB %s\n", + name, W, H, C, mae, psnr, mae < 1.0f ? "PASS" : "FAIL"); + assert(mae < 1.0f && "MAE >= 1.0, correctness check failed!"); +} + +int main() { + BilateralParams p{5, 3.0f, 30.0f}; + + run_test("naive_gray", 512, 512, 1, p, launch_bilateral_naive); + run_test("naive_rgb", 512, 512, 3, p, launch_bilateral_naive); + run_test("shared_gray", 512, 512, 1, p, launch_bilateral_shared); + run_test("shared_rgb", 512, 512, 3, p, launch_bilateral_shared); + + std::cout << "All tests passed!" << std::endl; + return 0; +} +``` + +**Step 2: 编译并运行测试** + +```bash +cd build && make test_correctness -j$(nproc) && ./test_correctness +``` + +Expected output: +``` +[naive_gray] W=512 H=512 C=1 MAE=0.xxxx PSNR=xx.xx dB PASS +[naive_rgb] W=512 H=512 C=3 MAE=0.xxxx PSNR=xx.xx dB PASS +All tests passed! +``` + +**Step 3: Commit** + +```bash +git add test/test_correctness.cpp +git commit -m "test: add correctness validation with MAE/PSNR checks" +``` + +--- + +## Task 7: main.cu — 程序入口和参数解析 + +**Files:** +- Modify: `src/main.cu` + +**Step 1: 编写 main.cu** + +```cpp +#include +#include +#include +#include +#include +#include "io.h" +#include "bilateral_filter.cuh" +#include "reference.h" +#include "metrics.h" + +BilateralParams load_params(const std::string& path) { + BilateralParams p{5, 3.0f, 30.0f}; + std::ifstream f(path); + if (!f) { std::cerr << "params file not found, using defaults\n"; return p; } + std::string line; + while (std::getline(f, line)) { + if (line.empty() || line[0] == '#') continue; + auto eq = line.find('='); + if (eq == std::string::npos) continue; + std::string key = line.substr(0, eq); + std::string val = line.substr(eq + 1); + // 去除空格 + key.erase(0, key.find_first_not_of(" \t")); + key.erase(key.find_last_not_of(" \t") + 1); + val.erase(0, val.find_first_not_of(" \t")); + // 去除注释 + auto hash = val.find('#'); + if (hash != std::string::npos) val = val.substr(0, hash); + if (key == "radius") p.radius = std::stoi(val); + else if (key == "sigma_spatial") p.sigma_spatial = std::stof(val); + else if (key == "sigma_color") p.sigma_color = std::stof(val); + } + return p; +} + +int main(int argc, char* argv[]) { + if (argc < 4) { + std::cerr << "Usage: " << argv[0] + << " [kernel: naive|shared|adaptive]\n"; + return 1; + } + std::string input_path = argv[1]; + std::string output_path = argv[2]; + std::string params_path = argv[3]; + std::string kernel_type = argc > 4 ? argv[4] : "shared"; + + BilateralParams params = load_params(params_path); + Image img = read_raw(input_path); + + int W = img.width, H = img.height, C = img.channels; + int N = W * H * C; + + auto input_f = image_to_float(img); + + float *d_in, *d_out; + cudaMalloc(&d_in, N * sizeof(float)); + cudaMalloc(&d_out, N * sizeof(float)); + cudaMemcpy(d_in, input_f.data(), N * sizeof(float), cudaMemcpyHostToDevice); + + // GPU 计时 + cudaEvent_t start, stop; + cudaEventCreate(&start); cudaEventCreate(&stop); + cudaEventRecord(start); + + if (kernel_type == "naive") launch_bilateral_naive (d_in, d_out, W, H, C, params); + else if (kernel_type == "shared") launch_bilateral_shared (d_in, d_out, W, H, C, params); + else if (kernel_type == "adaptive") launch_bilateral_adaptive(d_in, d_out, W, H, C, params); + else { std::cerr << "Unknown kernel: " << kernel_type << "\n"; return 1; } + + cudaEventRecord(stop); + cudaEventSynchronize(stop); + float gpu_ms = 0.f; + cudaEventElapsedTime(&gpu_ms, start, stop); + + std::vector output_f(N); + cudaMemcpy(output_f.data(), d_out, N * sizeof(float), cudaMemcpyDeviceToHost); + cudaFree(d_in); cudaFree(d_out); + + // 写输出 + Image out_img = float_to_image(output_f.data(), W, H, C); + write_raw(output_path, out_img); + + // CPU 参考和指标 + std::vector ref_f(N); + auto t0 = std::chrono::high_resolution_clock::now(); + bilateral_filter_cpu(input_f.data(), ref_f.data(), W, H, C, params); + auto t1 = std::chrono::high_resolution_clock::now(); + float cpu_ms = std::chrono::duration(t1 - t0).count(); + + float mae = compute_mae (output_f.data(), ref_f.data(), N); + float psnr = compute_psnr(output_f.data(), ref_f.data(), N); + float mpix = (float)(W * H) / 1e6f; + + // 获取 GPU 名称 + cudaDeviceProp prop; + cudaGetDeviceProperties(&prop, 0); + + printf("\n=== Performance Log ===\n"); + printf("Platform : %s\n", prop.name); + printf("Image : %dx%d %s\n", W, H, C == 3 ? "RGB" : "Gray"); + printf("Kernel : %s\n", kernel_type.c_str()); + printf("Radius : %d, sigma_s=%.1f, sigma_c=%.1f\n", + params.radius, params.sigma_spatial, params.sigma_color); + printf("GPU Time : %.2f ms\n", gpu_ms); + printf("Throughput : %.1f MPix/s\n", mpix / (gpu_ms / 1000.f)); + printf("CPU Time : %.2f ms (OpenCV)\n", cpu_ms); + printf("Speedup : %.1fx\n", cpu_ms / gpu_ms); + printf("MAE : %.4f\n", mae); + printf("PSNR : %.2f dB\n", psnr); + + return 0; +} +``` + +注意：需要在 main.cu 顶部添加 `#include `。 + +**Step 2: 编译并用自动生成的测试图验证** + +```bash +cd build && make bilateral_filter -j$(nproc) +# 生成测试 raw（可用 test_correctness 内部逻辑或 Python 脚本生成） +./bilateral_filter test.raw out.raw ../params.txt naive +``` + +**Step 3: Commit** + +```bash +git add src/main.cu +git commit -m "feat: add main entry point with param parsing and perf logging" +``` + +--- + +## Task 8: Phase 2 — Shared Memory 优化 Kernel + +**Files:** +- Modify: `src/bilateral_filter.cu`（替换 launch_bilateral_shared 占位实现） + +**Step 1: 在 bilateral_filter.cu 中添加常量内存和 Shared Memory kernel** + +在文件顶部添加常量内存声明： +```cuda +#define MAX_RADIUS 15 +#define MAX_WEIGHT_SIZE ((2*MAX_RADIUS+1)*(2*MAX_RADIUS+1)) +__constant__ float c_spatial_weight[MAX_WEIGHT_SIZE]; +``` + +添加 Shared Memory kernel： +```cuda +#define TILE 16 + +__global__ void kernel_shared( + const float* __restrict__ input, + float* output, + int W, int H, int C, + int radius, float inv2_sigma_c2) +{ + // shared memory 布局：(TILE + 2*radius)^2 * C 个 float + extern __shared__ float smem[]; + + int tx = threadIdx.x, ty = threadIdx.y; + int x = blockIdx.x * TILE + tx; + int y = blockIdx.y * TILE + ty; + + int tile_w = TILE + 2 * radius; + // 将 tile + halo 加载到 shared memory（多次加载覆盖 halo） + for (int j = ty; j < tile_w; j += TILE) { + for (int i = tx; i < tile_w; i += TILE) { + int gx = blockIdx.x * TILE - radius + i; + int gy = blockIdx.y * TILE - radius + j; + // 边界钳制 + gx = max(0, min(W - 1, gx)); + gy = max(0, min(H - 1, gy)); + int src = (gy * W + gx) * C; + int dst = (j * tile_w + i) * C; + for (int c = 0; c < C; c++) smem[dst + c] = input[src + c]; + } + } + __syncthreads(); + + if (x >= W || y >= H) return; + + int lx = tx + radius, ly = ty + radius; // 当前像素在 smem 中的坐标 + int ci = (ly * tile_w + lx) * C; // 中心像素在 smem 的偏移 + + float weight_sum = 0.f; + float val[3] = {0.f, 0.f, 0.f}; + int wi = 0; // 空间权重索引 + + for (int dy = -radius; dy <= radius; dy++) { + for (int dx = -radius; dx <= radius; dx++, wi++) { + int ni = ((ly + dy) * tile_w + (lx + dx)) * C; + float color_sq = 0.f; + for (int c = 0; c < C; c++) { + float d = smem[ci + c] - smem[ni + c]; + color_sq += d * d; + } + float w = c_spatial_weight[wi] * expf(color_sq * inv2_sigma_c2); + weight_sum += w; + for (int c = 0; c < C; c++) val[c] += w * smem[ni + c]; + } + } + + int out_idx = (y * W + x) * C; + for (int c = 0; c < C; c++) + output[out_idx + c] = val[c] / weight_sum; +} +``` + +更新 `launch_bilateral_shared`： +```cuda +void launch_bilateral_shared( + const float* d_in, float* d_out, + int W, int H, int C, const BilateralParams& p) +{ + int r = p.radius; + // 预计算空间权重并上传到 Constant Memory + int diam = 2 * r + 1; + std::vector sw(diam * diam); + float inv2s2 = 1.f / (2.f * p.sigma_spatial * p.sigma_spatial); + for (int dy = -r; dy <= r; dy++) + for (int dx = -r; dx <= r; dx++) + sw[(dy+r)*diam + (dx+r)] = expf(-(dx*dx + dy*dy) * inv2s2); + cudaMemcpyToSymbol(c_spatial_weight, sw.data(), diam*diam*sizeof(float)); + + float inv2c2 = -1.f / (2.f * p.sigma_color * p.sigma_color); + int tile_w = TILE + 2 * r; + size_t smem = (size_t)tile_w * tile_w * C * sizeof(float); + + dim3 block(TILE, TILE); + dim3 grid((W + TILE - 1) / TILE, (H + TILE - 1) / TILE); + kernel_shared<<>>(d_in, d_out, W, H, C, r, inv2c2); + cudaDeviceSynchronize(); +} +``` + +**Step 2: 运行正确性测试确认 Phase 2 通过** + +```bash +cd build && make test_correctness -j$(nproc) && ./test_correctness +``` + +Expected: 所有 PASS，包括 `shared_gray` 和 `shared_rgb` + +**Step 3: Commit** + +```bash +git add src/bilateral_filter.cu src/bilateral_filter.cuh +git commit -m "feat: add Phase 2 shared memory bilateral filter kernel" +``` + +--- + +## Task 9: Phase 3 — 自适应半径 + 查找表 Kernel + +**Files:** +- Modify: `src/bilateral_filter.cu`（替换 launch_bilateral_adaptive 占位） + +**Step 1: 添加颜色权重查找表常量内存** + +```cuda +__constant__ float c_color_lut[256]; // lut[i] = exp(-i^2 / (2*sigma_c^2)) +``` + +**Step 2: 添加 Sobel 梯度 kernel** + +```cuda +__global__ void kernel_sobel( + const float* __restrict__ input, + float* gradient, int W, int H, int C) +{ + int x = blockIdx.x * blockDim.x + threadIdx.x; + int y = blockIdx.y * blockDim.y + threadIdx.y; + if (x < 1 || x >= W-1 || y < 1 || y >= H-1) { + if (x < W && y < H) gradient[y*W+x] = 0.f; + return; + } + // 用灰度值（取第一通道或均值）计算梯度 + auto px = [&](int xi, int yi) { + float v = 0.f; + for (int c = 0; c < C; c++) v += input[(yi*W+xi)*C+c]; + return v / C; + }; + float gx = -px(x-1,y-1) + px(x+1,y-1) + -2*px(x-1,y) + 2*px(x+1,y) + -px(x-1,y+1) + px(x+1,y+1); + float gy = -px(x-1,y-1) - 2*px(x,y-1) - px(x+1,y-1) + +px(x-1,y+1) + 2*px(x,y+1) + px(x+1,y+1); + gradient[y*W+x] = sqrtf(gx*gx + gy*gy); +} +``` + +**Step 3: 添加自适应 kernel** + +```cuda +__global__ void kernel_adaptive( + const float* __restrict__ input, + const float* __restrict__ gradient, + float* output, + int W, int H, int C, + int r_small, int r_large, + float grad_thresh, + float inv2_sigma_s2) +{ + int x = blockIdx.x * blockDim.x + threadIdx.x; + int y = blockIdx.y * blockDim.y + threadIdx.y; + if (x >= W || y >= H) return; + + int radius = gradient[y*W+x] > grad_thresh ? r_small : r_large; + int center = y * W + x; + float weight_sum = 0.f; + float val[3] = {0.f, 0.f, 0.f}; + + for (int dy = -radius; dy <= radius; dy++) { + int ny = max(0, min(H-1, y+dy)); + for (int dx = -radius; dx <= radius; dx++) { + int nx = max(0, min(W-1, x+dx)); + int nbr = ny * W + nx; + float spatial_w = expf(-(dx*dx + dy*dy) * inv2_sigma_s2); + // 颜色距离：各通道差绝对值的均值（近似） + float cdist = 0.f; + for (int c = 0; c < C; c++) { + float d = fabsf(input[center*C+c] - input[nbr*C+c]); + cdist += d; + } + cdist /= C; + int lut_idx = min((int)cdist, 255); + float color_w = c_color_lut[lut_idx]; + float w = spatial_w * color_w; + weight_sum += w; + for (int c = 0; c < C; c++) val[c] += w * input[nbr*C+c]; + } + } + for (int c = 0; c < C; c++) + output[center*C+c] = val[c] / weight_sum; +} +``` + +**Step 4: 更新 launch_bilateral_adaptive** + +```cuda +void launch_bilateral_adaptive( + const float* d_in, float* d_out, + int W, int H, int C, const BilateralParams& p) +{ + // 上传颜色查找表 + std::vector lut(256); + float inv2c2 = 1.f / (2.f * p.sigma_color * p.sigma_color); + for (int i = 0; i < 256; i++) lut[i] = expf(-(float)(i*i) * inv2c2); + cudaMemcpyToSymbol(c_color_lut, lut.data(), 256*sizeof(float)); + + // 计算梯度 + float* d_grad; + cudaMalloc(&d_grad, W * H * sizeof(float)); + dim3 block(BLOCK_SIZE, BLOCK_SIZE); + dim3 grid((W+BLOCK_SIZE-1)/BLOCK_SIZE, (H+BLOCK_SIZE-1)/BLOCK_SIZE); + kernel_sobel<<>>(d_in, d_grad, W, H, C); + + float inv2s2 = -1.f / (2.f * p.sigma_spatial * p.sigma_spatial); + int r_small = max(1, p.radius / 2); + int r_large = p.radius; + float grad_thresh = 20.f; // 可配置 + + kernel_adaptive<<>>(d_in, d_grad, d_out, W, H, C, + r_small, r_large, grad_thresh, inv2s2); + cudaDeviceSynchronize(); + cudaFree(d_grad); +} +``` + +**Step 5: 运行正确性测试（Phase 3 允许 MAE 略高，但仍需 < 1.0）** + +在 test_correctness.cpp 中添加： +```cpp +run_test("adaptive_rgb", 512, 512, 3, p, launch_bilateral_adaptive); +``` + +```bash +cd build && make -j$(nproc) && ./test_correctness +``` + +**Step 6: Commit** + +```bash +git add src/bilateral_filter.cu +git commit -m "feat: add Phase 3 adaptive radius bilateral filter with LUT" +``` + +--- + +## Task 10: 性能 Benchmark（test_performance） + +**Files:** +- Modify: `test/test_performance.cpp` + +**Step 1: 编写 test_performance.cpp** + +```cpp +#include +#include +#include +#include +#include "../src/bilateral_filter.cuh" +#include "../src/reference.h" +#include "../src/metrics.h" + +struct BenchResult { + std::string name; + float gpu_ms; + float cpu_ms; + float mae; + float psnr; +}; + +BenchResult benchmark( + const char* name, int W, int H, int C, + const BilateralParams& params, + void (*launcher)(const float*, float*, int, int, int, const BilateralParams&), + int warmup = 3, int iters = 10) +{ + int N = W * H * C; + std::vector input(N); + std::srand(123); + for (auto& v : input) v = static_cast(std::rand() % 256); + + float *d_in, *d_out; + cudaMalloc(&d_in, N * sizeof(float)); + cudaMalloc(&d_out, N * sizeof(float)); + cudaMemcpy(d_in, input.data(), N * sizeof(float), cudaMemcpyHostToDevice); + + // Warmup + for (int i = 0; i < warmup; i++) launcher(d_in, d_out, W, H, C, params); + + // Timed iters + cudaEvent_t s, e; + cudaEventCreate(&s); cudaEventCreate(&e); + cudaEventRecord(s); + for (int i = 0; i < iters; i++) launcher(d_in, d_out, W, H, C, params); + cudaEventRecord(e); + cudaEventSynchronize(e); + float total_ms; cudaEventElapsedTime(&total_ms, s, e); + float gpu_ms = total_ms / iters; + + std::vector gpu_out(N); + cudaMemcpy(gpu_out.data(), d_out, N * sizeof(float), cudaMemcpyDeviceToHost); + cudaFree(d_in); cudaFree(d_out); + + // CPU 参考（只跑一次） + std::vector ref(N); + auto t0 = std::chrono::high_resolution_clock::now(); + bilateral_filter_cpu(input.data(), ref.data(), W, H, C, params); + auto t1 = std::chrono::high_resolution_clock::now(); + float cpu_ms = std::chrono::duration(t1 - t0).count(); + + float mae = compute_mae (gpu_out.data(), ref.data(), N); + float psnr = compute_psnr(gpu_out.data(), ref.data(), N); + + cudaDeviceProp prop; cudaGetDeviceProperties(&prop, 0); + float mpix = (float)(W * H) / 1e6f; + printf("[%-20s] %dx%d C=%d GPU=%.2fms Throughput=%.1fMPix/s CPU=%.1fms Speedup=%.1fx MAE=%.4f PSNR=%.2fdB\n", + name, W, H, C, gpu_ms, mpix/(gpu_ms/1000.f), cpu_ms, cpu_ms/gpu_ms, mae, psnr); + + return {name, gpu_ms, cpu_ms, mae, psnr}; +} + +int main() { + BilateralParams p{5, 3.0f, 30.0f}; + + printf("=== Bilateral Filter Benchmark ===\n\n"); + + // 512x512 对比三个 kernel + benchmark("naive_512_rgb", 512, 512, 3, p, launch_bilateral_naive); + benchmark("shared_512_rgb", 512, 512, 3, p, launch_bilateral_shared); + benchmark("adaptive_512_rgb", 512, 512, 3, p, launch_bilateral_adaptive); + + // 4K 性能测试（主要目标） + benchmark("naive_4K_rgb", 3840, 2160, 3, p, launch_bilateral_naive); + benchmark("shared_4K_rgb", 3840, 2160, 3, p, launch_bilateral_shared); + benchmark("adaptive_4K_rgb", 3840, 2160, 3, p, launch_bilateral_adaptive); + + return 0; +} +``` + +注意：需要在文件顶部添加 `#include `。 + +**Step 2: 编译并运行** + +```bash +cd build && make test_performance -j$(nproc) && ./test_performance +``` + +**Step 3: Commit** + +```bash +git add test/test_performance.cpp +git commit -m "test: add performance benchmark covering 512x512 and 4K" +``` + +--- + +## Task 11: 工具脚本——PNG/JPG 转 raw + +**Files:** +- Create: `tools/img2raw.py` + +**Step 1: 编写 img2raw.py** + +```python +#!/usr/bin/env python3 +"""将 PNG/JPG 图像转换为项目使用的 raw 格式""" +import sys +import struct +import numpy as np +from PIL import Image + +def img2raw(src, dst, grayscale=False): + img = Image.open(src) + if grayscale: + img = img.convert('L') + arr = np.array(img) + c = 1 + else: + img = img.convert('RGB') + arr = np.array(img) + c = 3 + h, w = arr.shape[:2] + with open(dst, 'wb') as f: + f.write(struct.pack(' [--gray]") + sys.exit(1) + img2raw(sys.argv[1], sys.argv[2], '--gray' in sys.argv) +``` + +**Step 2: Commit** + +```bash +git add tools/img2raw.py +git commit -m "tools: add img2raw.py for converting PNG/JPG to raw format" +``` + +--- + +## Task 12: ncu/nsys Profiling + +**Step 1: 用 ncu 分析 Phase 1 和 Phase 2 kernel** + +```bash +# 在远程 A100 上执行 +ncu --set full -o profile_naive ./bilateral_filter test_4k.raw /dev/null ../params.txt naive +ncu --set full -o profile_shared ./bilateral_filter test_4k.raw /dev/null ../params.txt shared +ncu --set full -o profile_adaptive ./bilateral_filter test_4k.raw /dev/null ../params.txt adaptive +``` + +**Step 2: 用 nsys 分析整体流程** + +```bash +nsys profile -o timeline ./bilateral_filter test_4k.raw out.raw ../params.txt shared +``` + +**Step 3: 在本地用 Nsight Compute UI 打开 .ncu-rep 文件查看分析** + +重点关注指标： +- `l1tex__t_bytes_pipe_lsu_mem_global_op_ld.sum.per_second`（Global Memory 带宽） +- `l1tex__data_bank_conflicts_pipe_lsu_mem_shared_op_ld.sum`（Shared Memory bank conflict） +- `sm__warps_active.avg.pct_of_peak_sustained_active`（Occupancy） + +**Step 4: 将 profiling 截图和分析写入报告** + +```bash +git add docs/report.md +git commit -m "docs: add profiling analysis and performance report" +``` + +--- + +## 验收标准 + +| 检查项 | 标准 | +|--------|------| +| MAE（Phase 1/2） | < 1.0 | +| MAE（Phase 3 自适应） | < 1.0 | +| 4K RGB Phase 2 throughput（A100） | > 1000 MPix/s（目标 60fps = 497 MPix/s） | +| 编译 | 无 error，无关键 warning | +| 测试 | test_correctness 全部 PASS | diff --git a/08_bilateral_filter/MLRichard/docs/plans/2026-03-07-readme-cmake-presets-design.md b/08_bilateral_filter/MLRichard/docs/plans/2026-03-07-readme-cmake-presets-design.md new file mode 100644 index 0000000..7751a32 --- /dev/null +++ b/08_bilateral_filter/MLRichard/docs/plans/2026-03-07-readme-cmake-presets-design.md @@ -0,0 +1,80 @@ +# README 与 CMake Presets 设计文档 + +## 文档信息 + +- 日期：2026-03-07 +- 范围：为 `bilateral_filter` 项目补充 `CMakePresets.json` 与 `README.md` +- 主环境：WSL2 + Ubuntu 22.04 LTS + Conda + +--- + +## 一、目标 + +- 为项目提供可复用的 `CMakePresets.json`，简化 WSL + Conda 环境下的配置、构建与调试。 +- 提供完整的 `README.md`，覆盖环境配置、编译运行、测试验证、输入输出格式与云服务器兼容说明。 +- 保持项目源码行为不变，仅增强构建入口与使用文档。 + +## 二、设计原则 + +- **WSL + Conda 优先**：文档和预设默认服务当前主开发环境。 +- **云服务器兼容**：使用同一套 Conda 依赖时，无需修改项目代码。 +- **低耦合**：预设使用 `$env{CONDA_PREFIX}`，避免硬编码单机绝对路径。 +- **编辑器友好**：保留 `compile_commands.json` 导出，方便 VS Code / clangd 补全。 +- **最少惊讶**：默认输出到独立构建目录，避免与已有临时构建目录混淆。 + +## 三、CMake Presets 设计 + +### 配置预设 + +- `conda-release` + - 生成器：`Ninja` + - 构建目录：`build/conda-release` + - 类型：`Release` + - 依赖当前已激活的 Conda 环境，通过 `$env{CONDA_PREFIX}` 注入： + - `CUDAToolkit_ROOT` + - `OpenCV_DIR` + - `CMAKE_PREFIX_PATH` + - `CPATH` + - `LIBRARY_PATH` + - `LD_LIBRARY_PATH` +- `conda-debug` + - 继承 `conda-release` + - 仅切换到 `Debug` + - 构建目录改为 `build/conda-debug` + +### 构建预设 + +- `build-conda-release` +- `build-conda-debug` +- `build-test-correctness` +- `build-test-performance` + +## 四、README 设计 + +### 结构 + +1. 项目简介 +2. 功能概览 +3. 目录结构 +4. 环境要求 +5. WSL + Conda 环境配置步骤 +6. 使用 `CMakePresets.json` 的配置/编译命令 +7. 项目运行说明 +8. 正确性测试与性能测试 +9. 输入/输出 raw 格式说明 +10. 参数文件说明 +11. 云服务器兼容说明 +12. 常见问题 + +### 云服务器兼容说明 + +- 推荐在 Linux 云服务器上复用同一套 Conda 环境创建命令。 +- 若云服务器已具备可用 NVIDIA 驱动和 GPU，只需激活 Conda 环境即可复用构建命令。 +- `/usr/lib/wsl/lib` 路径仅在 WSL 下生效；在普通 Linux 服务器上缺失时不会要求修改项目源码。 + +## 五、验收标准 + +- `cmake --preset conda-release` 可成功生成构建系统。 +- `cmake --build --preset build-conda-release` 可成功编译项目。 +- `README.md` 能独立指导新用户完成环境配置、编译、运行与测试。 +- `README.md` 明确写出 WSL + Conda 主路径，并补充云服务器兼容说明。 diff --git a/08_bilateral_filter/MLRichard/docs/plans/2026-03-07-readme-cmake-presets.md b/08_bilateral_filter/MLRichard/docs/plans/2026-03-07-readme-cmake-presets.md new file mode 100644 index 0000000..b3df3ed --- /dev/null +++ b/08_bilateral_filter/MLRichard/docs/plans/2026-03-07-readme-cmake-presets.md @@ -0,0 +1,123 @@ +# README And CMake Presets Implementation Plan + +> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task. + +**Goal:** 为项目补充面向 WSL + Conda 的 `CMakePresets.json` 和完整 `README.md`，并附带云服务器兼容说明。 + +**Architecture:** 通过 `CMakePresets.json` 统一 Conda 工具链入口，使用 `README.md` 作为单一用户指南，覆盖环境、构建、运行、测试、数据格式与兼容说明。方案保持源码行为不变，只增强配置与文档。 + +**Tech Stack:** CMake Presets、Ninja、CUDA Toolkit、OpenCV、Markdown + +--- + +### Task 1: 新增 CMake 预设 + +**Files:** +- Create: `CMakePresets.json` +- Modify: `CMakeLists.txt` + +**Step 1: 确认 `CMakeLists.txt` 导出 `compile_commands.json`** + +检查 `CMakeLists.txt` 中存在： + +```cmake +set(CMAKE_EXPORT_COMPILE_COMMANDS ON) +``` + +**Step 2: 编写 `CMakePresets.json`** + +添加： +- `conda-release` +- `conda-debug` +- `build-conda-release` +- `build-conda-debug` +- `build-test-correctness` +- `build-test-performance` + +要求： +- 默认依赖 `$env{CONDA_PREFIX}` +- 配置 `CUDAToolkit_ROOT`、`OpenCV_DIR`、`CMAKE_PREFIX_PATH` +- 输出到 `build/conda-release` 和 `build/conda-debug` + +**Step 3: 验证 release preset 可配置** + +Run: `cmake --preset conda-release` + +Expected: 成功生成 `build/conda-release` + +--- + +### Task 2: 编写 README + +**Files:** +- Create: `README.md` + +**Step 1: 编写项目简介与目录说明** + +要求： +- 解释项目目标 +- 概述三个 kernel 阶段 +- 给出目录结构 + +**Step 2: 编写环境配置说明** + +要求： +- 明确主环境为 WSL2 + Ubuntu 22.04 + Conda +- 给出 Conda 环境创建命令 +- 给出激活命令与基础验证命令 + +**Step 3: 编写构建与运行说明** + +要求： +- 优先使用 `cmake --preset conda-release` +- 给出 `cmake --build --preset build-conda-release` +- 给出主程序、正确性测试、性能测试运行命令 + +**Step 4: 编写数据格式与参数说明** + +要求： +- raw 文件格式 +- `params.txt` 格式 +- kernel 选择参数说明 + +**Step 5: 编写云服务器兼容说明与 FAQ** + +要求： +- 说明如何复用同一套 Conda 依赖 +- 说明 WSL 与普通 Linux 的差异点 +- 包含 `nvcc not found`、includePath、GPU 运行限制等常见问题 + +--- + +### Task 3: 验证文档与预设一致 + +**Files:** +- Verify: `CMakePresets.json` +- Verify: `README.md` + +**Step 1: 用 preset 重新配置** + +Run: `cmake --preset conda-release` + +Expected: 成功 + +**Step 2: 用 preset 构建主目标** + +Run: `cmake --build --preset build-conda-release` + +Expected: 成功生成 `bilateral_filter`、`test_correctness`、`test_performance` + +**Step 3: 人工检查 README 命令与 preset 名称一致** + +核对： +- 预设名称 +- 构建目录 +- 环境变量说明 +- 运行命令 + +**Step 4: 总结并汇报** + +记录： +- 新增文件 +- 验证命令 +- 任何仍需用户手动执行的步骤 diff --git a/08_bilateral_filter/MLRichard/docs/report.md b/08_bilateral_filter/MLRichard/docs/report.md new file mode 100644 index 0000000..5283fb8 --- /dev/null +++ b/08_bilateral_filter/MLRichard/docs/report.md @@ -0,0 +1,228 @@ +# Bilateral Filter Profiling Report + +## 1. Scope + +本报告对应 `docs/plans/2026-03-06-bilateral-filter-impl.md` 的 **Task 12**，目标是把 profiling 流程整理为默认适配 **英伟达（NVIDIA）环境**： + +- **训练营英伟达环境可直接复用** +- **标准 Linux / WSL + NVIDIA GPU 环境可执行** +- 不需要修改项目源码 +- 在计数器权限受限时也能保留可执行的降级路径 + +## 2. Added Assets + +新增或补强的资产： + +- `tools/generate_test_raw.py` + - 生成确定性的 `3840x2160 RGB raw` 测试输入 + - 避免 profiling 依赖外部真实图片数据集 +- `tools/profile_task12.sh` + - 自动定位 `bilateral_filter` + - 自动生成默认输入 + - 自动识别当前 GPU 并按 GPU 名称分类输出 + - 默认执行 `ncu + nsys` + - 自动导出 `timeline.sqlite` + - 若 `ncu` 命中 `ERR_NVGPUCTRPERM`，自动继续执行 `nsys` + - 自动生成 `ncu_permission_hint.txt` +- `docs/report.md` + - 记录英伟达环境下的验证结果与兼容说明 + +## 3. Standard Workflow + +如果训练营提供的英伟达环境已经具备基础依赖，可直接从激活项目环境开始；以下命令同时适用于普通 Linux 服务器和 WSL + NVIDIA CUDA 环境。 + +### 3.1 Activate environment + +```bash +source ~/miniconda3/etc/profile.d/conda.sh +conda activate bilateral-cuda124 +``` + +### 3.2 Configure and build + +```bash +cmake --preset conda-release +cmake --build --preset build-conda-release -j"$(nproc)" +``` + +### 3.3 Run profiling + +```bash +bash tools/profile_task12.sh +``` + +默认会： + +- 生成 `artifacts/profiling/inputs/test_4k.raw` +- 对 `naive / shared / adaptive` 尝试生成 `.ncu-rep` +- 对 `shared` 生成 `timeline.nsys-rep` +- 自动导出 `timeline.sqlite` + +### 3.4 Fallback mode + +如果当前机器未开放 GPU Performance Counters，可先执行： + +```bash +bash tools/profile_task12.sh --skip-ncu +``` + +这样仍可获得： + +- `timeline.nsys-rep` +- `timeline.sqlite` +- `profile_output.raw` + +## 4. Output Layout + +```text +artifacts/profiling/ +├── inputs/ +│ └── test_4k.raw +└── / + ├── profile_naive.ncu-rep + ├── profile_shared.ncu-rep + ├── profile_adaptive.ncu-rep + ├── profile_*.ncu.log + ├── ncu_permission_hint.txt + ├── timeline.nsys-rep + ├── timeline.sqlite + └── profile_output.raw +``` + +说明： + +- 若 `ncu` 完整成功，则会有 `profile_*.ncu-rep` +- 若 `ncu` 因权限失败，则至少保留 `profile_*.ncu.log` 与 `ncu_permission_hint.txt` + +## 5. Metrics To Inspect + +重点关注以下指标： + +- `l1tex__t_bytes_pipe_lsu_mem_global_op_ld.sum.per_second` + - Global Memory 读带宽 +- `l1tex__data_bank_conflicts_pipe_lsu_mem_shared_op_ld.sum` + - Shared Memory bank conflict +- `sm__warps_active.avg.pct_of_peak_sustained_active` + - Occupancy / warp 活跃度 + +## 6. Verification on NVIDIA GPUs + +### 6.1 Build and helper verification + +已验证： + +- `python tools/generate_test_raw.py --help` +- `bash tools/profile_task12.sh --help` +- `cmake --preset conda-release` +- `cmake --build --preset build-conda-release -j"$(nproc)"` +- `ctest --preset test-conda-all`（在真实英伟达 GPU 环境中通过） + +### 6.2 Measured evidence on RTX 4070 + +本地 `RTX 4070` 上已有 benchmark 结果： + +- `naive_4K_rgb`: `897.5 MPix/s` +- `shared_4K_rgb`: `1249.0 MPix/s` +- `adaptive_4K_rgb`: `1249.6 MPix/s` + +这说明： + +- `shared` 相比 `naive` 已有明显加速 +- 当前实现已达到计划中 `> 1000 MPix/s` 的吞吐目标 + +上述数据是当前报告中的实测样本，证明这套流程已在一张实际英伟达消费级 GPU 上跑通。对训练营服务器或其他 NVIDIA Linux 机器，本文将其视为同一套工具链的复用路径，而不是另一套独立流程。 + +### 6.3 Profiling execution status on RTX 4070 + +本次在本地 `RTX 4070` 上的实际执行结果： + +- `bash tools/profile_task12.sh` + - `ncu` 启动成功，但被主机侧 GPU Performance Counter 权限限制拦截 + - 错误为 `ERR_NVGPUCTRPERM` +- `bash tools/profile_task12.sh --skip-ncu` + - 成功生成 `timeline.nsys-rep` + - 成功生成 `timeline.sqlite` + - 成功生成 `profile_output.raw` + +实测 `shared` kernel 运行日志： + +- `GPU Time`: `7.90 ms` +- `Throughput`: `1050.1 MPix/s` +- `CPU Time`: `175.41 ms` +- `Speedup`: `22.2x` +- `MAE`: `0.3168` +- `PSNR`: `55.61 dB` + +当前已确认： + +- **Task 12 的脚本链路已在英伟达 GPU 实机上可执行** +- **在未开放 perf counters 时，仍可稳定获得 `nsys` 时间线结果** +- **开放 perf counters 后，无需改源码即可补齐 `ncu` 报告** + +## 7. Permission Fix Instructions + +### 7.1 Windows + WSL + NVIDIA GPU + +根据 NVIDIA 官方 `ERR_NVGPUCTRPERM` 说明，Windows 平台应： + +1. 以管理员身份打开 `NVIDIA Control Panel` +2. 打开 `Desktop -> Enable Developer Settings` +3. 打开 `Developer -> Manage GPU Performance Counters` +4. 选择 `Allow access to the GPU performance counter to all users` +5. 重新打开 WSL shell 后重新执行： + +```bash +source ~/miniconda3/etc/profile.d/conda.sh +conda activate bilateral-cuda124 +bash tools/profile_task12.sh +``` + +这里把 WSL 归到 Windows host 管理，是因为 WSL GPU profiling 依赖宿主机 NVIDIA 驱动控制。 + +### 7.2 Native Linux / NVIDIA server + +Ubuntu / Debian 永久配置： + +```bash +sudo tee /etc/modprobe.d/nvidia-prof.conf >/dev/null <<'EOCONF' +options nvidia NVreg_RestrictProfilingToAdminUsers=0 +EOCONF +sudo update-initramfs -u -k all +sudo reboot +``` + +重启后检查： + +```bash +cat /proc/driver/nvidia/params | grep RmProfilingAdminOnly +``` + +若输出为 `RmProfilingAdminOnly: 0`，普通用户即可运行 `ncu`。 + +临时配置（官方 Linux 方案，适合需要立即验证的机器）： + +```bash +sudo systemctl isolate multi-user +sudo modprobe -rf nvidia_uvm nvidia_drm nvidia_modeset nvidia-vgpu-vfio nvidia +sudo modprobe nvidia NVreg_RestrictProfilingToAdminUsers=0 +sudo systemctl isolate graphical +``` + +## 8. Compatibility Summary + +- `训练营英伟达环境` + - 可直接复用同一套构建、测试与 profiling 工作流 + - 若计数器权限受限，仍可通过 `--skip-ncu` 保留 `nsys` 结果 +- `Windows + WSL + NVIDIA GPU` + - 已有 `RTX 4070` 实测样本 + - `nsys` 已验证通过 + - `ncu` 需宿主机放开 perf counter 权限 +- `Linux + NVIDIA GPU` + - 使用同一套 Conda 环境与同一脚本即可执行 + - 包括 A100 在内的服务器型 GPU 复用方式一致 + - 若权限默认受限，仅需按上节执行一次 host 级配置 + - 不需要修改项目源码或 CMake 文件 + +## 9. Reference + +- NVIDIA official guide: `https://developer.nvidia.com/ERR_NVGPUCTRPERM` diff --git a/08_bilateral_filter/MLRichard/params.txt b/08_bilateral_filter/MLRichard/params.txt new file mode 100644 index 0000000..6fa2360 --- /dev/null +++ b/08_bilateral_filter/MLRichard/params.txt @@ -0,0 +1,3 @@ +radius = 5 +sigma_spatial = 3.0 +sigma_color = 30.0 diff --git a/08_bilateral_filter/MLRichard/src/bilateral_filter.cu b/08_bilateral_filter/MLRichard/src/bilateral_filter.cu new file mode 100644 index 0000000..068c9d6 --- /dev/null +++ b/08_bilateral_filter/MLRichard/src/bilateral_filter.cu @@ -0,0 +1,290 @@ +#include "bilateral_filter.cuh" +#include +#include +#include + +#define BLOCK_SIZE 16 +#define TILE 16 +#define MAX_RADIUS 15 +#define MAX_WEIGHT_SIZE ((2 * MAX_RADIUS + 1) * (2 * MAX_RADIUS + 1)) + +__constant__ float c_spatial_weight[MAX_WEIGHT_SIZE]; +__constant__ float c_color_lut[256]; + +__device__ inline int clamp_int(int value, int low, int high) { + return value < low ? low : (value > high ? high : value); +} + +__device__ inline float color_distance_l1_sq( + const float* img, int idx_a, int idx_b, int channels) +{ + float sum_abs = 0.f; + for (int channel = 0; channel < channels; ++channel) { + float diff = img[idx_a * channels + channel] - img[idx_b * channels + channel]; + sum_abs += fabsf(diff); + } + return sum_abs * sum_abs; +} + +__device__ inline float pixel_gray(const float* input, int pixel_idx, int channels) { + float value = 0.f; + int base = pixel_idx * channels; + for (int channel = 0; channel < channels; ++channel) { + value += input[base + channel]; + } + return value / channels; +} + +__global__ void kernel_naive( + const float* input, float* output, + int width, int height, int channels, + int radius, float inv2_sigma_s2, float inv2_sigma_c2) +{ + int x = blockIdx.x * blockDim.x + threadIdx.x; + int y = blockIdx.y * blockDim.y + threadIdx.y; + if (x >= width || y >= height) { + return; + } + + int center = y * width + x; + float weight_sum = 0.f; + float value[3] = {0.f, 0.f, 0.f}; + + for (int dy = -radius; dy <= radius; ++dy) { + int ny = y + dy; + if (ny < 0 || ny >= height) { + continue; + } + for (int dx = -radius; dx <= radius; ++dx) { + int nx = x + dx; + if (nx < 0 || nx >= width) { + continue; + } + + int neighbor = ny * width + nx; + float spatial = (dx * dx + dy * dy) * inv2_sigma_s2; + float color = color_distance_l1_sq(input, center, neighbor, channels) * inv2_sigma_c2; + float weight = expf(-(spatial + color)); + + weight_sum += weight; + for (int channel = 0; channel < channels; ++channel) { + value[channel] += weight * input[neighbor * channels + channel]; + } + } + } + + for (int channel = 0; channel < channels; ++channel) { + output[center * channels + channel] = value[channel] / weight_sum; + } +} + +__global__ void kernel_shared( + const float* __restrict__ input, + float* output, + int width, int height, int channels, + int radius, float inv2_sigma_c2) +{ + extern __shared__ float smem[]; + + int tx = threadIdx.x; + int ty = threadIdx.y; + int x = blockIdx.x * TILE + tx; + int y = blockIdx.y * TILE + ty; + int tile_w = TILE + 2 * radius; + + for (int j = ty; j < tile_w; j += blockDim.y) { + for (int i = tx; i < tile_w; i += blockDim.x) { + int gx = clamp_int(blockIdx.x * TILE - radius + i, 0, width - 1); + int gy = clamp_int(blockIdx.y * TILE - radius + j, 0, height - 1); + int src = (gy * width + gx) * channels; + int dst = (j * tile_w + i) * channels; + for (int channel = 0; channel < channels; ++channel) { + smem[dst + channel] = input[src + channel]; + } + } + } + __syncthreads(); + + if (x >= width || y >= height) { + return; + } + + int lx = tx + radius; + int ly = ty + radius; + int center = (ly * tile_w + lx) * channels; + float weight_sum = 0.f; + float value[3] = {0.f, 0.f, 0.f}; + int wi = 0; + + for (int dy = -radius; dy <= radius; ++dy) { + for (int dx = -radius; dx <= radius; ++dx, ++wi) { + int neighbor = ((ly + dy) * tile_w + (lx + dx)) * channels; + float sum_abs = 0.f; + for (int channel = 0; channel < channels; ++channel) { + sum_abs += fabsf(smem[center + channel] - smem[neighbor + channel]); + } + float color = (sum_abs * sum_abs) * inv2_sigma_c2; + float weight = c_spatial_weight[wi] * expf(-color); + weight_sum += weight; + for (int channel = 0; channel < channels; ++channel) { + value[channel] += weight * smem[neighbor + channel]; + } + } + } + + int out = (y * width + x) * channels; + for (int channel = 0; channel < channels; ++channel) { + output[out + channel] = value[channel] / weight_sum; + } +} + +__global__ void kernel_sobel( + const float* __restrict__ input, + float* gradient, + int width, int height, int channels) +{ + int x = blockIdx.x * blockDim.x + threadIdx.x; + int y = blockIdx.y * blockDim.y + threadIdx.y; + + if (x >= width || y >= height) { + return; + } + + if (x < 1 || x >= width - 1 || y < 1 || y >= height - 1) { + gradient[y * width + x] = 0.f; + return; + } + + float g00 = pixel_gray(input, (y - 1) * width + (x - 1), channels); + float g01 = pixel_gray(input, (y - 1) * width + x, channels); + float g02 = pixel_gray(input, (y - 1) * width + (x + 1), channels); + float g10 = pixel_gray(input, y * width + (x - 1), channels); + float g12 = pixel_gray(input, y * width + (x + 1), channels); + float g20 = pixel_gray(input, (y + 1) * width + (x - 1), channels); + float g21 = pixel_gray(input, (y + 1) * width + x, channels); + float g22 = pixel_gray(input, (y + 1) * width + (x + 1), channels); + + float gx = -g00 + g02 - 2.f * g10 + 2.f * g12 - g20 + g22; + float gy = -g00 - 2.f * g01 - g02 + g20 + 2.f * g21 + g22; + gradient[y * width + x] = sqrtf(gx * gx + gy * gy); +} + +__global__ void kernel_adaptive( + const float* __restrict__ input, + const float* __restrict__ gradient, + float* output, + int width, int height, int channels, + int radius_small, int radius_large, + float gradient_threshold, + float inv2_sigma_s2) +{ + int x = blockIdx.x * blockDim.x + threadIdx.x; + int y = blockIdx.y * blockDim.y + threadIdx.y; + if (x >= width || y >= height) { + return; + } + + int radius = gradient[y * width + x] > gradient_threshold ? radius_small : radius_large; + int center = y * width + x; + float weight_sum = 0.f; + float value[3] = {0.f, 0.f, 0.f}; + + for (int dy = -radius; dy <= radius; ++dy) { + int ny = clamp_int(y + dy, 0, height - 1); + for (int dx = -radius; dx <= radius; ++dx) { + int nx = clamp_int(x + dx, 0, width - 1); + int neighbor = ny * width + nx; + float spatial = expf(-((dx * dx + dy * dy) * inv2_sigma_s2)); + float color_sum_abs = 0.f; + for (int channel = 0; channel < channels; ++channel) { + color_sum_abs += fabsf(input[center * channels + channel] - + input[neighbor * channels + channel]); + } + int lut_idx = min(static_cast(color_sum_abs), 255); + float weight = spatial * c_color_lut[lut_idx]; + weight_sum += weight; + for (int channel = 0; channel < channels; ++channel) { + value[channel] += weight * input[neighbor * channels + channel]; + } + } + } + + for (int channel = 0; channel < channels; ++channel) { + output[center * channels + channel] = value[channel] / weight_sum; + } +} + +void launch_bilateral_naive( + const float* d_in, float* d_out, + int width, int height, int channels, + const BilateralParams& params) +{ + dim3 block(BLOCK_SIZE, BLOCK_SIZE); + dim3 grid((width + BLOCK_SIZE - 1) / BLOCK_SIZE, + (height + BLOCK_SIZE - 1) / BLOCK_SIZE); + float inv2s2 = 1.f / (2.f * params.sigma_spatial * params.sigma_spatial); + float inv2c2 = 1.f / (2.f * params.sigma_color * params.sigma_color); + kernel_naive<<>>(d_in, d_out, width, height, channels, + params.radius, inv2s2, inv2c2); + cudaDeviceSynchronize(); +} + +void launch_bilateral_shared( + const float* d_in, float* d_out, + int width, int height, int channels, + const BilateralParams& params) +{ + int radius = params.radius; + int diameter = 2 * radius + 1; + std::vector spatial_weights(diameter * diameter); + float inv2s2 = 1.f / (2.f * params.sigma_spatial * params.sigma_spatial); + for (int dy = -radius; dy <= radius; ++dy) { + for (int dx = -radius; dx <= radius; ++dx) { + spatial_weights[(dy + radius) * diameter + (dx + radius)] = + expf(-((dx * dx + dy * dy) * inv2s2)); + } + } + cudaMemcpyToSymbol(c_spatial_weight, spatial_weights.data(), + spatial_weights.size() * sizeof(float)); + + float inv2c2 = 1.f / (2.f * params.sigma_color * params.sigma_color); + int tile_w = TILE + 2 * radius; + size_t shared_mem = static_cast(tile_w) * tile_w * channels * sizeof(float); + + dim3 block(TILE, TILE); + dim3 grid((width + TILE - 1) / TILE, (height + TILE - 1) / TILE); + kernel_shared<<>>(d_in, d_out, width, height, channels, + radius, inv2c2); + cudaDeviceSynchronize(); +} + +void launch_bilateral_adaptive( + const float* d_in, float* d_out, + int width, int height, int channels, + const BilateralParams& params) +{ + std::vector lut(256); + float inv2c2 = 1.f / (2.f * params.sigma_color * params.sigma_color); + for (int value = 0; value < 256; ++value) { + lut[value] = expf(-((value * value) * inv2c2)); + } + cudaMemcpyToSymbol(c_color_lut, lut.data(), lut.size() * sizeof(float)); + + float* d_gradient = nullptr; + cudaMalloc(&d_gradient, width * height * sizeof(float)); + + dim3 block(BLOCK_SIZE, BLOCK_SIZE); + dim3 grid((width + BLOCK_SIZE - 1) / BLOCK_SIZE, + (height + BLOCK_SIZE - 1) / BLOCK_SIZE); + kernel_sobel<<>>(d_in, d_gradient, width, height, channels); + + float inv2s2 = 1.f / (2.f * params.sigma_spatial * params.sigma_spatial); + int radius_small = max(1, params.radius - 2); + int radius_large = params.radius; + float gradient_threshold = 20.f; + + kernel_adaptive<<>>(d_in, d_gradient, d_out, width, height, channels, + radius_small, radius_large, gradient_threshold, inv2s2); + cudaDeviceSynchronize(); + cudaFree(d_gradient); +} diff --git a/08_bilateral_filter/MLRichard/src/bilateral_filter.cuh b/08_bilateral_filter/MLRichard/src/bilateral_filter.cuh new file mode 100644 index 0000000..bf812ce --- /dev/null +++ b/08_bilateral_filter/MLRichard/src/bilateral_filter.cuh @@ -0,0 +1,26 @@ +#pragma once +#include "reference.h" // BilateralParams + +// Phase 1：朴素 kernel，每线程处理一个像素，直接读取 Global Memory +void launch_bilateral_naive( + const float* d_input, + float* d_output, + int width, int height, int channels, + const BilateralParams& params +); + +// Phase 2：Shared Memory 优化 kernel +void launch_bilateral_shared( + const float* d_input, + float* d_output, + int width, int height, int channels, + const BilateralParams& params +); + +// Phase 3：自适应半径 kernel +void launch_bilateral_adaptive( + const float* d_input, + float* d_output, + int width, int height, int channels, + const BilateralParams& params +); diff --git a/08_bilateral_filter/MLRichard/src/io.cpp b/08_bilateral_filter/MLRichard/src/io.cpp new file mode 100644 index 0000000..6d138cb --- /dev/null +++ b/08_bilateral_filter/MLRichard/src/io.cpp @@ -0,0 +1,59 @@ +#include "io.h" +#include +#include +#include + +Image read_raw(const std::string& path) { + std::ifstream f(path, std::ios::binary); + if (!f) throw std::runtime_error("Cannot open: " + path); + Image img; + f.read(reinterpret_cast(&img.width), 4); + f.read(reinterpret_cast(&img.height), 4); + f.read(reinterpret_cast(&img.channels), 4); + size_t n = (size_t)img.width * img.height * img.channels; + img.data.resize(n); + f.read(reinterpret_cast(img.data.data()), n); + return img; +} + +void write_raw(const std::string& path, const Image& img) { + std::ofstream f(path, std::ios::binary); + if (!f) throw std::runtime_error("Cannot write: " + path); + f.write(reinterpret_cast(&img.width), 4); + f.write(reinterpret_cast(&img.height), 4); + f.write(reinterpret_cast(&img.channels), 4); + f.write(reinterpret_cast(img.data.data()), img.data.size()); +} + +Image load_image(const std::string& path) { + cv::Mat mat = cv::imread(path, cv::IMREAD_UNCHANGED); + if (mat.empty()) throw std::runtime_error("Cannot load image: " + path); + Image img; + img.width = mat.cols; + img.height = mat.rows; + img.channels = mat.channels(); + if (img.channels == 3) cv::cvtColor(mat, mat, cv::COLOR_BGR2RGB); + img.data.assign(mat.data, mat.data + mat.total() * mat.elemSize()); + return img; +} + +Image float_to_image(const float* data, uint32_t w, uint32_t h, uint32_t c) { + Image img; + img.width = w; img.height = h; img.channels = c; + size_t n = (size_t)w * h * c; + img.data.resize(n); + for (size_t i = 0; i < n; i++) { + float v = data[i]; + if (v < 0.f) v = 0.f; + if (v > 255.f) v = 255.f; + img.data[i] = static_cast(v + 0.5f); + } + return img; +} + +std::vector image_to_float(const Image& img) { + size_t n = (size_t)img.width * img.height * img.channels; + std::vector f(n); + for (size_t i = 0; i < n; i++) f[i] = static_cast(img.data[i]); + return f; +} diff --git a/08_bilateral_filter/MLRichard/src/io.h b/08_bilateral_filter/MLRichard/src/io.h new file mode 100644 index 0000000..2dedfc5 --- /dev/null +++ b/08_bilateral_filter/MLRichard/src/io.h @@ -0,0 +1,26 @@ +#pragma once +#include +#include +#include + +struct Image { + uint32_t width; + uint32_t height; + uint32_t channels; // 1 (灰度) 或 3 (RGB) + std::vector data; // 行主序，交错存储 +}; + +// 读取 raw 格式文件 +Image read_raw(const std::string& path); + +// 写入 raw 格式文件 +void write_raw(const std::string& path, const Image& img); + +// 从 PNG/JPG 转换为 raw（借助 OpenCV） +Image load_image(const std::string& path); + +// 将 float 数组（0-255）转换回 uint8 Image +Image float_to_image(const float* data, uint32_t w, uint32_t h, uint32_t c); + +// 将 Image 转换为 float 数组（0-255） +std::vector image_to_float(const Image& img); diff --git a/08_bilateral_filter/MLRichard/src/main.cu b/08_bilateral_filter/MLRichard/src/main.cu new file mode 100644 index 0000000..ea7da35 --- /dev/null +++ b/08_bilateral_filter/MLRichard/src/main.cu @@ -0,0 +1,107 @@ +#include +#include +#include +#include +#include +#include +#include "io.h" +#include "bilateral_filter.cuh" +#include "reference.h" +#include "metrics.h" + +BilateralParams load_params(const std::string& path) { + BilateralParams p{5, 3.0f, 30.0f}; + std::ifstream f(path); + if (!f) { std::cerr << "params file not found, using defaults\n"; return p; } + std::string line; + while (std::getline(f, line)) { + if (line.empty() || line[0] == '#') continue; + auto eq = line.find('='); + if (eq == std::string::npos) continue; + std::string key = line.substr(0, eq); + std::string val = line.substr(eq + 1); + key.erase(0, key.find_first_not_of(" \t")); + key.erase(key.find_last_not_of(" \t") + 1); + val.erase(0, val.find_first_not_of(" \t")); + auto hash = val.find('#'); + if (hash != std::string::npos) val = val.substr(0, hash); + if (key == "radius") p.radius = std::stoi(val); + else if (key == "sigma_spatial") p.sigma_spatial = std::stof(val); + else if (key == "sigma_color") p.sigma_color = std::stof(val); + } + return p; +} + +int main(int argc, char* argv[]) { + if (argc < 4) { + std::cerr << "Usage: " << argv[0] + << " [kernel: naive|shared|adaptive]\n"; + return 1; + } + std::string input_path = argv[1]; + std::string output_path = argv[2]; + std::string params_path = argv[3]; + std::string kernel_type = argc > 4 ? argv[4] : "shared"; + + BilateralParams params = load_params(params_path); + Image img = read_raw(input_path); + + int W = img.width, H = img.height, C = img.channels; + int N = W * H * C; + + auto input_f = image_to_float(img); + + float *d_in, *d_out; + cudaMalloc(&d_in, N * sizeof(float)); + cudaMalloc(&d_out, N * sizeof(float)); + cudaMemcpy(d_in, input_f.data(), N * sizeof(float), cudaMemcpyHostToDevice); + + cudaEvent_t start, stop; + cudaEventCreate(&start); cudaEventCreate(&stop); + cudaEventRecord(start); + + if (kernel_type == "naive") launch_bilateral_naive (d_in, d_out, W, H, C, params); + else if (kernel_type == "shared") launch_bilateral_shared (d_in, d_out, W, H, C, params); + else if (kernel_type == "adaptive") launch_bilateral_adaptive(d_in, d_out, W, H, C, params); + else { std::cerr << "Unknown kernel: " << kernel_type << "\n"; return 1; } + + cudaEventRecord(stop); + cudaEventSynchronize(stop); + float gpu_ms = 0.f; + cudaEventElapsedTime(&gpu_ms, start, stop); + + std::vector output_f(N); + cudaMemcpy(output_f.data(), d_out, N * sizeof(float), cudaMemcpyDeviceToHost); + cudaFree(d_in); cudaFree(d_out); + + Image out_img = float_to_image(output_f.data(), W, H, C); + write_raw(output_path, out_img); + + std::vector ref_f(N); + auto t0 = std::chrono::high_resolution_clock::now(); + bilateral_filter_cpu(input_f.data(), ref_f.data(), W, H, C, params); + auto t1 = std::chrono::high_resolution_clock::now(); + float cpu_ms = std::chrono::duration(t1 - t0).count(); + + float mae = compute_mae (output_f.data(), ref_f.data(), N); + float psnr = compute_psnr(output_f.data(), ref_f.data(), N); + float mpix = (float)(W * H) / 1e6f; + + cudaDeviceProp prop; + cudaGetDeviceProperties(&prop, 0); + + printf("\n=== Performance Log ===\n"); + printf("Platform : %s\n", prop.name); + printf("Image : %dx%d %s\n", W, H, C == 3 ? "RGB" : "Gray"); + printf("Kernel : %s\n", kernel_type.c_str()); + printf("Radius : %d, sigma_s=%.1f, sigma_c=%.1f\n", + params.radius, params.sigma_spatial, params.sigma_color); + printf("GPU Time : %.2f ms\n", gpu_ms); + printf("Throughput : %.1f MPix/s\n", mpix / (gpu_ms / 1000.f)); + printf("CPU Time : %.2f ms (OpenCV)\n", cpu_ms); + printf("Speedup : %.1fx\n", cpu_ms / gpu_ms); + printf("MAE : %.4f\n", mae); + printf("PSNR : %.2f dB\n", psnr); + + return 0; +} diff --git a/08_bilateral_filter/MLRichard/src/metrics.cpp b/08_bilateral_filter/MLRichard/src/metrics.cpp new file mode 100644 index 0000000..081e426 --- /dev/null +++ b/08_bilateral_filter/MLRichard/src/metrics.cpp @@ -0,0 +1,20 @@ +#include "metrics.h" +#include +#include + +float compute_mae(const float* a, const float* b, int n) { + double sum = 0.0; + for (int i = 0; i < n; i++) sum += std::fabs(a[i] - b[i]); + return static_cast(sum / n); +} + +float compute_psnr(const float* a, const float* b, int n) { + double mse = 0.0; + for (int i = 0; i < n; i++) { + double d = a[i] - b[i]; + mse += d * d; + } + mse /= n; + if (mse < 1e-10) return 100.0f; + return static_cast(10.0 * std::log10(255.0 * 255.0 / mse)); +} diff --git a/08_bilateral_filter/MLRichard/src/metrics.h b/08_bilateral_filter/MLRichard/src/metrics.h new file mode 100644 index 0000000..7a0ef43 --- /dev/null +++ b/08_bilateral_filter/MLRichard/src/metrics.h @@ -0,0 +1,7 @@ +#pragma once + +// 计算平均绝对误差 MAE（输入为 float 数组，值域 0-255） +float compute_mae(const float* a, const float* b, int n); + +// 计算峰值信噪比 PSNR（最大值 255） +float compute_psnr(const float* a, const float* b, int n); diff --git a/08_bilateral_filter/MLRichard/src/reference.cpp b/08_bilateral_filter/MLRichard/src/reference.cpp new file mode 100644 index 0000000..b0bdd74 --- /dev/null +++ b/08_bilateral_filter/MLRichard/src/reference.cpp @@ -0,0 +1,27 @@ +#include "reference.h" +#include +#include +#include + +void bilateral_filter_cpu( + const float* input, float* output, + int w, int h, int c, + const BilateralParams& p) +{ + // 转换为 OpenCV Mat（uint8） + cv::Mat src(h, w, c == 3 ? CV_8UC3 : CV_8UC1); + for (int i = 0; i < h * w * c; i++) + src.data[i] = static_cast(std::min(std::max(input[i], 0.f), 255.f)); + + // OpenCV bilateralFilter 要求 BGR，我们存的是 RGB，需要转换 + if (c == 3) cv::cvtColor(src, src, cv::COLOR_RGB2BGR); + + cv::Mat dst; + // d = 2*radius+1，sigma_color 和 sigma_space 与我们的参数对应 + cv::bilateralFilter(src, dst, 2 * p.radius + 1, p.sigma_color, p.sigma_spatial); + + if (c == 3) cv::cvtColor(dst, dst, cv::COLOR_BGR2RGB); + + for (int i = 0; i < h * w * c; i++) + output[i] = static_cast(dst.data[i]); +} diff --git a/08_bilateral_filter/MLRichard/src/reference.h b/08_bilateral_filter/MLRichard/src/reference.h new file mode 100644 index 0000000..9c2ec06 --- /dev/null +++ b/08_bilateral_filter/MLRichard/src/reference.h @@ -0,0 +1,18 @@ +#pragma once +#include +#include + +struct BilateralParams { + int radius; + float sigma_spatial; + float sigma_color; +}; + +// CPU 参考实现，调用 OpenCV cv::bilateralFilter +// 输入/输出均为 float 数组（0-255），行主序，交错 RGB 或灰度 +void bilateral_filter_cpu( + const float* input, + float* output, + int width, int height, int channels, + const BilateralParams& params +); diff --git a/08_bilateral_filter/MLRichard/task.md b/08_bilateral_filter/MLRichard/task.md new file mode 100644 index 0000000..088aa84 --- /dev/null +++ b/08_bilateral_filter/MLRichard/task.md @@ -0,0 +1,105 @@ +# 选题八任务文档：实时图像双边滤波（CUDA） + +## 文档信息 + +- 来源： +- 提取范围：选题八（实时图像双边滤波） +- 提取日期：2026-03-03 + +## 一、原文内容提取 + +### 1. 题目 + +八. 实时图像双边滤波（CUDA） + +### 2. 任务背景 + +凭借你 InfiniTensor 训练营的经历和人工智能与并行计算方面的出色成绩，你受雇于一家领先的虚拟现实公司，负责为下一代 VR 头显开发实时图像增强模块。用户经常抱怨在弱光环境下看到的图像噪点严重，而现有降噪算法要么模糊细节，要么延迟太高导致眩晕。 + +你提出采用双边滤波算法，它能够在去除噪声的同时保持边缘清晰，非常适合VR图像处理。但双边滤波计算量极大，每个像素需要访问整个邻域并计算复杂的权重，难以在移动端实时运行。幸运的是，VR 头显内置了你知道的某单位生产的黑科技 GPU，你需要利用 CUDA 实现一个高度优化的双边滤波核，能够对 4K 分辨率、60 帧/秒的视频流进行实时处理。这将大幅提升用户的沉浸感和舒适度，为公司抢占市场提供核心技术。 + +### 3. 领域知识简介 + +双边滤波是一种非线性的保边滤波器，其输出像素值是邻域内所有像素的加权平均。权重由两部分组成：空间权重（依赖于像素间的空间距离，高斯函数）和颜色权重（依赖于像素值的差异，高斯函数）。因此，在平坦区域颜色相似，权重近似空间高斯，实现平滑；在边缘处颜色差异大，颜色权重小，避免跨边缘平滑。 + +双边滤波的难点在于计算量大：对于半径为 r 的窗口，每个像素需要计算 (2r+1)^2 个权重，且涉及指数运算。实时性要求（如 4K 60fps）对算法效率提出了极高挑战。 + +### 4. 任务内容 + +开发一个 CUDA 程序，实现每个像素独立计算的并行双边滤波。 + +### 5. 输入文件定义 + +1. 图像文件（标准格式，如 PNG、JPG），RGB 三通道或灰度。可使用 OpenCV 或 stb_image 读取，但本项目只关注 GPU 部分，因此可提供已读取的像素数组。为简化，输入可为二进制 raw 格式：宽、高、通道数，然后像素数据按行主序存储（RGBRGB...或灰度）。 +2. 参数文件（文本格式） + +```text +radius = 5 # 窗口半径，实际窗口大小为 (2*radius+1)^2 +sigma_spatial = 3.0 # 空间域标准差 +sigma_color = 30.0 # 颜色域标准差（对于8位图像，范围0-255） +``` + +### 6. 输出文件定义 + +- 滤波后的图像：与输入同格式的二进制 raw 文件。 +- 性能日志：处理时间（ms）、吞吐量（百万像素/秒）、加速比（对比 CPU OpenCV 实现）。 + +### 7. 要求 + +1. 图像格式：输入图像支持灰度图或 RGB 彩色图，像素值范围为 0-255（整数），处理时转换为浮点。输出为同格式。 +2. 滤波器参数：窗口半径 r 至少支持到 5（即 11×11 窗口），空间标准差 σs (sigma_spatial) 和颜色标准差 σc (sigma_color) 可配置。 +3. 正确性验证：输出图像应与 OpenCV 的 bilateralFilter 结果对比，计算平均绝对误差（MAE）或峰值信噪比（PSNR）。平均绝对误差小于 1（对于 8 位图像）。 +4. 进阶优化：实现自适应半径选择。 +5. 平台适配：默认需在英伟达平台上支持。每在一款国产平台上支持，额外加 20% 乘算系数。 + +### 8. 需提交内容 + +- 整个完成上述功能的程序（包含测试） +- 提交地址：Learning-CUDA 2025-winter-project 分支 +- 提交要求：参照项目代码要求中的第四条 +- 总结报告。报告需包括： + - 详细阐述实现思路以及优化方法，欢迎包含自己的优化历程和记录，开发中发现的问题等（取决于质量可以加分） + - 最终的性能指标和分析 + - 未来可继续提升的地方（可选） + - 包含 ncu 和/或 nsys 使用和分析的加分 + +## 二、执行任务清单（可直接用于开发） + +### A. 最小可交付版本（MVP） + +- 完成 raw 图像输入解析（宽/高/通道 + 像素数据）。 +- 完成 CUDA 双边滤波 kernel（支持灰度 + RGB）。 +- 实现参数读取（radius、sigma_spatial、sigma_color）。 +- 输出滤波后 raw 图像。 +- 输出基础性能日志（总耗时、百万像素/秒）。 + +### B. 正确性验证 + +- 接入 CPU 参考实现（OpenCV bilateralFilter）。 +- 计算 MAE/PSNR。 +- 确认 MAE < 1（8 位图像）。 + +### C. 性能优化方向 + +- 共享内存缓存邻域块，减少全局内存访问。 +- 预计算空间高斯权重表。 +- 使用常量内存存放小参数/查找表。 +- 调整 block/grid 配置并做 profile。 + +### D. 进阶项 + +- 自适应半径选择策略（按局部纹理/梯度）。 +- 多平台兼容适配（若有国产 GPU 环境）。 + +### E. 交付物打包 + +- 源码 + 构建脚本 + 测试样例。 +- 性能日志与对比结果。 +- 总结报告（实现、优化、指标、后续改进）。 + +### 项目代码要求 +1. 最终提交需整理代码：命名方式统一（不限定具体某种风格，全程序统一即可）、代码格式化（无具体某种格式要求，但可以默认使用默认配置的 clang-format）、无测试代码并且关键函数和代码块进行适当的注释。但与其他项目交叉的情况需遵循其他项目的规范； +2. 取决于具体选题，大体上是以总体性能为评判标准，因此代码的某些功能在适宜的情况下可以在 CPU 上完成，但必须仍有较为显著的部分在 CUDA 上完成。总体性能需超越 CPU 同级别实现； +3. 如有需要，可以使用合适的 CUDA 官方库。 +4. 如果选题的提交地址为 Learning-CUDA 仓库，则需要 fork Learning-CUDA 的 2025-winter-project 分支，并在其下对应的选题文件夹中放置自己的代码，即放置路径为 project 分支下 /<选题>/<你的ID>/。提交方式为 PR。例如 ID 为 lzm 并选做了 path_finding 的选题，则其代码提交地为 /path_finding/lzm/。 +如有任何疑问或不确定的地方，请询问导师或助教！不要等到最后提交反馈后才发现有不合规的地方！ \ No newline at end of file diff --git a/08_bilateral_filter/MLRichard/test/test_correctness.cpp b/08_bilateral_filter/MLRichard/test/test_correctness.cpp new file mode 100644 index 0000000..dfaff5c --- /dev/null +++ b/08_bilateral_filter/MLRichard/test/test_correctness.cpp @@ -0,0 +1,91 @@ +#include +#include +#include +#include +#include "../src/bilateral_filter.cuh" +#include "../src/reference.h" +#include "../src/metrics.h" + +namespace { + +bool check_cuda(cudaError_t err, const char* step) { + if (err == cudaSuccess) { + return true; + } + + std::cerr << "CUDA error at " << step << ": " + << cudaGetErrorString(err) << std::endl; + return false; +} + +} + +// 生成随机噪声图 +std::vector make_random_image(int w, int h, int c, unsigned seed = 42) { + std::srand(seed); + std::vector img(w * h * c); + for (auto& v : img) v = static_cast(std::rand() % 256); + return img; +} + +bool run_test(const char* name, int W, int H, int C, + const BilateralParams& params, + void (*launcher)(const float*, float*, int, int, int, const BilateralParams&)) +{ + auto input = make_random_image(W, H, C); + int N = W * H * C; + + // CPU 参考 + std::vector ref(N); + bilateral_filter_cpu(input.data(), ref.data(), W, H, C, params); + + // GPU + float *d_in = nullptr, *d_out = nullptr; + if (!check_cuda(cudaMalloc(&d_in, N * sizeof(float)), "cudaMalloc d_in") || + !check_cuda(cudaMalloc(&d_out, N * sizeof(float)), "cudaMalloc d_out") || + !check_cuda(cudaMemcpy(d_in, input.data(), N * sizeof(float), cudaMemcpyHostToDevice), + "cudaMemcpy H2D")) { + if (d_in) cudaFree(d_in); + if (d_out) cudaFree(d_out); + return false; + } + + std::vector gpu_out(N); + + launcher(d_in, d_out, W, H, C, params); + + if (!check_cuda(cudaGetLastError(), "kernel launch/sync") || + !check_cuda(cudaMemcpy(gpu_out.data(), d_out, N * sizeof(float), cudaMemcpyDeviceToHost), + "cudaMemcpy D2H")) { + cudaFree(d_in); + cudaFree(d_out); + return false; + } + cudaFree(d_in); cudaFree(d_out); + + float mae = compute_mae(gpu_out.data(), ref.data(), N); + float psnr = compute_psnr(gpu_out.data(), ref.data(), N); + bool pass = mae < 1.0f; + printf("[%s] W=%d H=%d C=%d MAE=%.4f PSNR=%.2f dB %s\n", + name, W, H, C, mae, psnr, pass ? "PASS" : "FAIL"); + return pass; +} + +int main() { + BilateralParams p{5, 3.0f, 30.0f}; + bool ok = true; + + ok &= run_test("naive_gray", 512, 512, 1, p, launch_bilateral_naive); + ok &= run_test("naive_rgb", 512, 512, 3, p, launch_bilateral_naive); + ok &= run_test("shared_gray", 512, 512, 1, p, launch_bilateral_shared); + ok &= run_test("shared_rgb", 512, 512, 3, p, launch_bilateral_shared); + ok &= run_test("adaptive_rgb", 512, 512, 3, p, launch_bilateral_adaptive); + + if (!ok) { + std::cerr << "Correctness tests failed!" << std::endl; + return 1; + } + + std::cout << "All tests passed!" << std::endl; + return 0; +} diff --git a/08_bilateral_filter/MLRichard/test/test_performance.cpp b/08_bilateral_filter/MLRichard/test/test_performance.cpp new file mode 100644 index 0000000..a1454fc --- /dev/null +++ b/08_bilateral_filter/MLRichard/test/test_performance.cpp @@ -0,0 +1,85 @@ +#include +#include +#include +#include +#include +#include +#include "../src/bilateral_filter.cuh" +#include "../src/reference.h" +#include "../src/metrics.h" + +struct BenchResult { + std::string name; + float gpu_ms; + float cpu_ms; + float mae; + float psnr; +}; + +BenchResult benchmark( + const char* name, int W, int H, int C, + const BilateralParams& params, + void (*launcher)(const float*, float*, int, int, int, const BilateralParams&), + int warmup = 3, int iters = 10) +{ + int N = W * H * C; + std::vector input(N); + std::srand(123); + for (auto& v : input) v = static_cast(std::rand() % 256); + + float *d_in, *d_out; + cudaMalloc(&d_in, N * sizeof(float)); + cudaMalloc(&d_out, N * sizeof(float)); + cudaMemcpy(d_in, input.data(), N * sizeof(float), cudaMemcpyHostToDevice); + + // Warmup + for (int i = 0; i < warmup; i++) launcher(d_in, d_out, W, H, C, params); + + // Timed iters + cudaEvent_t s, e; + cudaEventCreate(&s); cudaEventCreate(&e); + cudaEventRecord(s); + for (int i = 0; i < iters; i++) launcher(d_in, d_out, W, H, C, params); + cudaEventRecord(e); + cudaEventSynchronize(e); + float total_ms; cudaEventElapsedTime(&total_ms, s, e); + float gpu_ms = total_ms / iters; + + std::vector gpu_out(N); + cudaMemcpy(gpu_out.data(), d_out, N * sizeof(float), cudaMemcpyDeviceToHost); + cudaFree(d_in); cudaFree(d_out); + + // CPU 参考（只跑一次） + std::vector ref(N); + auto t0 = std::chrono::high_resolution_clock::now(); + bilateral_filter_cpu(input.data(), ref.data(), W, H, C, params); + auto t1 = std::chrono::high_resolution_clock::now(); + float cpu_ms = std::chrono::duration(t1 - t0).count(); + + float mae = compute_mae (gpu_out.data(), ref.data(), N); + float psnr = compute_psnr(gpu_out.data(), ref.data(), N); + + float mpix = (float)(W * H) / 1e6f; + printf("[%-20s] %dx%d C=%d GPU=%.2fms Throughput=%.1fMPix/s CPU=%.1fms Speedup=%.1fx MAE=%.4f PSNR=%.2fdB\n", + name, W, H, C, gpu_ms, mpix/(gpu_ms/1000.f), cpu_ms, cpu_ms/gpu_ms, mae, psnr); + + return {name, gpu_ms, cpu_ms, mae, psnr}; +} + +int main() { + BilateralParams p{5, 3.0f, 30.0f}; + + printf("=== Bilateral Filter Benchmark ===\n\n"); + + // 512x512 对比三个 kernel + benchmark("naive_512_rgb", 512, 512, 3, p, launch_bilateral_naive); + benchmark("shared_512_rgb", 512, 512, 3, p, launch_bilateral_shared); + benchmark("adaptive_512_rgb", 512, 512, 3, p, launch_bilateral_adaptive); + + // 4K 性能测试（主要目标） + benchmark("naive_4K_rgb", 3840, 2160, 3, p, launch_bilateral_naive); + benchmark("shared_4K_rgb", 3840, 2160, 3, p, launch_bilateral_shared); + benchmark("adaptive_4K_rgb", 3840, 2160, 3, p, launch_bilateral_adaptive); + + return 0; +} diff --git a/08_bilateral_filter/MLRichard/tools/generate_test_raw.py b/08_bilateral_filter/MLRichard/tools/generate_test_raw.py new file mode 100755 index 0000000..b503b21 --- /dev/null +++ b/08_bilateral_filter/MLRichard/tools/generate_test_raw.py @@ -0,0 +1,53 @@ +#!/usr/bin/env python3 +"""Generate a deterministic raw image for benchmark and profiling.""" + +import argparse +import struct +from pathlib import Path + +import numpy as np + + +def build_image(width: int, height: int, channels: int, seed: int) -> np.ndarray: + rng = np.random.default_rng(seed) + x = np.linspace(0.0, 1.0, width, dtype=np.float32) + y = np.linspace(0.0, 1.0, height, dtype=np.float32) + xx, yy = np.meshgrid(x, y) + + base_r = 255.0 * xx + base_g = 255.0 * yy + radial = np.sqrt((xx - 0.5) ** 2 + (yy - 0.5) ** 2) + base_b = np.clip(255.0 * (1.0 - 1.5 * radial), 0.0, 255.0) + checker = (((np.floor(xx * 32) + np.floor(yy * 32)) % 2) * 32.0).astype(np.float32) + noise = rng.normal(0.0, 10.0, size=(height, width, channels)).astype(np.float32) + + if channels == 1: + gray = 0.45 * base_r + 0.35 * base_g + 0.20 * base_b + checker + image = gray[..., None] + else: + image = np.stack([base_r + checker, base_g, base_b + 0.5 * checker], axis=-1) + + image = np.clip(image + noise, 0.0, 255.0).astype(np.uint8) + return image if channels > 1 else image[..., 0] + + +def write_raw(path: Path, array: np.ndarray, channels: int) -> None: + height, width = array.shape[:2] + path.parent.mkdir(parents=True, exist_ok=True) + with path.open("wb") as handle: + handle.write(struct.pack(" [--gray]") + sys.exit(1) + + source = Path(sys.argv[1]).expanduser() + target = Path(sys.argv[2]).expanduser() + img2raw(str(source), str(target), "--gray" in sys.argv) diff --git a/08_bilateral_filter/MLRichard/tools/profile_task12.sh b/08_bilateral_filter/MLRichard/tools/profile_task12.sh new file mode 100755 index 0000000..ff08d9b --- /dev/null +++ b/08_bilateral_filter/MLRichard/tools/profile_task12.sh @@ -0,0 +1,218 @@ +#!/usr/bin/env bash +set -euo pipefail + +ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" +BUILD_DIR="${ROOT_DIR}/build/conda-release" +APP="" +INPUT="${ROOT_DIR}/artifacts/profiling/inputs/test_4k.raw" +OUTPUT_ROOT="${ROOT_DIR}/artifacts/profiling" +PARAMS="${ROOT_DIR}/params.txt" +RUN_NCU=1 +RUN_NSYS=1 +GENERATE_INPUT=1 +NCU_SET="full" +NCU_PERMISSION_ERROR=0 + +usage() { + cat < Build directory containing bilateral_filter + --app Explicit bilateral_filter executable path + --input Input raw file path (default: auto-generated 4K raw) + --output-dir

Directory for profiling artifacts + --params Parameter file path (default: params.txt) + --skip-generate Do not auto-generate missing input raw + --skip-ncu Skip Nsight Compute captures + --skip-nsys Skip Nsight Systems capture + --ncu-set Nsight Compute set (default: full) + -h, --help Show this help +USAGE +} + +is_wsl() { + [[ -n "${WSL_DISTRO_NAME:-}" ]] || grep -qiE 'microsoft|wsl' /proc/version 2>/dev/null +} + +write_ncu_permission_hint() { + local hint_path="${RUN_DIR}/ncu_permission_hint.txt" + cat > "$hint_path" < Enable Developer Settings. + 3. Open: Developer -> Manage GPU Performance Counters. + 4. Select: Allow access to the GPU performance counter to all users. + 5. Reopen the WSL terminal and rerun: + source ~/miniconda3/etc/profile.d/conda.sh + conda activate bilateral-cuda124 + bash tools/profile_task12.sh + +Recommended fix for native Linux / A100 (permanent, Ubuntu/Debian): + sudo tee /etc/modprobe.d/nvidia-prof.conf >/dev/null <<'EOCONF' + options nvidia NVreg_RestrictProfilingToAdminUsers=0 + EOCONF + sudo update-initramfs -u -k all + sudo reboot + +Verification after reboot: + cat /proc/driver/nvidia/params | grep RmProfilingAdminOnly + +Temporary Linux workaround from NVIDIA (may require stopping the display manager): + sudo systemctl isolate multi-user + sudo modprobe -rf nvidia_uvm nvidia_drm nvidia_modeset nvidia-vgpu-vfio nvidia + sudo modprobe nvidia NVreg_RestrictProfilingToAdminUsers=0 + sudo systemctl isolate graphical +HINT + printf 'Nsight Compute permission hint written to: %s\n' "$hint_path" >&2 +} + +run_ncu_capture() { + local kernel_name="$1" + local report_base="${RUN_DIR}/profile_${kernel_name}" + local log_file="${RUN_DIR}/profile_${kernel_name}.ncu.log" + + set +e + "$NCU_BIN" --set "$NCU_SET" --target-processes all -f -o "$report_base" \ + "$APP" "$INPUT" /dev/null "$PARAMS" "$kernel_name" 2>&1 | tee "$log_file" + local status=${PIPESTATUS[0]} + set -e + + if [[ $status -eq 0 ]]; then + return 0 + fi + + if grep -q 'ERR_NVGPUCTRPERM' "$log_file"; then + NCU_PERMISSION_ERROR=1 + printf 'Nsight Compute permission denied for kernel=%s, continuing with remaining steps.\n' "$kernel_name" >&2 + return 0 + fi + + printf 'Nsight Compute failed for kernel=%s, see %s\n' "$kernel_name" "$log_file" >&2 + return "$status" +} + +while [[ $# -gt 0 ]]; do + case "$1" in + --build-dir) BUILD_DIR="$2"; shift 2 ;; + --app) APP="$2"; shift 2 ;; + --input) INPUT="$2"; shift 2 ;; + --output-dir) OUTPUT_ROOT="$2"; shift 2 ;; + --params) PARAMS="$2"; shift 2 ;; + --skip-generate) GENERATE_INPUT=0; shift ;; + --skip-ncu) RUN_NCU=0; shift ;; + --skip-nsys) RUN_NSYS=0; shift ;; + --ncu-set) NCU_SET="$2"; shift 2 ;; + -h|--help) usage; exit 0 ;; + *) echo "Unknown argument: $1" >&2; usage; exit 1 ;; + esac +done + +if [[ -z "${CONDA_PREFIX:-}" ]]; then + echo "Please activate the Conda environment first." >&2 + exit 1 +fi + +if [[ -z "$APP" ]]; then + if [[ -x "${BUILD_DIR}/bilateral_filter" ]]; then + APP="${BUILD_DIR}/bilateral_filter" + elif [[ -x "${ROOT_DIR}/build-activated/bilateral_filter" ]]; then + APP="${ROOT_DIR}/build-activated/bilateral_filter" + else + echo "Cannot find bilateral_filter executable." >&2 + exit 1 + fi +fi + +GPU_NAME="$(nvidia-smi --query-gpu=name --format=csv,noheader | head -1 | tr -d '\r')" +GPU_SLUG="$(printf '%s' "$GPU_NAME" | tr '[:upper:]' '[:lower:]' | tr ' /' '__' | tr -cd '[:alnum:]_-')" +RUN_DIR="${OUTPUT_ROOT}/${GPU_SLUG}" +mkdir -p "$RUN_DIR" "$(dirname "$INPUT")" + +NCU_BIN="${CONDA_PREFIX}/nsight-compute/2024.1.1/ncu" +NSYS_BIN="${CONDA_PREFIX}/nsight-compute/2024.1.1/host/target-linux-x64/nsys" + +if [[ ! -x "$NCU_BIN" ]]; then + echo "Nsight Compute not found: $NCU_BIN" >&2 + exit 1 +fi +if [[ $RUN_NSYS -eq 1 && ! -x "$NSYS_BIN" ]]; then + echo "Nsight Systems not found: $NSYS_BIN" >&2 + exit 1 +fi +if [[ ! -f "$PARAMS" ]]; then + echo "Parameter file not found: $PARAMS" >&2 + exit 1 +fi +if [[ ! -f "$INPUT" ]]; then + if [[ $GENERATE_INPUT -eq 0 ]]; then + echo "Input raw does not exist: $INPUT" >&2 + exit 1 + fi + python "${ROOT_DIR}/tools/generate_test_raw.py" "$INPUT" --width 3840 --height 2160 --channels 3 +fi + +export LD_LIBRARY_PATH="${CONDA_PREFIX}/lib:/usr/lib/wsl/lib:${LD_LIBRARY_PATH:-}" +export LIBRARY_PATH="${CONDA_PREFIX}/lib:${LIBRARY_PATH:-}" +export CPATH="${CONDA_PREFIX}/include:${CPATH:-}" + +BENCH_OUT="${RUN_DIR}/profile_output.raw" +printf 'GPU : %s\n' "$GPU_NAME" +printf 'App : %s\n' "$APP" +printf 'Input : %s\n' "$INPUT" +printf 'Output dir : %s\n' "$RUN_DIR" +printf 'Params : %s\n' "$PARAMS" + +if [[ $RUN_NCU -eq 1 ]]; then + run_ncu_capture naive + run_ncu_capture shared + run_ncu_capture adaptive + if [[ $NCU_PERMISSION_ERROR -eq 1 ]]; then + write_ncu_permission_hint + fi +fi + +if [[ $RUN_NSYS -eq 1 ]]; then + "$NSYS_BIN" profile --force-overwrite true -o "${RUN_DIR}/timeline" \ + "$APP" "$INPUT" "$BENCH_OUT" "$PARAMS" shared + if [[ -f "${RUN_DIR}/timeline.nsys-rep" ]]; then + "$NSYS_BIN" export --force-overwrite true --type sqlite \ + --output "${RUN_DIR}/timeline.sqlite" "${RUN_DIR}/timeline.nsys-rep" >/dev/null + fi +fi + +cat <